From 3a5f58355c37af06d2a43923cddfe540e68bf9f5 Mon Sep 17 00:00:00 2001
From: SE Zeltmann <steven.zeltmann@lbl.gov>
Date: Mon, 15 May 2023 12:00:21 -0700
Subject: [PATCH 001/362] starting to add parameter class

---
 py4DSTEM/process/phase/parameter_optimize.py | 75 ++++++++++++++++++++
 1 file changed, 75 insertions(+)
 create mode 100644 py4DSTEM/process/phase/parameter_optimize.py

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
new file mode 100644
index 000000000..c3a377fb4
--- /dev/null
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -0,0 +1,75 @@
+from tqdm import tqdm
+from skopt import gp_minimize
+from skopt.space import Real, Integer, Categorical
+from skopt.plots import plot_convergence, plot_gaussian_process, plot_evaluations, plot_objective
+from skopt.utils import use_named_args
+
+from functools import partialmethod
+from typing import Union
+
+from py4DSTEM.process.phase import PtychographicReconstruction
+
+class PtychographyOptimizer:
+	"""
+	doot doot
+	"""
+
+	def __init__(
+		self,
+		reconstruction_type: type[PtychographicReconstruction],
+		):
+		"""
+		Parameter optimization for ptychographic reconstruction based on Bayesian Optimization
+		with Gaussian Process. 
+		"""
+		pass
+
+	def optimize(self,):
+		pass
+
+	def visualize(self,):
+		pass
+
+class OptimizationParameter:
+	"""
+	Wrapper for scikit-optimize Space objects used for convenient calling in the PtyhochraphyOptimizer
+	"""
+
+	def __init__(
+		self,
+		name:str,
+		lower_bound:Union[float,int,bool],
+		upper_bound:Union[float,int,bool],
+		initial_value:Union[float,int,bool],
+		scaling:str='uniform',
+		space:str="real",
+		categories:list=[],
+		):
+
+		# Check input
+		space = space.lower()
+		assert space in ("real","integer","bool","categorical"), f"Unknown Parameter type: {space}"
+
+		scaling = scaling.lower()
+		assert scaling in ("uniform", "log-uniform"), f"Unknown scaling: {scaling}"
+
+		# Get the right scikit-optimize class
+		space_map = {'real':Real, 'integer':Integer, 'bool':Categorical, 'categorical':Categorical}
+		param = space_map[space]
+
+		# If a boolean property, the categories are True/False
+		if space == 'bool':
+			categories = [True, False]
+
+		# store necessary information
+		self.name = name
+		self.initial_value = initial_value
+
+		if param is Categorical:
+			assert categories is not None, "Empty list of categories!"
+			self._skopt_param = param(name=name, categories=categories)
+		else:
+			self._skopt_param = param(name=name, low=lower_bound, high=upper_bound, prior=scaling,)
+
+
+

From c1572df7a4608ed497f4ea1206bf86ac4ad1c4ef Mon Sep 17 00:00:00 2001
From: SE Zeltmann <steven.zeltmann@lbl.gov>
Date: Tue, 16 May 2023 14:59:04 -0700
Subject: [PATCH 002/362] bayesian optimization for hyperparameter tuning in
 ptychography

---
 py4DSTEM/process/phase/parameter_optimize.py | 285 +++++++++++++++----
 1 file changed, 224 insertions(+), 61 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index c3a377fb4..c41c611ec 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -3,73 +3,236 @@
 from skopt.space import Real, Integer, Categorical
 from skopt.plots import plot_convergence, plot_gaussian_process, plot_evaluations, plot_objective
 from skopt.utils import use_named_args
+import matplotlib.pyplot as plt
 
-from functools import partialmethod
+from functools import partial
 from typing import Union
 
-from py4DSTEM.process.phase import PtychographicReconstruction
+from py4DSTEM.process.phase.iterative_base_class import PhaseReconstruction
 
 class PtychographyOptimizer:
-	"""
-	doot doot
-	"""
-
-	def __init__(
-		self,
-		reconstruction_type: type[PtychographicReconstruction],
-		):
-		"""
-		Parameter optimization for ptychographic reconstruction based on Bayesian Optimization
-		with Gaussian Process. 
-		"""
-		pass
-
-	def optimize(self,):
-		pass
-
-	def visualize(self,):
-		pass
+    """
+    doot doot
+    """
+
+    def __init__(
+        self,
+        reconstruction_type: type[PhaseReconstruction],
+        init_args:dict,
+        preprocess_args:dict,
+        reconstruction_args:dict,
+        ):
+        """
+        Parameter optimization for ptychographic reconstruction based on Bayesian Optimization
+        with Gaussian Process. 
+        """
+        
+        # loop over each argument dictionary and split into static and optimization variables
+        self._init_static_args, self._init_optimize_args = self._split_static_and_optimization_vars(init_args)
+        self._preprocess_static_args, self._preprocess_optimize_args = self._split_static_and_optimization_vars(preprocess_args)
+        self._reconstruction_static_args, self._reconstruction_optimize_args = self._split_static_and_optimization_vars(reconstruction_args)
+
+        # Save list of skopt parameter objects and inital guess
+        self._parameter_list = []
+        self._x0 = []
+        for k,v in (self._init_optimize_args|self._preprocess_optimize_args|self._reconstruction_optimize_args).items():
+            self._parameter_list.append(v._get(k))
+            self._x0.append(v._initial_value)
+
+        self._init_args = init_args
+        self._preprocess_args = preprocess_args
+        self._reconstruction_args = reconstruction_args
+
+        self._reconstruction_type = reconstruction_type
+
+        self._set_optimizer_defaults()
+
+    def optimize(
+        self,
+        n_calls:int,
+        n_initial_points:int,
+        ):
+
+        self._optimization_function = self._get_optimization_function(
+            self._reconstruction_type,
+            self._parameter_list,
+            n_calls,
+            self._init_static_args,
+            self._preprocess_static_args,
+            self._reconstruction_static_args,
+            self._init_optimize_args,
+            self._preprocess_optimize_args,
+            self._reconstruction_optimize_args
+            )
+
+        self._skopt_result = gp_minimize(
+            self._optimization_function,
+            self._parameter_list,
+            n_calls = n_calls,
+            n_initial_points=n_initial_points,
+            x0 = self._x0
+        )
+        return self
+
+    def visualize(self,):
+        if len(self._parameter_list) == 1:
+            plot_gaussian_process(self._skopt_result)
+            plt.show()
+
+        plot_convergence(self._skopt_result)
+        plt.show()
+        plot_objective(self._skopt_result)
+        plt.show()
+        plot_evaluations(self._skopt_result)
+        plt.show()
+        return self
+
+    def get_optimized_arguments(self):
+        init_opt = self._replace_optimized_parameters(self._init_args, self._parameter_list)
+        prep_opt = self._replace_optimized_parameters(self._preprocess_args, self._parameter_list)
+        reco_opt = self._replace_optimized_parameters(self._reconstruction_args, self._parameter_list)
+
+        return init_opt, prep_opt, reco_opt
+
+    def _replace_optimized_parameters(self, arg_dict, parameters):
+        opt_args = {}
+        for k,v in arg_dict.items():
+            # Check for optimization parameters
+            if isinstance(v,OptimizationParameter):
+                # Find the right parameter in the list
+                # There is probably a better way to do this inverse mapping!
+                for i,p in enumerate(parameters):
+                    if p.name == k:
+                        opt_args[k] = self._skopt_result.x[i]
+            else:
+                opt_args[k] = v
+        return opt_args
+
+
+    def _split_static_and_optimization_vars(self,argdict):
+        static_args = {}
+        optimization_args = {}
+        for k,v in argdict.items():
+            if isinstance(v,OptimizationParameter):
+                # unwrap the OptimizationParameter object into a skopt object
+                optimization_args[k] = v #._get(k)
+            else:
+                static_args[k] = v
+        return static_args, optimization_args
+
+
+    def _get_optimization_function(
+        self,
+        cls:type[PhaseReconstruction], 
+        parameter_list:list,
+        n_iterations:int,
+        init_static_args:dict, 
+        preprocess_static_args:dict, 
+        reconstruct_static_args:dict, 
+        init_optimization_param_names:dict, 
+        preprocess_optimization_param_names:dict, 
+        reconstruct_optimization_param_names:dict):
+        """
+        Wrap the ptychography pipeline into a single function that encapsulates all of the
+        non-optimization arguments and accepts a concatenated set of keyword arguments. The
+        wrapper function returns the final error value from the ptychography run.
+
+        parameter_list is a list of skopt Dimension objects
+
+        Both static and optimization args are passed in dictionaries. The values of the
+        static dictionary are the fixed parameters, and only the keys of the optimization
+        dictionary are used. 
+        """
+
+        # Construct partial methods to encapsulate the static parameters
+        obj = partial(cls,**init_static_args)
+        prep = partial(cls.preprocess, **preprocess_static_args)
+        recon = partial(cls.reconstruct, **reconstruct_static_args)
+
+        init_params = list(init_optimization_param_names.keys())
+        prep_params = list(preprocess_optimization_param_names.keys())
+        reco_params = list(reconstruct_optimization_param_names.keys())
+
+        # Make a progress bar
+        pbar = tqdm(total=n_iterations,desc="Optimizing Parameters")
+
+        # Target function for Gaussian process optimization that takes a single
+        # dict of named parameters and returns the ptycho error metric
+        @use_named_args(parameter_list)
+        def f(**kwargs):
+            init_args = {k:kwargs[k] for k in init_params}
+            prep_args = {k:kwargs[k] for k in prep_params}
+            reco_args = {k:kwargs[k] for k in reco_params}
+
+            ptycho = obj(**init_args)
+            prep(ptycho,**prep_args)
+            recon(ptycho,**reco_args)
+
+            pbar.update(1)
+
+            return ptycho.error
+                
+        return f
+
+    def _set_optimizer_defaults(self):
+        """
+        Set all of the verbose and plotting to False
+        """
+        self._init_static_args['verbose'] = False
+
+        self._preprocess_static_args['plot_center_of_mass'] = False
+        self._preprocess_static_args['plot_rotation'] = False
+        self._preprocess_static_args['plot_probe_overlaps'] = False
+
+        self._reconstruction_static_args['progress_bar'] = False
+        self._reconstruction_static_args['store_iterations'] = False
 
-class OptimizationParameter:
-	"""
-	Wrapper for scikit-optimize Space objects used for convenient calling in the PtyhochraphyOptimizer
-	"""
-
-	def __init__(
-		self,
-		name:str,
-		lower_bound:Union[float,int,bool],
-		upper_bound:Union[float,int,bool],
-		initial_value:Union[float,int,bool],
-		scaling:str='uniform',
-		space:str="real",
-		categories:list=[],
-		):
-
-		# Check input
-		space = space.lower()
-		assert space in ("real","integer","bool","categorical"), f"Unknown Parameter type: {space}"
-
-		scaling = scaling.lower()
-		assert scaling in ("uniform", "log-uniform"), f"Unknown scaling: {scaling}"
-
-		# Get the right scikit-optimize class
-		space_map = {'real':Real, 'integer':Integer, 'bool':Categorical, 'categorical':Categorical}
-		param = space_map[space]
-
-		# If a boolean property, the categories are True/False
-		if space == 'bool':
-			categories = [True, False]
-
-		# store necessary information
-		self.name = name
-		self.initial_value = initial_value
-
-		if param is Categorical:
-			assert categories is not None, "Empty list of categories!"
-			self._skopt_param = param(name=name, categories=categories)
-		else:
-			self._skopt_param = param(name=name, low=lower_bound, high=upper_bound, prior=scaling,)
 
+class OptimizationParameter:
+    """
+    Wrapper for scikit-optimize Space objects used for convenient calling in the PtyhochraphyOptimizer
+    """
+
+    def __init__(
+        self,
+        lower_bound:Union[float,int,bool],
+        upper_bound:Union[float,int,bool],
+        initial_value:Union[float,int,bool],
+        scaling:str='uniform',
+        space:str="real",
+        categories:list=[],
+        ):
+
+        # Check input
+        space = space.lower()
+        assert space in ("real","integer","bool","categorical"), f"Unknown Parameter type: {space}"
+
+        scaling = scaling.lower()
+        assert scaling in ("uniform", "log-uniform"), f"Unknown scaling: {scaling}"
+
+        # Get the right scikit-optimize class
+        space_map = {'real':Real, 'integer':Integer, 'bool':Categorical, 'categorical':Categorical}
+        param = space_map[space]
+
+        # If a boolean property, the categories are True/False
+        if space == 'bool':
+            categories = [True, False]
+
+        # store necessary information
+        self._initial_value = initial_value
+        self._categories = categories
+        self._lower_bound = lower_bound
+        self._upper_bound = upper_bound
+        self._scaling = scaling
+        self._param_type = param
+
+    def _get(self,name):
+        self._name = name
+        if self._param_type is Categorical:
+            assert categories is not None, "Empty list of categories!"
+            self._skopt_param = self._param_type(name=self._name, categories=self._categories)
+        else:
+            self._skopt_param = self._param_type(name=self._name, low=self._lower_bound, high=self._upper_bound, prior=self._scaling,)
+        return self._skopt_param
 
 

From 39cc862e8a2ad3a0c93dcc39a1987b173047bf6c Mon Sep 17 00:00:00 2001
From: SE Zeltmann <steven.zeltmann@lbl.gov>
Date: Tue, 16 May 2023 15:23:12 -0700
Subject: [PATCH 003/362] improvements to plotting and progress bar

---
 py4DSTEM/process/phase/parameter_optimize.py | 35 ++++++++++++++------
 1 file changed, 24 insertions(+), 11 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index c41c611ec..1a5ad768b 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -53,7 +53,7 @@ def optimize(
         n_initial_points:int,
         ):
 
-        self._optimization_function = self._get_optimization_function(
+        self._optimization_function, pbar = self._get_optimization_function(
             self._reconstruction_type,
             self._parameter_list,
             n_calls,
@@ -72,19 +72,32 @@ def optimize(
             n_initial_points=n_initial_points,
             x0 = self._x0
         )
+
+        # Finish the tqdm progressbar so subsequent things behave nicely
+        pbar.close()
+
         return self
 
-    def visualize(self,):
-        if len(self._parameter_list) == 1:
+    def visualize(
+        self,
+        gp_model=True,
+        convergence=False,
+        objective=True,
+        evaluations=False,
+    ):
+        if len(self._parameter_list) == 1 and gp_model:
             plot_gaussian_process(self._skopt_result)
             plt.show()
 
-        plot_convergence(self._skopt_result)
-        plt.show()
-        plot_objective(self._skopt_result)
-        plt.show()
-        plot_evaluations(self._skopt_result)
-        plt.show()
+        if convergence:
+            plot_convergence(self._skopt_result)
+            plt.show()
+        if objective:
+            plot_objective(self._skopt_result)
+            plt.show()
+        if evaluations:
+            plot_evaluations(self._skopt_result)
+            plt.show()
         return self
 
     def get_optimized_arguments(self):
@@ -154,7 +167,7 @@ def _get_optimization_function(
         reco_params = list(reconstruct_optimization_param_names.keys())
 
         # Make a progress bar
-        pbar = tqdm(total=n_iterations,desc="Optimizing Parameters")
+        pbar = tqdm(total=n_iterations,desc="Optimizing parameters")
 
         # Target function for Gaussian process optimization that takes a single
         # dict of named parameters and returns the ptycho error metric
@@ -172,7 +185,7 @@ def f(**kwargs):
 
             return ptycho.error
                 
-        return f
+        return f, pbar
 
     def _set_optimizer_defaults(self):
         """

From 983db77e6c973c3d56aef240c51304e05c0b99dd Mon Sep 17 00:00:00 2001
From: SE Zeltmann <steven.zeltmann@lbl.gov>
Date: Tue, 16 May 2023 17:35:54 -0700
Subject: [PATCH 004/362] print optimization result

---
 py4DSTEM/process/phase/parameter_optimize.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 1a5ad768b..8d266e428 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -73,6 +73,10 @@ def optimize(
             x0 = self._x0
         )
 
+        print("Optimized parameters:")
+        for p,x in zip(self._parameter_list, self._skopt_result.x):
+            print(f"{p.name}: {x}")
+
         # Finish the tqdm progressbar so subsequent things behave nicely
         pbar.close()
 

From 62e03f80e6caeac8672def6f01c4b701414ab992 Mon Sep 17 00:00:00 2001
From: SE Zeltmann <steven.zeltmann@lbl.gov>
Date: Tue, 16 May 2023 18:05:58 -0700
Subject: [PATCH 005/362] format

---
 py4DSTEM/process/phase/parameter_optimize.py | 181 +++++++++++--------
 1 file changed, 109 insertions(+), 72 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 8d266e428..627cb04c5 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -1,7 +1,12 @@
 from tqdm import tqdm
 from skopt import gp_minimize
 from skopt.space import Real, Integer, Categorical
-from skopt.plots import plot_convergence, plot_gaussian_process, plot_evaluations, plot_objective
+from skopt.plots import (
+    plot_convergence,
+    plot_gaussian_process,
+    plot_evaluations,
+    plot_objective,
+)
 from skopt.utils import use_named_args
 import matplotlib.pyplot as plt
 
@@ -10,6 +15,7 @@
 
 from py4DSTEM.process.phase.iterative_base_class import PhaseReconstruction
 
+
 class PtychographyOptimizer:
     """
     doot doot
@@ -18,24 +24,37 @@ class PtychographyOptimizer:
     def __init__(
         self,
         reconstruction_type: type[PhaseReconstruction],
-        init_args:dict,
-        preprocess_args:dict,
-        reconstruction_args:dict,
-        ):
+        init_args: dict,
+        preprocess_args: dict,
+        reconstruction_args: dict,
+    ):
         """
         Parameter optimization for ptychographic reconstruction based on Bayesian Optimization
-        with Gaussian Process. 
+        with Gaussian Process.
         """
-        
+
         # loop over each argument dictionary and split into static and optimization variables
-        self._init_static_args, self._init_optimize_args = self._split_static_and_optimization_vars(init_args)
-        self._preprocess_static_args, self._preprocess_optimize_args = self._split_static_and_optimization_vars(preprocess_args)
-        self._reconstruction_static_args, self._reconstruction_optimize_args = self._split_static_and_optimization_vars(reconstruction_args)
+        (
+            self._init_static_args,
+            self._init_optimize_args,
+        ) = self._split_static_and_optimization_vars(init_args)
+        (
+            self._preprocess_static_args,
+            self._preprocess_optimize_args,
+        ) = self._split_static_and_optimization_vars(preprocess_args)
+        (
+            self._reconstruction_static_args,
+            self._reconstruction_optimize_args,
+        ) = self._split_static_and_optimization_vars(reconstruction_args)
 
         # Save list of skopt parameter objects and inital guess
         self._parameter_list = []
         self._x0 = []
-        for k,v in (self._init_optimize_args|self._preprocess_optimize_args|self._reconstruction_optimize_args).items():
+        for k, v in (
+            self._init_optimize_args
+            | self._preprocess_optimize_args
+            | self._reconstruction_optimize_args
+        ).items():
             self._parameter_list.append(v._get(k))
             self._x0.append(v._initial_value)
 
@@ -49,10 +68,9 @@ def __init__(
 
     def optimize(
         self,
-        n_calls:int,
-        n_initial_points:int,
-        ):
-
+        n_calls: int,
+        n_initial_points: int,
+    ):
         self._optimization_function, pbar = self._get_optimization_function(
             self._reconstruction_type,
             self._parameter_list,
@@ -62,19 +80,19 @@ def optimize(
             self._reconstruction_static_args,
             self._init_optimize_args,
             self._preprocess_optimize_args,
-            self._reconstruction_optimize_args
-            )
+            self._reconstruction_optimize_args,
+        )
 
         self._skopt_result = gp_minimize(
             self._optimization_function,
             self._parameter_list,
-            n_calls = n_calls,
+            n_calls=n_calls,
             n_initial_points=n_initial_points,
-            x0 = self._x0
+            x0=self._x0,
         )
 
         print("Optimized parameters:")
-        for p,x in zip(self._parameter_list, self._skopt_result.x):
+        for p, x in zip(self._parameter_list, self._skopt_result.x):
             print(f"{p.name}: {x}")
 
         # Finish the tqdm progressbar so subsequent things behave nicely
@@ -105,50 +123,55 @@ def visualize(
         return self
 
     def get_optimized_arguments(self):
-        init_opt = self._replace_optimized_parameters(self._init_args, self._parameter_list)
-        prep_opt = self._replace_optimized_parameters(self._preprocess_args, self._parameter_list)
-        reco_opt = self._replace_optimized_parameters(self._reconstruction_args, self._parameter_list)
+        init_opt = self._replace_optimized_parameters(
+            self._init_args, self._parameter_list
+        )
+        prep_opt = self._replace_optimized_parameters(
+            self._preprocess_args, self._parameter_list
+        )
+        reco_opt = self._replace_optimized_parameters(
+            self._reconstruction_args, self._parameter_list
+        )
 
         return init_opt, prep_opt, reco_opt
 
     def _replace_optimized_parameters(self, arg_dict, parameters):
         opt_args = {}
-        for k,v in arg_dict.items():
+        for k, v in arg_dict.items():
             # Check for optimization parameters
-            if isinstance(v,OptimizationParameter):
+            if isinstance(v, OptimizationParameter):
                 # Find the right parameter in the list
                 # There is probably a better way to do this inverse mapping!
-                for i,p in enumerate(parameters):
+                for i, p in enumerate(parameters):
                     if p.name == k:
                         opt_args[k] = self._skopt_result.x[i]
             else:
                 opt_args[k] = v
         return opt_args
 
-
-    def _split_static_and_optimization_vars(self,argdict):
+    def _split_static_and_optimization_vars(self, argdict):
         static_args = {}
         optimization_args = {}
-        for k,v in argdict.items():
-            if isinstance(v,OptimizationParameter):
+        for k, v in argdict.items():
+            if isinstance(v, OptimizationParameter):
                 # unwrap the OptimizationParameter object into a skopt object
-                optimization_args[k] = v #._get(k)
+                optimization_args[k] = v  # ._get(k)
             else:
                 static_args[k] = v
         return static_args, optimization_args
 
-
     def _get_optimization_function(
         self,
-        cls:type[PhaseReconstruction], 
-        parameter_list:list,
-        n_iterations:int,
-        init_static_args:dict, 
-        preprocess_static_args:dict, 
-        reconstruct_static_args:dict, 
-        init_optimization_param_names:dict, 
-        preprocess_optimization_param_names:dict, 
-        reconstruct_optimization_param_names:dict):
+        cls: type[PhaseReconstruction],
+        parameter_list: list,
+        n_iterations: int,
+        init_static_args: dict,
+        preprocess_static_args: dict,
+        reconstruct_static_args: dict,
+        init_optimization_param_names: dict,
+        preprocess_optimization_param_names: dict,
+        reconstruct_optimization_param_names: dict,
+    ):
         """
         Wrap the ptychography pipeline into a single function that encapsulates all of the
         non-optimization arguments and accepts a concatenated set of keyword arguments. The
@@ -158,11 +181,11 @@ def _get_optimization_function(
 
         Both static and optimization args are passed in dictionaries. The values of the
         static dictionary are the fixed parameters, and only the keys of the optimization
-        dictionary are used. 
+        dictionary are used.
         """
 
         # Construct partial methods to encapsulate the static parameters
-        obj = partial(cls,**init_static_args)
+        obj = partial(cls, **init_static_args)
         prep = partial(cls.preprocess, **preprocess_static_args)
         recon = partial(cls.reconstruct, **reconstruct_static_args)
 
@@ -171,38 +194,38 @@ def _get_optimization_function(
         reco_params = list(reconstruct_optimization_param_names.keys())
 
         # Make a progress bar
-        pbar = tqdm(total=n_iterations,desc="Optimizing parameters")
+        pbar = tqdm(total=n_iterations, desc="Optimizing parameters")
 
         # Target function for Gaussian process optimization that takes a single
         # dict of named parameters and returns the ptycho error metric
         @use_named_args(parameter_list)
         def f(**kwargs):
-            init_args = {k:kwargs[k] for k in init_params}
-            prep_args = {k:kwargs[k] for k in prep_params}
-            reco_args = {k:kwargs[k] for k in reco_params}
+            init_args = {k: kwargs[k] for k in init_params}
+            prep_args = {k: kwargs[k] for k in prep_params}
+            reco_args = {k: kwargs[k] for k in reco_params}
 
             ptycho = obj(**init_args)
-            prep(ptycho,**prep_args)
-            recon(ptycho,**reco_args)
+            prep(ptycho, **prep_args)
+            recon(ptycho, **reco_args)
 
             pbar.update(1)
 
             return ptycho.error
-                
+
         return f, pbar
 
     def _set_optimizer_defaults(self):
         """
         Set all of the verbose and plotting to False
         """
-        self._init_static_args['verbose'] = False
+        self._init_static_args["verbose"] = False
 
-        self._preprocess_static_args['plot_center_of_mass'] = False
-        self._preprocess_static_args['plot_rotation'] = False
-        self._preprocess_static_args['plot_probe_overlaps'] = False
+        self._preprocess_static_args["plot_center_of_mass"] = False
+        self._preprocess_static_args["plot_rotation"] = False
+        self._preprocess_static_args["plot_probe_overlaps"] = False
 
-        self._reconstruction_static_args['progress_bar'] = False
-        self._reconstruction_static_args['store_iterations'] = False
+        self._reconstruction_static_args["progress_bar"] = False
+        self._reconstruction_static_args["store_iterations"] = False
 
 
 class OptimizationParameter:
@@ -212,27 +235,36 @@ class OptimizationParameter:
 
     def __init__(
         self,
-        lower_bound:Union[float,int,bool],
-        upper_bound:Union[float,int,bool],
-        initial_value:Union[float,int,bool],
-        scaling:str='uniform',
-        space:str="real",
-        categories:list=[],
-        ):
-
+        lower_bound: Union[float, int, bool],
+        upper_bound: Union[float, int, bool],
+        initial_value: Union[float, int, bool],
+        scaling: str = "uniform",
+        space: str = "real",
+        categories: list = [],
+    ):
         # Check input
         space = space.lower()
-        assert space in ("real","integer","bool","categorical"), f"Unknown Parameter type: {space}"
+        assert space in (
+            "real",
+            "integer",
+            "bool",
+            "categorical",
+        ), f"Unknown Parameter type: {space}"
 
         scaling = scaling.lower()
         assert scaling in ("uniform", "log-uniform"), f"Unknown scaling: {scaling}"
 
         # Get the right scikit-optimize class
-        space_map = {'real':Real, 'integer':Integer, 'bool':Categorical, 'categorical':Categorical}
+        space_map = {
+            "real": Real,
+            "integer": Integer,
+            "bool": Categorical,
+            "categorical": Categorical,
+        }
         param = space_map[space]
 
         # If a boolean property, the categories are True/False
-        if space == 'bool':
+        if space == "bool":
             categories = [True, False]
 
         # store necessary information
@@ -243,13 +275,18 @@ def __init__(
         self._scaling = scaling
         self._param_type = param
 
-    def _get(self,name):
+    def _get(self, name):
         self._name = name
         if self._param_type is Categorical:
             assert categories is not None, "Empty list of categories!"
-            self._skopt_param = self._param_type(name=self._name, categories=self._categories)
+            self._skopt_param = self._param_type(
+                name=self._name, categories=self._categories
+            )
         else:
-            self._skopt_param = self._param_type(name=self._name, low=self._lower_bound, high=self._upper_bound, prior=self._scaling,)
+            self._skopt_param = self._param_type(
+                name=self._name,
+                low=self._lower_bound,
+                high=self._upper_bound,
+                prior=self._scaling,
+            )
         return self._skopt_param
-
-

From 3f1e05d54e12a1145db6bbbaa4d9c747eb341d12 Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <steven.zeltmann@berkeley.edu>
Date: Thu, 18 May 2023 15:06:19 -0700
Subject: [PATCH 006/362] add affine transform to bayesian optimize

---
 py4DSTEM/process/phase/parameter_optimize.py | 73 +++++++++++++++-----
 1 file changed, 56 insertions(+), 17 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 627cb04c5..dbecdb22c 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -9,11 +9,13 @@
 )
 from skopt.utils import use_named_args
 import matplotlib.pyplot as plt
+import numpy as np
 
 from functools import partial
 from typing import Union
 
 from py4DSTEM.process.phase.iterative_base_class import PhaseReconstruction
+from py4DSTEM.process.phase.utils import AffineTransform
 
 
 class PtychographyOptimizer:
@@ -25,6 +27,7 @@ def __init__(
         self,
         reconstruction_type: type[PhaseReconstruction],
         init_args: dict,
+        affine_args:dict,
         preprocess_args: dict,
         reconstruction_args: dict,
     ):
@@ -38,6 +41,10 @@ def __init__(
             self._init_static_args,
             self._init_optimize_args,
         ) = self._split_static_and_optimization_vars(init_args)
+        (
+            self._affine_static_args,
+            self._affine_optimize_args,
+        ) = self._split_static_and_optimization_vars(affine_args)
         (
             self._preprocess_static_args,
             self._preprocess_optimize_args,
@@ -52,6 +59,7 @@ def __init__(
         self._x0 = []
         for k, v in (
             self._init_optimize_args
+            | self._affine_optimize_args
             | self._preprocess_optimize_args
             | self._reconstruction_optimize_args
         ).items():
@@ -59,6 +67,7 @@ def __init__(
             self._x0.append(v._initial_value)
 
         self._init_args = init_args
+        self._affine_args = affine_args
         self._preprocess_args = preprocess_args
         self._reconstruction_args = reconstruction_args
 
@@ -71,24 +80,34 @@ def optimize(
         n_calls: int,
         n_initial_points: int,
     ):
-        self._optimization_function, pbar = self._get_optimization_function(
+        self._optimization_function = self._get_optimization_function(
             self._reconstruction_type,
             self._parameter_list,
             n_calls,
             self._init_static_args,
+            self._affine_static_args,
             self._preprocess_static_args,
             self._reconstruction_static_args,
             self._init_optimize_args,
+            self._affine_optimize_args,
             self._preprocess_optimize_args,
             self._reconstruction_optimize_args,
         )
 
+        # Make a progress bar
+        pbar = tqdm(total=n_calls, desc="Optimizing parameters")
+        # We need to wrap the callback because if it returns a value
+        # the optimizer breaks its loop
+        def callback(*args,**kwargs):
+            pbar.update(1)
+
         self._skopt_result = gp_minimize(
             self._optimization_function,
             self._parameter_list,
             n_calls=n_calls,
             n_initial_points=n_initial_points,
             x0=self._x0,
+            callback=callback,
         )
 
         print("Optimized parameters:")
@@ -107,10 +126,9 @@ def visualize(
         objective=True,
         evaluations=False,
     ):
-        if len(self._parameter_list) == 1 and gp_model:
+        if (len(self._parameter_list) == 1) and gp_model:
             plot_gaussian_process(self._skopt_result)
             plt.show()
-
         if convergence:
             plot_convergence(self._skopt_result)
             plt.show()
@@ -126,6 +144,13 @@ def get_optimized_arguments(self):
         init_opt = self._replace_optimized_parameters(
             self._init_args, self._parameter_list
         )
+        affine_opt = self._replace_optimized_parameters(
+            self._affine_args, self._parameter_list
+        )
+        affine_transform = partial(AffineTransform, **self._affine_static_args)(**affine_opt)
+        scan_positions = self._get_scan_positions(affine_transform, init_opt['datacube'])
+        init_opt['initial_scan_positions'] = scan_positions
+
         prep_opt = self._replace_optimized_parameters(
             self._preprocess_args, self._parameter_list
         )
@@ -154,23 +179,32 @@ def _split_static_and_optimization_vars(self, argdict):
         optimization_args = {}
         for k, v in argdict.items():
             if isinstance(v, OptimizationParameter):
-                # unwrap the OptimizationParameter object into a skopt object
-                optimization_args[k] = v  # ._get(k)
+                optimization_args[k] = v
             else:
                 static_args[k] = v
         return static_args, optimization_args
 
+    def _get_scan_positions(self, affine_transform, dataset):
+        R_pixel_size = dataset.calibration.get_R_pixel_size()
+        x,y = np.arange(dataset.R_Nx)*R_pixel_size, np.arange(dataset.R_Ny)*R_pixel_size
+        x, y = np.meshgrid(x, y, indexing="ij")
+        scan_positions = np.stack((x.ravel(),y.ravel()),axis=1)
+        scan_positions = scan_positions @ affine_transform.asarray()
+        return scan_positions
+
     def _get_optimization_function(
         self,
         cls: type[PhaseReconstruction],
         parameter_list: list,
         n_iterations: int,
         init_static_args: dict,
+        affine_static_args:dict,
         preprocess_static_args: dict,
         reconstruct_static_args: dict,
-        init_optimization_param_names: dict,
-        preprocess_optimization_param_names: dict,
-        reconstruct_optimization_param_names: dict,
+        init_optimization_params: dict,
+        affine_optimization_params: dict,
+        preprocess_optimization_params: dict,
+        reconstruct_optimization_params: dict,
     ):
         """
         Wrap the ptychography pipeline into a single function that encapsulates all of the
@@ -186,33 +220,38 @@ def _get_optimization_function(
 
         # Construct partial methods to encapsulate the static parameters
         obj = partial(cls, **init_static_args)
+        affine = partial(AffineTransform, **affine_static_args)
         prep = partial(cls.preprocess, **preprocess_static_args)
         recon = partial(cls.reconstruct, **reconstruct_static_args)
 
-        init_params = list(init_optimization_param_names.keys())
-        prep_params = list(preprocess_optimization_param_names.keys())
-        reco_params = list(reconstruct_optimization_param_names.keys())
-
-        # Make a progress bar
-        pbar = tqdm(total=n_iterations, desc="Optimizing parameters")
+        init_params = list(init_optimization_params.keys())
+        afft_params = list(affine_optimization_params.keys())
+        prep_params = list(preprocess_optimization_params.keys())
+        reco_params = list(reconstruct_optimization_params.keys())
 
         # Target function for Gaussian process optimization that takes a single
         # dict of named parameters and returns the ptycho error metric
         @use_named_args(parameter_list)
         def f(**kwargs):
             init_args = {k: kwargs[k] for k in init_params}
+            afft_args = {k: kwargs[k] for k in afft_params}
             prep_args = {k: kwargs[k] for k in prep_params}
             reco_args = {k: kwargs[k] for k in reco_params}
 
+            # Create affine transform object
+            tr = affine(**afft_args)
+            # Apply affine transform to pixel grid, using the 
+            # calibrations lifted from the dataset
+            dataset = init_static_args['datacube']
+            init_args['initial_scan_positions'] = self._get_scan_positions(tr, dataset)
+
             ptycho = obj(**init_args)
             prep(ptycho, **prep_args)
             recon(ptycho, **reco_args)
 
-            pbar.update(1)
-
             return ptycho.error
 
-        return f, pbar
+        return f
 
     def _set_optimizer_defaults(self):
         """

From 2aac54c1508260d8ea243b98feedba225d487249 Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <steven.zeltmann@berkeley.edu>
Date: Thu, 18 May 2023 15:16:09 -0700
Subject: [PATCH 007/362] bugfix from linter

---
 py4DSTEM/process/phase/parameter_optimize.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index dbecdb22c..dffa991ab 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -317,7 +317,7 @@ def __init__(
     def _get(self, name):
         self._name = name
         if self._param_type is Categorical:
-            assert categories is not None, "Empty list of categories!"
+            assert self._categories is not None, "Empty list of categories!"
             self._skopt_param = self._param_type(
                 name=self._name, categories=self._categories
             )

From 57b363a0f84b637a97fa2df0cbc7e6bc4818d51c Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <steven.zeltmann@berkeley.edu>
Date: Fri, 19 May 2023 14:51:52 -0700
Subject: [PATCH 008/362] add documentation and format

---
 py4DSTEM/process/phase/parameter_optimize.py | 120 ++++++++++++++++---
 1 file changed, 106 insertions(+), 14 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index dffa991ab..987ffedef 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -20,20 +20,48 @@
 
 class PtychographyOptimizer:
     """
-    doot doot
+    Optimize ptychographic hyperparameters with Bayesian Optimization of a
+    Gaussian process. Any of the arguments to the ptychographic
+    init-preprocess-reconstruct pipeline can be optimized over (including
+    boolean or other flag options)
     """
 
     def __init__(
         self,
         reconstruction_type: type[PhaseReconstruction],
         init_args: dict,
-        affine_args:dict,
+        affine_args: dict,
         preprocess_args: dict,
         reconstruction_args: dict,
     ):
         """
         Parameter optimization for ptychographic reconstruction based on Bayesian Optimization
         with Gaussian Process.
+
+        Usage
+        -----
+        Dictionaries of the arguments to __init__, AffineTransform (for distorting the initial
+        scan positions), preprocess, and reconstruct are required. For parameters not optimized
+        over, the value in the dictionary is used. To optimize a parameter, instead pass an
+        OptimizationParameter object inside the dictionary to specify the bounds, initial guess,
+        and type of parameter. Calling optimize will then run the optimization simultaneously
+        over all optimization parameters. To obtain the optimized parameters, call get_optimized_arguments
+        to return a set of dictionaries where the OptimizationParameter objects have been replaced
+        with the optimal values. These can then be modified for running a full reconstruction.
+
+        Parameters
+        ----------
+        reconstruction_type: class
+            Type of ptychographic reconstruction to perform
+        init_args: dict
+            Keyword arguments passed to the __init__ method of the reconstruction class
+        affine_args: dict
+            Keyword arguments passed to AffineTransform. The transform is applied to the initial
+            scan positions.
+        preprocess_args: dict
+            Keyword arguments passed to the preprocess method the reconstruction object
+        reconstruction_args: dict
+            Keyword arguments passed to the reconstruct method the the reconstruction object
         """
 
         # loop over each argument dictionary and split into static and optimization variables
@@ -79,7 +107,22 @@ def optimize(
         self,
         n_calls: int,
         n_initial_points: int,
+        **skopt_kwargs: dict,
     ):
+        """
+        Run optimizer
+
+        Parameters
+        ----------
+        n_calls: int
+            Number of times to run ptychographic reconstruction
+        n_initial_points: int
+            Number of uniformly spaced trial points to test before
+            beginning Bayesian optimization (must be less than n_calls)
+        skopt_kwargs: dict
+            Additional arguments to be passed to skopt.gp_minimize
+
+        """
         self._optimization_function = self._get_optimization_function(
             self._reconstruction_type,
             self._parameter_list,
@@ -96,9 +139,10 @@ def optimize(
 
         # Make a progress bar
         pbar = tqdm(total=n_calls, desc="Optimizing parameters")
+
         # We need to wrap the callback because if it returns a value
         # the optimizer breaks its loop
-        def callback(*args,**kwargs):
+        def callback(*args, **kwargs):
             pbar.update(1)
 
         self._skopt_result = gp_minimize(
@@ -108,6 +152,7 @@ def callback(*args,**kwargs):
             n_initial_points=n_initial_points,
             x0=self._x0,
             callback=callback,
+            **skopt_kwargs,
         )
 
         print("Optimized parameters:")
@@ -126,6 +171,20 @@ def visualize(
         objective=True,
         evaluations=False,
     ):
+        """
+        Visualize optimization results
+
+        Parameters
+        ----------
+        gp_model: bool
+            Display fitted Gaussian process model (only available for 1-dimensional problem)
+        convergence: bool
+            Display convergence history
+        objective: bool
+            Display GP objective function and partial dependence plots
+        evaluations: bool
+            Display histograms of sampled points
+        """
         if (len(self._parameter_list) == 1) and gp_model:
             plot_gaussian_process(self._skopt_result)
             plt.show()
@@ -141,15 +200,29 @@ def visualize(
         return self
 
     def get_optimized_arguments(self):
+        """
+        Get argument dictionaries containing optimized hyperparameters
+
+        Returns
+        -------
+        init_opt, prep_opt, reco_opt: dicts
+            Dictionaries of arguments to __init__, preprocess, and reconstruct
+            where the OptimizationParameter items have been replaced with the optimal
+            values obtained from the optimizer
+        """
         init_opt = self._replace_optimized_parameters(
             self._init_args, self._parameter_list
         )
         affine_opt = self._replace_optimized_parameters(
             self._affine_args, self._parameter_list
         )
-        affine_transform = partial(AffineTransform, **self._affine_static_args)(**affine_opt)
-        scan_positions = self._get_scan_positions(affine_transform, init_opt['datacube'])
-        init_opt['initial_scan_positions'] = scan_positions
+        affine_transform = partial(AffineTransform, **self._affine_static_args)(
+            **affine_opt
+        )
+        scan_positions = self._get_scan_positions(
+            affine_transform, init_opt["datacube"]
+        )
+        init_opt["initial_scan_positions"] = scan_positions
 
         prep_opt = self._replace_optimized_parameters(
             self._preprocess_args, self._parameter_list
@@ -186,9 +259,12 @@ def _split_static_and_optimization_vars(self, argdict):
 
     def _get_scan_positions(self, affine_transform, dataset):
         R_pixel_size = dataset.calibration.get_R_pixel_size()
-        x,y = np.arange(dataset.R_Nx)*R_pixel_size, np.arange(dataset.R_Ny)*R_pixel_size
+        x, y = (
+            np.arange(dataset.R_Nx) * R_pixel_size,
+            np.arange(dataset.R_Ny) * R_pixel_size,
+        )
         x, y = np.meshgrid(x, y, indexing="ij")
-        scan_positions = np.stack((x.ravel(),y.ravel()),axis=1)
+        scan_positions = np.stack((x.ravel(), y.ravel()), axis=1)
         scan_positions = scan_positions @ affine_transform.asarray()
         return scan_positions
 
@@ -198,7 +274,7 @@ def _get_optimization_function(
         parameter_list: list,
         n_iterations: int,
         init_static_args: dict,
-        affine_static_args:dict,
+        affine_static_args: dict,
         preprocess_static_args: dict,
         reconstruct_static_args: dict,
         init_optimization_params: dict,
@@ -240,10 +316,10 @@ def f(**kwargs):
 
             # Create affine transform object
             tr = affine(**afft_args)
-            # Apply affine transform to pixel grid, using the 
+            # Apply affine transform to pixel grid, using the
             # calibrations lifted from the dataset
-            dataset = init_static_args['datacube']
-            init_args['initial_scan_positions'] = self._get_scan_positions(tr, dataset)
+            dataset = init_static_args["datacube"]
+            init_args["initial_scan_positions"] = self._get_scan_positions(tr, dataset)
 
             ptycho = obj(**init_args)
             prep(ptycho, **prep_args)
@@ -274,13 +350,29 @@ class OptimizationParameter:
 
     def __init__(
         self,
-        lower_bound: Union[float, int, bool],
-        upper_bound: Union[float, int, bool],
         initial_value: Union[float, int, bool],
+        lower_bound: Union[float, int, bool] = None,
+        upper_bound: Union[float, int, bool] = None,
         scaling: str = "uniform",
         space: str = "real",
         categories: list = [],
     ):
+        """
+        Wrapper for scikit-optimize Space objects used as inputs to PtychographyOptimizer
+
+        Parameters
+        ----------
+        initial_value:
+            Initial value, used for first evaluation in optimizer
+        lower_bound, upper_bound:
+            Bounds on real or integer variables (not needed for bool or categorical)
+        scaling: str
+            Prior knowledge on sensitivity of the variable. Can be 'uniform' or 'log-uniform'
+        space: str
+            Type of variable. Can be 'real', 'integer', 'bool', or 'categorical'
+        categories: list
+            List of options for Categorical parameter
+        """
         # Check input
         space = space.lower()
         assert space in (

From 0cde08db1fb4e984821a2ddeba7982a55c852a93 Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <steven.zeltmann@berkeley.edu>
Date: Fri, 19 May 2023 14:57:52 -0700
Subject: [PATCH 009/362] add isotropic expansion option to AffineTransform

---
 py4DSTEM/process/phase/utils.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/process/phase/utils.py b/py4DSTEM/process/phase/utils.py
index 12028408a..504adebd4 100644
--- a/py4DSTEM/process/phase/utils.py
+++ b/py4DSTEM/process/phase/utils.py
@@ -644,6 +644,8 @@ class AffineTransform:
         x-translation
     t1: float
         y-translation
+    dilation: float
+        Isotropic expansion (multiplies scale0 and scale1)
     """
 
     def __init__(
@@ -654,9 +656,10 @@ def __init__(
         angle: float = 0.0,
         t0: float = 0.0,
         t1: float = 0.0,
+        dilation: float = 1.0,
     ):
-        self.scale0 = scale0
-        self.scale1 = scale1
+        self.scale0 = scale0 * dilation
+        self.scale1 = scale1 * dilation
         self.shear1 = shear1
         self.angle = angle
         self.t0 = t0

From 40e1a1c918a53db26ba5e2f4e971dad72b2e4c83 Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Wed, 17 May 2023 11:32:12 -0400
Subject: [PATCH 010/362] fix calibration move

---
 py4DSTEM/preprocess/preprocess.py              | 3 +++
 py4DSTEM/process/phase/iterative_base_class.py | 3 +--
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/preprocess/preprocess.py b/py4DSTEM/preprocess/preprocess.py
index 76a12f4b5..82794b07d 100644
--- a/py4DSTEM/preprocess/preprocess.py
+++ b/py4DSTEM/preprocess/preprocess.py
@@ -565,6 +565,7 @@ def resample_data_diffraction(
         datacube.data = fourier_resample(
             datacube.data, scale=resampling_factor, output_size=output_size
         )
+        datacube.calibration.set_Q_pixel_size(datacube.calibration.get_Q_pixel_size() / resampling_factor)
 
     elif method == "bilinear":
         from scipy.ndimage import zoom
@@ -596,6 +597,8 @@ def resample_data_diffraction(
 
         resampling_factor = np.concatenate(((1, 1), resampling_factor))
         datacube.data = zoom(datacube.data, resampling_factor, order=1)
+        datacube.calibration.set_Q_pixel_size(datacube.calibration.get_Q_pixel_size() / resampling_factor[2])
+
     else:
         raise ValueError(
             f"'method' needs to be one of 'bilinear' or 'fourier', not {method}."
diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index 249b685b4..c2a522dc1 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -193,8 +193,7 @@ def _preprocess_datacube_and_vacuum_probe(
                         output_size=diffraction_intensities_shape,
                         force_nonnegative=True,
                     )
-            datacube.calibration.set_Q_pixel_size(Q_pixel_size / resampling_factor_x)
-
+        
         if probe_roi_shape is not None:
             Qx, Qy = datacube.shape[-2:]
             Sx, Sy = probe_roi_shape

From 946cc77fc726d22f81cfca955a09d6f028cec8b0 Mon Sep 17 00:00:00 2001
From: RPSankaran <rohini.sankaran@gmail.com>
Date: Mon, 29 May 2023 16:40:52 -0700
Subject: [PATCH 011/362] fix version bug in py4DSTEM dev

setup.py python <3.11 changed to <=3.11.3
---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index b7ca8ad39..710f20a8a 100644
--- a/setup.py
+++ b/setup.py
@@ -21,7 +21,7 @@
     author_email='ben.savitzky@gmail.com',
     license='GNU GPLv3',
     keywords="STEM 4DSTEM",
-    python_requires='>=3.9,<3.11',
+    python_requires='>=3.9,<=3.11.3',
     install_requires=[
         'numpy >= 1.19',
         'scipy >= 1.5.2',

From a980eb67c376f88ee81945216b9751273bb97771 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Thu, 1 Jun 2023 13:56:32 -0700
Subject: [PATCH 012/362] doc strings modification

---
 py4DSTEM/process/phase/parameter_optimize.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 987ffedef..ce17ec023 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -43,9 +43,11 @@ def __init__(
         Dictionaries of the arguments to __init__, AffineTransform (for distorting the initial
         scan positions), preprocess, and reconstruct are required. For parameters not optimized
         over, the value in the dictionary is used. To optimize a parameter, instead pass an
-        OptimizationParameter object inside the dictionary to specify the bounds, initial guess,
-        and type of parameter. Calling optimize will then run the optimization simultaneously
-        over all optimization parameters. To obtain the optimized parameters, call get_optimized_arguments
+        OptimizationParameter object inside the dictionary to specify the initial guess, bounds, 
+        and type of parameter, for example: 
+            >>> 'param':OptimizationParameter(initial guess, lower bound, upper bound)
+        Calling optimize will then run the optimization simultaneously over all 
+        optimization parameters. To obtain the optimized parameters, call get_optimized_arguments
         to return a set of dictionaries where the OptimizationParameter objects have been replaced
         with the optimal values. These can then be modified for running a full reconstruction.
 

From b24e0d257f985531131baae4427db9151ee42ab6 Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Sat, 3 Jun 2023 12:13:26 -0400
Subject: [PATCH 013/362] backtracking in DPC

---
 py4DSTEM/process/phase/iterative_dpc.py | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index b2d8ef891..248512a66 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -602,6 +602,7 @@ def reconstruct(
         max_iter: int = 64,
         step_size: float = None,
         stopping_criterion: float = 1e-6,
+        backtrack: bool = True,
         progress_bar: bool = True,
         gaussian_filter_sigma: float = None,
         gaussian_filter_iter: int = np.inf,
@@ -666,6 +667,8 @@ def reconstruct(
             self._step_size = step_size if step_size is not None else 0.5
             self._padded_phase_object = self._padded_phase_object_initial.copy()
 
+        previous_iteration = self._padded_phase_object.copy()
+
         self.error = getattr(self, "error", np.inf)
 
         if step_size is None:
@@ -688,10 +691,19 @@ def reconstruct(
                 break
 
             # forward operator
-            com_dx, com_dy, self.error, self._step_size = self._forward(
+            com_dx, com_dy, new_error, self._step_size = self._forward(
                 self._padded_phase_object, mask, mask_inv, self.error, self._step_size
             )
 
+            # if the error went up after the previous step, go back to the step
+            # before the error rose and continue with the halved step size
+            if (new_error > self.error) and backtrack:
+                self._padded_phase_object = previous_iteration
+                print(f"Iteration {a0}, step reduced to {self._step_size}")
+                continue
+            self.error = new_error
+            previous_iteration = self._padded_phase_object.copy()
+
             # adjoint operator
             phase_update = self._adjoint(com_dx, com_dy, self._kx_op, self._ky_op)
 

From ce7f180f78b5299da9b12365c5e5b742389a5446 Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Sat, 3 Jun 2023 12:16:40 -0400
Subject: [PATCH 014/362] DPC backtrack docs

---
 py4DSTEM/process/phase/iterative_dpc.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index 248512a66..d03990dc0 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -624,6 +624,10 @@ def reconstruct(
             Reconstruction update step size
         stopping_criterion: float, optional
             step_size below which reconstruction exits
+        backtrack: bool, optional
+            If True, steps that increase the error metric are rejected
+            and iteration continues with a reduced step size from the
+            previous iteration
         progress_bar: bool, optional
             If True, reconstruction progress bar will be printed
         gaussian_filter_sigma: float, optional

From e3aa53dd390e47156ecfccc86e85b1df61da758f Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Sun, 4 Jun 2023 11:07:46 -0400
Subject: [PATCH 015/362] add calibration overrides to ptycho base class

---
 .../process/phase/iterative_base_class.py     | 164 +++++++++++-------
 1 file changed, 104 insertions(+), 60 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index c2a522dc1..cfc5e6cb0 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -220,6 +220,9 @@ def _extract_intensities_and_calibrations_from_datacube(
         self,
         datacube: DataCube,
         require_calibrations: bool = False,
+        force_scan_sampling: Optional[float] = None,
+        force_angular_sampling: Optional[float] = None,
+        force_reciprocal_sampling: Optional[float] = None,
     ):
         """
         Method to extract intensities and calibrations from datacube.
@@ -230,6 +233,12 @@ def _extract_intensities_and_calibrations_from_datacube(
             Input 4D diffraction pattern intensities
         require_calibrations: bool
             If False, warning is issued instead of raising an error
+        force_scan_sampling: float, optional
+            Override DataCube real space scan pixel size calibrations, in Angstrom
+        force_angular_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in mrad
+        force_reciprocal_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in A^-1
 
         Assigns
         --------
@@ -275,80 +284,115 @@ def _extract_intensities_and_calibrations_from_datacube(
         reciprocal_space_units = calibration.get_Q_pixel_units()
 
         # Real-space
-        if real_space_units == "pixels":
-            if require_calibrations:
-                raise ValueError("Real-space calibrations must be given in 'A'")
-
-            warnings.warn(
-                (
-                    "Iterative reconstruction will not be quantitative unless you specify "
-                    "real-space calibrations in 'A'"
-                ),
-                UserWarning,
-            )
+        if force_scan_sampling is not None:
+            self._scan_sampling = (force_scan_sampling, force_scan_sampling)
+            self._scan_units = "A"
+        else:
+            if real_space_units == "pixels":
+                if require_calibrations:
+                    raise ValueError("Real-space calibrations must be given in 'A'")
 
-            self._scan_sampling = (1.0, 1.0)
-            self._scan_units = ("pixels",) * 2
+                warnings.warn(
+                    (
+                        "Iterative reconstruction will not be quantitative unless you specify "
+                        "real-space calibrations in 'A'"
+                    ),
+                    UserWarning,
+                )
 
-        elif real_space_units == "A":
-            self._scan_sampling = (calibration.get_R_pixel_size(),) * 2
-            self._scan_units = ("A",) * 2
-        elif real_space_units == "nm":
-            self._scan_sampling = (calibration.get_R_pixel_size() * 10,) * 2
-            self._scan_units = ("A",) * 2
-        else:
-            raise ValueError(
-                f"Real-space calibrations must be given in 'A', not {real_space_units}"
-            )
+                self._scan_sampling = (1.0, 1.0)
+                self._scan_units = ("pixels",) * 2
 
-        # Reciprocal-space
-        if reciprocal_space_units == "pixels":
-            if require_calibrations:
+            elif real_space_units == "A":
+                self._scan_sampling = (calibration.get_R_pixel_size(),) * 2
+                self._scan_units = ("A",) * 2
+            elif real_space_units == "nm":
+                self._scan_sampling = (calibration.get_R_pixel_size() * 10,) * 2
+                self._scan_units = ("A",) * 2
+            else:
                 raise ValueError(
-                    "Reciprocal-space calibrations must be given in in 'A^-1' or 'mrad'"
+                    f"Real-space calibrations must be given in 'A', not {real_space_units}"
                 )
 
-            warnings.warn(
-                (
-                    "Iterative reconstruction will not be quantitative unless you specify "
-                    "appropriate reciprocal-space calibrations"
-                ),
-                UserWarning,
+        # Reciprocal-space
+        if force_angular_sampling is not None or force_reciprocal_sampling is not None:
+            # there is no xor keyword in Python!
+            angular = force_angular_sampling is not None
+            reciprocal = force_reciprocal_sampling is not None
+            assert (angular and not reciprocal) or (not angular and reciprocal), (
+                "Only one of angular or reciprocal calibration can be forced!"
             )
 
-            self._angular_sampling = (1.0, 1.0)
-            self._angular_units = ("pixels",) * 2
-            self._reciprocal_sampling = (1.0, 1.0)
-            self._reciprocal_units = ("pixels",) * 2
-
-        elif reciprocal_space_units == "A^-1":
-            reciprocal_size = calibration.get_Q_pixel_size()
-            self._reciprocal_sampling = (reciprocal_size,) * 2
-            self._reciprocal_units = ("A^-1",) * 2
-
-            if self._energy is not None:
-                self._angular_sampling = (
-                    reciprocal_size * electron_wavelength_angstrom(self._energy) * 1e3,
-                ) * 2
+            # angular calibration specified
+            if angular:
+                self._angular_sampling = (force_angular_sampling,) * 2
                 self._angular_units = ("mrad",) * 2
 
-        elif reciprocal_space_units == "mrad":
-            angular_size = calibration.get_Q_pixel_size()
-            self._angular_sampling = (angular_size,) * 2
-            self._angular_units = ("mrad",) * 2
+                if self._energy is not None:
+                    self._reciprocal_sampling = (
+                        force_angular_sampling / electron_wavelength_angstrom(self._energy) / 1e3,
+                    ) * 2
+                    self._reciprocal_units = ("A^-1",) * 2
 
-            if self._energy is not None:
-                self._reciprocal_sampling = (
-                    angular_size / electron_wavelength_angstrom(self._energy) / 1e3,
-                ) * 2
+            # reciprocal calibration specified
+            if reciprocal:
+                self._reciprocal_sampling = (force_reciprocal_sampling,) * 2
                 self._reciprocal_units = ("A^-1",) * 2
+
+                if self._energy is not None:
+                    self._angular_sampling = (
+                        force_reciprocal_sampling * electron_wavelength_angstrom(self._energy) * 1e3,
+                    ) * 2
+                    self._angular_units = ("mrad",) * 2
+
         else:
-            raise ValueError(
-                (
-                    "Reciprocal-space calibrations must be given in 'A^-1' or 'mrad', "
-                    f"not {reciprocal_space_units}"
+            if reciprocal_space_units == "pixels":
+                if require_calibrations:
+                    raise ValueError(
+                        "Reciprocal-space calibrations must be given in in 'A^-1' or 'mrad'"
+                    )
+
+                warnings.warn(
+                    (
+                        "Iterative reconstruction will not be quantitative unless you specify "
+                        "appropriate reciprocal-space calibrations"
+                    ),
+                    UserWarning,
+                )
+
+                self._angular_sampling = (1.0, 1.0)
+                self._angular_units = ("pixels",) * 2
+                self._reciprocal_sampling = (1.0, 1.0)
+                self._reciprocal_units = ("pixels",) * 2
+
+            elif reciprocal_space_units == "A^-1":
+                reciprocal_size = calibration.get_Q_pixel_size()
+                self._reciprocal_sampling = (reciprocal_size,) * 2
+                self._reciprocal_units = ("A^-1",) * 2
+
+                if self._energy is not None:
+                    self._angular_sampling = (
+                        reciprocal_size * electron_wavelength_angstrom(self._energy) * 1e3,
+                    ) * 2
+                    self._angular_units = ("mrad",) * 2
+
+            elif reciprocal_space_units == "mrad":
+                angular_size = calibration.get_Q_pixel_size()
+                self._angular_sampling = (angular_size,) * 2
+                self._angular_units = ("mrad",) * 2
+
+                if self._energy is not None:
+                    self._reciprocal_sampling = (
+                        angular_size / electron_wavelength_angstrom(self._energy) / 1e3,
+                    ) * 2
+                    self._reciprocal_units = ("A^-1",) * 2
+            else:
+                raise ValueError(
+                    (
+                        "Reciprocal-space calibrations must be given in 'A^-1' or 'mrad', "
+                        f"not {reciprocal_space_units}"
+                    )
                 )
-            )
 
         return intensities
 

From db0b1c2c01af9fccb97f4741df83d685a84e5360 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Mon, 5 Jun 2023 11:31:39 -0700
Subject: [PATCH 016/362] no empty dictionaries required!

---
 py4DSTEM/process/phase/parameter_optimize.py | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index ce17ec023..0d1245a62 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -30,9 +30,9 @@ def __init__(
         self,
         reconstruction_type: type[PhaseReconstruction],
         init_args: dict,
-        affine_args: dict,
         preprocess_args: dict,
         reconstruction_args: dict,
+        affine_args: dict = None,
     ):
         """
         Parameter optimization for ptychographic reconstruction based on Bayesian Optimization
@@ -43,10 +43,10 @@ def __init__(
         Dictionaries of the arguments to __init__, AffineTransform (for distorting the initial
         scan positions), preprocess, and reconstruct are required. For parameters not optimized
         over, the value in the dictionary is used. To optimize a parameter, instead pass an
-        OptimizationParameter object inside the dictionary to specify the initial guess, bounds, 
-        and type of parameter, for example: 
+        OptimizationParameter object inside the dictionary to specify the initial guess, bounds,
+        and type of parameter, for example:
             >>> 'param':OptimizationParameter(initial guess, lower bound, upper bound)
-        Calling optimize will then run the optimization simultaneously over all 
+        Calling optimize will then run the optimization simultaneously over all
         optimization parameters. To obtain the optimized parameters, call get_optimized_arguments
         to return a set of dictionaries where the OptimizationParameter objects have been replaced
         with the optimal values. These can then be modified for running a full reconstruction.
@@ -57,14 +57,16 @@ def __init__(
             Type of ptychographic reconstruction to perform
         init_args: dict
             Keyword arguments passed to the __init__ method of the reconstruction class
-        affine_args: dict
-            Keyword arguments passed to AffineTransform. The transform is applied to the initial
-            scan positions.
         preprocess_args: dict
             Keyword arguments passed to the preprocess method the reconstruction object
         reconstruction_args: dict
             Keyword arguments passed to the reconstruct method the the reconstruction object
+        affine_args: dict
+            Keyword arguments passed to AffineTransform. The transform is applied to the initial
+            scan positions.
         """
+        if affine_args is None:
+            affine_args = {}
 
         # loop over each argument dictionary and split into static and optimization variables
         (

From 809013ed559f509b79be3387abf2ced92cd79ad9 Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Mon, 5 Jun 2023 15:04:52 -0400
Subject: [PATCH 017/362] bugfix and document previous commit

---
 py4DSTEM/preprocess/preprocess.py             |  8 +++++++-
 .../process/phase/iterative_base_class.py     |  6 +++---
 .../iterative_singleslice_ptychography.py     | 19 +++++++++++++++++++
 3 files changed, 29 insertions(+), 4 deletions(-)

diff --git a/py4DSTEM/preprocess/preprocess.py b/py4DSTEM/preprocess/preprocess.py
index 82794b07d..03598b824 100644
--- a/py4DSTEM/preprocess/preprocess.py
+++ b/py4DSTEM/preprocess/preprocess.py
@@ -562,10 +562,16 @@ def resample_data_diffraction(
             )
             resampling_factor = resampling_factor[0]
 
+        old_size = datacube.data.shape
+
         datacube.data = fourier_resample(
             datacube.data, scale=resampling_factor, output_size=output_size
         )
-        datacube.calibration.set_Q_pixel_size(datacube.calibration.get_Q_pixel_size() / resampling_factor)
+
+        if not resampling_factor:
+            resampling_factor = old_size[2] / output_size[0]
+        if datacube.calibration.get_Q_pixel_size() is not None:
+            datacube.calibration.set_Q_pixel_size(datacube.calibration.get_Q_pixel_size() / resampling_factor)
 
     elif method == "bilinear":
         from scipy.ndimage import zoom
diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index cfc5e6cb0..eb3541dc4 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -220,9 +220,9 @@ def _extract_intensities_and_calibrations_from_datacube(
         self,
         datacube: DataCube,
         require_calibrations: bool = False,
-        force_scan_sampling: Optional[float] = None,
-        force_angular_sampling: Optional[float] = None,
-        force_reciprocal_sampling: Optional[float] = None,
+        force_scan_sampling: float = None,
+        force_angular_sampling: float = None,
+        force_reciprocal_sampling: float = None,
     ):
         """
         Method to extract intensities and calibrations from datacube.
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index 3507f606b..67a843115 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -91,6 +91,7 @@ def __init__(
         energy: float,
         datacube: DataCube = None,
         semiangle_cutoff: float = None,
+        semiangle_cutoff_pixels: float = None,
         rolloff: float = 2.0,
         vacuum_probe_intensity: np.ndarray = None,
         polar_parameters: Mapping[str, float] = None,
@@ -156,6 +157,7 @@ def __init__(
         self._scan_positions = initial_scan_positions
         self._energy = energy
         self._semiangle_cutoff = semiangle_cutoff
+        self._semiangle_cutoff_pixels = semiangle_cutoff_pixels
         self._rolloff = rolloff
         self._object_type = object_type
         self._object_padding_px = object_padding_px
@@ -180,6 +182,9 @@ def preprocess(
         force_com_rotation: float = None,
         force_com_transpose: float = None,
         force_com_shifts: float = None,
+        force_scan_sampling: float = None,
+        force_angular_sampling: float = None,
+        force_reciprocal_sampling: float = None,
         object_fov_mask: np.ndarray = None,
         **kwargs,
     ):
@@ -229,6 +234,12 @@ def preprocess(
             Amplitudes come from diffraction patterns shifted with
             the CoM in the upper left corner for each probe unless
             shift is overwritten.
+        force_scan_sampling: float, optional
+            Override DataCube real space scan pixel size calibrations, in Angstrom
+        force_angular_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in mrad
+        force_reciprocal_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in A^-1
         object_fov_mask: np.ndarray (boolean)
             Boolean mask of FOV. Used to calculate additional shrinkage of object
             If None, probe_overlap intensity is thresholded
@@ -273,8 +284,16 @@ def preprocess(
         self._intensities = self._extract_intensities_and_calibrations_from_datacube(
             self._datacube,
             require_calibrations=True,
+            force_scan_sampling=force_scan_sampling,
+            force_angular_sampling=force_angular_sampling,
+            force_reciprocal_sampling=force_reciprocal_sampling,
         )
 
+        # handle semiangle specified in pixels
+        if self._semiangle_cutoff_pixels:
+            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
+
+
         (
             self._com_measured_x,
             self._com_measured_y,

From ed9f4ff208298c4de8fa9b6b23623bcbdd2d2608 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <55254539+smribet@users.noreply.github.com>
Date: Wed, 7 Jun 2023 13:58:36 -0700
Subject: [PATCH 018/362] step size reorg

---
 py4DSTEM/process/phase/iterative_dpc.py | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index d03990dc0..27749758b 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -420,9 +420,6 @@ def _forward(
             xp.mean(self._com_x.ravel() ** 2 + self._com_y.ravel() ** 2)
         )
 
-        if new_error > error:
-            step_size /= 2
-
         return obj_dx, obj_dy, new_error, step_size
 
     def _adjoint(
@@ -670,9 +667,7 @@ def reconstruct(
             self.error = np.inf
             self._step_size = step_size if step_size is not None else 0.5
             self._padded_phase_object = self._padded_phase_object_initial.copy()
-
-        previous_iteration = self._padded_phase_object.copy()
-
+            
         self.error = getattr(self, "error", np.inf)
 
         if step_size is None:
@@ -693,7 +688,9 @@ def reconstruct(
         ):
             if self._step_size < stopping_criterion:
                 break
-
+                
+            previous_iteration = self._padded_phase_object.copy()
+            
             # forward operator
             com_dx, com_dy, new_error, self._step_size = self._forward(
                 self._padded_phase_object, mask, mask_inv, self.error, self._step_size
@@ -703,10 +700,10 @@ def reconstruct(
             # before the error rose and continue with the halved step size
             if (new_error > self.error) and backtrack:
                 self._padded_phase_object = previous_iteration
+                self._step_size /= 2
                 print(f"Iteration {a0}, step reduced to {self._step_size}")
                 continue
             self.error = new_error
-            previous_iteration = self._padded_phase_object.copy()
 
             # adjoint operator
             phase_update = self._adjoint(com_dx, com_dy, self._kx_op, self._ky_op)

From 45a1c7162c9e40858a70c8868b68541a09dc305a Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Thu, 8 Jun 2023 10:04:25 -0700
Subject: [PATCH 019/362] anti gridding filter

---
 py4DSTEM/process/phase/iterative_dpc.py | 81 +++++++++++++++++++------
 1 file changed, 63 insertions(+), 18 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index 27749758b..062bb8d5c 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -337,13 +337,13 @@ def preprocess(
         padded_object_shape = np.round(
             np.array(self._grid_scan_shape) * padding_factor
         ).astype("int")
-        self._padded_phase_object = xp.zeros(padded_object_shape, dtype=xp.float32)
+        self._padded_object_phase = xp.zeros(padded_object_shape, dtype=xp.float32)
         if self._object_phase is not None:
-            self._padded_phase_object[
+            self._padded_object_phase[
                 : self._grid_scan_shape[0], : self._grid_scan_shape[1]
             ] = xp.asarray(self._object_phase, dtype=xp.float32)
 
-        self._padded_phase_object_initial = self._padded_phase_object.copy()
+        self._padded_object_phase_initial = self._padded_object_phase.copy()
 
         # Fourier coordinates and operators
         kx = xp.fft.fftfreq(padded_object_shape[0], d=self._scan_sampling[0])
@@ -478,7 +478,7 @@ def _update(
 
         Returns
         --------
-        updated_padded_phase_object: np.ndarray
+        updated_padded_object_phase: np.ndarray
             Updated padded phase object estimate
         """
 
@@ -547,6 +547,37 @@ def _object_butterworth_constraint(self, current_object, q_lowpass, q_highpass):
 
         return xp.real(current_object)
 
+    def _object_anti_gridding_contraint(self, current_object):
+        """
+        Zero outer pixels of object fft to remove gridding artifacts
+
+        Parameters
+        --------
+        current_object: np.ndarray
+            Current object estimate
+
+        Returns
+        --------
+        constrained_object: np.ndarray
+            Constrained object estimate
+        """
+        xp = self._xp
+
+        #find indices to zero accounting for object padding 
+        width_x = self._grid_scan_shape[0]
+        width_y = self._grid_scan_shape[1]
+        ind_min_x = int(xp.floor(width_x / 2) - 1)
+        ind_max_x = int(xp.ceil(width_x / 2) + 1)
+        ind_min_y = int(xp.floor(width_y / 2) - 1)
+        ind_max_y = int(xp.ceil(width_y / 2) + 1)
+
+        #zero pixels
+        object_fft = xp.fft.fft2(current_object)
+        object_fft[ind_min_x:-ind_max_x] = 0
+        object_fft[:, ind_min_y:-ind_max_y] = 0
+
+        return xp.real(xp.fft.ifft2(object_fft))
+
     def _constraints(
         self,
         current_object,
@@ -555,6 +586,7 @@ def _constraints(
         butterworth_filter,
         q_lowpass,
         q_highpass,
+        anti_gridding,
     ):
         """
         DPC constraints operator.
@@ -573,6 +605,9 @@ def _constraints(
             Cut-off frequency in A^-1 for low-pass butterworth filter
         q_highpass: float
             Cut-off frequency in A^-1 for high-pass butterworth filter
+        anti_gridding: bool
+            If true, zero outer pixels of object fft to remove
+            gridding artifacts
 
         Returns
         --------
@@ -591,6 +626,11 @@ def _constraints(
                 q_highpass,
             )
 
+        if anti_gridding:
+            current_object = self._object_anti_gridding_contraint(
+                current_object,
+            )
+
         return current_object
 
     def reconstruct(
@@ -606,6 +646,7 @@ def reconstruct(
         butterworth_filter_iter: int = np.inf,
         q_lowpass: float = None,
         q_highpass: float = None,
+        anti_gridding: float = True,
         store_iterations: bool = False,
     ):
         """
@@ -637,6 +678,9 @@ def reconstruct(
             Cut-off frequency in A^-1 for low-pass butterworth filter
         q_highpass: float
             Cut-off frequency in A^-1 for high-pass butterworth filter
+        anti_gridding: bool
+            If true, zero outer pixels of object fft to remove
+            gridding artifacts
         store_iterations: bool, optional
             If True, all reconstruction iterations will be stored
 
@@ -666,8 +710,8 @@ def reconstruct(
         if reset:
             self.error = np.inf
             self._step_size = step_size if step_size is not None else 0.5
-            self._padded_phase_object = self._padded_phase_object_initial.copy()
-            
+            self._padded_object_phase = self._padded_object_phase_initial.copy()
+
         self.error = getattr(self, "error", np.inf)
 
         if step_size is None:
@@ -675,7 +719,7 @@ def reconstruct(
         else:
             self._step_size = step_size
 
-        mask = xp.zeros(self._padded_phase_object.shape, dtype="bool")
+        mask = xp.zeros(self._padded_object_phase.shape, dtype="bool")
         mask[: self._grid_scan_shape[0], : self._grid_scan_shape[1]] = True
         mask_inv = xp.logical_not(mask)
 
@@ -688,18 +732,18 @@ def reconstruct(
         ):
             if self._step_size < stopping_criterion:
                 break
-                
-            previous_iteration = self._padded_phase_object.copy()
-            
+
+            previous_iteration = self._padded_object_phase.copy()
+
             # forward operator
             com_dx, com_dy, new_error, self._step_size = self._forward(
-                self._padded_phase_object, mask, mask_inv, self.error, self._step_size
+                self._padded_object_phase, mask, mask_inv, self.error, self._step_size
             )
 
             # if the error went up after the previous step, go back to the step
             # before the error rose and continue with the halved step size
             if (new_error > self.error) and backtrack:
-                self._padded_phase_object = previous_iteration
+                self._padded_object_phase = previous_iteration
                 self._step_size /= 2
                 print(f"Iteration {a0}, step reduced to {self._step_size}")
                 continue
@@ -709,13 +753,13 @@ def reconstruct(
             phase_update = self._adjoint(com_dx, com_dy, self._kx_op, self._ky_op)
 
             # update
-            self._padded_phase_object = self._update(
-                self._padded_phase_object, phase_update, self._step_size
+            self._padded_object_phase = self._update(
+                self._padded_object_phase, phase_update, self._step_size
             )
 
             # constraints
-            self._padded_phase_object = self._constraints(
-                self._padded_phase_object,
+            self._padded_object_phase = self._constraints(
+                self._padded_object_phase,
                 gaussian_filter=a0 < gaussian_filter_iter
                 and gaussian_filter_sigma is not None,
                 gaussian_filter_sigma=gaussian_filter_sigma,
@@ -723,12 +767,13 @@ def reconstruct(
                 and (q_lowpass is not None or q_highpass is not None),
                 q_lowpass=q_lowpass,
                 q_highpass=q_highpass,
+                anti_gridding=anti_gridding,
             )
 
             if store_iterations:
                 self.object_phase_iterations.append(
                     asnumpy(
-                        self._padded_phase_object[
+                        self._padded_object_phase[
                             : self._grid_scan_shape[0], : self._grid_scan_shape[1]
                         ].copy()
                     )
@@ -742,7 +787,7 @@ def reconstruct(
             )
 
         # crop result
-        self._object_phase = self._padded_phase_object[
+        self._object_phase = self._padded_object_phase[
             : self._grid_scan_shape[0], : self._grid_scan_shape[1]
         ]
         self.object_phase = asnumpy(self._object_phase)

From 9045cca4ba9a5f444c568b43cee9ebd1b7e6ed68 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Thu, 8 Jun 2023 20:02:09 -0700
Subject: [PATCH 020/362] fix for anti gridding

---
 py4DSTEM/process/phase/iterative_dpc.py | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index 062bb8d5c..6711a21c6 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -563,18 +563,18 @@ def _object_anti_gridding_contraint(self, current_object):
         """
         xp = self._xp
 
-        #find indices to zero accounting for object padding 
-        width_x = self._grid_scan_shape[0]
-        width_y = self._grid_scan_shape[1]
-        ind_min_x = int(xp.floor(width_x / 2) - 1)
-        ind_max_x = int(xp.ceil(width_x / 2) + 1)
-        ind_min_y = int(xp.floor(width_y / 2) - 1)
-        ind_max_y = int(xp.ceil(width_y / 2) + 1)
+        #find indices to zero 
+        width_x = current_object.shape[0]
+        width_y = current_object.shape[1]
+        ind_min_x = int(xp.floor(width_x / 2) - 2)
+        ind_max_x = int(xp.ceil(width_x / 2) + 2)
+        ind_min_y = int(xp.floor(width_y / 2) - 2)
+        ind_max_y = int(xp.ceil(width_y / 2) + 2)
 
         #zero pixels
         object_fft = xp.fft.fft2(current_object)
-        object_fft[ind_min_x:-ind_max_x] = 0
-        object_fft[:, ind_min_y:-ind_max_y] = 0
+        object_fft[ind_min_x:ind_max_x] = 0
+        object_fft[:, ind_min_y:ind_max_y] = 0
 
         return xp.real(xp.fft.ifft2(object_fft))
 

From af5218c4ee88a4d6125beb4337ebc4515c1c6a46 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Sat, 10 Jun 2023 15:46:18 -0700
Subject: [PATCH 021/362] butterworth order

---
 .../process/phase/iterative_base_class.py     |  2 +-
 py4DSTEM/process/phase/iterative_dpc.py       | 22 +++++++++++----
 .../iterative_multislice_ptychography.py      |  2 ++
 .../iterative_overlap_magnetic_tomography.py  | 28 +++++++++++++++----
 .../phase/iterative_overlap_tomography.py     | 22 +++++++++++----
 5 files changed, 59 insertions(+), 17 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index c2acbee34..78a8b59f9 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -2181,6 +2181,6 @@ def positions(self):
 
     @property
     def _object_cropped(self):
-        """ cropped and rotated object """
+        """cropped and rotated object"""
 
         return self._crop_rotate_object_fov(self._object)
diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index 6711a21c6..f2c1bb20f 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -509,7 +509,9 @@ def _object_gaussian_constraint(self, current_object, gaussian_filter_sigma):
 
         return current_object
 
-    def _object_butterworth_constraint(self, current_object, q_lowpass, q_highpass):
+    def _object_butterworth_constraint(
+        self, current_object, q_lowpass, q_highpass, butterworth_order
+    ):
         """
         Butterworth filter used for low/high-pass filtering.
 
@@ -521,6 +523,8 @@ def _object_butterworth_constraint(self, current_object, q_lowpass, q_highpass):
             Cut-off frequency in A^-1 for low-pass butterworth filter
         q_highpass: float
             Cut-off frequency in A^-1 for high-pass butterworth filter
+        butterworth_order: float
+            Butterworth filter order. Smaller gives a smoother filter
 
         Returns
         --------
@@ -536,9 +540,9 @@ def _object_butterworth_constraint(self, current_object, q_lowpass, q_highpass):
 
         env = xp.ones_like(qra)
         if q_highpass:
-            env *= 1 - 1 / (1 + (qra / q_highpass) ** 4)
+            env *= 1 - 1 / (1 + (qra / q_highpass) ** butterworth_order)
         if q_lowpass:
-            env *= 1 / (1 + (qra / q_lowpass) ** 4)
+            env *= 1 / (1 + (qra / q_lowpass) ** butterworth_order)
 
         current_object_mean = xp.mean(current_object)
         current_object -= current_object_mean
@@ -563,7 +567,7 @@ def _object_anti_gridding_contraint(self, current_object):
         """
         xp = self._xp
 
-        #find indices to zero 
+        # find indices to zero
         width_x = current_object.shape[0]
         width_y = current_object.shape[1]
         ind_min_x = int(xp.floor(width_x / 2) - 2)
@@ -571,7 +575,7 @@ def _object_anti_gridding_contraint(self, current_object):
         ind_min_y = int(xp.floor(width_y / 2) - 2)
         ind_max_y = int(xp.ceil(width_y / 2) + 2)
 
-        #zero pixels
+        # zero pixels
         object_fft = xp.fft.fft2(current_object)
         object_fft[ind_min_x:ind_max_x] = 0
         object_fft[:, ind_min_y:ind_max_y] = 0
@@ -586,6 +590,7 @@ def _constraints(
         butterworth_filter,
         q_lowpass,
         q_highpass,
+        butterworth_order,
         anti_gridding,
     ):
         """
@@ -605,6 +610,8 @@ def _constraints(
             Cut-off frequency in A^-1 for low-pass butterworth filter
         q_highpass: float
             Cut-off frequency in A^-1 for high-pass butterworth filter
+        butterworth_order: float
+            Butterworth filter order. Smaller gives a smoother filter
         anti_gridding: bool
             If true, zero outer pixels of object fft to remove
             gridding artifacts
@@ -624,6 +631,7 @@ def _constraints(
                 current_object,
                 q_lowpass,
                 q_highpass,
+                butterworth_order,
             )
 
         if anti_gridding:
@@ -646,6 +654,7 @@ def reconstruct(
         butterworth_filter_iter: int = np.inf,
         q_lowpass: float = None,
         q_highpass: float = None,
+        butterworth_order: float = 2,
         anti_gridding: float = True,
         store_iterations: bool = False,
     ):
@@ -678,6 +687,8 @@ def reconstruct(
             Cut-off frequency in A^-1 for low-pass butterworth filter
         q_highpass: float
             Cut-off frequency in A^-1 for high-pass butterworth filter
+        butterworth_order: float
+            Butterworth filter order. Smaller gives a smoother filter
         anti_gridding: bool
             If true, zero outer pixels of object fft to remove
             gridding artifacts
@@ -767,6 +778,7 @@ def reconstruct(
                 and (q_lowpass is not None or q_highpass is not None),
                 q_lowpass=q_lowpass,
                 q_highpass=q_highpass,
+                butterworth_order=butterworth_order,
                 anti_gridding=anti_gridding,
             )
 
diff --git a/py4DSTEM/process/phase/iterative_multislice_ptychography.py b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
index a7fe53589..58f7152c4 100644
--- a/py4DSTEM/process/phase/iterative_multislice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
@@ -1331,6 +1331,8 @@ def _object_butterworth_constraint(
             Cut-off frequency in A^-1 for low-pass butterworth filter
         q_highpass: float
             Cut-off frequency in A^-1 for high-pass butterworth filter
+        butterworth_order: float
+            Butterworth filter order. Smaller gives a smoother filter
 
         Returns
         --------
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 9eda852a1..5b06a364d 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -327,9 +327,9 @@ def _euler_angle_rotate_volume(
         """
         Rotate 3D volume using alpha, beta, gamma Euler angles according to convention:
 
-        - \-alpha tilt around first axis (z)
-        - \beta tilt around second axis (x)
-        - \alpha tilt around first axis (z)
+        - \\-alpha tilt around first axis (z)
+        - \\beta tilt around second axis (x)
+        - \\alpha tilt around first axis (z)
 
         Note: since we store array as zxy, the x- and y-axis rotations flip sign below.
 
@@ -1591,7 +1591,9 @@ def _object_gaussian_constraint(self, current_object, gaussian_filter_sigma):
 
         return current_object
 
-    def _object_butterworth_constraint(self, current_object, q_lowpass, q_highpass):
+    def _object_butterworth_constraint(
+        self, current_object, q_lowpass, q_highpass, butterworth_order
+    ):
         """
         Butterworth filter
 
@@ -1603,6 +1605,8 @@ def _object_butterworth_constraint(self, current_object, q_lowpass, q_highpass):
             Cut-off frequency in A^-1 for low-pass butterworth filter
         q_highpass: float
             Cut-off frequency in A^-1 for high-pass butterworth filter
+        butterworth_order: float
+            Butterworth filter order. Smaller gives a smoother filter
 
         Returns
         --------
@@ -1618,9 +1622,9 @@ def _object_butterworth_constraint(self, current_object, q_lowpass, q_highpass):
 
         env = xp.ones_like(qra)
         if q_highpass:
-            env *= 1 - 1 / (1 + (qra / q_highpass) ** 4)
+            env *= 1 - 1 / (1 + (qra / q_highpass) ** butterworth_order)
         if q_lowpass:
-            env *= 1 / (1 + (qra / q_lowpass) ** 4)
+            env *= 1 / (1 + (qra / q_lowpass) ** butterworth_order)
 
         current_object_mean = xp.mean(current_object)
         current_object -= current_object_mean
@@ -1677,6 +1681,7 @@ def _constraints(
         q_lowpass_m,
         q_highpass_e,
         q_highpass_m,
+        butterworth_order,
         object_positivity,
         shrinkage_rad,
         object_mask,
@@ -1732,6 +1737,8 @@ def _constraints(
             Cut-off frequency in A^-1 for high-pass filtering electrostatic object
         q_highpass_m: float
             Cut-off frequency in A^-1 for high-pass filtering magnetic object
+        butterworth_order: float
+            Butterworth filter order. Smaller gives a smoother filter
         object_positivity: bool
             If True, forces object to be positive
         shrinkage_rad: float
@@ -1766,21 +1773,25 @@ def _constraints(
                 current_object[0],
                 q_lowpass_e,
                 q_highpass_e,
+                butterworth_order,
             )
             current_object[1] = self._object_butterworth_constraint(
                 current_object[1],
                 q_lowpass_m,
                 q_highpass_m,
+                butterworth_order,
             )
             current_object[2] = self._object_butterworth_constraint(
                 current_object[2],
                 q_lowpass_m,
                 q_highpass_m,
+                butterworth_order,
             )
             current_object[3] = self._object_butterworth_constraint(
                 current_object[3],
                 q_lowpass_m,
                 q_highpass_m,
+                butterworth_order,
             )
 
         if shrinkage_rad > 0.0 or object_mask is not None:
@@ -1863,6 +1874,7 @@ def reconstruct(
         q_lowpass_m: float = None,
         q_highpass_e: float = None,
         q_highpass_m: float = None,
+        butterworth_order: float = 2,
         object_positivity: bool = True,
         shrinkage_rad: float = 0.0,
         fix_potential_baseline: bool = True,
@@ -1942,6 +1954,8 @@ def reconstruct(
             Cut-off frequency in A^-1 for low-pass butterworth filter
         q_highpass: float
             Cut-off frequency in A^-1 for high-pass butterworth filter
+        butterworth_order: float
+            Butterworth filter order. Smaller gives a smoother filter
         object_positivity: bool, optional
             If True, forces object to be positive
         shrinkage_rad: float
@@ -2408,6 +2422,7 @@ def reconstruct(
                         q_lowpass_m=q_lowpass_m,
                         q_highpass_e=q_highpass_e,
                         q_highpass_m=q_highpass_m,
+                        butterworth_order=butterworth_order,
                         object_positivity=object_positivity,
                         shrinkage_rad=shrinkage_rad,
                         object_mask=self._object_fov_mask_inverse
@@ -2454,6 +2469,7 @@ def reconstruct(
                     q_lowpass_m=q_lowpass_m,
                     q_highpass_e=q_highpass_e,
                     q_highpass_m=q_highpass_m,
+                    butterworth_order=butterworth_order,
                     object_positivity=object_positivity,
                     shrinkage_rad=shrinkage_rad,
                     object_mask=self._object_fov_mask_inverse
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index 3337d02cc..c005081b2 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -1492,13 +1492,15 @@ def _object_gaussian_constraint(self, current_object, gaussian_filter_sigma):
         """
         gaussian_filter = self._gaussian_filter
         xp = self._xp
-        gaussian_filter_sigma /= xp.sqrt(self.sampling[0] ** 2 + self.sampling[1] ** 2)
 
+        gaussian_filter_sigma /= xp.sqrt(self.sampling[0] ** 2 + self.sampling[1] ** 2)
         current_object = gaussian_filter(current_object, gaussian_filter_sigma)
 
         return current_object
 
-    def _object_butterworth_constraint(self, current_object, q_lowpass, q_highpass):
+    def _object_butterworth_constraint(
+        self, current_object, q_lowpass, q_highpass, butterworth_order
+    ):
         """
         Butterworth filter
 
@@ -1510,7 +1512,8 @@ def _object_butterworth_constraint(self, current_object, q_lowpass, q_highpass):
             Cut-off frequency in A^-1 for low-pass butterworth filter
         q_highpass: float
             Cut-off frequency in A^-1 for high-pass butterworth filter
-
+        butterworth_order: float
+            Butterworth filter order. Smaller gives a smoother filter
         Returns
         --------
         constrained_object: np.ndarray
@@ -1525,9 +1528,9 @@ def _object_butterworth_constraint(self, current_object, q_lowpass, q_highpass):
 
         env = xp.ones_like(qra)
         if q_highpass:
-            env *= 1 - 1 / (1 + (qra / q_highpass) ** 4)
+            env *= 1 - 1 / (1 + (qra / q_highpass) ** butterworth_order)
         if q_lowpass:
-            env *= 1 / (1 + (qra / q_lowpass) ** 4)
+            env *= 1 / (1 + (qra / q_lowpass) ** butterworth_order)
 
         current_object_mean = xp.mean(current_object)
         current_object -= current_object_mean
@@ -1557,6 +1560,7 @@ def _constraints(
         butterworth_filter,
         q_lowpass,
         q_highpass,
+        butterworth_order,
         object_positivity,
         shrinkage_rad,
         object_mask,
@@ -1605,6 +1609,8 @@ def _constraints(
             Cut-off frequency in A^-1 for low-pass butterworth filter
         q_highpass: float
             Cut-off frequency in A^-1 for high-pass butterworth filter
+        butterworth_order: float
+            Butterworth filter order. Smaller gives a smoother filter
         object_positivity: bool
             If True, forces object to be positive
         shrinkage_rad: float
@@ -1632,6 +1638,7 @@ def _constraints(
                 current_object,
                 q_lowpass,
                 q_highpass,
+                butterworth_order,
             )
 
         if shrinkage_rad > 0.0 or object_mask is not None:
@@ -1711,6 +1718,7 @@ def reconstruct(
         butterworth_filter_iter: int = np.inf,
         q_lowpass: float = None,
         q_highpass: float = None,
+        butterworth_order: float = 2,
         object_positivity: bool = True,
         shrinkage_rad: float = 0.0,
         fix_potential_baseline: bool = True,
@@ -1788,6 +1796,8 @@ def reconstruct(
             Cut-off frequency in A^-1 for low-pass butterworth filter
         q_highpass: float
             Cut-off frequency in A^-1 for high-pass butterworth filter
+        butterworth_order: float
+            Butterworth filter order. Smaller gives a smoother filter
         object_positivity: bool, optional
             If True, forces object to be positive
         shrinkage_rad: float
@@ -2172,6 +2182,7 @@ def reconstruct(
                         and (q_lowpass is not None or q_highpass is not None),
                         q_lowpass=q_lowpass,
                         q_highpass=q_highpass,
+                        butterworth_order=butterworth_order,
                         object_positivity=object_positivity,
                         shrinkage_rad=shrinkage_rad,
                         object_mask=self._object_fov_mask_inverse
@@ -2213,6 +2224,7 @@ def reconstruct(
                     and (q_lowpass is not None or q_highpass is not None),
                     q_lowpass=q_lowpass,
                     q_highpass=q_highpass,
+                    butterworth_order=butterworth_order,
                     object_positivity=object_positivity,
                     shrinkage_rad=shrinkage_rad,
                     object_mask=self._object_fov_mask_inverse

From 3fc351c735bbddb59a437e86c541eecf237cc755 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Sun, 11 Jun 2023 11:29:28 -0700
Subject: [PATCH 022/362] fixing small butterworth order bug

---
 py4DSTEM/process/phase/iterative_dpc.py                |  4 ++--
 .../phase/iterative_overlap_magnetic_tomography.py     | 10 +++++++---
 py4DSTEM/process/phase/iterative_overlap_tomography.py | 10 +++++++---
 3 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index f2c1bb20f..87741809d 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -540,9 +540,9 @@ def _object_butterworth_constraint(
 
         env = xp.ones_like(qra)
         if q_highpass:
-            env *= 1 - 1 / (1 + (qra / q_highpass) ** butterworth_order)
+            env *= 1 - 1 / (1 + (qra / q_highpass) ** (2 * butterworth_order))
         if q_lowpass:
-            env *= 1 / (1 + (qra / q_lowpass) ** butterworth_order)
+            env *= 1 / (1 + (qra / q_lowpass) ** (2 * butterworth_order))
 
         current_object_mean = xp.mean(current_object)
         current_object -= current_object_mean
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 5b06a364d..60f3a1c3c 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -1622,9 +1622,9 @@ def _object_butterworth_constraint(
 
         env = xp.ones_like(qra)
         if q_highpass:
-            env *= 1 - 1 / (1 + (qra / q_highpass) ** butterworth_order)
+            env *= 1 - 1 / (1 + (qra / q_highpass) ** (2 * butterworth_order))
         if q_lowpass:
-            env *= 1 / (1 + (qra / q_lowpass) ** butterworth_order)
+            env *= 1 / (1 + (qra / q_lowpass) ** (2 * butterworth_order))
 
         current_object_mean = xp.mean(current_object)
         current_object -= current_object_mean
@@ -2439,7 +2439,11 @@ def reconstruct(
             if collective_tilt_updates:
                 self._object += collective_object / self._num_tilts
 
-                (self._object, self._probe, _,) = self._constraints(
+                (
+                    self._object,
+                    self._probe,
+                    _,
+                ) = self._constraints(
                     self._object,
                     self._probe,
                     None,
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index c005081b2..6c773b269 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -1528,9 +1528,9 @@ def _object_butterworth_constraint(
 
         env = xp.ones_like(qra)
         if q_highpass:
-            env *= 1 - 1 / (1 + (qra / q_highpass) ** butterworth_order)
+            env *= 1 - 1 / (1 + (qra / q_highpass) ** (2 * butterworth_order))
         if q_lowpass:
-            env *= 1 / (1 + (qra / q_lowpass) ** butterworth_order)
+            env *= 1 / (1 + (qra / q_lowpass) ** (2 * butterworth_order))
 
         current_object_mean = xp.mean(current_object)
         current_object -= current_object_mean
@@ -2197,7 +2197,11 @@ def reconstruct(
             if collective_tilt_updates:
                 self._object += collective_object / self._num_tilts
 
-                (self._object, self._probe, _,) = self._constraints(
+                (
+                    self._object,
+                    self._probe,
+                    _,
+                ) = self._constraints(
                     self._object,
                     self._probe,
                     None,

From 445cca1018b9e225cd230f8809e26a4f61ad31a9 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Sun, 11 Jun 2023 14:13:09 -0700
Subject: [PATCH 023/362] nesterov acceleration prefactors for reference.
 currently unused - see comment on PR #443

---
 py4DSTEM/process/phase/utils.py | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/py4DSTEM/process/phase/utils.py b/py4DSTEM/process/phase/utils.py
index bb11db7d4..621223b60 100644
--- a/py4DSTEM/process/phase/utils.py
+++ b/py4DSTEM/process/phase/utils.py
@@ -2,6 +2,7 @@
 
 import matplotlib.pyplot as plt
 import numpy as np
+import functools
 
 try:
     import cupy as cp
@@ -1284,3 +1285,16 @@ def project_vector_field_divergence(vector_field, spacings=(1, 1, 1), xp=np):
     p = preconditioned_poisson_solver(div_v, spacings[0], xp=xp)
     grad_p = compute_gradient(p, spacings, xp=xp)
     return vector_field - grad_p
+
+# Nesterov acceleration functions
+# https://blogs.princeton.edu/imabandit/2013/04/01/acceleratedgradientdescent/
+
+@functools.cache
+def nesterov_lambda(one_indexed_iter_num):
+    if one_indexed_iter_num == 0:
+        return 0
+    return (1+np.sqrt(1+4*nesterov_lambda(one_indexed_iter_num-1)**2))/2
+
+def nesterov_gamma(zero_indexed_iter_num):
+    one_indexed_iter_num = zero_indexed_iter_num + 1
+    return (1-nesterov_lambda(one_indexed_iter_num))/nesterov_lambda(one_indexed_iter_num+1)

From 0e9c45786310b9bda85055985bdcb5703a4cb016 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Wed, 14 Jun 2023 08:42:58 -0700
Subject: [PATCH 024/362] step size default update

---
 py4DSTEM/process/phase/iterative_mixedstate_ptychography.py     | 2 +-
 py4DSTEM/process/phase/iterative_multislice_ptychography.py     | 2 +-
 py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py | 2 +-
 py4DSTEM/process/phase/iterative_overlap_tomography.py          | 2 +-
 py4DSTEM/process/phase/iterative_simultaneous_ptychography.py   | 2 +-
 py4DSTEM/process/phase/iterative_singleslice_ptychography.py    | 2 +-
 6 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
index d09b5a339..ff32f5b49 100644
--- a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
@@ -1226,7 +1226,7 @@ def reconstruct(
         reconstruction_parameter: float = 1.0,
         max_batch_size: int = None,
         seed_random: int = None,
-        step_size: float = 0.9,
+        step_size: float = 0.5,
         normalization_min: float = 1,
         positions_step_size: float = 0.9,
         pure_phase_object_iter: int = 0,
diff --git a/py4DSTEM/process/phase/iterative_multislice_ptychography.py b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
index 58f7152c4..c0e73e13b 100644
--- a/py4DSTEM/process/phase/iterative_multislice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
@@ -1623,7 +1623,7 @@ def reconstruct(
         reconstruction_parameter: float = 1.0,
         max_batch_size: int = None,
         seed_random: int = None,
-        step_size: float = 0.9,
+        step_size: float = 0.5,
         normalization_min: float = 1,
         positions_step_size: float = 0.9,
         fix_com: bool = True,
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 60f3a1c3c..a41c83517 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -1849,7 +1849,7 @@ def reconstruct(
         reconstruction_parameter: float = 1.0,
         max_batch_size: int = None,
         seed_random: int = None,
-        step_size: float = 0.9,
+        step_size: float = 0.5,
         normalization_min: float = 1,
         positions_step_size: float = 0.9,
         fix_com: bool = True,
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index 6c773b269..36d32fba7 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -1696,7 +1696,7 @@ def reconstruct(
         reconstruction_parameter: float = 1.0,
         max_batch_size: int = None,
         seed_random: int = None,
-        step_size: float = 0.9,
+        step_size: float = 0.5,
         normalization_min: float = 1,
         positions_step_size: float = 0.9,
         fix_com: bool = True,
diff --git a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
index c655b82a1..c2a6f047f 100644
--- a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
@@ -2398,7 +2398,7 @@ def reconstruct(
         reconstruction_parameter: float = 1.0,
         max_batch_size: int = None,
         seed_random: int = None,
-        step_size: float = 0.9,
+        step_size: float = 0.5,
         normalization_min: float = 1,
         positions_step_size: float = 0.9,
         pure_phase_object_iter: int = 0,
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index 8a83fa5ba..bccc54074 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -1138,7 +1138,7 @@ def reconstruct(
         reconstruction_parameter: float = 1.0,
         max_batch_size: int = None,
         seed_random: int = None,
-        step_size: float = 0.9,
+        step_size: float = 0.5,
         normalization_min: float = 1,
         positions_step_size: float = 0.9,
         pure_phase_object_iter: int = 0,

From 322bf371e8a13e18dbe7e3f5b529b6d7930b7110 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Wed, 14 Jun 2023 09:59:34 -0700
Subject: [PATCH 025/362] changing gaussian sigma normalization

---
 py4DSTEM/process/phase/iterative_dpc.py                     | 2 +-
 .../process/phase/iterative_overlap_magnetic_tomography.py  | 2 +-
 py4DSTEM/process/phase/iterative_overlap_tomography.py      | 2 +-
 .../process/phase/iterative_ptychographic_constraints.py    | 6 ++----
 4 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index 87741809d..583128da5 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -504,7 +504,7 @@ def _object_gaussian_constraint(self, current_object, gaussian_filter_sigma):
         xp = self._xp
         gaussian_filter = self._gaussian_filter
 
-        gaussian_filter_sigma /= xp.sqrt(self.sampling[0] ** 2 + self.sampling[1] ** 2)
+        gaussian_filter_sigma /= self.sampling[0]
         current_object = gaussian_filter(current_object, gaussian_filter_sigma)
 
         return current_object
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index a41c83517..aaede8dfc 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -1586,7 +1586,7 @@ def _object_gaussian_constraint(self, current_object, gaussian_filter_sigma):
         gaussian_filter = self._gaussian_filter
         xp = self._xp
 
-        gaussian_filter_sigma /= xp.sqrt(self.sampling[0] ** 2 + self.sampling[1] ** 2)
+        gaussian_filter_sigma /= self.sampling[0]
         current_object = gaussian_filter(current_object, gaussian_filter_sigma)
 
         return current_object
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index 36d32fba7..ac98738dc 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -1493,7 +1493,7 @@ def _object_gaussian_constraint(self, current_object, gaussian_filter_sigma):
         gaussian_filter = self._gaussian_filter
         xp = self._xp
 
-        gaussian_filter_sigma /= xp.sqrt(self.sampling[0] ** 2 + self.sampling[1] ** 2)
+        gaussian_filter_sigma /= self.sampling[0]
         current_object = gaussian_filter(current_object, gaussian_filter_sigma)
 
         return current_object
diff --git a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
index d0a637204..2abad3d45 100644
--- a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
+++ b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
@@ -120,7 +120,7 @@ def _object_gaussian_constraint(
         """
         xp = self._xp
         gaussian_filter = self._gaussian_filter
-        gaussian_filter_sigma /= xp.sqrt(self.sampling[0] ** 2 + self.sampling[1] ** 2)
+        gaussian_filter_sigma /= self.sampling[0]
 
         if pure_phase_object:
             phase = xp.angle(current_object)
@@ -518,9 +518,7 @@ def _probe_residual_aberration_filtering_constraint(
         xp = self._xp
         gaussian_filter = self._gaussian_filter
         known_aberrations_array = self._known_aberrations_array
-        gaussian_filter_sigma /= xp.sqrt(
-            self._reciprocal_sampling[0] ** 2 + self._reciprocal_sampling[1] ** 2
-        )
+        gaussian_filter_sigma /= self._reciprocal_sampling[0]
 
         fourier_probe = self._return_fourier_probe(current_probe)
         if fix_amplitude:

From f3c9c727ba5d536a5644b35fb97fc4d0ebd88ae7 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Wed, 14 Jun 2023 10:06:49 -0700
Subject: [PATCH 026/362] small device specification cleanup

---
 py4DSTEM/process/phase/iterative_parallax.py                  | 3 ++-
 py4DSTEM/process/phase/iterative_ptychographic_constraints.py | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_parallax.py b/py4DSTEM/process/phase/iterative_parallax.py
index 94f32ad12..5ab4c6cdd 100644
--- a/py4DSTEM/process/phase/iterative_parallax.py
+++ b/py4DSTEM/process/phase/iterative_parallax.py
@@ -79,6 +79,7 @@ def __init__(
         # Metadata
         self._energy = energy
         self._verbose = verbose
+        self._device = device
         self._object_padding_px = object_padding_px
         self._preprocessed = False
 
@@ -725,7 +726,7 @@ def reconstruct(
                     G_ref,
                     G,
                     upsample_factor=upsample_factor,
-                    device="cpu" if xp is np else "gpu",
+                    device=self._device,
                 )
 
                 dx = (
diff --git a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
index 2abad3d45..790edaa69 100644
--- a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
+++ b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
@@ -333,7 +333,7 @@ def _probe_center_of_mass_constraint(self, current_probe):
         probe_intensity = xp.abs(current_probe) ** 2
 
         probe_x0, probe_y0 = get_CoM(
-            probe_intensity, device="cpu" if xp is np else "gpu"
+            probe_intensity, device=self._device
         )
         shifted_probe = fft_shift(
             current_probe, probe_center - xp.array([probe_x0, probe_y0]), xp

From 7790b227969410de816fbfee096c9f83bc19bf84 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Thu, 15 Jun 2023 13:19:12 -0700
Subject: [PATCH 027/362] read_arina start

---
 py4DSTEM/io/filereaders/__init__.py   |  2 +-
 py4DSTEM/io/filereaders/read_arina.py | 65 +++++++++++++++++++++++++++
 2 files changed, 66 insertions(+), 1 deletion(-)
 create mode 100644 py4DSTEM/io/filereaders/read_arina.py

diff --git a/py4DSTEM/io/filereaders/__init__.py b/py4DSTEM/io/filereaders/__init__.py
index d256334a8..44c083856 100644
--- a/py4DSTEM/io/filereaders/__init__.py
+++ b/py4DSTEM/io/filereaders/__init__.py
@@ -2,4 +2,4 @@
 from py4DSTEM.io.filereaders.read_K2 import read_gatan_K2_bin
 from py4DSTEM.io.filereaders.empad import read_empad
 from py4DSTEM.io.filereaders.read_mib import load_mib
-
+from py4DSTEM.io.filereaders.read_arina import read_arina
diff --git a/py4DSTEM/io/filereaders/read_arina.py b/py4DSTEM/io/filereaders/read_arina.py
new file mode 100644
index 000000000..86ed2ee9b
--- /dev/null
+++ b/py4DSTEM/io/filereaders/read_arina.py
@@ -0,0 +1,65 @@
+import h5py
+import numpy as np
+from py4DSTEM.classes import DataCube
+
+def read_arina(filename, scan_width):
+
+    """
+    Args:
+        filename: str or Path Path to the file
+        scan_width: x dimension of scan
+
+    Returns:
+            DataCube
+    """
+    f = h5py.File(filename, "r")
+    nimages = 0
+
+    # Count the number of images in all datasets
+    for dset in f["entry"]["data"]:
+        nimages = nimages + f["entry"]["data"][dset].shape[0]
+        height = f["entry"]["data"][dset].shape[1]
+        width = f["entry"]["data"][dset].shape[2]
+        dtype = f["entry"]["data"][dset].dtype
+
+    assert (
+        nimages % scan_width < 1e-6
+    ), "scan_width must be integer multiple of x*y size"
+
+    if dtype.type is np.uint32:
+        print("Dataset is uint32 but will be converted to uint16")
+        dtype = np.dtype(np.uint16)
+
+    array_3D = np.empty((nimages, width, height), dtype=dtype)
+
+    image_index = 0
+
+    for dset in f["entry"]["data"]:
+        image_index = _processDataSet(
+            f["entry"]["data"][dset], image_index, array_3D, scan_width
+        )
+
+    if f.__bool__():
+        f.close()
+
+    scan_height = int(nimages / scan_width)
+
+    datacube = DataCube(
+        array_3D.reshape(
+            scan_width, scan_height, array_3D.data.shape[1], array_3D.data.shape[2]
+        )
+    )
+
+    return datacube
+
+
+def _processDataSet(dset, start_index, array_3D, scan_width):
+    image_index = start_index
+    nimages_dset = dset.shape[0]
+
+    for i in range(nimages_dset):
+        array_3D[image_index] = dset[i].astype(array_3D.dtype)
+
+        image_index = image_index + 1
+
+    return image_index

From d287e22cc5f3c065cea22828af40276c5c415e8b Mon Sep 17 00:00:00 2001
From: Ben Savitzky <ben.savitzky@gmail.com>
Date: Thu, 15 Jun 2023 18:02:21 -0700
Subject: [PATCH 028/362] add file shortcut to gdrive downloader

---
 py4DSTEM/io/google_drive_downloader.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/py4DSTEM/io/google_drive_downloader.py b/py4DSTEM/io/google_drive_downloader.py
index 00b81d39d..052dbdace 100644
--- a/py4DSTEM/io/google_drive_downloader.py
+++ b/py4DSTEM/io/google_drive_downloader.py
@@ -20,6 +20,7 @@
     'polycrystal_2D_WS2':'1AWB3-UTPiTR9dgrEkNFD7EJYsKnbEy0y',
     'WS2cif':'13zBl6aFExtsz_sew-L0-_ALYJfcgHKjo',
     'polymers':'1lK-TAMXN1MpWG0Q3_4vss_uEZgW2_Xh7',
+    'vac_probe':'1QTcSKzZjHZd1fDimSI_q9_WsAU25NIXe',
 }
 
 # collections of files
@@ -38,6 +39,7 @@
         ('polycrystal_2D_WS2.h5',sample_file_ids['polycrystal_2D_WS2']),
         ('WS2.cif',sample_file_ids['WS2cif']),
         ('polymers.h5',sample_file_ids['polymers']),
+        ('vac_probe.h5',sample_file_ids['vac_probe']),
     ),
 }
 

From c70ccac7f8b5dc83ca60ecd21d453959d09fc547 Mon Sep 17 00:00:00 2001
From: Ben Savitzky <ben.savitzky@gmail.com>
Date: Thu, 15 Jun 2023 20:46:27 -0700
Subject: [PATCH 029/362] fixes binning datatyping bug

---
 py4DSTEM/classes/methods/datacube_methods.py | 18 +++++++--
 py4DSTEM/preprocess/preprocess.py            | 19 ++++++++-
 test/test_classes/test_datacube.py           | 41 ++++++++++++++++++++
 3 files changed, 72 insertions(+), 6 deletions(-)
 create mode 100644 test/test_classes/test_datacube.py

diff --git a/py4DSTEM/classes/methods/datacube_methods.py b/py4DSTEM/classes/methods/datacube_methods.py
index e6ce58632..bf347e5ae 100644
--- a/py4DSTEM/classes/methods/datacube_methods.py
+++ b/py4DSTEM/classes/methods/datacube_methods.py
@@ -108,16 +108,26 @@ def crop_R(
 
     def bin_Q(
         self,
-        N
+        N,
+        dtype = None
         ):
         """
         Bins the data in diffraction space by bin factor N
 
-        Accepts:
-            N (int): the binning factor
+        Parameters
+        ----------
+        N : int
+            The binning factor
+        dtype : a datatype (optional)
+            Specify the datatype for the output. If not passed, the datatype
+            is left unchanged
+
+        Returns
+        ------
+        datacube : DataCube
         """
         from py4DSTEM.preprocess import bin_data_diffraction
-        d = bin_data_diffraction(self,N)
+        d = bin_data_diffraction(self,N,dtype)
         return d
 
     def pad_Q(
diff --git a/py4DSTEM/preprocess/preprocess.py b/py4DSTEM/preprocess/preprocess.py
index de8ff62c1..343c20895 100644
--- a/py4DSTEM/preprocess/preprocess.py
+++ b/py4DSTEM/preprocess/preprocess.py
@@ -208,15 +208,30 @@ def crop_data_real(datacube, crop_Rx_min, crop_Rx_max, crop_Ry_min, crop_Ry_max)
     return datacube
 
 
-def bin_data_diffraction(datacube, bin_factor):
+def bin_data_diffraction(
+    datacube,
+    bin_factor,
+    dtype=None
+    ):
     """
     Performs diffraction space binning of data by bin_factor.
+
+    Parameters
+    ----------
+    N : int
+        The binning factor
+    dtype : a datatype (optional)
+        Specify the datatype for the output. If not passed, the datatype
+        is left unchanged
+
     """
     # validate inputs
     assert(type(bin_factor) is int
         ), f"Error: binning factor {bin_factor} is not an int."
     if bin_factor == 1:
         return datacube
+    if dtype is None:
+        dtype = datacube.data.dtype
 
     # get shape
     R_Nx, R_Ny, Q_Nx, Q_Ny = (
@@ -245,7 +260,7 @@ def bin_data_diffraction(datacube, bin_factor):
         bin_factor,
         int(Q_Ny / bin_factor),
         bin_factor,
-    ).sum(axis=(3, 5))
+    ).sum(axis=(3, 5)).astype(dtype)
 
 
     # set dim vectors
diff --git a/test/test_classes/test_datacube.py b/test/test_classes/test_datacube.py
new file mode 100644
index 000000000..57a225abb
--- /dev/null
+++ b/test/test_classes/test_datacube.py
@@ -0,0 +1,41 @@
+import py4DSTEM
+import numpy as np
+from os.path import join
+
+# set filepath
+path = join(py4DSTEM._TESTPATH, "small_dm3.dm3")
+
+
+
+
+class TestDataCube:
+
+    # setup/teardown
+    def setup_class(cls):
+
+        # Read sim Au datacube
+        datacube = py4DSTEM.import_file(path)
+        datacube = py4DSTEM.DataCube(
+            data=datacube.data.reshape((10,10,512,512))
+        )
+        cls.datacube = datacube
+
+    # tests
+
+    def test_binning_default_dtype(self):
+
+        dtype = self.datacube.data.dtype
+        assert(dtype == np.uint16)
+
+        self.datacube.bin_Q(2)
+
+        assert(self.datacube.data.dtype == dtype)
+
+        new_dtype = np.uint32
+        self.datacube.bin_Q(2, dtype=new_dtype)
+
+        assert(self.datacube.data.dtype == new_dtype)
+        assert(self.datacube.data.dtype != dtype)
+
+        pass
+

From 65ae5272dc8408d75a2ee78d6dace17c1e3a0792 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 16 Jun 2023 09:25:04 -0700
Subject: [PATCH 030/362] handing of single value for com shifts

---
 py4DSTEM/process/phase/iterative_base_class.py | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index 78a8b59f9..6fe24fa0d 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -142,6 +142,12 @@ def _preprocess_datacube_and_vacuum_probe(
         datacube: Datacube
             Resampled and Padded datacube
         """
+        if com_shifts is not None:
+            if np.isscalar(com_shifts[0]):
+                com_shifts = (
+                    np.ones(self._datacube.Rshape) * com_shifts[0],
+                    np.ones(self._datacube.Rshape) * com_shifts[1],
+                )
 
         if diffraction_intensities_shape is not None:
             Qx, Qy = datacube.shape[-2:]

From 40e69e63844a61cea69aa2f5296a220f161d7df2 Mon Sep 17 00:00:00 2001
From: Ben Savitzky <ben.savitzky@gmail.com>
Date: Fri, 16 Jun 2023 10:49:52 -0700
Subject: [PATCH 031/362] bugfix supporting 'root' io syntax

---
 py4DSTEM/io/read.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/py4DSTEM/io/read.py b/py4DSTEM/io/read.py
index 3fe94ca41..e5d227b86 100644
--- a/py4DSTEM/io/read.py
+++ b/py4DSTEM/io/read.py
@@ -71,6 +71,10 @@ def read(
     filetype = _parse_filetype(filepath)
     assert filetype == "H5", f"`py4DSTEM.read` loads native HDF5 formatted files, but a file of type {filetype} was detected.  Try loading it using py4DSTEM.import_file"
 
+    # support older `root` input
+    if datapath is None:
+        if 'root' in kwargs:
+            datapath = kwargs['root']
 
     # EMD 1.0 formatted files (py4DSTEM v0.14+)
     if emd._is_EMD_file(filepath):

From 4db3121f4254fd45eb79a1e2920b4ff6894bc60c Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 16 Jun 2023 11:17:42 -0700
Subject: [PATCH 032/362] bug fixes and including in importfile

---
 py4DSTEM/io/filereaders/read_arina.py | 40 +++++++++++++++++++++------
 py4DSTEM/io/importfile.py             | 15 +++++-----
 2 files changed, 39 insertions(+), 16 deletions(-)

diff --git a/py4DSTEM/io/filereaders/read_arina.py b/py4DSTEM/io/filereaders/read_arina.py
index 86ed2ee9b..b52dc994e 100644
--- a/py4DSTEM/io/filereaders/read_arina.py
+++ b/py4DSTEM/io/filereaders/read_arina.py
@@ -1,17 +1,34 @@
 import h5py
+import hdf5plugin
 import numpy as np
 from py4DSTEM.classes import DataCube
+from py4DSTEM.preprocess.utils import bin2D
 
-def read_arina(filename, scan_width):
+
+def read_arina(
+    filename,
+    scan_width,
+    mem="RAM",
+    binfactor:int=1,
+):
 
     """
+    File reader for arina 4D-STEM datasets
     Args:
-        filename: str or Path Path to the file
+        filename: str with path to master file
         scan_width: x dimension of scan
+        mem (str):  Must be "RAM" or "MEMMAP". Specifies how the data is
+            loaded; "RAM" transfer the data from storage to RAM, while "MEMMAP"
+            leaves the data in storage and creates a memory map which points to
+            the diffraction patterns, allowing them to be retrieved individually
+            from storage.
+        binfactor (int): Diffraction space binning factor for bin-on-load.
 
     Returns:
-            DataCube
+        DataCube
     """
+    assert mem == "RAM", "ARNIA does not support memory mapping"
+
     f = h5py.File(filename, "r")
     nimages = 0
 
@@ -21,7 +38,10 @@ def read_arina(filename, scan_width):
         height = f["entry"]["data"][dset].shape[1]
         width = f["entry"]["data"][dset].shape[2]
         dtype = f["entry"]["data"][dset].dtype
-
+    
+    width = width//binfactor
+    height = height//binfactor
+    
     assert (
         nimages % scan_width < 1e-6
     ), "scan_width must be integer multiple of x*y size"
@@ -36,7 +56,7 @@ def read_arina(filename, scan_width):
 
     for dset in f["entry"]["data"]:
         image_index = _processDataSet(
-            f["entry"]["data"][dset], image_index, array_3D, scan_width
+            f["entry"]["data"][dset], image_index, array_3D, binfactor
         )
 
     if f.__bool__():
@@ -53,13 +73,15 @@ def read_arina(filename, scan_width):
     return datacube
 
 
-def _processDataSet(dset, start_index, array_3D, scan_width):
+def _processDataSet(dset, start_index, array_3D, binfactor):
     image_index = start_index
     nimages_dset = dset.shape[0]
 
     for i in range(nimages_dset):
-        array_3D[image_index] = dset[i].astype(array_3D.dtype)
-
+        if binfactor == 1:
+            array_3D[image_index] = dset[i].astype(array_3D.dtype)
+        else: 
+            array_3D[image_index] = bin2D(dset[i].astype(array_3D.dtype), binfactor)
+        
         image_index = image_index + 1
-
     return image_index
diff --git a/py4DSTEM/io/importfile.py b/py4DSTEM/io/importfile.py
index 17b052601..9048e0f7f 100644
--- a/py4DSTEM/io/importfile.py
+++ b/py4DSTEM/io/importfile.py
@@ -9,12 +9,11 @@
     read_empad,
     read_dm,
     read_gatan_K2_bin,
-    load_mib
+    load_mib,
+    read_arina
 )
 
 
-
-
 def import_file(
     filepath: Union[str, pathlib.Path],
     mem: Optional[str] = "RAM",
@@ -37,6 +36,7 @@ def import_file(
             from storage.
         binfactor (int): Diffraction space binning factor for bin-on-load.
         filetype (str): Used to override automatic filetype detection.
+            options include "dm", "empad", "gatan_K2_bin", "mib","arina"
         **kwargs: any additional kwargs are passed to the downstream reader -
             refer to the individual filetype reader function call signatures
             and docstrings for more details.
@@ -72,7 +72,8 @@ def import_file(
         "dm",
         "empad",
         "gatan_K2_bin",
-        "mib"
+        "mib",
+        "arina",
         # "kitware_counted",
     ], "Error: filetype not recognized"
 
@@ -85,10 +86,10 @@ def import_file(
     # elif filetype == "kitware_counted":
     #    data = read_kitware_counted(filepath, mem, binfactor, metadata=metadata, **kwargs)
     elif filetype == "mib":
-        data = load_mib(filepath, mem=mem, binfactor=binfactor,**kwargs)
+        data = load_mib(filepath, mem=mem, binfactor=binfactor, **kwargs)
+    elif filetype == "arina":
+        data = read_arina(filepath, mem=mem, binfactor=binfactor, **kwargs)
     else:
         raise Exception("Bad filetype!")
 
     return data
-
-

From 5ab9bd703674dfe02b4b37e6679b6674eed64169 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Fri, 16 Jun 2023 15:29:45 -0400
Subject: [PATCH 033/362] dm bin-on-load dtyping bug fix

---
 py4DSTEM/io/filereaders/read_dm.py | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/py4DSTEM/io/filereaders/read_dm.py b/py4DSTEM/io/filereaders/read_dm.py
index 153e6d939..60b8975c9 100644
--- a/py4DSTEM/io/filereaders/read_dm.py
+++ b/py4DSTEM/io/filereaders/read_dm.py
@@ -30,7 +30,7 @@ def read_dm(
             Metadata instance.
         kwargs:
             "dtype": a numpy dtype specifier to use for data binned on load,
-                defaults to np.float32
+                defaults to the data's current dtype
 
     Returns:
        DataCube if a 4D dataset is found, else an ND Array
@@ -96,7 +96,7 @@ def read_dm(
                 elif Q_pixel_units == "1/nm":
                     Q_pixel_units = "A^-1"
                     Q_pixel_size /= 10
-                    
+
                 pixel_size_found = True
             except Exception as err:
                 pass
@@ -108,10 +108,12 @@ def read_dm(
             if binfactor == 1:
                 _data = dmFile.getDataset(dataset_index)["data"]
             else:
+                # get a memory map
+                _mmap = dmFile.getMemmap(dataset_index)
+
                 # get the dtype for the binned data
-                dtype = kwargs.get("dtype", np.float32)
+                dtype = kwargs.get("dtype", _mmap[0,0].dtype)
 
-                _mmap = dmFile.getMemmap(dataset_index)
                 if titan_shape is not None:
                     # NCEM TitanX tags were found
                     _mmap = np.reshape(_mmap, titan_shape + _mmap.shape[-2:])
@@ -120,7 +122,7 @@ def read_dm(
                     _mmap.shape[2] // binfactor,
                     _mmap.shape[3] // binfactor,
                 )
-                _data = np.zeros(new_shape)
+                _data = np.zeros(new_shape, dtype=dtype)
 
                 for rx, ry in tqdmnd(*_data.shape[:2]):
                     _data[rx, ry] = bin2D(_mmap[rx, ry], binfactor, dtype=dtype)

From 8d18c70ea0f2745e013e12ac3d2cad8a68e7b7e2 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 16 Jun 2023 12:55:43 -0700
Subject: [PATCH 034/362] hdf5plugin dependency

---
 setup.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/setup.py b/setup.py
index 06c85ea70..3dc0b9e5a 100644
--- a/setup.py
+++ b/setup.py
@@ -26,6 +26,7 @@
         'numpy >= 1.19',
         'scipy >= 1.5.2',
         'h5py >= 3.2.0',
+        'hdf5plugin >= 4.1.3',
         'ncempy >= 1.8.1',
         'matplotlib >= 3.2.2',
         'scikit-image >= 0.17.2',

From 7641d4d1a6cd892c6521223d15a44ac9f7bd5a42 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Fri, 16 Jun 2023 14:45:14 -0700
Subject: [PATCH 035/362] switching to corner-centered probes

---
 py4DSTEM/process/phase/__init__.py            |  28 +--
 .../process/phase/iterative_base_class.py     | 181 ++++++++----------
 .../iterative_ptychographic_constraints.py    |  36 ++--
 .../iterative_singleslice_ptychography.py     |  88 +++++----
 py4DSTEM/process/phase/utils.py               |  63 +++---
 py4DSTEM/process/utils/utils.py               |  15 +-
 6 files changed, 197 insertions(+), 214 deletions(-)

diff --git a/py4DSTEM/process/phase/__init__.py b/py4DSTEM/process/phase/__init__.py
index c2e141399..207e44b56 100644
--- a/py4DSTEM/process/phase/__init__.py
+++ b/py4DSTEM/process/phase/__init__.py
@@ -1,22 +1,14 @@
+# fmt: off
+
 _emd_hook = True
 
 from py4DSTEM.process.phase.iterative_dpc import DPCReconstruction
-from py4DSTEM.process.phase.iterative_mixedstate_ptychography import (
-    MixedstatePtychographicReconstruction,
-)
-from py4DSTEM.process.phase.iterative_multislice_ptychography import (
-    MultislicePtychographicReconstruction,
-)
-from py4DSTEM.process.phase.iterative_overlap_magnetic_tomography import (
-    OverlapMagneticTomographicReconstruction,
-)
-from py4DSTEM.process.phase.iterative_overlap_tomography import (
-    OverlapTomographicReconstruction,
-)
+from py4DSTEM.process.phase.iterative_mixedstate_ptychography import MixedstatePtychographicReconstruction
+from py4DSTEM.process.phase.iterative_multislice_ptychography import MultislicePtychographicReconstruction
+from py4DSTEM.process.phase.iterative_overlap_magnetic_tomography import OverlapMagneticTomographicReconstruction
+from py4DSTEM.process.phase.iterative_overlap_tomography import OverlapTomographicReconstruction
 from py4DSTEM.process.phase.iterative_parallax import ParallaxReconstruction
-from py4DSTEM.process.phase.iterative_simultaneous_ptychography import (
-    SimultaneousPtychographicReconstruction,
-)
-from py4DSTEM.process.phase.iterative_singleslice_ptychography import (
-    SingleslicePtychographicReconstruction,
-)
+from py4DSTEM.process.phase.iterative_simultaneous_ptychography import SimultaneousPtychographicReconstruction
+from py4DSTEM.process.phase.iterative_singleslice_ptychography import SingleslicePtychographicReconstruction
+
+# fmt: on
diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index 78a8b59f9..171493fc0 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -143,6 +143,13 @@ def _preprocess_datacube_and_vacuum_probe(
             Resampled and Padded datacube
         """
 
+        if com_shifts is not None:
+            if np.isscalar(com_shifts[0]):
+                com_shifts = (
+                    np.ones(self._datacube.Rshape) * com_shifts[0],
+                    np.ones(self._datacube.Rshape) * com_shifts[1],
+                )
+
         if diffraction_intensities_shape is not None:
             Qx, Qy = datacube.shape[-2:]
             Sx, Sy = diffraction_intensities_shape
@@ -527,7 +534,7 @@ def _solve_for_center_of_mass_relative_rotation(
                 warnings.warn(
                     (
                         "Best fit rotation forced to "
-                        f"{str(np.round(force_com_rotation))} degrees."
+                        f"{force_com_rotation:.0f} degrees."
                     ),
                     UserWarning,
                 )
@@ -697,12 +704,7 @@ def _solve_for_center_of_mass_relative_rotation(
                         _rotation_best_rad = rotation_angles_rad[ind_min]
 
                 if self._verbose:
-                    print(
-                        (
-                            "Best fit rotation = "
-                            f"{str(np.round(rotation_best_deg))} degrees."
-                        )
-                    )
+                    print(("Best fit rotation = " f"{rotation_best_deg:.0f} degrees."))
 
                 if plot_rotation:
                     figsize = kwargs.get("figsize", (8, 2))
@@ -857,12 +859,7 @@ def _solve_for_center_of_mass_relative_rotation(
                 self._rotation_angles_deg = rotation_angles_deg
                 # Print summary
                 if self._verbose:
-                    print(
-                        (
-                            "Best fit rotation = "
-                            f"{str(np.round(rotation_best_deg))} degrees."
-                        )
-                    )
+                    print(("Best fit rotation = " f"{rotation_best_deg:.0f} degrees."))
                     if _rotation_best_transpose:
                         print("Diffraction intensities should be transposed.")
                     else:
@@ -1329,11 +1326,6 @@ def _set_polar_parameters(self, parameters: dict):
         ----------
         parameters: dict
             Mapping from aberration symbols to their corresponding values.
-
-        Mutates
-        -------
-        self._polar_parameters: dict
-            Updated polar aberrations dictionary
         """
 
         for symbol, value in parameters.items():
@@ -1359,11 +1351,6 @@ def _calculate_scan_positions_in_pixels(self, positions: np.ndarray):
             Input probe positions in Å.
             If None, a raster scan using experimental parameters is constructed.
 
-        Mutates
-        -------
-        self._object_padding_px: np.ndarray
-            Object array padding in pixels
-
         Returns
         -------
         positions_in_px: (J,2) np.ndarray
@@ -1412,74 +1399,17 @@ def _calculate_scan_positions_in_pixels(self, positions: np.ndarray):
         positions -= np.min(positions, axis=0)
 
         if self._object_padding_px is None:
-            self._object_padding_px = self._region_of_interest_shape / 2
-        positions += self._object_padding_px
+            float_padding = self._region_of_interest_shape / 2
+            self._object_padding_px = (float_padding, float_padding)
+        positions[:, 0] += self._object_padding_px[0][0]
+        positions[:, 1] += self._object_padding_px[1][0]
 
         return positions
 
-    def _wrapped_indices_2D_window(
-        self,
-        center_position: np.ndarray,
-        window_shape: Sequence[int],
-        array_shape: Sequence[int],
-    ):
-        """
-        Computes periodic indices for a window_shape probe centered at center_position,
-        in object of size array_shape.
-
-        Parameters
-        ----------
-        center_position: (2,) np.ndarray
-            The window center positions in pixels
-        window_shape: (2,) Sequence[int]
-            The pixel dimensions of the window
-        array_shape: (2,) Sequence[int]
-            The pixel dimensions of the array the window will be embedded in
-
-        Returns
-        -------
-        window_indices: length-2 tuple of
-            The 2D indices of the window
-        """
-
-        asnumpy = self._asnumpy
-        sx, sy = array_shape
-        nx, ny = window_shape
-
-        cx, cy = np.round(asnumpy(center_position)).astype(int)
-        ox, oy = (cx - nx // 2, cy - ny // 2)
-
-        return np.ix_(np.arange(ox, ox + nx) % sx, np.arange(oy, oy + ny) % sy)
-
-    def _sum_overlapping_patches(self, patches: np.ndarray):
-        """
-        Sum overlapping patches defined into object shaped array
-
-        Parameters
-        ----------
-        patches: (Rx*Ry,Sx,Sy) np.ndarray
-            Patches to sum
-
-        Returns
-        -------
-        out_array: (Px,Py) np.ndarray
-            Summed array
-        """
-        xp = self._xp
-        positions = self._positions_px
-        patch_shape = self._region_of_interest_shape
-        array_shape = self._object_shape
-
-        out_array = xp.zeros(array_shape, patches.dtype)
-        for ind, pos in enumerate(positions):
-            indices = self._wrapped_indices_2D_window(pos, patch_shape, array_shape)
-            out_array[indices] += patches[ind]
-
-        return out_array
-
     def _sum_overlapping_patches_bincounts_base(self, patches: np.ndarray):
         """
         Base bincouts overlapping patches sum function, operating on real-valued arrays.
+        Note this assumes the probe is corner-centered.
 
         Parameters
         ----------
@@ -1496,8 +1426,8 @@ def _sum_overlapping_patches_bincounts_base(self, patches: np.ndarray):
         y0 = xp.round(self._positions_px[:, 1]).astype("int")
 
         roi_shape = self._region_of_interest_shape
-        x_ind = xp.round(xp.arange(roi_shape[0]) - roi_shape[0] / 2).astype("int")
-        y_ind = xp.round(xp.arange(roi_shape[1]) - roi_shape[1] / 2).astype("int")
+        x_ind = xp.fft.fftfreq(roi_shape[0], d=1 / roi_shape[0]).astype("int")
+        y_ind = xp.fft.fftfreq(roi_shape[1], d=1 / roi_shape[1]).astype("int")
 
         flat_weights = patches.ravel()
         indices = (
@@ -1539,6 +1469,7 @@ def _sum_overlapping_patches_bincounts(self, patches: np.ndarray):
     def _extract_vectorized_patch_indices(self):
         """
         Sets the vectorized row/col indices used for the overlap projection
+        Note this assumes the probe is corner-centered.
 
         Returns
         -------
@@ -1552,8 +1483,8 @@ def _extract_vectorized_patch_indices(self):
         y0 = xp.round(self._positions_px[:, 1]).astype("int")
 
         roi_shape = self._region_of_interest_shape
-        x_ind = xp.round(xp.arange(roi_shape[0]) - roi_shape[0] / 2).astype("int")
-        y_ind = xp.round(xp.arange(roi_shape[1]) - roi_shape[1] / 2).astype("int")
+        x_ind = xp.fft.fftfreq(roi_shape[0], d=1 / roi_shape[0]).astype("int")
+        y_ind = xp.fft.fftfreq(roi_shape[1], d=1 / roi_shape[1]).astype("int")
 
         obj_shape = self._object_shape
         vectorized_patch_indices_row = (
@@ -1725,8 +1656,7 @@ def tune_angle_and_defocus(
 
             fig = plt.figure(figsize=figsize)
 
-        progress_bar = kwargs.get("progress_bar", False)
-        kwargs.pop("progress_bar", None)
+        progress_bar = kwargs.pop("progress_bar", False)
         # run loop and plot along the way
         self._verbose = False
         for flat_index, (angle, defocus) in enumerate(
@@ -1994,7 +1924,7 @@ def _return_fourier_probe(
     ):
         """
         Returns complex fourier probe shifted to center of array from
-        complex real space probe in center
+        corner-centered complex real space probe
 
         Parameters
         ----------
@@ -2013,16 +1943,61 @@ def _return_fourier_probe(
         else:
             probe = xp.asarray(probe, dtype=xp.complex64)
 
-        return xp.fft.fftshift(
-            xp.fft.fft2(xp.fft.ifftshift(probe, axes=(-2, -1))), axes=(-2, -1)
-        )
+        return xp.fft.fftshift(xp.fft.fft2(probe), axes=(-2, -1))
+
+    def _return_fourier_probe_from_centered_probe(
+        self,
+        probe=None,
+    ):
+        """
+        Returns complex fourier probe shifted to center of array from
+        centered complex real space probe
+
+        Parameters
+        ----------
+        probe: complex array, optional
+            if None is specified, uses self._probe
+
+        Returns
+        -------
+        fourier_probe: np.ndarray
+            Fourier-transformed and center-shifted probe.
+        """
+        xp = self._xp
+        return self._return_fourier_probe(xp.fft.ifftshift(probe, axes=(-2, -1)))
+
+    def _return_centered_probe(
+        self,
+        probe=None,
+    ):
+        """
+        Returns complex probe centered in middle of the array.
+
+        Parameters
+        ----------
+        probe: complex array, optional
+            if None is specified, uses self._probe
+
+        Returns
+        -------
+        centered_probe: np.ndarray
+            Center-shifted probe.
+        """
+        xp = self._xp
+
+        if probe is None:
+            probe = self._probe
+        else:
+            probe = xp.asarray(probe, dtype=xp.complex64)
+
+        return xp.fft.fftshift(probe, axes=(-2, -1))
 
     def _return_object_fft(
         self,
         obj=None,
     ):
         """
-        Returns obj fft shifted to center of array
+        Returns absolute value of obj fft shifted to center of array
 
         Parameters
         ----------
@@ -2040,7 +2015,7 @@ def _return_object_fft(
             obj = self._object
 
         obj = self._crop_rotate_object_fov(asnumpy(obj))
-        return np.abs(np.fft.fftshift(np.fft.fft2(obj)))
+        return np.abs(np.fft.fftshift(np.fft.fft2(np.fft.ifftshift(obj))))
 
     def show_fourier_probe(
         self,
@@ -2131,13 +2106,21 @@ def show_object_fft(self, obj=None, **kwargs):
     @property
     def probe_fourier(self):
         """Current probe estimate in Fourier space"""
-
         if not hasattr(self, "_probe"):
             return None
 
         asnumpy = self._asnumpy
         return asnumpy(self._return_fourier_probe(self._probe))
 
+    @property
+    def probe_centered(self):
+        """Current probe estimate shifted to the center"""
+        if not hasattr(self, "_probe"):
+            return None
+
+        asnumpy = self._asnumpy
+        return asnumpy(self._return_centered_probe(self._probe))
+
     @property
     def object_fft(self):
         """Fourier transform of current object estimate"""
@@ -2180,7 +2163,7 @@ def positions(self):
         return asnumpy(positions)
 
     @property
-    def _object_cropped(self):
+    def object_cropped(self):
         """cropped and rotated object"""
 
         return self._crop_rotate_object_fov(self._object)
diff --git a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
index 790edaa69..10b24eb78 100644
--- a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
+++ b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
@@ -315,7 +315,7 @@ def _object_denoise_tv_chambolle(
     def _probe_center_of_mass_constraint(self, current_probe):
         """
         Ptychographic center of mass constraint.
-        Used for centering probe intensity.
+        Used for centering corner-centered probe intensity.
 
         Parameters
         --------
@@ -329,15 +329,12 @@ def _probe_center_of_mass_constraint(self, current_probe):
         """
         xp = self._xp
 
-        probe_center = xp.array(self._region_of_interest_shape) / 2
         probe_intensity = xp.abs(current_probe) ** 2
 
         probe_x0, probe_y0 = get_CoM(
-            probe_intensity, device=self._device
-        )
-        shifted_probe = fft_shift(
-            current_probe, probe_center - xp.array([probe_x0, probe_y0]), xp
+            probe_intensity, device=self._device, corner_centered=True
         )
+        shifted_probe = fft_shift(current_probe, -xp.array([probe_x0, probe_y0]), xp)
 
         return shifted_probe
 
@@ -352,13 +349,14 @@ def _probe_radial_symmetrization_constraint_base(
         sx, sy = current_probe.shape
 
         if center is None:
-            center = (sx // 2, sy // 2)
+            center = (0, 0)
 
         if num_bins is None:
             num_bins = np.maximum(sx, sy) * 2 + 1
 
         cx, cy = center
-        X, Y = xp.ogrid[0:sx, 0:sy]
+        X = xp.fft.fftfreq(sx, d=1 / sx)[:, None]
+        Y = xp.fft.fftfreq(sy, d=1 / sy)[None]
         r = xp.hypot(X - cx, Y - cy)
 
         rbin = (num_bins * r / r.max()).astype("int")
@@ -383,7 +381,7 @@ def _probe_radial_symmetrization_constraint(
         xp = self._xp
 
         current_probe_sum = xp.sum(xp.abs(current_probe) ** 2)
-        fourier_probe = self._return_fourier_probe(current_probe)
+        fourier_probe = xp.fft.fft2(current_probe)
 
         fourier_probe_real = fourier_probe.real.copy()
         fourier_probe_imag = fourier_probe.imag.copy()
@@ -396,7 +394,7 @@ def _probe_radial_symmetrization_constraint(
         )
 
         fourier_probe = fourier_probe_real + 1.0j * fourier_probe_imag
-        current_probe = xp.fft.ifftshift(xp.fft.ifft2(xp.fft.fftshift(fourier_probe)))
+        current_probe = xp.fft.ifft2(fourier_probe)
         current_probe *= xp.sqrt(current_probe_sum / np.sum(np.abs(current_probe) ** 2))
 
         return current_probe
@@ -427,13 +425,12 @@ def _probe_amplitude_constraint(
         probe_intensity = xp.abs(current_probe) ** 2
         current_probe_sum = xp.sum(probe_intensity)
 
-        x = xp.linspace(-1 / 2, 1 / 2, current_probe.shape[0])
-        y = xp.linspace(-1 / 2, 1 / 2, current_probe.shape[1])
-        xa, ya = xp.meshgrid(x, y, indexing="ij")
-        ra = xp.sqrt(xa**2 + ya**2) - relative_radius
+        X = xp.fft.fftfreq(current_probe.shape[0])[:, None]
+        Y = xp.fft.fftfreq(current_probe.shape[1])[None]
+        r = xp.hypot(X, Y) - relative_radius
 
         sigma = np.sqrt(np.pi) / relative_width
-        tophat_mask = 0.5 * (1 - erf(sigma * ra / (1 - ra**2)))
+        tophat_mask = 0.5 * (1 - erf(sigma * r / (1 - r**2)))
 
         updated_probe = current_probe * tophat_mask
         updated_probe_sum = xp.sum(xp.abs(updated_probe) ** 2)
@@ -483,7 +480,6 @@ def _probe_fourier_amplitude_constraint(
 
         sigma = np.sqrt(np.pi) / relative_width
         tophat_mask = 0.5 * (1 - erf(sigma * qra / (1 - qra**2)))
-
         updated_probe = xp.fft.ifft2(current_probe_fft * tophat_mask)
         updated_probe_sum = xp.sum(xp.abs(updated_probe) ** 2)
         normalization = xp.sqrt(current_probe_sum / updated_probe_sum)
@@ -520,19 +516,21 @@ def _probe_residual_aberration_filtering_constraint(
         known_aberrations_array = self._known_aberrations_array
         gaussian_filter_sigma /= self._reciprocal_sampling[0]
 
-        fourier_probe = self._return_fourier_probe(current_probe)
+        fourier_probe = xp.fft.fft2(current_probe)
         if fix_amplitude:
             fourier_probe_abs = xp.abs(fourier_probe)
 
         fourier_probe *= xp.conjugate(known_aberrations_array)
-        fourier_probe = gaussian_filter(fourier_probe, gaussian_filter_sigma)
+        fourier_probe = gaussian_filter(
+            fourier_probe, gaussian_filter_sigma, mode="wrap"
+        )
         fourier_probe *= known_aberrations_array
 
         if fix_amplitude:
             fourier_probe_angle = xp.angle(fourier_probe)
             fourier_probe = fourier_probe_abs * xp.exp(1.0j * fourier_probe_angle)
 
-        current_probe = xp.fft.ifftshift(xp.fft.ifft2(xp.fft.fftshift(fourier_probe)))
+        current_probe = xp.fft.ifft2(fourier_probe)
 
         return current_probe
 
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index bccc54074..1cf9e4e44 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -327,16 +327,16 @@ def preprocess(
         self._positions_px = self._calculate_scan_positions_in_pixels(
             self._scan_positions
         )
-
         # Object Initialization
         if self._object is None:
-            pad_x, pad_y = self._object_padding_px
-            p, q = np.max(self._positions_px, axis=0)
+            pad_x = self._object_padding_px[0][1]
+            pad_y = self._object_padding_px[1][1]
+            p, q = np.round(np.max(self._positions_px, axis=0))
             p = np.max([np.round(p + pad_x), self._region_of_interest_shape[0]]).astype(
-                int
+                "int"
             )
             q = np.max([np.round(q + pad_y), self._region_of_interest_shape[1]]).astype(
-                int
+                "int"
             )
             if self._object_type == "potential":
                 self._object = xp.zeros((p, q), dtype=xp.float32)
@@ -379,18 +379,16 @@ def preprocess(
                     self._vacuum_probe_intensity, dtype=xp.float32
                 )
                 probe_x0, probe_y0 = get_CoM(
-                    self._vacuum_probe_intensity, device=self._device
+                    self._vacuum_probe_intensity,
+                    device=self._device,
                 )
-                shift_x = self._region_of_interest_shape[0] // 2 - probe_x0
-                shift_y = self._region_of_interest_shape[1] // 2 - probe_y0
                 self._vacuum_probe_intensity = get_shifted_ar(
                     self._vacuum_probe_intensity,
-                    shift_x,
-                    shift_y,
+                    -probe_x0,
+                    -probe_y0,
                     bilinear=True,
                     device=self._device,
                 )
-
             self._probe = (
                 ComplexProbe(
                     gpts=self._region_of_interest_shape,
@@ -438,8 +436,6 @@ def preprocess(
             device=self._device,
         )._evaluate_ctf()
 
-        self._known_aberrations_array = xp.fft.ifftshift(self._known_aberrations_array)
-
         # overlaps
         shifted_probes = fft_shift(self._probe, self._positions_px_fractional, xp)
         probe_intensities = xp.abs(shifted_probes) ** 2
@@ -462,7 +458,7 @@ def preprocess(
 
             # initial probe
             complex_probe_rgb = Complex2RGB(
-                asnumpy(self._probe),
+                self.probe_centered,
                 vmin=vmin,
                 vmax=vmax,
                 hue_start=hue_start,
@@ -1578,11 +1574,11 @@ def reconstruct(
             self.error_iterations.append(error.item())
             if store_iterations:
                 self.object_iterations.append(asnumpy(self._object.copy()))
-                self.probe_iterations.append(asnumpy(self._probe.copy()))
+                self.probe_iterations.append(self.probe_centered)
 
         # store result
         self.object = asnumpy(self._object)
-        self.probe = asnumpy(self._probe)
+        self.probe = self.probe_centered
         self.error = error.item()
 
         return self
@@ -1696,12 +1692,20 @@ def _visualize_last_iteration(
             0,
         ]
 
-        probe_extent = [
-            0,
-            self.sampling[1] * self._region_of_interest_shape[1],
-            self.sampling[0] * self._region_of_interest_shape[0],
-            0,
-        ]
+        if plot_fourier_probe:
+            probe_extent = [
+                0,
+                self.angular_sampling[1] * self._region_of_interest_shape[1],
+                self.angular_sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
+        elif plot_probe:
+            probe_extent = [
+                0,
+                self.sampling[1] * self._region_of_interest_shape[1],
+                self.sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
 
         if plot_convergence:
             if plot_probe or plot_fourier_probe:
@@ -1767,19 +1771,21 @@ def _visualize_last_iteration(
                     self.probe_fourier, hue_start=hue_start, invert=invert
                 )
                 ax.set_title("Reconstructed Fourier probe")
+                ax.set_ylabel("kx [mrad]")
+                ax.set_xlabel("ky [mrad]")
             else:
                 probe_array = Complex2RGB(
                     self.probe, hue_start=hue_start, invert=invert
                 )
                 ax.set_title("Reconstructed probe")
+                ax.set_ylabel("x [A]")
+                ax.set_xlabel("y [A]")
 
             im = ax.imshow(
                 probe_array,
                 extent=probe_extent,
                 **kwargs,
             )
-            ax.set_ylabel("x [A]")
-            ax.set_xlabel("y [A]")
 
             if cbar:
                 divider = make_axes_locatable(ax)
@@ -1923,12 +1929,20 @@ def _visualize_all_iterations(
             0,
         ]
 
-        probe_extent = [
-            0,
-            self.sampling[1] * self._region_of_interest_shape[1],
-            self.sampling[0] * self._region_of_interest_shape[0],
-            0,
-        ]
+        if plot_fourier_probe:
+            probe_extent = [
+                0,
+                self.angular_sampling[1] * self._region_of_interest_shape[1],
+                self.angular_sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
+        elif plot_probe:
+            probe_extent = [
+                0,
+                self.sampling[1] * self._region_of_interest_shape[1],
+                self.sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
 
         if plot_convergence:
             if plot_probe or plot_fourier_probe:
@@ -1984,16 +1998,25 @@ def _visualize_all_iterations(
             for n, ax in enumerate(grid):
                 if plot_fourier_probe:
                     probe_array = Complex2RGB(
-                        asnumpy(self._return_fourier_probe(probes[grid_range[n]])),
+                        asnumpy(
+                            self._return_fourier_probe_from_centered_probe(
+                                probes[grid_range[n]]
+                            )
+                        ),
                         hue_start=hue_start,
                         invert=invert,
                     )
                     ax.set_title(f"Iter: {grid_range[n]} Fourier probe")
+                    ax.set_ylabel("kx [mrad]")
+                    ax.set_xlabel("ky [mrad]")
+
                 else:
                     probe_array = Complex2RGB(
                         probes[grid_range[n]], hue_start=hue_start, invert=invert
                     )
                     ax.set_title(f"Iter: {grid_range[n]} probe")
+                    ax.set_ylabel("x [A]")
+                    ax.set_xlabel("y [A]")
 
                 im = ax.imshow(
                     probe_array,
@@ -2001,9 +2024,6 @@ def _visualize_all_iterations(
                     **kwargs,
                 )
 
-                ax.set_ylabel("x [A]")
-                ax.set_xlabel("y [A]")
-
                 if cbar:
                     add_colorbar_arg(
                         grid.cbar_axes[n], hue_start=hue_start, invert=invert
diff --git a/py4DSTEM/process/phase/utils.py b/py4DSTEM/process/phase/utils.py
index 621223b60..63377be75 100644
--- a/py4DSTEM/process/phase/utils.py
+++ b/py4DSTEM/process/phase/utils.py
@@ -15,46 +15,26 @@
 from py4DSTEM.process.utils.utils import electron_wavelength_angstrom
 from scipy.ndimage import gaussian_filter
 
+# fmt: off
+
 #: Symbols for the polar representation of all optical aberrations up to the fifth order.
 polar_symbols = (
-    "C10",
-    "C12",
-    "phi12",
-    "C21",
-    "phi21",
-    "C23",
-    "phi23",
-    "C30",
-    "C32",
-    "phi32",
-    "C34",
-    "phi34",
-    "C41",
-    "phi41",
-    "C43",
-    "phi43",
-    "C45",
-    "phi45",
-    "C50",
-    "C52",
-    "phi52",
-    "C54",
-    "phi54",
-    "C56",
-    "phi56",
+        "C10", "C12", "phi12",
+        "C21", "phi21", "C23", "phi23",
+        "C30", "C32", "phi32", "C34", "phi34",
+        "C41", "phi41", "C43", "phi43", "C45", "phi45",
+        "C50", "C52", "phi52", "C54", "phi54", "C56", "phi56",
 )
 
 #: Aliases for the most commonly used optical aberrations.
 polar_aliases = {
-    "defocus": "C10",
-    "astigmatism": "C12",
-    "astigmatism_angle": "phi12",
-    "coma": "C21",
-    "coma_angle": "phi21",
-    "Cs": "C30",
-    "C5": "C50",
+        "defocus": "C10", "astigmatism": "C12", "astigmatism_angle": "phi12",
+        "coma": "C21", "coma_angle": "phi21",
+        "Cs": "C30",
+        "C5": "C50",
 }
 
+# fmt: on
 
 ### Probe functions
 
@@ -81,6 +61,8 @@ class ComplexProbe:
         Device to perform calculations on. Must be either 'cpu' or 'gpu'
     rolloff: float, optional
         Tapers the cutoff edge over the given angular range [mrad].
+    vacuum_probe_intensity: np.ndarray, optional
+        Squared of corner-centered aperture amplitude to use, instead of semiangle_cutoff + rolloff
     focal_spread: float, optional
         The 1/e width of the focal spread due to chromatic aberration and lens current instability [Å].
     angular_spread: float, optional
@@ -180,7 +162,7 @@ def evaluate_aperture(
                 self._vacuum_probe_intensity, dtype=xp.float32
             )
             vacuum_probe_amplitude = xp.sqrt(xp.maximum(vacuum_probe_intensity, 0))
-            return xp.fft.ifftshift(vacuum_probe_amplitude)
+            return vacuum_probe_amplitude
 
         if self._semiangle_cutoff == xp.inf:
             return xp.ones_like(alpha)
@@ -432,9 +414,9 @@ def polar_coordinates(self, x, y):
         return alpha, phi
 
     def build(self):
-        """Builds complex probe in the center of the region of interest."""
+        """Builds corner-centered complex probe in the center of the region of interest."""
         xp = self._xp
-        array = xp.fft.fftshift(xp.fft.ifft2(self._evaluate_ctf()))
+        array = xp.fft.ifft2(self._evaluate_ctf())
         array = array / xp.sqrt((xp.abs(array) ** 2).sum())
         self._array = array
         return self
@@ -448,7 +430,7 @@ def visualize(self, **kwargs):
         kwargs.pop("cmap", None)
 
         plt.imshow(
-            asnumpy(xp.abs(self._array) ** 2),
+            asnumpy(xp.abs(xp.fft.ifftshift(self._array)) ** 2),
             cmap=cmap,
             **kwargs,
         )
@@ -1286,15 +1268,20 @@ def project_vector_field_divergence(vector_field, spacings=(1, 1, 1), xp=np):
     grad_p = compute_gradient(p, spacings, xp=xp)
     return vector_field - grad_p
 
+
 # Nesterov acceleration functions
 # https://blogs.princeton.edu/imabandit/2013/04/01/acceleratedgradientdescent/
 
+
 @functools.cache
 def nesterov_lambda(one_indexed_iter_num):
     if one_indexed_iter_num == 0:
         return 0
-    return (1+np.sqrt(1+4*nesterov_lambda(one_indexed_iter_num-1)**2))/2
+    return (1 + np.sqrt(1 + 4 * nesterov_lambda(one_indexed_iter_num - 1) ** 2)) / 2
+
 
 def nesterov_gamma(zero_indexed_iter_num):
     one_indexed_iter_num = zero_indexed_iter_num + 1
-    return (1-nesterov_lambda(one_indexed_iter_num))/nesterov_lambda(one_indexed_iter_num+1)
+    return (1 - nesterov_lambda(one_indexed_iter_num)) / nesterov_lambda(
+        one_indexed_iter_num + 1
+    )
diff --git a/py4DSTEM/process/utils/utils.py b/py4DSTEM/process/utils/utils.py
index 29badd389..1df4e78c5 100644
--- a/py4DSTEM/process/utils/utils.py
+++ b/py4DSTEM/process/utils/utils.py
@@ -174,21 +174,24 @@ def make_Fourier_coords2D(Nx, Ny, pixelSize=1):
     qy, qx = np.meshgrid(qy, qx)
     return qx, qy
 
-
-def get_CoM(ar, device = "cpu"):
+def get_CoM(ar, device="cpu", corner_centered=False):
     """
     Finds and returns the center of mass of array ar.
+    If corner_centered is True, uses fftfreq for indices.
     """
     if device == "cpu":
         xp = np
-
     elif device == "gpu":
         xp = cp
 
-    ar = xp.asarray(ar)
-
+    ar = xp.asarray(ar) 
     nx, ny = ar.shape
-    ry, rx = xp.meshgrid(xp.arange(ny), xp.arange(nx))
+
+    if corner_centered:
+        ry, rx = xp.meshgrid(xp.fft.fftfreq(ny, 1 / ny), xp.fft.fftfreq(nx, 1 / nx))
+    else:
+        ry, rx = xp.meshgrid(xp.arange(ny), xp.arange(nx))
+    
     tot_intens = xp.sum(ar)
     xCoM = xp.sum(rx * ar) / tot_intens
     yCoM = xp.sum(ry * ar) / tot_intens

From e4f5af0bfa8a5aab9058403083a5f82f05341273 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Fri, 16 Jun 2023 14:46:17 -0700
Subject: [PATCH 036/362] removing merge conflict duplicate lines

---
 py4DSTEM/process/phase/iterative_base_class.py | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index c6a151e5f..b33ea78a9 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -149,13 +149,6 @@ def _preprocess_datacube_and_vacuum_probe(
                     np.ones(self._datacube.Rshape) * com_shifts[1],
                 )
 
-        if com_shifts is not None:
-            if np.isscalar(com_shifts[0]):
-                com_shifts = (
-                    np.ones(self._datacube.Rshape) * com_shifts[0],
-                    np.ones(self._datacube.Rshape) * com_shifts[1],
-                )
-
         if diffraction_intensities_shape is not None:
             Qx, Qy = datacube.shape[-2:]
             Sx, Sy = diffraction_intensities_shape

From dca06e52e3bea640f282ed38290e8e69d69fe038 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Fri, 16 Jun 2023 15:21:29 -0700
Subject: [PATCH 037/362] corner-centered probe multislice

---
 .../iterative_multislice_ptychography.py      | 95 ++++++++++++-------
 1 file changed, 59 insertions(+), 36 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_multislice_ptychography.py b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
index c0e73e13b..ce8d13325 100644
--- a/py4DSTEM/process/phase/iterative_multislice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
@@ -421,13 +421,14 @@ def preprocess(
 
         # Object Initialization
         if self._object is None:
-            pad_x, pad_y = self._object_padding_px
-            p, q = np.max(self._positions_px, axis=0)
+            pad_x = self._object_padding_px[0][1]
+            pad_y = self._object_padding_px[1][1]
+            p, q = np.round(np.max(self._positions_px, axis=0))
             p = np.max([np.round(p + pad_x), self._region_of_interest_shape[0]]).astype(
-                int
+                "int"
             )
             q = np.max([np.round(q + pad_y), self._region_of_interest_shape[1]]).astype(
-                int
+                "int"
             )
             if self._object_type == "potential":
                 self._object = xp.zeros((self._num_slices, p, q), dtype=xp.float32)
@@ -470,14 +471,13 @@ def preprocess(
                     self._vacuum_probe_intensity, dtype=xp.float32
                 )
                 probe_x0, probe_y0 = get_CoM(
-                    self._vacuum_probe_intensity, device=self._device
+                    self._vacuum_probe_intensity,
+                    device=self._device,
                 )
-                shift_x = self._region_of_interest_shape[0] // 2 - probe_x0
-                shift_y = self._region_of_interest_shape[1] // 2 - probe_y0
                 self._vacuum_probe_intensity = get_shifted_ar(
                     self._vacuum_probe_intensity,
-                    shift_x,
-                    shift_y,
+                    -probe_x0,
+                    -probe_y0,
                     bilinear=True,
                     device=self._device,
                 )
@@ -530,8 +530,6 @@ def preprocess(
             device=self._device,
         )._evaluate_ctf()
 
-        self._known_aberrations_array = xp.fft.ifftshift(self._known_aberrations_array)
-
         # Precomputed propagator arrays
         self._propagator_arrays = self._precompute_propagator_arrays(
             self._region_of_interest_shape,
@@ -562,7 +560,7 @@ def preprocess(
 
             # initial probe
             complex_probe_rgb = Complex2RGB(
-                asnumpy(self._probe),
+                self.probe_centered,
                 vmin=vmin,
                 vmax=vmax,
                 hue_start=hue_start,
@@ -577,7 +575,7 @@ def preprocess(
                     propagated_probe, self._propagator_arrays[s]
                 )
             complex_propagated_rgb = Complex2RGB(
-                asnumpy(propagated_probe),
+                asnumpy(self._return_centered_probe(propagated_probe)),
                 vmin=vmin,
                 vmax=vmax,
                 hue_start=hue_start,
@@ -2090,11 +2088,11 @@ def reconstruct(
             self.error_iterations.append(error.item())
             if store_iterations:
                 self.object_iterations.append(asnumpy(self._object.copy()))
-                self.probe_iterations.append(asnumpy(self._probe.copy()))
+                self.probe_iterations.append(self.probe_centered)
 
         # store result
         self.object = asnumpy(self._object)
-        self.probe = asnumpy(self._probe)
+        self.probe = self.probe_centered
         self.error = error.item()
 
         return self
@@ -2215,12 +2213,21 @@ def _visualize_last_iteration(
             0,
         ]
 
-        probe_extent = [
-            0,
-            self.sampling[1] * self._region_of_interest_shape[1],
-            self.sampling[0] * self._region_of_interest_shape[0],
-            0,
-        ]
+        if plot_fourier_probe:
+            probe_extent = [
+                0,
+                self.angular_sampling[1] * self._region_of_interest_shape[1],
+                self.angular_sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
+
+        elif plot_probe:
+            probe_extent = [
+                0,
+                self.sampling[1] * self._region_of_interest_shape[1],
+                self.sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
 
         if plot_convergence:
             if plot_probe or plot_fourier_probe:
@@ -2287,19 +2294,21 @@ def _visualize_last_iteration(
                     self.probe_fourier, hue_start=hue_start, invert=invert
                 )
                 ax.set_title("Reconstructed Fourier probe")
+                ax.set_ylabel("kx [mrad]")
+                ax.set_xlabel("ky [mrad]")
             else:
                 probe_array = Complex2RGB(
                     self.probe, hue_start=hue_start, invert=invert
                 )
                 ax.set_title("Reconstructed probe")
+                ax.set_ylabel("x [A]")
+                ax.set_xlabel("y [A]")
 
             im = ax.imshow(
                 probe_array,
                 extent=probe_extent,
                 **kwargs,
             )
-            ax.set_ylabel("x [A]")
-            ax.set_xlabel("y [A]")
 
             if cbar:
                 divider = make_axes_locatable(ax)
@@ -2445,12 +2454,20 @@ def _visualize_all_iterations(
             0,
         ]
 
-        probe_extent = [
-            0,
-            self.sampling[1] * self._region_of_interest_shape[1],
-            self.sampling[0] * self._region_of_interest_shape[0],
-            0,
-        ]
+        if plot_fourier_probe:
+            probe_extent = [
+                0,
+                self.angular_sampling[1] * self._region_of_interest_shape[1],
+                self.angular_sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
+        elif plot_probe:
+            probe_extent = [
+                0,
+                self.sampling[1] * self._region_of_interest_shape[1],
+                self.sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
 
         if plot_convergence:
             if plot_probe or plot_fourier_probe:
@@ -2505,16 +2522,24 @@ def _visualize_all_iterations(
             for n, ax in enumerate(grid):
                 if plot_fourier_probe:
                     probe_array = Complex2RGB(
-                        asnumpy(self._return_fourier_probe(probes[grid_range[n]])),
+                        asnumpy(
+                            self._return_fourier_probe_from_centered_probe(
+                                probes[grid_range[n]]
+                            )
+                        ),
                         hue_start=hue_start,
                         invert=invert,
                     )
                     ax.set_title(f"Iter: {grid_range[n]} Fourier probe")
+                    ax.set_ylabel("kx [mrad]")
+                    ax.set_xlabel("ky [mrad]")
                 else:
                     probe_array = Complex2RGB(
                         probes[grid_range[n]], hue_start=hue_start, invert=invert
                     )
                     ax.set_title(f"Iter: {grid_range[n]} probe")
+                    ax.set_ylabel("x [A]")
+                    ax.set_xlabel("y [A]")
 
                 im = ax.imshow(
                     probe_array,
@@ -2522,9 +2547,6 @@ def _visualize_all_iterations(
                     **kwargs,
                 )
 
-                ax.set_ylabel("x [A]")
-                ax.set_xlabel("y [A]")
-
                 if cbar:
                     add_colorbar_arg(
                         grid.cbar_axes[n], hue_start=hue_start, invert=invert
@@ -2621,6 +2643,7 @@ def show_transmitted_probe(
         """
 
         xp = self._xp
+        asnumpy = self._asnumpy
 
         transmitted_probe_intensities = xp.sum(
             xp.abs(self._transmitted_probes) ** 2, axis=(-2, -1)
@@ -2633,7 +2656,7 @@ def show_transmitted_probe(
         ]
         mean_transmitted = self._transmitted_probes.mean(0)
         probes = [
-            self._asnumpy(probe)
+            asnumpy(self._return_centered_probe(probe))
             for probe in [
                 mean_transmitted,
                 min_intensity_transmitted,
@@ -2648,7 +2671,7 @@ def show_transmitted_probe(
 
         if plot_fourier_probe:
             bottom_row = [
-                self._asnumpy(self._return_fourier_probe(probe))
+                asnumpy(self._return_fourier_probe(probe))
                 for probe in [
                     mean_transmitted,
                     min_intensity_transmitted,
@@ -2988,4 +3011,4 @@ def _return_object_fft(
             obj = np.angle(obj)
 
         obj = self._crop_rotate_object_fov(np.sum(obj, axis=0))
-        return np.abs(np.fft.fftshift(np.fft.fft2(obj)))
+        return np.abs(np.fft.fftshift(np.fft.fft2(np.fft.ifftshift(obj))))

From 2b203eb3e3230d53509c1056806e2e7e30c0938e Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Fri, 16 Jun 2023 16:22:27 -0700
Subject: [PATCH 038/362] corner-centered probe mixedstate

---
 .../iterative_mixedstate_ptychography.py      | 112 ++++++++++--------
 1 file changed, 64 insertions(+), 48 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
index ff32f5b49..2d595fab1 100644
--- a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
@@ -347,13 +347,14 @@ def preprocess(
 
         # Object Initialization
         if self._object is None:
-            pad_x, pad_y = self._object_padding_px
-            p, q = np.max(self._positions_px, axis=0)
+            pad_x = self._object_padding_px[0][1]
+            pad_y = self._object_padding_px[1][1]
+            p, q = np.round(np.max(self._positions_px, axis=0))
             p = np.max([np.round(p + pad_x), self._region_of_interest_shape[0]]).astype(
-                int
+                "int"
             )
             q = np.max([np.round(q + pad_y), self._region_of_interest_shape[1]]).astype(
-                int
+                "int"
             )
             if self._object_type == "potential":
                 self._object = xp.zeros((p, q), dtype=xp.float32)
@@ -400,12 +401,10 @@ def preprocess(
                         self._vacuum_probe_intensity,
                         device=self._device,
                     )
-                    shift_x = self._region_of_interest_shape[0] // 2 - probe_x0
-                    shift_y = self._region_of_interest_shape[1] // 2 - probe_y0
                     self._vacuum_probe_intensity = get_shifted_ar(
                         self._vacuum_probe_intensity,
-                        shift_x,
-                        shift_y,
+                        -probe_x0,
+                        -probe_y0,
                         bilinear=True,
                         device=self._device,
                     )
@@ -476,8 +475,6 @@ def preprocess(
             device=self._device,
         )._evaluate_ctf()
 
-        self._known_aberrations_array = xp.fft.ifftshift(self._known_aberrations_array)
-
         # overlaps
         shifted_probes = fft_shift(self._probe[0], self._positions_px_fractional, xp)
         probe_intensities = xp.abs(shifted_probes) ** 2
@@ -500,7 +497,7 @@ def preprocess(
 
             # initial probe
             complex_probe_rgb = Complex2RGB(
-                asnumpy(self._probe[0]),
+                self.probe_centered[0],
                 vmin=vmin,
                 vmax=vmax,
                 hue_start=hue_start,
@@ -536,7 +533,7 @@ def preprocess(
             )
             ax1.set_ylabel("x [A]")
             ax1.set_xlabel("y [A]")
-            ax1.set_title("Initial Probe")
+            ax1.set_title("Initial Probe[0]")
 
             ax2.imshow(
                 asnumpy(probe_overlap),
@@ -1021,8 +1018,8 @@ def _adjoint(
 
     def _probe_center_of_mass_constraint(self, current_probe):
         """
-        Ptychographic threshold constraint.
-        Used for avoiding the scaling ambiguity between probe and object.
+        Ptychographic center of mass constraint.
+        Used for centering corner-centered probe intensity.
 
         Parameters
         --------
@@ -1035,15 +1032,12 @@ def _probe_center_of_mass_constraint(self, current_probe):
             Constrained probe estimate
         """
         xp = self._xp
-        asnumpy = self._asnumpy
-
-        probe_center = xp.array(self._region_of_interest_shape) / 2
-        probe_intensity = asnumpy(xp.abs(current_probe[0]) ** 2)
+        probe_intensity = xp.abs(current_probe[0]) ** 2
 
-        probe_x0, probe_y0 = get_CoM(probe_intensity)
-        shifted_probe = fft_shift(
-            current_probe, probe_center - xp.array([probe_x0, probe_y0]), xp
+        probe_x0, probe_y0 = get_CoM(
+            probe_intensity, device=self._device, corner_centered=True
         )
+        shifted_probe = fft_shift(current_probe, -xp.array([probe_x0, probe_y0]), xp)
 
         return shifted_probe
 
@@ -1063,10 +1057,9 @@ def _probe_orthogonalization_constraint(self, current_probe):
             Orthogonalized probe estimate
         """
         xp = self._xp
+        shape = current_probe.shape
 
-        return orthogonalize(current_probe.reshape((self._num_probes, -1)), xp).reshape(
-            current_probe.shape
-        )
+        return orthogonalize(current_probe.reshape((shape[0], -1)), xp).reshape(shape)
 
     def _constraints(
         self,
@@ -1663,11 +1656,11 @@ def reconstruct(
             self.error_iterations.append(error.item())
             if store_iterations:
                 self.object_iterations.append(asnumpy(self._object.copy()))
-                self.probe_iterations.append(asnumpy(self._probe.copy()))
+                self.probe_iterations.append(self.probe_centered)
 
         # store result
         self.object = asnumpy(self._object)
-        self.probe = asnumpy(self._probe)
+        self.probe = self.probe_centered
         self.error = error.item()
 
         return self
@@ -1779,12 +1772,20 @@ def _visualize_last_iteration(
             0,
         ]
 
-        probe_extent = [
-            0,
-            self.sampling[1] * self._region_of_interest_shape[1],
-            self.sampling[0] * self._region_of_interest_shape[0],
-            0,
-        ]
+        if plot_fourier_probe:
+            probe_extent = [
+                0,
+                self.angular_sampling[1] * self._region_of_interest_shape[1],
+                self.angular_sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
+        elif plot_probe:
+            probe_extent = [
+                0,
+                self.sampling[1] * self._region_of_interest_shape[1],
+                self.sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
 
         if plot_convergence:
             if plot_probe or plot_fourier_probe:
@@ -1849,20 +1850,22 @@ def _visualize_last_iteration(
                 probe_array = Complex2RGB(
                     self.probe_fourier[0], hue_start=hue_start, invert=invert
                 )
-                ax.set_title("Reconstructed Fourier probe")
+                ax.set_title("Reconstructed Fourier probe[0]")
+                ax.set_ylabel("kx [mrad]")
+                ax.set_xlabel("ky [mrad]")
             else:
                 probe_array = Complex2RGB(
                     self.probe[0], hue_start=hue_start, invert=invert
                 )
-                ax.set_title("Reconstructed probe")
+                ax.set_title("Reconstructed probe[0]")
+                ax.set_ylabel("x [A]")
+                ax.set_xlabel("y [A]")
 
             im = ax.imshow(
                 probe_array,
                 extent=probe_extent,
                 **kwargs,
             )
-            ax.set_ylabel("x [A]")
-            ax.set_xlabel("y [A]")
 
             if cbar:
                 divider = make_axes_locatable(ax)
@@ -2006,12 +2009,20 @@ def _visualize_all_iterations(
             0,
         ]
 
-        probe_extent = [
-            0,
-            self.sampling[1] * self._region_of_interest_shape[1],
-            self.sampling[0] * self._region_of_interest_shape[0],
-            0,
-        ]
+        if plot_fourier_probe:
+            probe_extent = [
+                0,
+                self.angular_sampling[1] * self._region_of_interest_shape[1],
+                self.angular_sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
+        elif plot_probe:
+            probe_extent = [
+                0,
+                self.sampling[1] * self._region_of_interest_shape[1],
+                self.sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
 
         if plot_convergence:
             if plot_probe or plot_fourier_probe:
@@ -2066,16 +2077,24 @@ def _visualize_all_iterations(
             for n, ax in enumerate(grid):
                 if plot_fourier_probe:
                     probe_array = Complex2RGB(
-                        asnumpy(self._return_fourier_probe(probes[grid_range[n]][0])),
+                        asnumpy(
+                            self._return_fourier_probe_from_centered_probe(
+                                probes[grid_range[n]][0]
+                            )
+                        ),
                         hue_start=hue_start,
                         invert=invert,
                     )
-                    ax.set_title(f"Iter: {grid_range[n]} Fourier probe")
+                    ax.set_title(f"Iter: {grid_range[n]} Fourier probe[0]")
+                    ax.set_ylabel("kx [mrad]")
+                    ax.set_xlabel("ky [mrad]")
                 else:
                     probe_array = Complex2RGB(
                         probes[grid_range[n]][0], hue_start=hue_start, invert=invert
                     )
-                    ax.set_title(f"Iter: {grid_range[n]} probe")
+                    ax.set_title(f"Iter: {grid_range[n]} probe[0]")
+                    ax.set_ylabel("x [A]")
+                    ax.set_xlabel("y [A]")
 
                 im = ax.imshow(
                     probe_array,
@@ -2083,9 +2102,6 @@ def _visualize_all_iterations(
                     **kwargs,
                 )
 
-                ax.set_ylabel("x [A]")
-                ax.set_xlabel("y [A]")
-
                 if cbar:
                     add_colorbar_arg(
                         grid.cbar_axes[n], hue_start=hue_start, invert=invert

From 7e4dd35064e89bf880edc668ec9cf362b1827834 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Fri, 16 Jun 2023 16:41:35 -0700
Subject: [PATCH 039/362] corner-centered probe simultaneous

---
 .../iterative_simultaneous_ptychography.py    | 77 +++++++------------
 1 file changed, 28 insertions(+), 49 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
index c2a6f047f..e872bc42e 100644
--- a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
@@ -593,13 +593,14 @@ def preprocess(
 
         # Object Initialization
         if self._object is None:
-            pad_x, pad_y = self._object_padding_px
-            p, q = np.max(self._positions_px, axis=0)
+            pad_x = self._object_padding_px[0][1]
+            pad_y = self._object_padding_px[1][1]
+            p, q = np.round(np.max(self._positions_px, axis=0))
             p = np.max([np.round(p + pad_x), self._region_of_interest_shape[0]]).astype(
-                int
+                "int"
             )
             q = np.max([np.round(q + pad_y), self._region_of_interest_shape[1]]).astype(
-                int
+                "int"
             )
             if self._object_type == "potential":
                 object_e = xp.zeros((p, q), dtype=xp.float32)
@@ -647,12 +648,10 @@ def preprocess(
                 probe_x0, probe_y0 = get_CoM(
                     self._vacuum_probe_intensity, device=self._device
                 )
-                shift_x = self._region_of_interest_shape[0] // 2 - probe_x0
-                shift_y = self._region_of_interest_shape[1] // 2 - probe_y0
                 self._vacuum_probe_intensity = get_shifted_ar(
                     self._vacuum_probe_intensity,
-                    shift_x,
-                    shift_y,
+                    -probe_x0,
+                    -probe_y0,
                     bilinear=True,
                     device=self._device,
                 )
@@ -704,8 +703,6 @@ def preprocess(
             device=self._device,
         )._evaluate_ctf()
 
-        self._known_aberrations_array = xp.fft.ifftshift(self._known_aberrations_array)
-
         # overlaps
         shifted_probes = fft_shift(self._probe, self._positions_px_fractional, xp)
         probe_intensities = xp.abs(shifted_probes) ** 2
@@ -728,7 +725,7 @@ def preprocess(
 
             # initial probe
             complex_probe_rgb = Complex2RGB(
-                asnumpy(self._probe),
+                self.probe_centered,
                 vmin=vmin,
                 vmax=vmax,
                 hue_start=hue_start,
@@ -2173,34 +2170,6 @@ def _adjoint(
 
         return current_object, current_probe
 
-    def _probe_center_of_mass_constraint(self, current_probe):
-        """
-        Ptychographic threshold constraint.
-        Used for avoiding the scaling ambiguity between probe and object.
-
-        Parameters
-        --------
-        current_probe: np.ndarray
-            Current probe estimate
-
-        Returns
-        --------
-        constrained_probe: np.ndarray
-            Constrained probe estimate
-        """
-        xp = self._xp
-        asnumpy = self._asnumpy
-
-        probe_center = xp.array(self._region_of_interest_shape) / 2
-        probe_intensity = asnumpy(xp.abs(current_probe) ** 2)
-
-        probe_x0, probe_y0 = get_CoM(probe_intensity)
-        shifted_probe = fft_shift(
-            current_probe, probe_center - xp.array([probe_x0, probe_y0]), xp
-        )
-
-        return shifted_probe
-
     def _constraints(
         self,
         current_object,
@@ -2885,14 +2854,14 @@ def reconstruct(
                             asnumpy(self._object[1].copy()),
                         )
                     )
-                self.probe_iterations.append(asnumpy(self._probe.copy()))
+                self.probe_iterations.append(self.probe_centered)
 
         # store result
         if a0 < warmup_iter:
             self.object = (asnumpy(self._object[0]), None)
         else:
             self.object = (asnumpy(self._object[0]), asnumpy(self._object[1]))
-        self.probe = asnumpy(self._probe)
+        self.probe = self.probe_centered
         self.error = error.item()
 
         return self
@@ -3019,12 +2988,20 @@ def _visualize_last_iteration(
             0,
         ]
 
-        probe_extent = [
-            0,
-            self.sampling[1] * self._region_of_interest_shape[1],
-            self.sampling[0] * self._region_of_interest_shape[0],
-            0,
-        ]
+        if plot_fourier_probe:
+            probe_extent = [
+                0,
+                self.angular_sampling[1] * self._region_of_interest_shape[1],
+                self.angular_sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
+        elif plot_probe:
+            probe_extent = [
+                0,
+                self.sampling[1] * self._region_of_interest_shape[1],
+                self.sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
 
         if plot_convergence:
             if plot_probe or plot_fourier_probe:
@@ -3111,19 +3088,21 @@ def _visualize_last_iteration(
                     self.probe_fourier, hue_start=hue_start, invert=invert
                 )
                 ax.set_title("Reconstructed Fourier probe")
+                ax.set_ylabel("kx [mrad]")
+                ax.set_xlabel("ky [mrad]")
             else:
                 probe_array = Complex2RGB(
                     self.probe, hue_start=hue_start, invert=invert
                 )
                 ax.set_title("Reconstructed probe")
+                ax.set_ylabel("x [A]")
+                ax.set_xlabel("y [A]")
 
             im = ax.imshow(
                 probe_array,
                 extent=probe_extent,
                 **kwargs,
             )
-            ax.set_ylabel("x [A]")
-            ax.set_xlabel("y [A]")
 
             if cbar:
                 divider = make_axes_locatable(ax)

From 47f0a41f0f2e7dba45408a16d506e59530ee3b95 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Fri, 16 Jun 2023 17:02:43 -0700
Subject: [PATCH 040/362] corner-centered probe overlap tomography

---
 .../iterative_overlap_magnetic_tomography.py  |  23 ++--
 .../phase/iterative_overlap_tomography.py     | 115 ++++++++----------
 2 files changed, 62 insertions(+), 76 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index aaede8dfc..2a11f87b5 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -602,8 +602,9 @@ def preprocess(
 
         # Object Initialization
         if self._object is None:
-            pad_x, pad_y = self._object_padding_px
-            p, q = np.max(self._positions_px_all, axis=0)
+            pad_x = self._object_padding_px[0][1]
+            pad_y = self._object_padding_px[1][1]
+            p, q = np.round(np.max(self._positions_px_all, axis=0))
             p = np.max([np.round(p + pad_x), self._region_of_interest_shape[0]]).astype(
                 "int"
             )
@@ -654,12 +655,10 @@ def preprocess(
                 probe_x0, probe_y0 = get_CoM(
                     self._vacuum_probe_intensity, device=self._device
                 )
-                shift_x = self._region_of_interest_shape[0] // 2 - probe_x0
-                shift_y = self._region_of_interest_shape[1] // 2 - probe_y0
                 self._vacuum_probe_intensity = get_shifted_ar(
                     self._vacuum_probe_intensity,
-                    shift_x,
-                    shift_y,
+                    -probe_x0,
+                    -probe_y0,
                     bilinear=True,
                     device=self._device,
                 )
@@ -717,8 +716,6 @@ def preprocess(
             device=self._device,
         )._evaluate_ctf()
 
-        self._known_aberrations_array = xp.fft.ifftshift(self._known_aberrations_array)
-
         # Precomputed propagator arrays
         self._slice_thicknesses = np.tile(
             self._object_shape[1] * self.sampling[1] / self._num_slices,
@@ -795,7 +792,7 @@ def preprocess(
 
             # initial probe
             complex_probe_rgb = Complex2RGB(
-                asnumpy(self._probe),
+                self.probe_centered,
                 vmin=vmin,
                 vmax=vmax,
                 hue_start=hue_start,
@@ -810,7 +807,7 @@ def preprocess(
                     propagated_probe, self._propagator_arrays[s]
                 )
             complex_propagated_rgb = Complex2RGB(
-                asnumpy(propagated_probe),
+                asnumpy(self._return_centered_probe(propagated_probe)),
                 vmin=vmin,
                 vmax=vmax,
                 hue_start=hue_start,
@@ -2485,11 +2482,11 @@ def reconstruct(
             self.error_iterations.append(error.item())
             if store_iterations:
                 self.object_iterations.append(asnumpy(self._object.copy()))
-                self.probe_iterations.append(asnumpy(self._probe.copy()))
+                self.probe_iterations.append(self.probe_centered)
 
         # store result
         self.object = asnumpy(self._object)
-        self.probe = asnumpy(self._probe)
+        self.probe = self.probe_centered
         self.error = error.item()
 
         return self
@@ -3030,7 +3027,7 @@ def _return_object_fft(
             rotated_3d_obj.sum(0), angle=None, x_lims=x_lims, y_lims=y_lims
         )
 
-        return np.abs(np.fft.fftshift(np.fft.fft2(rotated_object)))
+        return np.abs(np.fft.fftshift(np.fft.fft2(np.fft.ifftshift(rotated_object))))
 
     def show_object_fft(
         self,
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index ac98738dc..dd5eb2be8 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -254,40 +254,6 @@ def _propagate_array(self, array: np.ndarray, propagator_array: np.ndarray):
 
         return xp.fft.ifft2(xp.fft.fft2(array) * propagator_array)
 
-    def _expand_or_project_sliced_object(self, array: np.ndarray, output_z):
-        """
-        OLD Version
-
-        Expands supersliced object or projects voxel-sliced object.
-
-        Parameters
-        ----------
-        array: np.ndarray
-            3D array to expand/project
-        output_z: int
-            Output_dimension to expand/project array to.
-            If output_z > array.shape[0] array is expanded, else it's projected
-
-        Returns
-        -------
-        expanded_or_projected_array: np.ndarray
-            expanded or projected array
-        """
-        zoom = self._zoom
-        input_z = array.shape[0]
-
-        return (
-            zoom(
-                array,
-                (output_z / input_z, 1, 1),
-                order=0,
-                mode="nearest",
-                grid_mode=True,
-            )
-            * input_z
-            / output_z
-        )
-
     def _project_sliced_object(self, array: np.ndarray, output_z):
         """
         Expands supersliced object or projects voxel-sliced object.
@@ -545,8 +511,9 @@ def preprocess(
 
         # Object Initialization
         if self._object is None:
-            pad_x, pad_y = self._object_padding_px
-            p, q = np.max(self._positions_px_all, axis=0)
+            pad_x = self._object_padding_px[0][1]
+            pad_y = self._object_padding_px[1][1]
+            p, q = np.round(np.max(self._positions_px_all, axis=0))
             p = np.max([np.round(p + pad_x), self._region_of_interest_shape[0]]).astype(
                 "int"
             )
@@ -601,8 +568,8 @@ def preprocess(
                 shift_y = self._region_of_interest_shape[1] // 2 - probe_y0
                 self._vacuum_probe_intensity = get_shifted_ar(
                     self._vacuum_probe_intensity,
-                    shift_x,
-                    shift_y,
+                    -probe_x0,
+                    -probe_y0,
                     bilinear=True,
                     device=self._device,
                 )
@@ -660,8 +627,6 @@ def preprocess(
             device=self._device,
         )._evaluate_ctf()
 
-        self._known_aberrations_array = xp.fft.ifftshift(self._known_aberrations_array)
-
         # Precomputed propagator arrays
         self._slice_thicknesses = np.tile(
             self._object_shape[1] * self.sampling[1] / self._num_slices,
@@ -741,7 +706,7 @@ def preprocess(
 
             # initial probe
             complex_probe_rgb = Complex2RGB(
-                asnumpy(self._probe),
+                self.probe_centered,
                 vmin=vmin,
                 vmax=vmax,
                 hue_start=hue_start,
@@ -756,7 +721,7 @@ def preprocess(
                     propagated_probe, self._propagator_arrays[s]
                 )
             complex_propagated_rgb = Complex2RGB(
-                asnumpy(propagated_probe),
+                asnumpy(self._return_centered_probe(propagated_probe)),
                 vmin=vmin,
                 vmax=vmax,
                 hue_start=hue_start,
@@ -2240,11 +2205,11 @@ def reconstruct(
             self.error_iterations.append(error.item())
             if store_iterations:
                 self.object_iterations.append(asnumpy(self._object.copy()))
-                self.probe_iterations.append(asnumpy(self._probe.copy()))
+                self.probe_iterations.append(self.probe_centered)
 
         # store result
         self.object = asnumpy(self._object)
-        self.probe = asnumpy(self._probe)
+        self.probe = self.probe_centered
         self.error = error.item()
 
         return self
@@ -2440,12 +2405,21 @@ def _visualize_last_iteration(
             0,
         ]
 
-        probe_extent = [
-            0,
-            self.sampling[1] * self._region_of_interest_shape[1],
-            self.sampling[0] * self._region_of_interest_shape[0],
-            0,
-        ]
+        if plot_fourier_probe:
+            probe_extent = [
+                0,
+                self.angular_sampling[1] * self._region_of_interest_shape[1],
+                self.angular_sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
+
+        elif plot_probe:
+            probe_extent = [
+                0,
+                self.sampling[1] * self._region_of_interest_shape[1],
+                self.sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
 
         if plot_convergence:
             if plot_probe or plot_fourier_probe:
@@ -2509,19 +2483,21 @@ def _visualize_last_iteration(
                     self.probe_fourier, hue_start=hue_start, invert=invert
                 )
                 ax.set_title("Reconstructed Fourier probe")
+                ax.set_ylabel("kx [mrad]")
+                ax.set_xlabel("ky [mrad]")
             else:
                 probe_array = Complex2RGB(
                     self.probe, hue_start=hue_start, invert=invert
                 )
                 ax.set_title("Reconstructed probe")
+                ax.set_ylabel("x [A]")
+                ax.set_xlabel("y [A]")
 
             im = ax.imshow(
                 probe_array,
                 extent=probe_extent,
                 **kwargs,
             )
-            ax.set_ylabel("x [A]")
-            ax.set_xlabel("y [A]")
 
             if cbar:
                 divider = make_axes_locatable(ax)
@@ -2686,12 +2662,20 @@ def _visualize_all_iterations(
             0,
         ]
 
-        probe_extent = [
-            0,
-            self.sampling[1] * self._region_of_interest_shape[1],
-            self.sampling[0] * self._region_of_interest_shape[0],
-            0,
-        ]
+        if plot_fourier_probe:
+            probe_extent = [
+                0,
+                self.angular_sampling[1] * self._region_of_interest_shape[1],
+                self.angular_sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
+        elif plot_probe:
+            probe_extent = [
+                0,
+                self.sampling[1] * self._region_of_interest_shape[1],
+                self.sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
 
         if plot_convergence:
             if plot_probe or plot_fourier_probe:
@@ -2745,16 +2729,24 @@ def _visualize_all_iterations(
             for n, ax in enumerate(grid):
                 if plot_fourier_probe:
                     probe_array = Complex2RGB(
-                        asnumpy(self._return_fourier_probe(probes[grid_range[n]])),
+                        asnumpy(
+                            self._return_fourier_probe_from_centered_probe(
+                                probes[grid_range[n]]
+                            )
+                        ),
                         hue_start=hue_start,
                         invert=invert,
                     )
                     ax.set_title(f"Iter: {grid_range[n]} Fourier probe")
+                    ax.set_ylabel("kx [mrad]")
+                    ax.set_xlabel("ky [mrad]")
                 else:
                     probe_array = Complex2RGB(
                         probes[grid_range[n]], hue_start=hue_start, invert=invert
                     )
                     ax.set_title(f"Iter: {grid_range[n]} probe")
+                    ax.set_ylabel("x [A]")
+                    ax.set_xlabel("y [A]")
 
                 im = ax.imshow(
                     probe_array,
@@ -2762,9 +2754,6 @@ def _visualize_all_iterations(
                     **kwargs,
                 )
 
-                ax.set_ylabel("x [A]")
-                ax.set_xlabel("y [A]")
-
                 if cbar:
                     add_colorbar_arg(
                         grid.cbar_axes[n], hue_start=hue_start, invert=invert
@@ -2909,7 +2898,7 @@ def _return_object_fft(
             rotated_3d_obj.sum(0), angle=None, x_lims=x_lims, y_lims=y_lims
         )
 
-        return np.abs(np.fft.fftshift(np.fft.fft2(rotated_object)))
+        return np.abs(np.fft.fftshift(np.fft.fft2(np.fft.ifftshift(rotated_object))))
 
     def show_object_fft(
         self,

From 1ac6d0a2b8e06453ba11afea08db61f2493cb543 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Fri, 16 Jun 2023 17:05:55 -0700
Subject: [PATCH 041/362] some flake8 gotchas

---
 py4DSTEM/process/phase/iterative_base_class.py                 | 1 -
 .../process/phase/iterative_overlap_magnetic_tomography.py     | 1 -
 py4DSTEM/process/phase/iterative_overlap_tomography.py         | 3 ---
 3 files changed, 5 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index b33ea78a9..5a149f14c 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -3,7 +3,6 @@
 """
 
 import warnings
-from typing import Sequence
 
 import matplotlib.pyplot as plt
 import numpy as np
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 2a11f87b5..3c33d46f5 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -1581,7 +1581,6 @@ def _object_gaussian_constraint(self, current_object, gaussian_filter_sigma):
             Constrained object estimate
         """
         gaussian_filter = self._gaussian_filter
-        xp = self._xp
 
         gaussian_filter_sigma /= self.sampling[0]
         current_object = gaussian_filter(current_object, gaussian_filter_sigma)
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index dd5eb2be8..4a64f17af 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -564,8 +564,6 @@ def preprocess(
                 probe_x0, probe_y0 = get_CoM(
                     self._vacuum_probe_intensity, device=self._device
                 )
-                shift_x = self._region_of_interest_shape[0] // 2 - probe_x0
-                shift_y = self._region_of_interest_shape[1] // 2 - probe_y0
                 self._vacuum_probe_intensity = get_shifted_ar(
                     self._vacuum_probe_intensity,
                     -probe_x0,
@@ -1456,7 +1454,6 @@ def _object_gaussian_constraint(self, current_object, gaussian_filter_sigma):
             Constrained object estimate
         """
         gaussian_filter = self._gaussian_filter
-        xp = self._xp
 
         gaussian_filter_sigma /= self.sampling[0]
         current_object = gaussian_filter(current_object, gaussian_filter_sigma)

From 316ba9b8a9596d7beead9cf82fc7b8cb1bc11b91 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Fri, 16 Jun 2023 17:09:41 -0700
Subject: [PATCH 042/362] supporting old padding format

---
 py4DSTEM/process/phase/iterative_base_class.py | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index 5a149f14c..e17b677a1 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -1399,6 +1399,12 @@ def _calculate_scan_positions_in_pixels(self, positions: np.ndarray):
         if self._object_padding_px is None:
             float_padding = self._region_of_interest_shape / 2
             self._object_padding_px = (float_padding, float_padding)
+        elif np.isscalar(self._object_padding_px[0]):
+            self._object_padding_px = (
+                    (self._object_padding_px[0],)*2,
+                    (self._object_padding_px[1],)*2
+                    )
+
         positions[:, 0] += self._object_padding_px[0][0]
         positions[:, 1] += self._object_padding_px[1][0]
 

From d95c706930d7a4b1ba55386eceda3a86b0a47d10 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Fri, 16 Jun 2023 17:23:37 -0700
Subject: [PATCH 043/362] comment out leftover debugging print statement

---
 py4DSTEM/io/legacy/read_legacy_13.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/io/legacy/read_legacy_13.py b/py4DSTEM/io/legacy/read_legacy_13.py
index ebf86d5c3..a325be2d9 100644
--- a/py4DSTEM/io/legacy/read_legacy_13.py
+++ b/py4DSTEM/io/legacy/read_legacy_13.py
@@ -257,7 +257,7 @@ def _get_v13_class(grp):
         'QPoints' : QPoints,
         'BraggVectors' : BraggVectors
     }
-    print(grp)
+    #print(grp)
     if 'py4dstem_class' in grp.attrs:
         classname = grp.attrs['py4dstem_class']
     elif 'emd_group_type' in grp.attrs:

From 5a02566b8622a0d9ba1456b84ee537b2f5febdde Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Fri, 16 Jun 2023 17:25:37 -0700
Subject: [PATCH 044/362] adding show_complex to top-level imports

---
 py4DSTEM/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/__init__.py b/py4DSTEM/__init__.py
index dc4f765ae..3c7803666 100644
--- a/py4DSTEM/__init__.py
+++ b/py4DSTEM/__init__.py
@@ -47,7 +47,7 @@
 
 # functions
 from emdfile import print_h5_tree
-from py4DSTEM.visualize import show
+from py4DSTEM.visualize import show, show_complex
 from py4DSTEM.io import import_file,read,save
 from py4DSTEM.utils.configuration_checker import check_config
 

From 9c3913bf85ab2fccb6ac4cf8d4457ce8dc57022d Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Sat, 17 Jun 2023 08:29:09 -0700
Subject: [PATCH 045/362] updates for file parser and dtype

---
 py4DSTEM/io/filereaders/read_arina.py |  8 ++++++-
 py4DSTEM/io/parsefiletype.py          | 32 ++++++++++++++++++++++++---
 py4DSTEM/io/read.py                   |  6 ++---
 3 files changed, 39 insertions(+), 7 deletions(-)

diff --git a/py4DSTEM/io/filereaders/read_arina.py b/py4DSTEM/io/filereaders/read_arina.py
index b52dc994e..4d0b605fd 100644
--- a/py4DSTEM/io/filereaders/read_arina.py
+++ b/py4DSTEM/io/filereaders/read_arina.py
@@ -10,6 +10,7 @@ def read_arina(
     scan_width,
     mem="RAM",
     binfactor:int=1,
+    dtype_bin:float=None,
 ):
 
     """
@@ -23,6 +24,8 @@ def read_arina(
             the diffraction patterns, allowing them to be retrieved individually
             from storage.
         binfactor (int): Diffraction space binning factor for bin-on-load.
+        dtype_bin(float): specify datatype for bin on load if need something 
+            other than uint16
 
     Returns:
         DataCube
@@ -50,7 +53,10 @@ def read_arina(
         print("Dataset is uint32 but will be converted to uint16")
         dtype = np.dtype(np.uint16)
 
-    array_3D = np.empty((nimages, width, height), dtype=dtype)
+    if dtype_bin:
+        array_3D = np.empty((nimages, width, height), dtype=dtype_bin)
+    else:
+        array_3D = np.empty((nimages, width, height), dtype=dtype)
 
     image_index = 0
 
diff --git a/py4DSTEM/io/parsefiletype.py b/py4DSTEM/io/parsefiletype.py
index 5903ce814..b2889511a 100644
--- a/py4DSTEM/io/parsefiletype.py
+++ b/py4DSTEM/io/parsefiletype.py
@@ -1,9 +1,13 @@
 # File parser utility
 
 from os.path import splitext
+import py4DSTEM.io.legacy as legacy
+import emdfile as emd
+import h5py
 
 def _parse_filetype(fp):
-    """ Accepts a path to a data file, and returns the file type as a string.
+    """ 
+    Accepts a path to a data file, and returns the file type as a string.
     """
     _, fext = splitext(fp)
     fext = fext.lower()
@@ -13,7 +17,16 @@ def _parse_filetype(fp):
         ".py4dstem",
         ".emd",
     ]:
-        return "H5"
+        if emd._is_EMD_file(fp):
+            return "emd"
+
+        elif legacy.is_py4DSTEM_file(fp):
+            return "legacy"
+
+        elif _is_arina(fp):
+            return "arina"
+
+
     elif fext in [
         ".dm",
         ".dm3",
@@ -33,5 +46,18 @@ def _parse_filetype(fp):
     else:
         raise Exception(f"Unrecognized file extension {fext}.")
 
-
+def _is_arina(filepath):
+    """
+    Check if an h5 file is an Arina file.
+    """
+    with h5py.File(filepath,'r') as f:
+        try:
+            assert("entry" in f.keys())
+        except AssertionError:
+            return False
+        try:
+            assert("NX_class" in f["entry"].attrs.keys())
+        except AssertionError:
+            return False
+    return True
 
diff --git a/py4DSTEM/io/read.py b/py4DSTEM/io/read.py
index 3fe94ca41..82815779f 100644
--- a/py4DSTEM/io/read.py
+++ b/py4DSTEM/io/read.py
@@ -69,11 +69,11 @@ def read(
     assert(exists(filepath)), er2
 
     filetype = _parse_filetype(filepath)
-    assert filetype == "H5", f"`py4DSTEM.read` loads native HDF5 formatted files, but a file of type {filetype} was detected.  Try loading it using py4DSTEM.import_file"
+    assert filetype in ('emd', 'legacy'), f"`py4DSTEM.read` loads native HDF5 formatted files, but a file of type {filetype} was detected.  Try loading it using py4DSTEM.import_file"
 
 
     # EMD 1.0 formatted files (py4DSTEM v0.14+)
-    if emd._is_EMD_file(filepath):
+    if filetype == "emd":
         version = emd._get_EMD_version(filepath)
         if verbose: print(f"EMD version {version[0]}.{version[1]}.{version[2]} detected. Reading...")
         assert emd._version_is_geq(version,(1,0,0)), f"EMD version {version} detected. Expected version >= 1.0.0"
@@ -88,7 +88,7 @@ def read(
 
     # legacy py4DSTEM files (v <= 0.13)
     else:
-        assert legacy.is_py4DSTEM_file(filepath), "path points to an H5 file which is neither an EMD 1.0+ file, nor a recognized legacy py4DSTEM file."
+        assert filetype == "legacy", "path points to an H5 file which is neither an EMD 1.0+ file, nor a recognized legacy py4DSTEM file."
 
 
         # read v13

From f846e921439af7429cae035347e06bf626a8c7d9 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Sat, 17 Jun 2023 09:10:07 -0700
Subject: [PATCH 046/362] switched to svd-like orthogonalization (minor
 differences)

---
 .../iterative_mixedstate_ptychography.py      | 22 ++++++++++++++++---
 py4DSTEM/process/phase/utils.py               | 14 ------------
 2 files changed, 19 insertions(+), 17 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
index 2d595fab1..067f2aa8a 100644
--- a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
@@ -24,7 +24,6 @@
     ComplexProbe,
     fft_shift,
     generate_batches,
-    orthogonalize,
     polar_aliases,
     polar_symbols,
 )
@@ -1045,6 +1044,7 @@ def _probe_orthogonalization_constraint(self, current_probe):
         """
         Ptychographic probe-orthogonalization constraint.
         Used to ensure mixed states are orthogonal to each other.
+        Adapted from https://github.com/AdvancedPhotonSource/tike/blob/main/src/tike/ptycho/probe.py#L690
 
         Parameters
         --------
@@ -1057,9 +1057,25 @@ def _probe_orthogonalization_constraint(self, current_probe):
             Orthogonalized probe estimate
         """
         xp = self._xp
-        shape = current_probe.shape
+        n_probes = self._num_probes
 
-        return orthogonalize(current_probe.reshape((shape[0], -1)), xp).reshape(shape)
+        # compute upper half of P* @ P
+        pairwise_dot_product = xp.empty((n_probes, n_probes), dtype=current_probe.dtype)
+
+        for i in range(n_probes):
+            for j in range(i, n_probes):
+                pairwise_dot_product[i, j] = xp.sum(
+                    current_probe[i].conj() * current_probe[j]
+                )
+
+        # compute eigenvectors (effectively cheaper way of computing V* from SVD)
+        _, evecs = xp.linalg.eigh(pairwise_dot_product, UPLO="U")
+        current_probe = xp.tensordot(evecs.T, current_probe, axes=1)
+
+        # sort by real-space intensity
+        intensities = xp.sum(xp.abs(current_probe) ** 2, axis=(-2, -1))
+        intensities_order = xp.argsort(intensities, axis=None)[::-1]
+        return current_probe[intensities_order]
 
     def _constraints(
         self,
diff --git a/py4DSTEM/process/phase/utils.py b/py4DSTEM/process/phase/utils.py
index 63377be75..c52076582 100644
--- a/py4DSTEM/process/phase/utils.py
+++ b/py4DSTEM/process/phase/utils.py
@@ -458,20 +458,6 @@ def spatial_frequencies(gpts: Tuple[int, int], sampling: Tuple[float, float]):
     )
 
 
-def projection(u: np.ndarray, v: np.ndarray, xp):
-    """Projection of vector u onto vector v."""
-    return u * xp.vdot(u, v) / xp.vdot(u, u)
-
-
-def orthogonalize(V: np.ndarray, xp):
-    """Non-normalized QR decomposition using repeated projections."""
-    U = V.copy()
-    for i in range(1, V.shape[0]):
-        for j in range(i):
-            U[i, :] -= projection(U[j, :], V[i, :], xp)
-    return U
-
-
 ### FFT-shift functions
 
 

From d7dbbafcf06044aa392dfbba4b289b834109b0d8 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Sat, 17 Jun 2023 09:10:41 -0700
Subject: [PATCH 047/362] fixed mixed-state probe initialization bug, expanded
 preprocess viz to help debug

---
 .../iterative_mixedstate_ptychography.py      | 59 +++++++++----------
 1 file changed, 27 insertions(+), 32 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
index 067f2aa8a..4b2187a15 100644
--- a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
@@ -442,16 +442,10 @@ def preprocess(
             # Randomly shift phase of other probes
             for i_probe in range(1, self._num_probes):
                 shift_x = xp.exp(
-                    -2j
-                    * np.pi
-                    * (xp.random.rand() - 0.5)
-                    * ((xp.arange(sx) + 0.5) / sx - 0.5)
+                    -2j * np.pi * (xp.random.rand() - 0.5) * xp.fft.fftfreq(sx)
                 )
                 shift_y = xp.exp(
-                    -2j
-                    * np.pi
-                    * (xp.random.rand() - 0.5)
-                    * ((xp.arange(sy) + 0.5) / sy - 0.5)
+                    -2j * np.pi * (xp.random.rand() - 0.5) * xp.fft.fftfreq(sy)
                 )
                 self._probe[i_probe] = (
                     self._probe[i_probe - 1] * shift_x[:, None] * shift_y[None]
@@ -487,7 +481,7 @@ def preprocess(
         self._object_fov_mask_inverse = np.invert(self._object_fov_mask)
 
         if plot_probe_overlaps:
-            figsize = kwargs.pop("figsize", (9, 4))
+            figsize = kwargs.pop("figsize", (4.5 * self._num_probes + 4, 4))
             cmap = kwargs.pop("cmap", "Greys_r")
             vmin = kwargs.pop("vmin", None)
             vmax = kwargs.pop("vmax", None)
@@ -496,7 +490,7 @@ def preprocess(
 
             # initial probe
             complex_probe_rgb = Complex2RGB(
-                self.probe_centered[0],
+                self.probe_centered,
                 vmin=vmin,
                 vmax=vmax,
                 hue_start=hue_start,
@@ -517,40 +511,41 @@ def preprocess(
                 0,
             ]
 
-            fig, (ax1, ax2) = plt.subplots(1, 2, figsize=figsize)
+            fig, axs = plt.subplots(1, self._num_probes + 1, figsize=figsize)
 
-            ax1.imshow(
-                complex_probe_rgb,
-                extent=probe_extent,
-                **kwargs,
-            )
-
-            divider = make_axes_locatable(ax1)
-            cax1 = divider.append_axes("right", size="5%", pad="2.5%")
-            add_colorbar_arg(
-                cax1, vmin=vmin, vmax=vmax, hue_start=hue_start, invert=invert
-            )
-            ax1.set_ylabel("x [A]")
-            ax1.set_xlabel("y [A]")
-            ax1.set_title("Initial Probe[0]")
+            for i in range(self._num_probes):
+                axs[i].imshow(
+                    complex_probe_rgb[i],
+                    extent=probe_extent,
+                    **kwargs,
+                )
+                axs[i].set_ylabel("x [A]")
+                axs[i].set_xlabel("y [A]")
+                axs[i].set_title(f"Initial Probe[{i}]")
+
+                divider = make_axes_locatable(axs[i])
+                cax = divider.append_axes("right", size="5%", pad="2.5%")
+                add_colorbar_arg(
+                    cax, vmin=vmin, vmax=vmax, hue_start=hue_start, invert=invert
+                )
 
-            ax2.imshow(
+            axs[-1].imshow(
                 asnumpy(probe_overlap),
                 extent=extent,
                 cmap=cmap,
                 **kwargs,
             )
-            ax2.scatter(
+            axs[-1].scatter(
                 self.positions[:, 1],
                 self.positions[:, 0],
                 s=2.5,
                 color=(1, 0, 0, 1),
             )
-            ax2.set_ylabel("x [A]")
-            ax2.set_xlabel("y [A]")
-            ax2.set_xlim((extent[0], extent[1]))
-            ax2.set_ylim((extent[2], extent[3]))
-            ax2.set_title("Object Field of View")
+            axs[-1].set_ylabel("x [A]")
+            axs[-1].set_xlabel("y [A]")
+            axs[-1].set_xlim((extent[0], extent[1]))
+            axs[-1].set_ylim((extent[2], extent[3]))
+            axs[-1].set_title("Object Field of View")
 
             fig.tight_layout()
 

From b4a93d315141c2a175dcc2a114ebd590ab114151 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Sat, 17 Jun 2023 09:20:35 -0700
Subject: [PATCH 048/362] read abTEM

---
 py4DSTEM/io/filereaders/__init__.py   |  1 +
 py4DSTEM/io/filereaders/read_abTEM.py | 59 +++++++++++++++++++++++++++
 py4DSTEM/io/filereaders/read_arina.py | 20 ++++-----
 py4DSTEM/io/importfile.py             |  8 +++-
 py4DSTEM/io/parsefiletype.py          | 16 +++++++-
 5 files changed, 91 insertions(+), 13 deletions(-)
 create mode 100644 py4DSTEM/io/filereaders/read_abTEM.py

diff --git a/py4DSTEM/io/filereaders/__init__.py b/py4DSTEM/io/filereaders/__init__.py
index 44c083856..b6f4eb0a2 100644
--- a/py4DSTEM/io/filereaders/__init__.py
+++ b/py4DSTEM/io/filereaders/__init__.py
@@ -3,3 +3,4 @@
 from py4DSTEM.io.filereaders.empad import read_empad
 from py4DSTEM.io.filereaders.read_mib import load_mib
 from py4DSTEM.io.filereaders.read_arina import read_arina
+from py4DSTEM.io.filereaders.read_abTEM import read_abTEM
diff --git a/py4DSTEM/io/filereaders/read_abTEM.py b/py4DSTEM/io/filereaders/read_abTEM.py
new file mode 100644
index 000000000..3e60f5fee
--- /dev/null
+++ b/py4DSTEM/io/filereaders/read_abTEM.py
@@ -0,0 +1,59 @@
+import h5py
+from py4DSTEM.classes import DataCube
+
+
+def read_abTEM(
+    filename,
+    mem="RAM",
+    binfactor: int = 1,
+):
+    """
+    File reader for abTEM 4D-STEM datasets
+    Args:
+        filename: str with path to master file
+        scan_width: x dimension of scan
+        mem (str):  Must be "RAM" or "MEMMAP". Specifies how the data is
+            loaded; "RAM" transfer the data from storage to RAM, while "MEMMAP"
+            leaves the data in storage and creates a memory map which points to
+            the diffraction patterns, allowing them to be retrieved individually
+            from storage.
+        binfactor (int): Diffraction space binning factor for bin-on-load.
+
+    Returns:
+        DataCube
+    """
+    assert mem == "RAM", "read_abTEM does not support memory mapping"
+    assert binfactor == 1, "abTEM files can only be read at full resolution"
+
+    with h5py.File(filename, "r") as f:
+        datasets = {}
+        for key in f.keys():
+            datasets[key] = f.get(key)[()]
+
+    data = datasets["array"]
+    assert len(data.shape) == 4, "reader is for 4D-STEM datasets only"
+
+    datacube = DataCube(data=data)
+
+    sampling = datasets["sampling"]
+    units = datasets["units"]
+
+    datacube.calibration.set_R_pixel_size(sampling[0])
+    if sampling[0] != sampling[1]:
+        print(
+            "Warning: py4DSTEM currently only handles uniform x,y sampling. Setting sampling with x calibration"
+        )
+    datacube.calibration.set_Q_pixel_size(sampling[2])
+    if sampling[2] != sampling[3]:
+        print(
+            "Warning: py4DSTEM currently only handles uniform qx,qy sampling. Setting sampling with qx calibration"
+        )
+
+    if units[0] == b"\xc3\x85":
+        datacube.calibration.set_R_pixel_units("A")
+    else:
+        datacube.calibration.set_R_pixel_units(units[0].decode("utf-8"))
+
+    datacube.calibration.set_Q_pixel_units(units[2].decode("utf-8"))
+
+    return datacube
diff --git a/py4DSTEM/io/filereaders/read_arina.py b/py4DSTEM/io/filereaders/read_arina.py
index 4d0b605fd..0f334f52b 100644
--- a/py4DSTEM/io/filereaders/read_arina.py
+++ b/py4DSTEM/io/filereaders/read_arina.py
@@ -9,8 +9,8 @@ def read_arina(
     filename,
     scan_width,
     mem="RAM",
-    binfactor:int=1,
-    dtype_bin:float=None,
+    binfactor: int = 1,
+    dtype_bin: float = None,
 ):
 
     """
@@ -24,13 +24,13 @@ def read_arina(
             the diffraction patterns, allowing them to be retrieved individually
             from storage.
         binfactor (int): Diffraction space binning factor for bin-on-load.
-        dtype_bin(float): specify datatype for bin on load if need something 
+        dtype_bin(float): specify datatype for bin on load if need something
             other than uint16
 
     Returns:
         DataCube
     """
-    assert mem == "RAM", "ARNIA does not support memory mapping"
+    assert mem == "RAM", "read_arina does not support memory mapping"
 
     f = h5py.File(filename, "r")
     nimages = 0
@@ -41,10 +41,10 @@ def read_arina(
         height = f["entry"]["data"][dset].shape[1]
         width = f["entry"]["data"][dset].shape[2]
         dtype = f["entry"]["data"][dset].dtype
-    
-    width = width//binfactor
-    height = height//binfactor
-    
+
+    width = width // binfactor
+    height = height // binfactor
+
     assert (
         nimages % scan_width < 1e-6
     ), "scan_width must be integer multiple of x*y size"
@@ -86,8 +86,8 @@ def _processDataSet(dset, start_index, array_3D, binfactor):
     for i in range(nimages_dset):
         if binfactor == 1:
             array_3D[image_index] = dset[i].astype(array_3D.dtype)
-        else: 
+        else:
             array_3D[image_index] = bin2D(dset[i].astype(array_3D.dtype), binfactor)
-        
+
         image_index = image_index + 1
     return image_index
diff --git a/py4DSTEM/io/importfile.py b/py4DSTEM/io/importfile.py
index 9048e0f7f..9c3287642 100644
--- a/py4DSTEM/io/importfile.py
+++ b/py4DSTEM/io/importfile.py
@@ -10,7 +10,8 @@
     read_dm,
     read_gatan_K2_bin,
     load_mib,
-    read_arina
+    read_arina,
+    read_abTEM
 )
 
 
@@ -36,7 +37,7 @@ def import_file(
             from storage.
         binfactor (int): Diffraction space binning factor for bin-on-load.
         filetype (str): Used to override automatic filetype detection.
-            options include "dm", "empad", "gatan_K2_bin", "mib","arina"
+            options include "dm", "empad", "gatan_K2_bin", "mib", "arina", "abTEM"
         **kwargs: any additional kwargs are passed to the downstream reader -
             refer to the individual filetype reader function call signatures
             and docstrings for more details.
@@ -74,6 +75,7 @@ def import_file(
         "gatan_K2_bin",
         "mib",
         "arina",
+        "abTEM"
         # "kitware_counted",
     ], "Error: filetype not recognized"
 
@@ -89,6 +91,8 @@ def import_file(
         data = load_mib(filepath, mem=mem, binfactor=binfactor, **kwargs)
     elif filetype == "arina":
         data = read_arina(filepath, mem=mem, binfactor=binfactor, **kwargs)
+    elif filetype == "abTEM":
+        data = read_abTEM(filepath, mem=mem, binfactor=binfactor, **kwargs)
     else:
         raise Exception("Bad filetype!")
 
diff --git a/py4DSTEM/io/parsefiletype.py b/py4DSTEM/io/parsefiletype.py
index b2889511a..ab7529ec6 100644
--- a/py4DSTEM/io/parsefiletype.py
+++ b/py4DSTEM/io/parsefiletype.py
@@ -26,7 +26,9 @@ def _parse_filetype(fp):
         elif _is_arina(fp):
             return "arina"
 
-
+        elif _is_abTEM(fp):
+            return "abTEM"
+            
     elif fext in [
         ".dm",
         ".dm3",
@@ -61,3 +63,15 @@ def _is_arina(filepath):
             return False
     return True
 
+def _is_abTEM(filepath):
+    """
+    Check if an h5 file is an abTEM file. 
+    """
+    with h5py.File(filepath,'r') as f:
+        try:
+            assert("array" in f.keys())
+        except AssertionError:
+            return False
+    return True
+
+

From b81e74f903dcd18d9d6a0b0c0e250b68816ac4bd Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Sat, 17 Jun 2023 09:45:46 -0700
Subject: [PATCH 049/362] fix warning statement and doc strings

---
 py4DSTEM/io/filereaders/read_abTEM.py | 3 +--
 py4DSTEM/io/importfile.py             | 4 ++--
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/py4DSTEM/io/filereaders/read_abTEM.py b/py4DSTEM/io/filereaders/read_abTEM.py
index 3e60f5fee..1008bcc0e 100644
--- a/py4DSTEM/io/filereaders/read_abTEM.py
+++ b/py4DSTEM/io/filereaders/read_abTEM.py
@@ -10,8 +10,7 @@ def read_abTEM(
     """
     File reader for abTEM 4D-STEM datasets
     Args:
-        filename: str with path to master file
-        scan_width: x dimension of scan
+        filename: str with path to  file
         mem (str):  Must be "RAM" or "MEMMAP". Specifies how the data is
             loaded; "RAM" transfer the data from storage to RAM, while "MEMMAP"
             leaves the data in storage and creates a memory map which points to
diff --git a/py4DSTEM/io/importfile.py b/py4DSTEM/io/importfile.py
index 9c3287642..98ef05238 100644
--- a/py4DSTEM/io/importfile.py
+++ b/py4DSTEM/io/importfile.py
@@ -67,8 +67,8 @@ def import_file(
 
     filetype = _parse_filetype(filepath) if filetype is None else filetype
 
-    if filetype == 'EMD':
-        raise Exception("EMD file detected - use py4DSTEM.read, not py4DSTEM.import_file!")
+    if filetype in ('emd', 'legacy'):
+        raise Exception("EMD file or py4DSTEM detected - use py4DSTEM.read, not py4DSTEM.import_file!")
     assert filetype in [
         "dm",
         "empad",

From 5565d957cba2f698d8f5d3e29eb86224c69ff953 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Sat, 17 Jun 2023 10:16:28 -0700
Subject: [PATCH 050/362] fixed read-write of corner-centered probes

---
 .../process/phase/iterative_base_class.py     | 50 ++++++++-----------
 1 file changed, 21 insertions(+), 29 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index e17b677a1..34f1a221f 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -1166,6 +1166,15 @@ def to_h5(self, group):
             data=self._polar_parameters,
         )
 
+        # object
+        self._object_emd = Array(
+            name="reconstruction_object",
+            data=asnumpy(self._xp.asarray(self._object)),
+        )
+
+        # probe
+        self._probe_emd = Array(name="reconstruction_probe", data=asnumpy(self._probe))
+
         if is_stack:
             iterations_labels = [f"iteration_{i:03}" for i in iterations]
 
@@ -1173,32 +1182,20 @@ def to_h5(self, group):
             object_iterations = [
                 np.asarray(self.object_iterations[i]) for i in iterations
             ]
-            self._object_emd = Array(
-                name="reconstruction_object",
+            self._object_iterations_emd = Array(
+                name="reconstruction_object_iterations",
                 data=np.stack(object_iterations, axis=0),
                 slicelabels=iterations_labels,
             )
 
             # probe
             probe_iterations = [self.probe_iterations[i] for i in iterations]
-            self._probe_emd = Array(
-                name="reconstruction_probe",
+            self._probe_iterations_emd = Array(
+                name="reconstruction_probe_iterations",
                 data=np.stack(probe_iterations, axis=0),
                 slicelabels=iterations_labels,
             )
 
-        else:
-            # object
-            self._object_emd = Array(
-                name="reconstruction_object",
-                data=asnumpy(self._xp.asarray(self._object)),
-            )
-
-            # probe
-            self._probe_emd = Array(
-                name="reconstruction_probe", data=asnumpy(self._probe)
-            )
-
         # exit_waves
         if self._save_exit_waves:
             self._exit_waves_emd = Array(
@@ -1239,13 +1236,8 @@ def _get_constructor_args(cls, group):
         else:
             dc = None
 
-        # Check if stack
-        if dict_data["_object_emd"].is_stack:
-            obj = dict_data["_object_emd"][-1].data
-            probe = dict_data["_probe_emd"][-1].data
-        else:
-            obj = dict_data["_object_emd"].data
-            probe = dict_data["_probe_emd"].data
+        obj = dict_data["_object_emd"].data
+        probe = dict_data["_probe_emd"].data
 
         # Populate args and return
         kwargs = {
@@ -1303,8 +1295,8 @@ def _populate_instance(self, group):
 
         # Check if stack
         if hasattr(error, "__len__"):
-            self.object_iterations = list(dict_data["_object_emd"].data)
-            self.probe_iterations = list(dict_data["_probe_emd"].data)
+            self.object_iterations = list(dict_data["_object_iterations_emd"].data)
+            self.probe_iterations = list(dict_data["_probe_iterations_emd"].data)
             self.error_iterations = error
             self.error = error[-1]
         else:
@@ -1313,7 +1305,7 @@ def _populate_instance(self, group):
         # Slim preprocessing to enable visualize
         self._positions_px_com = xp.mean(self._positions_px, axis=0)
         self.object = asnumpy(self._object)
-        self.probe = asnumpy(self._probe)
+        self.probe = self.probe_centered
         self._preprocessed = True
 
     def _set_polar_parameters(self, parameters: dict):
@@ -1401,9 +1393,9 @@ def _calculate_scan_positions_in_pixels(self, positions: np.ndarray):
             self._object_padding_px = (float_padding, float_padding)
         elif np.isscalar(self._object_padding_px[0]):
             self._object_padding_px = (
-                    (self._object_padding_px[0],)*2,
-                    (self._object_padding_px[1],)*2
-                    )
+                (self._object_padding_px[0],) * 2,
+                (self._object_padding_px[1],) * 2,
+            )
 
         positions[:, 0] += self._object_padding_px[0][0]
         positions[:, 1] += self._object_padding_px[1][0]

From 1a8fcbef906eec659c46cf2d18ef01e4a70e2466 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 20 Jun 2023 12:50:37 -0400
Subject: [PATCH 051/362] fixes gdrive downloader, adds test data downloader
 command line interface

---
 py4DSTEM/io/__init__.py                       |  12 +-
 py4DSTEM/io/google_drive_downloader.py        | 205 +++++--------
 py4DSTEM/io/sample_file_ids.py                |  89 ++++++
 test/gettestdata.py                           |  71 +++++
 test/unit_test_data/crystal/LCO.cif           |  96 ------
 test/unit_test_data/crystal/Li2MnO3.cif       |  79 -----
 test/unit_test_data/crystal/LiMn2O4.cif       | 277 ------------------
 .../unit_test_data/crystal/braggdisks_cali.h5 | Bin 3099136 -> 0 bytes
 8 files changed, 237 insertions(+), 592 deletions(-)
 create mode 100644 py4DSTEM/io/sample_file_ids.py
 create mode 100644 test/gettestdata.py
 delete mode 100644 test/unit_test_data/crystal/LCO.cif
 delete mode 100644 test/unit_test_data/crystal/Li2MnO3.cif
 delete mode 100644 test/unit_test_data/crystal/LiMn2O4.cif
 delete mode 100644 test/unit_test_data/crystal/braggdisks_cali.h5

diff --git a/py4DSTEM/io/__init__.py b/py4DSTEM/io/__init__.py
index 399127577..71a0f2dd5 100644
--- a/py4DSTEM/io/__init__.py
+++ b/py4DSTEM/io/__init__.py
@@ -5,15 +5,9 @@
 from py4DSTEM.io.save import save
 
 
-# TODO
-# - read fn - triage new/old EMD files
-# - save fn - call EMD write fn with any special defaults
-#   (mod root __init__ emd.write import)
-
 # google downloader
-from py4DSTEM.io.google_drive_downloader import (
-    download_file_from_google_drive,
-    get_sample_data_ids
-)
+from py4DSTEM.io.google_drive_downloader import gdrive_download
+from py4DSTEM.io.sample_file_ids import get_sample_file_ids
+
 
 
diff --git a/py4DSTEM/io/google_drive_downloader.py b/py4DSTEM/io/google_drive_downloader.py
index 052dbdace..a4ff72abe 100644
--- a/py4DSTEM/io/google_drive_downloader.py
+++ b/py4DSTEM/io/google_drive_downloader.py
@@ -1,148 +1,91 @@
 import gdown
-from typing import Union
-import pathlib
 import os
 
+from py4DSTEM.io.sample_file_ids import file_ids, collection_ids
 
-# Built-in sample datasets
-
-# single files
-sample_file_ids = {
-    'FCU-Net' : '1-KX0saEYfhZ9IJAOwabH38PCVtfXidJi',
-    'sample_diffraction_pattern':'1ymYMnuDC0KV6dqduxe2O1qafgSd0jjnU',
-    'Au_sim':'1PmbCYosA1eYydWmmZebvf6uon9k_5g_S',
-    'carbon_nanotube':'1bHv3u61Cr-y_GkdWHrJGh1lw2VKmt3UM',
-    'Si_SiGe_exp':'1fXNYSGpe6w6E9RBA-Ai_owZwoj3w8PNC',
-    'Si_SiGe_probe':'141Tv0YF7c5a-MCrh3CkY_w4FgWtBih80',
-    'Si_SiGe_EELS_strain':'1klkecq8IuEOYB-bXchO7RqOcgCl4bmDJ',
-    'AuAgPd_wire':'1OQYW0H6VELsmnLTcwicP88vo2V5E3Oyt',
-    'AuAgPd_wire_probe':'17OduUKpxVBDumSK_VHtnc2XKkaFVN8kq',
-    'polycrystal_2D_WS2':'1AWB3-UTPiTR9dgrEkNFD7EJYsKnbEy0y',
-    'WS2cif':'13zBl6aFExtsz_sew-L0-_ALYJfcgHKjo',
-    'polymers':'1lK-TAMXN1MpWG0Q3_4vss_uEZgW2_Xh7',
-    'vac_probe':'1QTcSKzZjHZd1fDimSI_q9_WsAU25NIXe',
-}
-
-# collections of files
-sample_collection_ids = {
-    'unit_test_data' : (
-        ('dm_test_file.dm3', '1RxI1QY6vYMDqqMVPt5GBN6Q_iCwHFU4B'),
-     ),
-    'tutorials' : (
-        ('simulated_Au_single+polyXtal.h5', sample_file_ids['Au_sim']),
-        ('carbon_nanotube.h5', sample_file_ids['carbon_nanotube']),
-        ('Si_SiGe_exp.h5',sample_file_ids['Si_SiGe_exp']),
-        ('Si_SiGe_probe.h5',sample_file_ids['Si_SiGe_probe']),
-        ('Si_SiGe_EELS_strain.h5',sample_file_ids['Si_SiGe_EELS_strain']),
-        ('AuAgPd_wire.h5',sample_file_ids['AuAgPd_wire']),
-        ('AuAgPd_wire_probe.h5',sample_file_ids['AuAgPd_wire_probe']),
-        ('polycrystal_2D_WS2.h5',sample_file_ids['polycrystal_2D_WS2']),
-        ('WS2.cif',sample_file_ids['WS2cif']),
-        ('polymers.h5',sample_file_ids['polymers']),
-        ('vac_probe.h5',sample_file_ids['vac_probe']),
-    ),
-}
-
-
-def download_file_from_google_drive(id_, destination, overwrite=False):
+def gdrive_download(
+    id_,
+    destination = None,
+    overwrite = False,
+    filename = None,
+    verbose = True,
+    ):
     """
-    Downloads a file or collection of files from google drive to the
-    destination file path.
-
-    Args:
-        id_ (str): File ID for the desired file.  May be:
-            - the file id, i.e. for
-              https://drive.google.com/file/d/1bHv3u61Cr-y_GkdWHrJGh1lw2VKmt3UM/
-              id='1bHv3u61Cr-y_GkdWHrJGh1lw2VKmt3UM'
-            - the complete URL,
-            - a special string denoting a sample dataset or collection of
-              datasets. For a list of sample datasets and their keys, run
-              get_sample_data_ids().
-        destination (str or Path): path file will be downloaded to. For
-            collections of files, this should point to an existing directory;
-            a subdirectory will be created inside this directory whose name
-            will be given by `id_`, and the colletion of files will be placed
-            inside that subdirectory. If a subdirectory of this name already
-            exists, aborts or deletes and overwrite the entire subdirectory,
-            depending on the value of `overwrite`.
-        overwrite (bool): turn overwrite protection on/off
+    Downloads a file or collection of files from google drive.
+
+    Parameters
+    ----------
+    id_ : str
+        File ID for the desired file.  May be either a key from the list
+        of files and collections of files accessible at get_sample_file_ids(),
+        or a complete url, or the portions of a google drive link specifying
+        the file ID, i.e. for the address
+        https://drive.google.com/file/d/1bHv3u61Cr-y_GkdWHrJGh1lw2VKmt3UM/,
+        the id string '1bHv3u61Cr-y_GkdWHrJGh1lw2VKmt3UM'.
+    destination : None or str
+        The location to download to. If None, downloads to the current
+        working directory. If a string is passed which points to a valid
+        location on the filesystem, downloads there. For collections of
+        files, makes a new directory named after the collection id and
+        places all files there.
+    overwrite : bool
+        Turns overwrite protection on/off.
+    filename : None or str
+        Used only if `id_` is a url or gdrive id. Specifies the name of the
+        output file.  If left as None, saves to 'gdrivedownload.file'. If `id_`
+        is a key from the sample file id list, this parameter is ignored and
+        the filenames in that list are used.
+    verbose : bool
+        Toggles verbose output
     """
-    # handle paths
-
-    # for collections of files
-    if id_ in sample_collection_ids.keys():
+    # parse destination
+    if destination is None:
+        destination = os.getcwd()
+    assert(os.path.exists(destination)), f"`destination` must exist on filesystem. Received {destination}"
+
+    # download single files
+    if id_ not in collection_ids:
+
+        # assign the name and id
+        kwargs = {
+            'fuzzy' : True
+        }
+        if id_ in file_ids:
+            f = file_ids[id_]
+            filename = f[0]
+            kwargs['id'] = f[1]
+        else:
+            filename = 'gdrivedownload.file' if filename is None else filename
+            kwargs['url'] = id_
+
+        # download
+        kwargs['output'] = os.path.join(destination, filename)
+        if not(overwrite) and os.path.exists(kwargs['output']):
+            if verbose:
+                print(f"A file already exists at {kwargs['output']}, skipping...")
+        else:
+            gdown.download( **kwargs )
 
-        # check if directory exists
-        assert os.path.exists(destination), "specified directory does not exist; check filepath"
+    # download a collections of files
+    else:
 
-        # update the path with a new sub-directory name
+        # set destination
         destination = os.path.join(destination, id_)
-
-        # check if it already exists
-        if os.path.exists(destination):
-
-            # check if it contains any files
-            paths = os.listdir(destination)
-            if len(paths) > 0:
-
-                # check `overwrite`
-                if overwrite:
-                    for p in paths:
-                        os.remove(os.path.join(destination, p))
-                else:
-                    raise Exception('a populated directory exists at the specified location. to overwrite set `overwrite=True`.')
-
-        # if it doesn't exist, make a new directory
-        else:
+        if not os.path.exists(destination):
             os.mkdir(destination)
 
-        # get the files
-        for file_name,file_id in sample_collection_ids[id_]:
-            if file_id[:4].lower() == 'http':
-                gdown.download(
-                    url = file_id,
-                    output = os.path.join(destination, file_name),
-                    fuzzy = True
-                )
+        # loop
+        for x in collection_ids[id_]:
+            file_name,file_id = file_ids[x]
+            output = os.path.join(destination, file_name)
+            # download
+            if not(overwrite) and os.path.exists(output):
+                if verbose:
+                    print(f"A file already exists at {output}, skipping...")
             else:
                 gdown.download(
                     id = file_id,
-                    output = os.path.join(destination, file_name),
+                    output = output,
                     fuzzy = True
                 )
 
-        return None
-
-
-    # for single files
-
-    # Check and handle if a file at the destination filepath exists
-    if os.path.exists(destination):
-
-        # check `overwrite`
-        if overwrite == True:
-            print(f"File already existed, downloading and overwriting")
-            os.remove(destination)
-        else:
-            raise Exception('File already exists; aborting. To overwrite, use `overwrite=True`.')
-
-    # Check if the id_ is a key pointing to a known sample dataset
-    if id_ in sample_file_ids.keys():
-        id_ = sample_file_ids[id_]
-
-    # Check if `id_` is a file ID or a URL, and download
-    if id_[:4].lower()=='http':
-        gdown.download(url=id_,output=destination,fuzzy=True)
-    else:
-        gdown.download(id=id_,output=destination,fuzzy=True)
-
-    return None
-
-
-
-def get_sample_data_ids():
-    return {'files' : sample_file_ids.keys(),
-            'collections' : sample_collection_ids.keys()}
-
-
-
diff --git a/py4DSTEM/io/sample_file_ids.py b/py4DSTEM/io/sample_file_ids.py
new file mode 100644
index 000000000..b42b7eccc
--- /dev/null
+++ b/py4DSTEM/io/sample_file_ids.py
@@ -0,0 +1,89 @@
+# single files
+file_ids = {
+    'sample_diffraction_pattern' : (
+        'a_diffraction_pattern.h5',
+        '1ymYMnuDC0KV6dqduxe2O1qafgSd0jjnU',
+    ),
+    'Au_sim' : (
+        'au_sim.h5',
+        '1PmbCYosA1eYydWmmZebvf6uon9k_5g_S',
+    ),
+    'carbon_nanotube' : (
+        'carbon_nanotube.h5',
+        '1bHv3u61Cr-y_GkdWHrJGh1lw2VKmt3UM',
+    ),
+    'Si_SiGe_exp' : (
+        'Si_SiGe_exp.h5',
+        '1fXNYSGpe6w6E9RBA-Ai_owZwoj3w8PNC',
+    ),
+    'Si_SiGe_probe' : (
+        'Si_SiGe_probe.h5',
+        '141Tv0YF7c5a-MCrh3CkY_w4FgWtBih80',
+    ),
+    'Si_SiGe_EELS_strain' : (
+        'Si_SiGe_EELS_strain.h5',
+        '1klkecq8IuEOYB-bXchO7RqOcgCl4bmDJ',
+    ),
+    'AuAgPd_wire' : (
+        'AuAgPd_wire.h5',
+        '1OQYW0H6VELsmnLTcwicP88vo2V5E3Oyt',
+    ),
+    'AuAgPd_wire_probe' : (
+        'AuAgPd_wire_probe.h5',
+        '17OduUKpxVBDumSK_VHtnc2XKkaFVN8kq',
+    ),
+    'polycrystal_2D_WS2' : (
+        'polycrystal_2D_WS2.h5',
+        '1AWB3-UTPiTR9dgrEkNFD7EJYsKnbEy0y',
+    ),
+    'WS2cif' : (
+        'WS2.cif',
+        '13zBl6aFExtsz_sew-L0-_ALYJfcgHKjo',
+    ),
+    'polymers' : (
+        'polymers.h5',
+        '1lK-TAMXN1MpWG0Q3_4vss_uEZgW2_Xh7',
+    ),
+    'vac_probe' : (
+        'vac_probe.h5',
+        '1QTcSKzZjHZd1fDimSI_q9_WsAU25NIXe',
+    ),
+    'small_dm3' : (
+        'small_dm3.dm3',
+        '1RxI1QY6vYMDqqMVPt5GBN6Q_iCwHFU4B'
+    ),
+    'FCU-Net' : (
+        'filename.name',
+        '1-KX0saEYfhZ9IJAOwabH38PCVtfXidJi',
+    ),
+}
+
+# collections of files
+collection_ids = {
+    'tutorials' : (
+        'Au_sim',
+        'carbon_nanotube',
+        'Si_SiGe_exp',
+        'Si_SiGe_probe',
+        'Si_SiGe_EELS_strain',
+        'AuAgPd_wire',
+        'AuAgPd_wire_probe',
+        'polycrystal_2D_WS2',
+        'WS2cif',
+        'polymers',
+        'vac_probe',
+    ),
+    'io_test_data' : (
+        'small_dm3',
+        'vac_probe',
+    ),
+}
+
+
+def get_sample_file_ids():
+    return {
+        'files' : file_ids.keys(),
+        'collections' : collection_ids.keys()
+    }
+
+
diff --git a/test/gettestdata.py b/test/gettestdata.py
new file mode 100644
index 000000000..eb5e7c5a8
--- /dev/null
+++ b/test/gettestdata.py
@@ -0,0 +1,71 @@
+# A command line tool for downloading data to run the py4DSTEM test suite
+
+
+import argparse
+from os.path import join, exists
+from os import makedirs
+
+from py4DSTEM import _TESTPATH as testpath
+from py4DSTEM.io import gdrive_download as download
+
+
+
+# Make the argument parser
+parser = argparse.ArgumentParser(
+    description = "A command line tool for downloading data to run the py4DSTEM test suite"
+)
+
+# Set up data download options
+data_options = [
+    'tutorials',
+    'io',
+]
+
+# Add arguments
+parser.add_argument(
+    "data",
+    help = "which data to download.",
+    choices = data_options,
+)
+parser.add_argument(
+    "-o", "--overwrite",
+    help = "if turned on, overwrite files that are already present. Otherwise, skips these files.",
+    action = "store_true"
+)
+parser.add_argument(
+    "-v", "--verbose",
+    help = "turn on verbose output",
+    action = "store_true"
+)
+
+
+
+# Get the command line arguments
+args = parser.parse_args()
+
+
+# Set up paths
+if not exists(testpath):
+    makedirs(testpath)
+
+
+# Set data collection key
+if args.data == 'tutorials':
+    data = 'tutorials'
+elif args.data == 'io':
+    data = 'io_test_data'
+else:
+    raise Exception(f"invalid data choice, {parser.data}")
+
+# Download data
+download(
+    data,
+    destination = testpath,
+    overwrite = args.overwrite,
+    verbose = args.verbose
+)
+
+
+
+
+
diff --git a/test/unit_test_data/crystal/LCO.cif b/test/unit_test_data/crystal/LCO.cif
deleted file mode 100644
index 8fe2b777e..000000000
--- a/test/unit_test_data/crystal/LCO.cif
+++ /dev/null
@@ -1,96 +0,0 @@
-#------------------------------------------------------------------------------
-#$Date: 2016-02-13 21:28:24 +0200 (Sat, 13 Feb 2016) $
-#$Revision: 176429 $
-#$URL: svn://www.crystallography.net/cod/cif/1/53/38/1533825.cif $
-#------------------------------------------------------------------------------
-#
-# This file is available in the Crystallography Open Database (COD),
-# http://www.crystallography.net/
-#
-# All data on this site have been placed in the public domain by the
-# contributors.
-#
-data_1533825
-loop_
-_publ_author_name
-'Hong Jin K'
-'Oh Seung M'
-_publ_section_title
-;
- Crystal structure and electrochemical performance of Li Ni1-x Cox O2 (0
- <= x < 1.0) according to Co substitution
-;
-_journal_name_full
-'Journal of the Korean Electrochemical Society'
-_journal_page_first              1
-_journal_page_last               5
-_journal_volume                  6
-_journal_year                    2003
-_chemical_formula_sum            'Co Li O2'
-_chemical_name_systematic        'Li (Co O2)'
-_space_group_IT_number           166
-_symmetry_space_group_name_Hall  '-R 3 2"'
-_symmetry_space_group_name_H-M   'R -3 m :H'
-_cell_angle_alpha                90
-_cell_angle_beta                 90
-_cell_angle_gamma                120
-_cell_formula_units_Z            3
-_cell_length_a                   2.92
-_cell_length_b                   2.92
-_cell_length_c                   14.25
-_cell_volume                     96.337
-_citation_journal_id_ASTM        JKESFC
-_cod_data_source_file            HongJinK_JKESFC_2003_777.cif
-_cod_data_source_block           Co1Li1O2
-_cod_original_cell_volume        96.33704
-_cod_original_formula_sum        'Co1 Li1 O2'
-_cod_database_code               1533825
-loop_
-_symmetry_equiv_pos_as_xyz
-x,y,z
--y,x-y,z
--x+y,-x,z
-y,x,-z
--x,-x+y,-z
-x-y,-y,-z
--x,-y,-z
-y,-x+y,-z
-x-y,x,-z
--y,-x,z
-x,x-y,z
--x+y,y,z
-x+2/3,y+1/3,z+1/3
--y+2/3,x-y+1/3,z+1/3
--x+y+2/3,-x+1/3,z+1/3
-y+2/3,x+1/3,-z+1/3
--x+2/3,-x+y+1/3,-z+1/3
-x-y+2/3,-y+1/3,-z+1/3
--x+2/3,-y+1/3,-z+1/3
-y+2/3,-x+y+1/3,-z+1/3
-x-y+2/3,x+1/3,-z+1/3
--y+2/3,-x+1/3,z+1/3
-x+2/3,x-y+1/3,z+1/3
--x+y+2/3,y+1/3,z+1/3
-x+1/3,y+2/3,z+2/3
--y+1/3,x-y+2/3,z+2/3
--x+y+1/3,-x+2/3,z+2/3
-y+1/3,x+2/3,-z+2/3
--x+1/3,-x+y+2/3,-z+2/3
-x-y+1/3,-y+2/3,-z+2/3
--x+1/3,-y+2/3,-z+2/3
-y+1/3,-x+y+2/3,-z+2/3
-x-y+1/3,x+2/3,-z+2/3
--y+1/3,-x+2/3,z+2/3
-x+1/3,x-y+2/3,z+2/3
--x+y+1/3,y+2/3,z+2/3
-loop_
-_atom_site_label
-_atom_site_type_symbol
-_atom_site_fract_x
-_atom_site_fract_y
-_atom_site_fract_z
-_atom_site_occupancy
-_atom_site_U_iso_or_equiv
-O1 O-2 0 0 0.2268 1 0.0
-Co1 Co+3 0 0 0 1 0.0
-Li1 Li+1 0 0 0.5 1 0.0
diff --git a/test/unit_test_data/crystal/Li2MnO3.cif b/test/unit_test_data/crystal/Li2MnO3.cif
deleted file mode 100644
index 7a74b4fae..000000000
--- a/test/unit_test_data/crystal/Li2MnO3.cif
+++ /dev/null
@@ -1,79 +0,0 @@
-#------------------------------------------------------------------------------
-#$Date: 2015-01-27 21:58:39 +0200 (Tue, 27 Jan 2015) $
-#$Revision: 130149 $
-#$URL: svn://www.crystallography.net/cod/cif/1/00/83/1008373.cif $
-#------------------------------------------------------------------------------
-#
-# This file is available in the Crystallography Open Database (COD),
-# http://www.crystallography.net/
-#
-# All data on this site have been placed in the public domain by the
-# contributors.
-#
-data_1008373
-loop_
-_publ_author_name
-'Strobel, P'
-'Lambert-Andron, B'
-_publ_section_title
-;
-Crystallographic and Magnetic Structure of Li~2~ Mn O~3~
-;
-_journal_coden_ASTM              JSSCBI
-_journal_name_full               'Journal of Solid State Chemistry'
-_journal_page_first              90
-_journal_page_last               98
-_journal_paper_doi               10.1016/0022-4596(88)90305-2
-_journal_volume                  75
-_journal_year                    1988
-_chemical_formula_structural     'Li2 Mn O3'
-_chemical_formula_sum            'Li2 Mn O3'
-_chemical_name_systematic        'Dilithium manganese(IV) trioxide'
-_space_group_IT_number           12
-_symmetry_cell_setting           monoclinic
-_symmetry_Int_Tables_number      12
-_symmetry_space_group_name_Hall  '-C 2y'
-_symmetry_space_group_name_H-M   'C 1 2/m 1'
-_cell_angle_alpha                90
-_cell_angle_beta                 109.46(3)
-_cell_angle_gamma                90
-_cell_formula_units_Z            4
-_cell_length_a                   5.1
-_cell_length_b                   8.5
-_cell_length_c                   5.1
-_cell_volume                     199.8
-_refine_ls_R_factor_all          0.02
-_cod_database_code               1008373
-loop_
-_symmetry_equiv_pos_as_xyz
-x,y,z
-x,-y,z
--x,-y,-z
--x,y,-z
-1/2+x,1/2+y,z
-1/2+x,1/2-y,z
-1/2-x,1/2-y,-z
-1/2-x,1/2+y,-z
-loop_
-_atom_site_label
-_atom_site_type_symbol
-_atom_site_symmetry_multiplicity
-_atom_site_Wyckoff_symbol
-_atom_site_fract_x
-_atom_site_fract_y
-_atom_site_fract_z
-_atom_site_occupancy
-_atom_site_attached_hydrogens
-_atom_site_calc_flag
-Mn1 Mn4+ 4 g 0. 0.16708(2) 0. 1. 0 d
-Li1 Li1+ 2 b 0. 0.5 0. 1. 0 d
-Li2 Li1+ 2 c 0. 0. 0.5 1. 0 d
-Li3 Li1+ 4 h 0. 0.6606(3) 0.5 1. 0 d
-O1 O2- 4 i 0.2189(2) 0. 0.2273(2) 1. 0 d
-O2 O2- 8 j 0.2540(1) 0.32119(7) 0.2233(1) 1. 0 d
-loop_
-_atom_type_symbol
-_atom_type_oxidation_number
-Mn4+ 4.000
-Li1+ 1.000
-O2- -2.000
diff --git a/test/unit_test_data/crystal/LiMn2O4.cif b/test/unit_test_data/crystal/LiMn2O4.cif
deleted file mode 100644
index 81f8db377..000000000
--- a/test/unit_test_data/crystal/LiMn2O4.cif
+++ /dev/null
@@ -1,277 +0,0 @@
-#------------------------------------------------------------------------------
-#$Date: 2016-02-20 20:10:49 +0200 (Sat, 20 Feb 2016) $
-#$Revision: 176788 $
-#$URL: svn://www.crystallography.net/cod/cif/1/51/39/1513962.cif $
-#------------------------------------------------------------------------------
-#
-# This file is available in the Crystallography Open Database (COD),
-# http://www.crystallography.net/
-#
-# All data on this site have been placed in the public domain by the
-# contributors.
-#
-data_1513962
-loop_
-_publ_author_name
-'Mosbah, A.'
-'Verbaere, A.'
-'Tournoux, M.'
-_publ_section_title
-;
- Phases Lix Mn O2 lambda rattachees au type spinelle
-;
-_journal_coden_ASTM              MRBUAC
-_journal_name_full               'Materials Research Bulletin'
-_journal_page_first              1375
-_journal_page_last               1381
-_journal_year                    1983
-_chemical_formula_structural     'Li Mn2 O4'
-_chemical_formula_sum            'Li Mn2 O4'
-_chemical_name_systematic        'Lithium Dimanganese Tetraoxide'
-_space_group_IT_number           227
-_symmetry_Int_Tables_number      227
-_symmetry_space_group_name_Hall  '-F 4vw 2vw 3'
-_symmetry_space_group_name_H-M   'F d -3 m :2'
-_audit_creation_date             1999-11-30
-_audit_update_record             2005-10-01
-_cell_angle_alpha                90.
-_cell_angle_beta                 90.
-_cell_angle_gamma                90.
-_cell_formula_units_Z            8
-_cell_length_a                   8.245(1)
-_cell_length_b                   8.245(1)
-_cell_length_c                   8.245(1)
-_cell_volume                     560.50(12)
-_refine_ls_R_factor_all          0.036
-_cod_data_source_file            'data_LiMn2O4melanie040485.cif'
-_cod_data_source_block
-/var/www/cod/tmp/uploads/1395678109.95-D290F29E9218B844.cif
-_cod_original_cell_volume        560.5
-_cod_original_sg_symbol_H-M      'F d -3 m Z'
-_cod_original_formula_sum        'Li1 Mn2 O4'
-_cod_database_code               1513962
-loop_
-_symmetry_equiv_pos_site_id
-_symmetry_equiv_pos_as_xyz
-1 '-z, y+3/4, x+3/4'
-2 'z+3/4, -y, x+3/4'
-3 'z+3/4, y+3/4, -x'
-4 '-z, -y, -x'
-5 'y+3/4, x+3/4, -z'
-6 '-y, x+3/4, z+3/4'
-7 'y+3/4, -x, z+3/4'
-8 '-y, -x, -z'
-9 'x+3/4, -z, y+3/4'
-10 'x+3/4, z+3/4, -y'
-11 '-x, z+3/4, y+3/4'
-12 '-x, -z, -y'
-13 '-z, x+3/4, y+3/4'
-14 'z+3/4, x+3/4, -y'
-15 'z+3/4, -x, y+3/4'
-16 '-z, -x, -y'
-17 'y+3/4, -z, x+3/4'
-18 '-y, z+3/4, x+3/4'
-19 'y+3/4, z+3/4, -x'
-20 '-y, -z, -x'
-21 'x+3/4, y+3/4, -z'
-22 'x+3/4, -y, z+3/4'
-23 '-x, y+3/4, z+3/4'
-24 '-x, -y, -z'
-25 'z, -y+1/4, -x+1/4'
-26 '-z+1/4, y, -x+1/4'
-27 '-z+1/4, -y+1/4, x'
-28 'z, y, x'
-29 '-y+1/4, -x+1/4, z'
-30 'y, -x+1/4, -z+1/4'
-31 '-y+1/4, x, -z+1/4'
-32 'y, x, z'
-33 '-x+1/4, z, -y+1/4'
-34 '-x+1/4, -z+1/4, y'
-35 'x, -z+1/4, -y+1/4'
-36 'x, z, y'
-37 'z, -x+1/4, -y+1/4'
-38 '-z+1/4, -x+1/4, y'
-39 '-z+1/4, x, -y+1/4'
-40 'z, x, y'
-41 '-y+1/4, z, -x+1/4'
-42 'y, -z+1/4, -x+1/4'
-43 '-y+1/4, -z+1/4, x'
-44 'y, z, x'
-45 '-x+1/4, -y+1/4, z'
-46 '-x+1/4, y, -z+1/4'
-47 'x, -y+1/4, -z+1/4'
-48 'x, y, z'
-49 '-z, y+1/4, x+1/4'
-50 '-z+1/2, y+3/4, x+1/4'
-51 '-z+1/2, y+1/4, x+3/4'
-52 'z+3/4, -y+1/2, x+1/4'
-53 'z+1/4, -y, x+1/4'
-54 'z+1/4, -y+1/2, x+3/4'
-55 'z+3/4, y+1/4, -x+1/2'
-56 'z+1/4, y+3/4, -x+1/2'
-57 'z+1/4, y+1/4, -x'
-58 '-z, -y+1/2, -x+1/2'
-59 '-z+1/2, -y, -x+1/2'
-60 '-z+1/2, -y+1/2, -x'
-61 'y+3/4, x+1/4, -z+1/2'
-62 'y+1/4, x+3/4, -z+1/2'
-63 'y+1/4, x+1/4, -z'
-64 '-y, x+1/4, z+1/4'
-65 '-y+1/2, x+3/4, z+1/4'
-66 '-y+1/2, x+1/4, z+3/4'
-67 'y+3/4, -x+1/2, z+1/4'
-68 'y+1/4, -x, z+1/4'
-69 'y+1/4, -x+1/2, z+3/4'
-70 '-y, -x+1/2, -z+1/2'
-71 '-y+1/2, -x, -z+1/2'
-72 '-y+1/2, -x+1/2, -z'
-73 'x+3/4, -z+1/2, y+1/4'
-74 'x+1/4, -z, y+1/4'
-75 'x+1/4, -z+1/2, y+3/4'
-76 'x+3/4, z+1/4, -y+1/2'
-77 'x+1/4, z+3/4, -y+1/2'
-78 'x+1/4, z+1/4, -y'
-79 '-x, z+1/4, y+1/4'
-80 '-x+1/2, z+3/4, y+1/4'
-81 '-x+1/2, z+1/4, y+3/4'
-82 '-x, -z+1/2, -y+1/2'
-83 '-x+1/2, -z, -y+1/2'
-84 '-x+1/2, -z+1/2, -y'
-85 '-z, x+1/4, y+1/4'
-86 '-z+1/2, x+3/4, y+1/4'
-87 '-z+1/2, x+1/4, y+3/4'
-88 'z+3/4, x+1/4, -y+1/2'
-89 'z+1/4, x+3/4, -y+1/2'
-90 'z+1/4, x+1/4, -y'
-91 'z+3/4, -x+1/2, y+1/4'
-92 'z+1/4, -x, y+1/4'
-93 'z+1/4, -x+1/2, y+3/4'
-94 '-z, -x+1/2, -y+1/2'
-95 '-z+1/2, -x, -y+1/2'
-96 '-z+1/2, -x+1/2, -y'
-97 'y+3/4, -z+1/2, x+1/4'
-98 'y+1/4, -z, x+1/4'
-99 'y+1/4, -z+1/2, x+3/4'
-100 '-y, z+1/4, x+1/4'
-101 '-y+1/2, z+3/4, x+1/4'
-102 '-y+1/2, z+1/4, x+3/4'
-103 'y+3/4, z+1/4, -x+1/2'
-104 'y+1/4, z+3/4, -x+1/2'
-105 'y+1/4, z+1/4, -x'
-106 '-y, -z+1/2, -x+1/2'
-107 '-y+1/2, -z, -x+1/2'
-108 '-y+1/2, -z+1/2, -x'
-109 'x+3/4, y+1/4, -z+1/2'
-110 'x+1/4, y+3/4, -z+1/2'
-111 'x+1/4, y+1/4, -z'
-112 'x+3/4, -y+1/2, z+1/4'
-113 'x+1/4, -y, z+1/4'
-114 'x+1/4, -y+1/2, z+3/4'
-115 '-x, y+1/4, z+1/4'
-116 '-x+1/2, y+3/4, z+1/4'
-117 '-x+1/2, y+1/4, z+3/4'
-118 '-x, -y+1/2, -z+1/2'
-119 '-x+1/2, -y, -z+1/2'
-120 '-x+1/2, -y+1/2, -z'
-121 'z, -y+3/4, -x+3/4'
-122 'z+1/2, -y+1/4, -x+3/4'
-123 'z+1/2, -y+3/4, -x+1/4'
-124 '-z+1/4, y+1/2, -x+3/4'
-125 '-z+3/4, y, -x+3/4'
-126 '-z+3/4, y+1/2, -x+1/4'
-127 '-z+1/4, -y+3/4, x+1/2'
-128 '-z+3/4, -y+1/4, x+1/2'
-129 '-z+3/4, -y+3/4, x'
-130 'z, y+1/2, x+1/2'
-131 'z+1/2, y, x+1/2'
-132 'z+1/2, y+1/2, x'
-133 '-y+1/4, -x+3/4, z+1/2'
-134 '-y+3/4, -x+1/4, z+1/2'
-135 '-y+3/4, -x+3/4, z'
-136 'y, -x+3/4, -z+3/4'
-137 'y+1/2, -x+1/4, -z+3/4'
-138 'y+1/2, -x+3/4, -z+1/4'
-139 '-y+1/4, x+1/2, -z+3/4'
-140 '-y+3/4, x, -z+3/4'
-141 '-y+3/4, x+1/2, -z+1/4'
-142 'y, x+1/2, z+1/2'
-143 'y+1/2, x, z+1/2'
-144 'y+1/2, x+1/2, z'
-145 '-x+1/4, z+1/2, -y+3/4'
-146 '-x+3/4, z, -y+3/4'
-147 '-x+3/4, z+1/2, -y+1/4'
-148 '-x+1/4, -z+3/4, y+1/2'
-149 '-x+3/4, -z+1/4, y+1/2'
-150 '-x+3/4, -z+3/4, y'
-151 'x, -z+3/4, -y+3/4'
-152 'x+1/2, -z+1/4, -y+3/4'
-153 'x+1/2, -z+3/4, -y+1/4'
-154 'x, z+1/2, y+1/2'
-155 'x+1/2, z, y+1/2'
-156 'x+1/2, z+1/2, y'
-157 'z, -x+3/4, -y+3/4'
-158 'z+1/2, -x+1/4, -y+3/4'
-159 'z+1/2, -x+3/4, -y+1/4'
-160 '-z+1/4, -x+3/4, y+1/2'
-161 '-z+3/4, -x+1/4, y+1/2'
-162 '-z+3/4, -x+3/4, y'
-163 '-z+1/4, x+1/2, -y+3/4'
-164 '-z+3/4, x, -y+3/4'
-165 '-z+3/4, x+1/2, -y+1/4'
-166 'z, x+1/2, y+1/2'
-167 'z+1/2, x, y+1/2'
-168 'z+1/2, x+1/2, y'
-169 '-y+1/4, z+1/2, -x+3/4'
-170 '-y+3/4, z, -x+3/4'
-171 '-y+3/4, z+1/2, -x+1/4'
-172 'y, -z+3/4, -x+3/4'
-173 'y+1/2, -z+1/4, -x+3/4'
-174 'y+1/2, -z+3/4, -x+1/4'
-175 '-y+1/4, -z+3/4, x+1/2'
-176 '-y+3/4, -z+1/4, x+1/2'
-177 '-y+3/4, -z+3/4, x'
-178 'y, z+1/2, x+1/2'
-179 'y+1/2, z, x+1/2'
-180 'y+1/2, z+1/2, x'
-181 '-x+1/4, -y+3/4, z+1/2'
-182 '-x+3/4, -y+1/4, z+1/2'
-183 '-x+3/4, -y+3/4, z'
-184 '-x+1/4, y+1/2, -z+3/4'
-185 '-x+3/4, y, -z+3/4'
-186 '-x+3/4, y+1/2, -z+1/4'
-187 'x, -y+3/4, -z+3/4'
-188 'x+1/2, -y+1/4, -z+3/4'
-189 'x+1/2, -y+3/4, -z+1/4'
-190 'x, y+1/2, z+1/2'
-191 'x+1/2, y, z+1/2'
-192 'x+1/2, y+1/2, z'
-loop_
-_atom_site_label
-_atom_site_type_symbol
-_atom_site_symmetry_multiplicity
-_atom_site_Wyckoff_symbol
-_atom_site_fract_x
-_atom_site_fract_y
-_atom_site_fract_z
-_atom_site_occupancy
-_atom_site_attached_hydrogens
-_atom_site_B_iso_or_equiv
-Li1 Li1+ 8 a 0.125 0.125 0.125 1. 0 0.5
-Mn1 Mn3.5+ 16 d 0.5 0.5 0.5 1. 0 0.3(2)
-O1 O2- 32 e 0.261(2) 0.261(2) 0.261(2) 1. 0 0.4(2)
-loop_
-_atom_type_symbol
-_atom_type_oxidation_number
-Li1+ 1
-Mn3.5+ 3.5
-O2- -2
-loop_
-_citation_id
-_citation_journal_full
-_citation_year
-_citation_journal_volume
-_citation_page_first
-_citation_page_last
-_citation_journal_id_ASTM
-primary 'Materials Research Bulletin' 1983 18 1375 1381 MRBUAC
-2 'Golden Book of Phase Transitions, Wroclaw' 2002 1 1 123 GBOPT5
diff --git a/test/unit_test_data/crystal/braggdisks_cali.h5 b/test/unit_test_data/crystal/braggdisks_cali.h5
deleted file mode 100644
index 066474fad8a3da42bb00f463898292b0ebe7b3b1..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 3099136
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%0Dqe=~$!417A)9lM
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%0ApLgM;FIns
zvU2M-3ssDVV0P(WS1o5iq^{9v)u$R>2(2#{8ODKz{eaGu)BT8x!IOPUvIY$d5(Ssf
z#lrc2&&BuOe$c)X;$Ycp3{vT#ULj#7z=Oi*rgqr~Qe<cSKHRTE!L`~UT%+S)YNUUX
z_VN-u>!JIbpq_#E!!mJO`gS0&55?NAbpoT4l5GAyZ!n%@`uO)vE4p|wBRDRh6?{&N
zPO<;01p}=n)^i!-NTfXa^TY3WUTJta=v<$Hjnl(C8kEhTqZ6eRe<>G=!^yX%YntKq
z_;lvqgeufDE`CWtG#gZ3SsU|qEP)H9wsH9HUNm~&iQix=4P>sg^nlYS&>WN^<x<1-
z);+CNHQ5xnB-E>>(v0f@uliCGu#b-`uw=l{_$TZutn8>s=|%1%8kB5IWvJhDw$26n
zEe?xXNObnkAbEudqH(M{b?laYJjNOeJa@81g$Y9_D>TUFn_dCrWYX%}vd6%%f$7ub
zu3m6_XR4@xb^oz^1}xOY(QuhWmbmO#4&3Dvk%`wDL9L?7TjxuoLC9vGxr=QFN;xzi
zS2x&+y2)N$H9H**Lzk!XT|T9v&5``L9phE>xyWOFj5Hc9{QI8%>n|C9U~GM*Z;1Sk
zxy7{KFoC-(o7(Q%^n_qeayLSEE&7n)O0F`3&rLkE!Tm0zg!y03lvrkK;CA+6(;(IX
zs#b&%w=`Elr(f$<&Z8Mvr&^;8tZ0Um4DYv6+hq{$nlrqQEgIPP+Nzl?TTth3zM5yM
z1yE(V^-grM2P{Q-4W^1pKz&s2x?EQ-42(~8SYzEV)qHGZTtE-%JfPU7ekK=m!xy|6
ze~$uJEYlz1+<B-ht(=P2%z>Mxy-!uM5|QY+C)ELl9YFUyUc+282PRdWQg1Pg!7&oA
z2geUr1I=_jt;TLD=9k*68P(08mf^7ai2F@ApTy2R|86Qg&Qw3IeyaiurX{`Qd8gqf
z{a4Pb{YkL+$hAEd>$;^V4m>mWnT5e)$2t6NCPMJ_7ZkTOTTqdc+hL{Tay&1h-&7hT
zKydZ*ix<__K<eUt={27zn7Q;lrQv)6xM}8|ju2W#@tRTOduhFJfveGsIwThKHYj4*
zr#wOC@r6dqmPxqAEcj=(C<Z<z)oVGW<s*rSm^(c$*N|W$IkA6M3?%jF2Z(fyqPIF5
z=?L?EV&)w9T^V9PUOq}dwsZ(}#DAImfc^DdDI{9&M<OBBLncACuNRWOmg_{kSVK&0
zMji%O|HiU#=*wnmA1Z7-Q`L11p|}iLmdDOmFY7(0<vNP>n2E9R?=nZw`y+Cnc5Xz#
z-<g05Ur-~?9j+r2WU5B(r%0WwZ(+VfnkH8g+akOiENA1u^_Sop7LNk#$H^l)A$Znc
z228mIgpwQwQJ}#-D$&s}$cS;8XM8e(Z0QGg7d#i?#qZ98$=||ot`FPgWYaw8BNIe-
z7qFj8v+U1Hw@?V;$r_b3Uq;6);_}k@>oNcIR=Llu5U6*vaFn~Y2^CB3+P$y);Ox|1
zKXYj?oO^V9+lprfj;l`h1dJ>|rQR(spV&ayjE}kfx~v(D4~C4+IcLH56uszoQh_id
zwV<<iHxF`R4E!#eE+D3K%apH7*uV2{p8V(2`?j<FyYNFT(phPcTl_T+!BYc+<vcWm
z;~oAd4%-@{g~6a_d`~qXGFi||(wmHMol=j+L;EX`-5eVc8l8mQa&8gt3)tuKCR^w6
z!Fm)GHz%Qb^(V6K&b|9~sTw3cGT+nN--Dk|$&)hNZwi0#>;0{|O0e{5i%oey223nJ
zES|lqhOopEh{ino^gH)Wu7_5DlIZ4hg8T$JlX#p`$-NAA)$K^4rDlQo_w`P1hC%dk
zxzoViun^8~s?29%KMub(?To!b4{9SzKT$`K584&ZSll)Wt86U0TT1h=uB0~k#xoZ_
zL&fJmO*6m~-L9d`+628hP3HSta-jFi7?-r`64JYU_ONh$F9_xQc*94X4MGoB>c?w)
z0PeY;Gb$^G_&z75U&2}7YB;i2{cHx=+WQGdoTx|RCrP*?TQa~NDlPi}bGTD3(DjWE
zgF8cE`QVE*ko#k;`)7X><UcW<qoPlNP;aRA@=AtH(d6?Fj`gF8fjt@q&QS<-85^%y
zN`fbmVx$%YVTe(%EMvy272WcwNgb_EfV?~HG!O2sfpE}7_Ml=H$ocR8&3Qfso{YVZ
zpY&LTqif%v6J3}Frdyu|Jj<eBxa*}*kzEgBey7cSIHL$PbT~r>=Ga~k@@ApwA4B_I
z+6z&U;+%mcSK;Rh5tui{N<*C052FD!OlP%5(MiMR%iNq1P;E@nnQ$uz&P>u~6Lq(N
znVArgEzYUp41J9DQLRCFq9hZ$$_g?Nd9^2j^D@RkV2@;D2}q(&KM~k&g`ns*;kaU~
z%arl?DtTxG*ZsGeGH~C^dS&{wj%*0bY<X8G7~y<tzSGS8e;1KEXa1TyZwNf5*FOAe
zs~vq%JYf=Gv5N9I`rco-8;tp^iN9E`wZNhHHHq-GDpc?%+^d8w7@8h@y*FIZ3x<8^
z`5Xaj=wagI-`=$#kbf>ZaEW~wbCA3b-o1i-;K2*oGtog1r#k*Y3-_sXp1;|D#SrIs
zrDtZhiv)nw$C48iI~$P09dc%xb^tgMz7b`!1YqvcfWNjA)`hhV$Gxmxh6z<eb7Mb$
z%;{YlI`?J`<vnuJ;@@aP`$;6KwD0=?on!BTJ9%@EE<||rM|A>nV%;YWQ2Bw~!V5wA
zGdO1{!!6+x?GV__(LOLB_63SVtC5mFXAtMIM^fL>S(u!CB+Gfy2P9PG(g$V7kgEZ=
zi~h_QQkXxIvrL6^Z~u}nk&VnDz4+t5P2VoUT-w!)y(MqB`nLUBy3rzNW;=-Zx8VGN
zu%j}y1Kwa8okSHNzlI(}6Fs-!YX|aUyN^knyx~RauK}}nD`=EnUCvT)3=(MyU)*!?
zhEJ;mo#f&XaOvrux=z=Qntn_^xqTS(22n<m^3n$AZs?qBd$I~HI(MC^b-lpdsOGQY
zwFacPEgaxrTo2M@o1_A~UcmEj-T9A0xbMtMyVh?tXzBpk`B;th*3-h~w+0Rq>`6b2
zYo5LVjIsAJxz4^tF5QEbX?(vSiT8ESM(h`0|H2p<i*-XVKUF%8`*wERr*s75$AAM=
z1~|qmaNqBNjZ|wZ)Vr!bYMaNr+LQYeZgVGrUcrQV#E%vb`f{vg5U*2r`Do88h5ba;
zog~e4-8HaoU`CnwrwUYeat^1$1Y$VaU{^O;31h-Z2UH|_pw2<5h86cgUfZa3MGjYh
zSKen!!>&;{_uHY^PjVh|NN$@s{C`}XcR1GJ+y6s$W(gHCi!`)loG3(!D3!=aNhKpP
zDl;Ql*?Z4q?~Kddd+)vH&5fkg?|Od6^L_sK{`)y_9PZ<DU*~n6=llJB3D$t@T!PZ4
zp9`qh!+SaWNgImfduC}iR|Z*x$d#qVHIy?R-8sg9bHt;ae2vXY;Ho4K-Nr-)YW{pQ
zHV5x>f1lM`T`MXE>v=AwmGK2Ur`(<X_@@PucUv}M7xSTB>BDSo#{x9SS5)wP8bjsB
zlsgu(@*&>IIptvD8r<2_z5K0h5GA@=%1LVG0rY&OE4wy@^56JRjS$B{-#p?0+k<Ry
zP(P_<gy*1-=%!a2H##B3!tSWS?<{DeC4Ip2u^+wTA$1WKFGGKmIO)gP(%_whkp#(J
zHc+p%eEJC8An1IKp~C1pG;e6q%5@Av>L%U5)AI-jO0gf#ucyK`&BmDWuL1C#Ft`*j
zHHjKXV$Zg_r$Uut*Uq$P11yWRi)3J37>h=$M9;G%5I27z$27DEjM_K<+6Avd#QUcc
zd!31p>702^C~6AlP30<bdrcrKHP@y$A&C&QGM3=GSO@|82Blknb|OkUu|4ONScv?6
zgrfX75%}0sj%~~lpx<+-Bm>uTsczYT?)@8}qhlZ<RXq##S01)Jm&5)y=fHi&f3|>`
z=Jiw}=1hHTe07v~BL+BbWlSY}#dG-qG+@!O24q2%j;nxw-iJ)v+bkC%j<M%{KeCNH
zSr_#^Sz@pbSju8Na{wKxKHI9Ifpf@iE1%|-iH5pv?=1_rCiJ9T<X0ayS+hO;W_R^S
zG|Z<w6YW12irPr)2Ykwi=$X=WlgBera4D06^=8usya_oo(3Us=?ED;8OB|wLNlQ<s
zuJao-R!Xr-sLZ2t4NC=MAESWGFI_Q>5$7Z}7M;5rKLEnPG)B`nk5$;bRn*sF9PwTB
z3w(rm8o{#*)&}nXqksRmv3If$?Mr$-&)B<)7`R3EMB*agU9QHupJESUVk5GT9@>Dk
zLNm{r)o@^+|NUaHeF-TEo@}kUy^74dzU+5v2#0>NvQ-VX6=2+IE{fxxgL1Qd5wxM<
zaH5Q;eQ&l44U?(f-q0RE(Yrmghcv?>h@8J7(RvLQHlz<cBE@_>$+vM|w?aT1j$PxG
zngA;KH&=Vqdr;K4i1o3eV0d$G#aMz9`@TaK3@FO+{VtAI5S0eQ=f^Vod}(Vy_tkc(
zq176u_6+ax#|C5F<@<|kGAqa;W#9U#?g_LzTk?^?Di}6Tiz#O?U_Jkr&_Yui0t%cC
zPknel2=1x>nDgi!1>J#SHZkorR5fa#riJ-NzJEl5-uziZbA>y#MW4ISzNWW?ab?VJ
zHM;rH8S8XqHsf*x<h#(#j^^Bw<v`F*A~C8tIg4nj_P%xGRKba#CsgX41L4qOb9&=1
zytkv(br)NmK`RUbTlaPX;AYk#$@$0)^tj~0)aNyvf6}7(tn^_3cs^8{cEbDQMD8~J
zeVOY}WUjE&su2JYe&~|XXCl)0`TQ*b?-8>H7bb%K`or1(Jx~9`G13~n6Dqylh(=}x
zhCX9o5*b(J_V__ssiByd0)u1=bY|a+`zmpk=tWa-7($pw-nJtr8rKMK?woH)d7cHG
zea=r;OxNH5BMq^!(GM0ix9)Ksnu9@~&<uw6-EhL1yt<BU3e0C-YB*zk=@%j&;be9P
zP>K1K^~g4YI}@!7tJw_FATl$h`E&sD%8!A{Pg5Y2zpP>1SPS(*DKpBuwOF@#@aIcf
z0+R2HYkmA^0Q&U(Uq;B)f|GH=#F}gqvN0(hx;mVJl4m=$M>A?bJ@UjP@$~>iy>_^8
zuK@3%kI3$RORR<q5vOJDnJoZYY?^=gp=OA82o~QFtA=y_aXjmBnCo77PV4~n7~=o?
z<N8`(73jZjV3_qN0<FjpvG?wsNb}&GnZ~jzkgD$HEDmgd>q=5GgvNRJ)!Dd1uTu%N
zAN=>pV&AU4MuMkWYAez-u-JEX96@+rw3H_+0Um}tab4i*f=9PZ98a(o!^f!$iwszA
zm>!y)uBtVJg39!t(q1kCCzYCxu(voj*4sDR<}(6$`b|^VDu7S-mFi%65=he1Qrh24
zAjeT3qcxoZkQ&gGi@HUGR_ouvURr&CJXyqoUSXcvr^^KPw+Q_*_It<k4C~m`eLp-9
z$OmO|CEti%A6N@{Ges<%MZfz_MBR7Ig_Dfl_FsgDkbLYN<JcFI@Z`>${9$4iyk4U1
z{}fq_IF1#(oosDKCILUCsquXIa8#oW7a6|K@K}flo?C;0sFl;1c&@BF&FFp}&tp`S
z7*G4Z?tn3_4_{U<X23`Q7<pbIf}>_Tt>7R5Zu^$K`?Qw^OFEaF$8o;gR)o-xcg|f%
z)tBe$E#WkfeX+zB6F3NMb$^|f8>f)J&;i|E$#0<lM2C4E=V6~ZKAv}2AE8>2gzp<o
zDexgMW4Qd$Hqd_R6#u6&1fmXG7oPt}f;HQpkNzH>Mj_Q1wvo@rVbE5E(El<KN=}D;
zm=aw8TF&4Z@tqZDzx>abk1i49i*1Nj3R8%B>E=J<Bg;qxNh-%@#6w(Nf!oM+oO}Dd
z&PpbD9ok4j5{tjbgWccbU-wN-!(F-O2iKD}kReZp3-kUsIHlveoI5)M9C{hYmT#4z
z`O;Og&r>l#sl-;YTS7#G?*)!0yz2yS4)a~trD%|-8GB8pLj+kjc9EE)y-1wXiBr@#
z8phNjYDh+N5YKjFMOiKpy-pG^kmANZ%rl&8*IyEGPPh6|G&uwJ#cP@P#iKyMrY6TJ
zuoot)GCtjK-a?D7Z|Bv1h=hxI7wegsu|CG9Ygp573*C{}BaM6*0So&?=HA(kqu!hT
zb(Rk%@aMm4a>70wx|sVHzrS2X7r%d)R-7XuAD7+WgYQEjj69t2X<9F&3^iIhd32!t
z>;um!WkMl<+I1~EY#qFd8_ci$+(a?Sd(Zz_hXC<~n%WxM8oEyJXG2t2LBpzsv;)c^
zP-RCOnRyG}#~u7gi|IFjM()tWGr<tp@*6a)pIbr(#h30^GG!w32;o1q__<@G@Oul&
zEvOR<p|hTvLKS(vQndIS-_v*<EihG&R<kZA@fa^6*Dz6E!r5RzXAfnBVt<U+Gt+@|
zTb#S;6eV#M^B@LJe0q|Yy9RKIFT(BAI%){qvkY7a0wXaaVny-~<Tz+y#E$i6Bm-;b
zS~~+khV48@b6ziMO;3+7VctfAQRg0x%LhP)hA!<{tpBpxq%Zkyk8@_UXg5De1_0sb
zVMS7`M=ADjEuPLGAWe#B)qMOsw4B2wrxEvgNsjjY`<H=JcSY2eD*#TNVtK}Qf(TP5
zD<81=%pzyYre^7WfA}7KI5XaP4Q)LmKU!=u3zL_nz9(Js2d^PnGGamw=%0IR>4x>k
z&lBD_og?@GXJAAaQEeXeN|*_n^OS*_Q;}obV?WU1yK$7)eHL_B1RVVvr(wrOcJ`sH
zA6)Rhm^5;oi2lA+zMX)5^-sSbeOGxupj;0<c*%GaS&3P@UeQ{C4>kfkT<85@!(B!3
z8T&F?P<JtS*0KcZg1rSPi@v~L`Y$Wz(Gt$Vm+PJ<TS1Q5b8FA?e4)%EG_sO>1DW^?
z(M)RhA#t-Hjn)!hkj=KrpkSLqsbQ}Ss7bcbQeVf_W*%So&))Vw^~vW~_McW<pI-Nb
zSnKs;-f+|>4;5Q#DNj+-dlSo|(DJ?RVu6b%s;S&#RC`A$H8rBWWv0~x<R6&BE4<P{
z$3i-*cw`0G`mQV9#=bCVUi}qgrWvH$H2mt#@ex=#x>mAse+sDQB(L!KEQ4lmQb`F_
z2RtIxdGm_Z2a;r8kY4&Z3)AymL)>_dM_biLe#~M4s@Ydc(yojk&Enf*M{l*ms7>sx
zA@M;_G~3NdnJfV}bCnOXJ1r2RA;%WQvIr&fjD|zsT0!T^#mp|zX7HsNJ6d`Y=V0wR
zyw~IzLe%9A^CY*M;DU0%t>MoD(E83K{jTXE#Ej7y#fD&B-$v`()Z7JBsm`}G%Grka
zJp0;>0%}12ZJhmBbpr%xW~z!XF2Js)hGv;XHAqG`e7tWrgl@$b_S9=nLTjWf)5QnX
zAe3Y6+{1(Yv?uSL63!a{MGdfhb)^!5<ix|6aGf5h%&vHvTnCR-zWjT`UkS4J<DB*J
z_aw&WZBYDLCj_!HlF%G32kQjp=vKyJkbJB(IHb~ntoe>8xNR1}i~S~!#}t~8@!PY?
zY&jW7a*L0-_(&nJoZ2<@$Mcg#CzaueEUc$`A`y49ssM9Mt}zs?Z=hrMnRb$9dw@H5
zcRaWQ?`57m-ZGS#MBlflwjYE}z*~x!ti8T@U~@!4AicU9r5dnOP2xU&l=|k~j1#%w
zl@Jx#x3mWHb&8EG*k42-<zJCv&IOWp&o<w<Oo548=-w%uqjvjg*SWK&vfw}O&+OzU
z+RxUr$l-L-RMu1`Z0K<;W||cv-`}OTYE(Kv$<fX_Gbj_T3mzZHcrXOFn;m{VJ~@T%
z6sS9rn`J<bwoh=<p+VGPJ1AG;fKZ>ELboG+?*#8Wxg3N2u63)dd9<l3=$@^fo!Mpz
z?3(YVoDRly+JQk(z^oU2sAulK(vl3(9f~|^12yRJ>)VNwf>;N)OXBJpm<)-W%szoZ
zIG<i5W8+3(HOi1-&<w0hf@T`w;ic=HaQ#z?h_p{Tn)hYWFnp8*&u#aTZsERU!^4B-
zL*)>JdD>DC<&(gn|MD^G5u5`OITc^{i-_Ls<2KdG!~1@wB%z4BZO{!pXm>HH8~He$
zV!tn$2rLJmp3A^>)Qm8yV#2%uLnE%o#>x^v`sFQ`92No+O(U-$lj}r!qIQwjmf}E~
zu6CLtb`ZQ6xHG&twva+WfOlR;99#=(w8<4AVh*=SmFAsw*f}pOKpr0lk8cjtCT{nm
zkSCTU1Mv&!nv1c}(^GLkX3gwCsZa{X4l~vEaS%|efmUY-YaFNxR1+P^iC}U2!S{-t
zUMTD(JiezD3wCrA)--g*@N|b~{UO^R@Ulg#OMH$2{vBm%+%=%Ny!jAGs}acIKBXn+
z5Df}sv`~rpJg1qStAA`DqKJXYq;>gdPz`zYbjV{G4X$u^{rgZ02|I!c?{HuB=Nt|D
zjwSB@WC+`g893iK;@fb>y+}A2y4rC_XAIIJBtpCm*U;i2%hkm8aQKxT3=lO38Tym_
zRtk+sMO&IyIVBvH@m&4f@fEbp@#v?W$pTbfD&MKc`A0)0>)iojt0*mcw3TXT3aNF=
zb8GR20`&=5*+r3Jct7V$;Gx<=`$NVOB{4sO`on5(2*VsopYWj%dcTR@B;MKYD;@%9
zn_-0}w-SsSIRwu8V!gzLxJ+-6VCV~gth`&3=>MN%tgB!e=T@olHwcDK9z<LPGbrND
zg`bD<|0m%uS!Fegb1a<>rHUnC9TmlLexgAgn*Y<kzFQm!Gp{H;Y7~fQbEIv&Yy2}R
zPcaJZstbfm6O=_8a;xZ_jZ(si;w@w@o<Uu#6!?GV<dt0Gwb;=OBr0oBXGakTZ8A(8
z@3{#`q<3InpWZhR@-2L7JRbmdCJ)qfVuw-S{gv={`ID%}%%*QRGXSo>XYBSNUqDyJ
zB5ZY()=;Aw^U+6k0pK-oKC^{y95r~|Sx?0|=jMO3hCKTGfit9_WT0ye9e>S5{5(WJ
zr{;*(iV6Op=)g(OPH0C74@^^&eTc~a`6Bt%aDRA8vEjtaxem^U?d6BFH&FErGnOef
ze=tYyGc_AF(BXjhj!IuQ&~=%A)fP<tAo5@R6TN*_?~Z>XqQ{9X*1R)N<(Ck5mV#dD
z%SU5X()8=dpK5refYKb&IXBj%dnu)gUB6Uo(lmmrz)tiO_IpQ7JXK4^oRQ@HO}~EN
zyi&ISRl|(nGzhPCYO7<NgOqFr0n_XO5Y(Z2abCR~L~p*Zd(F`Ut?pHOW?XL2;1*sT
z-#81LBevHPUt*s&Yr_1se*E+Hj60>z7s2XT(x}^y7HHSJGB#Q@3D2pkTuzx`t~5uY
z3eAxgV7e2QD(<}it>3*)ZjrWw<W{fPSKbE9-FfJJ*JA;WN*62md{_m=7uN3CdG&Dg
zcR;YGBmrV;#z~3_2GMYd_oL^{weYL3Hl|y65uC=U<T&g{(T4{Se=luUgGs-@(93yz
ze;EnvW{MbuZJ;9;o2~+4VzwT=$rQw|jf}e%j-w)hzFZ&Ya$qdXGcwVrhgTBaB?b%&
zAUvm$73f_C%l?_?r*S=?4?gor^~?%lW&Z6c=3EH!XZ~dJT%Us4KI+fTN9w>;^`FO$
zr-fh}eLkaiV;oJd-scxB#Cv8biy@;Yg;02TdO!@%XZ%v7<L9s*Q=db@%21{dF75pi
zO2Fsotp{~8SJv85e1LkUK2st5az8~dzOjH_F8(&RdE1I^8tC2{3@d<k{=%~8)j?3-
zul(rsz9}@_dEZz>C?6^#Ddci-9kRUaBT|I-3xQI~jS7$Rz?hsuO8C?dq~931BWOB^
zir<bZ2r%WrY35{4;!+oKa(YW1W7+{Vo}@i&;hAv%>tdbFodIOY&);psT!utG>G?N$
zWr91o??mg&IP|Wacvo|I1>Lc>6eHfme%MOh-DlASP&(6PY#`nX6y$uN?)e$O5HuaJ
z>V*3h4v(R4bQ_QwOPY%0(m<K_*_(rwMD)8Q?U){WFVr;k_iapk2d+QHO8I!c`TgM1
z-FMixKj}GbSw4exFPl5GH`K$>fN=mf&Eq+A=O_{NR3w8mJu{+9#`#!5rrHeGac+d-
ze$&OgBseYbX6L*R_CbynS1^clp#rwB3EKE1*dE|2u@f$WeOq>)C7TK8<-S*)E4+#D
zq<Zd<*TyW?l~6PD306XVM81PNeIkUt<l=Fb`GNlPdEP6h7S*Om06yXJYh%?L@OE-7
zF8T2~zQ?HXE)wG*qP9`zw(SDah|IqKt!os*>$ysn9pd5KMfqcz2Nuy}UxBA%&nlvK
z`!PP#6$gJVaW__$VP0kDke?l6FCyNtZQ(y02l0PilPED_pS@VhrMtbefJpq*3Mga2
z__{OclQS)Nzd<anF-%9qpR9cs8e@R5*dzI>=q#9?i+`s_-GID8XaBkI#DI|MdXXW?
zD%@TE6}^P@>LLl@4MR-PZ~^HFB}Z+;&~J%Sja!2t_xGvbEy`$!DinJ3cNxK*!F|S6
z4n&y0t<sg;90mV5XK1XXCH1)$kjVoE4zZ_E5X#@+Lw_0bJdP+XRwk~aeJrE95`QBh
zVa0Cq*Zv_8*8JAy$G(LO*3#E*ypI62bo&q5LUWLLkV5;=d92$TkWQgK6afthRZg{I
z`KZgB{>YV|9iU<Jr2bi8I8cOaidgVZ0FV36rcv!06gfvZnCBV}UcDmM%p*sU@zIS=
zZ|zM8Y|omTF%O5D<5@mza%C`lmbXvIXbWxi*mIPA4g<1)qQm`)n}7mSkFm)U&~TDS
z+<-wCyk&mJ8a7o94GY$<{+=TuRadPq%UPjtGA*F2MPeSsR5He2Jh}+l$+MI8OCb;@
zkxKi`Wed8?>59$eW{`;yfx!1880a3|j#xKdMV*AQa~!g(aDJ|apL8Y&6j~(70(Uxr
zDt+iXsp=5?%w@jG(j5f<Y;CI?7m9)D^Ao2DrB0;8@N&Y&C<sixKceoLS%-nZ8@0i+
z-e}i@MmNzS2pU_)^R{M|(Tac)i{kA~v{<H@n%Ni#C#&sB>OYO63#K$3Pd=@HtB})s
z9pgYa9Y0L1xYdgS?i+qJeXs_K9-3B}bpeoiJyF}Ti-0z+>fB@0AfU6Yb8H9c0>DLx
zWt@R`1fA{9BNq2<AWqe_+Eb4HP|dvNL9=fJJuJKzb)st;jTyp9s<b~O@+2J8E?$A%
z*B(KOtaFGwOYZLqsXv_muln@;!^ZKSy87tz;)#DYwDutN`d(A>I-S&!-(TF~Pc@*2
zb0g1X=yBb;lDBgA>3%7Th37%1aUD9O=UrZ<mId#*#pJw`W`W<fnd>X&aOcZ*UrsBU
zMmM{tO+s+J%c&1E&BnR~eftC<CiyZ5d~%<c_4z2II8MYS&Mp9Da%s7(SSxh@IV`mF
zwF7jTBeGVau>PQE^oH!uc@QWL8hGc`4lWu8JzhriNyc?dhN|(+LC@y|P95%caCqCh
z^6xd)EhxFw1xl@ew)8xKq^KEg35dKsV!r@#fh0B)HLKv#+!^Pf(hN~McS9<$Uim@j
zqen!^B`|&S{3d$X1gcXtclw08;Ozm)teGgRo4Oxnv%XRbA35sFZ{xmX)!S(A%ePVF
zbhSE0Y^@sf&abAKHZEYkLU^MIM=P32cr;9+R}Bky3}49YCjd38xUDB;H)N_0pD+De
z1zQa&e=aCbfv1Or%AenLkht%Lilsp%xLl1iGrNMnpLNg53H}3UTZNbLcx(ks(vqoI
zV@}6beM*t6I({#u_m!|tAlQ`7$f+FaLLbH)-6VwCVd^Q>WSm<mSTd7s+L;!ih9j?@
zI$@5%x17nISF=C<@BfV#2{38L`x1_$y_8ndxDT7z2y)ZF_o?uOyejP5Aw2(E)IMAQ
zrbi=0ue=)vdurC{!&WQk^<8hRYYYW&um2IxO@nsCJ>XK1c{(4-dzF8rbk7GrFMWZY
zm}2x-{6MaJ5dp%ot&fb5<U^xTV;70;8h9yq`F+Lrfg0Ao(mzb|z}|T<it-Syr^7TK
z*-87s-PyLZ;A%EpX-VCzJGFqqy4FU2JRAkDuL>7t-erN~q_=E&$TsW_mhR9J2Vp<8
zj&T7^8u0F&X&4g4`wfa*pM~09;3#0OG0OZ7i8S<`*0^7J%IiWhS=fb~$+PJ@w7x?e
z$*1hY*w4k1cj+isH~~cj4b%A~V~&Z*+UUCf6e7KglPx@!QTOkA--G{tgJScXro(ze
zP;zGP#v{%xM7nVCl(XnJ;2o+sWo*0+`}z*G%>-?L@}l(~6V8<`IboNTDm9DdGS=IV
zdX@ow_%8vSS1Ir@-In3gFy@5kxjZsIunub<L#|xIx+NOQEqlGbO&A_%w%JcRjcS#4
zV%0Mef$rj0!*!1`WNvJCg4=+I&flCkOonqANlz(PjW`gXmr-4laeN((3|znKe>?$f
z4oSu=j!(jY8M|rcU*l+Gy@2KWu>=tCIbQSOa4~E$l1a0&_Mo%H?RDQN<6-Kdt5$vJ
zB#P%WNRGvOJJF2^Enh+$NQ|KiUicpN@8T&Gr_zl$o5l1})Z*ZBwpZ6h{J90w472Bk
z^n$(?-<z(#v7k3h5uy6F39U*5g*`a3fNURks6I@?dougL7azID(FA9OX{N&{64xDU
zoqG@qRSS|cjkwR_;nDwg=xQ(0E@0rgu@M8pt}b>p9W$tk^N?psC;^Fg`}6#|77fYq
zqanxUW}$COE=n>9>(eJ+scK!0hGSRf<yP^1>hNSxr;P^Is|-m|tS^T{RQZKpV;@SO
zhvoiSRLLe9Z1-_+pAX0U8*4Lb@kMy^joa4<=WEWrP|;%f69#uW9#NB7t^>m=_5Ovq
zIkb)5sXiGCgVFe^f2x0nLFy~XAI5{@@WW4Brl$>a2qdJ*(+bxisOWG0Sa>|@BzrND
z+!6-IlBoVjHFbkQWl`*2%`j+nMfmRKhQXJ1Taho{7m)a1QPdLODym(fKC)dD2AY4n
z)P6Fpz+-}eOTzFpTo|TnIvp4a&llsR%<*1`Q~JChJ^MBqU9A(RH4DW$0(0_fuRGxg
z^La-L=~a|C*|bQu69T!9N}rFFVqS!dx4_xkbKsrVwnwuU0;(s@O%-7-ui9{d?s4`_
z2*07?%6dHnC|gs$O*xE%;`t}VlkeJ)udXiNzEdGE<3w*Bld^&;`#%=_ot!{{%5tO8
zr$fM2(&76zFPsN`msQ1&iU=2;%Na(92E#_?cy-*~4CpEE>-zCx2A;EY-{-3ff;RRF
zd*<yal<XQ8;TSW8T<*86iZ%qo2g2)?yW^c`dc9EV?8+)S%}A;-7#0BB&P|aC%%f=X
zuHeVhf}5b_m`z1S@P`ZkRiC1-Wh}6*Ss)A2gEyiEB#=c#oR0Mw3Mt-OW4xBcMkHKM
z(qTn60~9?Td*whTwW0T-lnmD)248C)Nvdr4IbzD_{9zqrT1hWOUvC77t45h$3Z~J-
zU5Ar48gpRk9Q28UWf1s1Wtpg&@mxWaweEb|0ML39S?z-BL5zaDJowxK1b+xQdULrG
z9x45avx;5-Udc%#_s&(!MN5iGEb9Pc=Bo0k&vRwF6RN5HhI2rOU7WsM)((75zi(Ju
z452M;-m3%2lMs5hr@Sww9X?!>{5vh#4bJ)hde{}((bW5@1}&#H_>;x{0^z!KeET6!
ze_t!~+{-CvW^V;2HKtJpixRYNA=i2X`|b^04j$RaY=G8M)~tuCYhW$)j>gHY3rzIR
zq@5P22N4;+5BfM~z_wwi@d@n^*idt$CZT$8qvXqR!t+eM00}Ndyl>N}jP;metAnwi
zBeL`P{czjLT$JYbA`sR!^nLHufct05`<e?2i0RPg4bJIS^xEU`&vK7yi1d3C;YN-5
z;=vDB+6PBbYsrdaA5_5GmygaI@G3)G=!m)1`F?bMou(y_yc|A$4Q}Ws#kuOCPUdq&
z?2mF&=VJ{lg9EpY_4Mguzk7ZC(Qh5O$kDet{`H+QU@z7$e}(T2Z1)zJ%7iCTiD>xk
z#`IEPTc^8lDsu{@Pw#x$e6WoET<kWJ?koU}5c{k;<0-iNQ|!XA_l;0uJ(<I^mk0ct
zBtNI5#^J3<i31m&uUu>1(65io1J8wyk1@YC;NM3<#_#v~(8)NnGx`@Z!TYCnUwq&^
z>Rze{X_Xy^2MlM*g9S3N|8^jb0p}=gjtF;1oWOjk13Eu{^<}^{7Ux&-I2Ui!U9#@a
zF!mLu+VVcQln!SF4&RgE?n1`$J+W;Z9S|d2GQk#*281L19Y^vL(6mfW&%PgXXnuVS
z6Un}VVhKIX8lI;NZt_~%Sk0lH<<N+89p9i_W;3Y~`}Rb$rfcu4ts~;GZ@<*_QXur4
z!rpxcd}t?(+FNm8{sS?_+&nQEW@~RByo)*QcE8Ua@47?)-$<SpgRM!R8R95Vn6VAB
zhkJ6H`8VK<x5@S>&S&wWDtyovnUBVPs<RiM4P<IFnlU4l1b<3I)0N|=U~tgK&<(~>
zwv0W2{yVNuEN}JL@V!!svOeuhHs&E0>NxA%OoX-X2`Ln08xYn=Ti7cbg7!+(-<`Bb
zfaD6pnD8UhNX0_Y^3j0_5WN+tTA3LSx?>tsE%JCjNA;U<TDctkm=awrREq~zh1_tR
z&<gCgn7CxEgL6{$X$5QA#KG#q&W_*j0+36U_I%w#K%8l@BsVu>fvbsmVE6PEBn>Z?
zSNKn(HB<g@-Gx}p^LCb0-kC(=YUv%UhwIR!ueWdiOe~bAIelk{Ac7|K_DglUbr|M2
zV@+Kc3t57e*M--|z#;T_(+RseL_4Xu-sKkyD+<&(2Sf6}b>8xzCH8a9+ZgqQImd$1
zkTP3@<pNmtEJlk95fS(FzK^o9v4DQ7J&ewtMGvex-X+bIgVIf>`=6F$KqmX9xHR_j
z|2bQxbsPxj*sA%}lT<N4C8TB(fxlmy)Nj1J%Gc1cSqh*2{urpKey5P&g!d}m^}4s>
zvHo_}UBPHK8mz_K!v&sg<DACtc@<HEaQzG2iN_n5zq9k2dHLxQd}&$Cax7RydZzz)
zIv1ni4XYk!DCVo!GDY2u!t=@VLlxZJ(NS>Ol$4)-8uLfOe{{)2RG^35f_r44QBYyO
zclzMVG5AKEn9{hn0oO{Md@Fl#o_o-}8#ARFNcUAlTABdndpN9Ud0&jgxj(;1lI{~x
zslD)-l(U#yWq5%+aVP@L(S5NIEZc_UufOhnBJV<sYsQfq#Sy?Hu10UPZw_8|o-kdP
z!g-N`-;9rYM8NC1$FdC12*}S(vym))4Q&flRaM!9gU`J4n08k?uuO$i*{O_x7eV#c
zqx<3icOJgE)g*DJZ3~faQXTfZ8HV@Vd|zFjtOAF`jZb`(RcJYl>Es=SFklxuZP-kK
zeW*_#ItwJN0T(IVMfvVfI7V&rvSw!qZ7qw?dtcZ>%$}TAkClf)&$F0YX9Xrvd5>B?
z=Nu7axHvV9NkZY`f7K_iwNJAPHyY7U>Y18W<r&E5y3JL}NiIbi9ufYJ!vMZSng-2(
zaE7q{_=#I(yAZ4q>7~rn05yDl56Fen@w~c5U+2{_7^${%`P&9S_`R-!3{G?4^x%rn
zwL#3OJ=gwAAM5Oi8K1g-$6zimY0a+5r(sZ(U==tQ(Fl#Byw<0-rcvQmMPUx6B{lte
z?5;stjtmEC(>-yW2wwg~@(()ULU3aBwTUheLyI*}tZ^>C(l9e^dOOr?##3EV9)us_
zs!q2nD`5K5vpMD^oFDP{^QJA|0x*a3+`l=o3KV_Px2!UoVR1cY@+utxg`Tv37Q{IO
zk^k!c@dq?RGx?>>=)xwTm3=hw6#w2`hhO3H0@z2g-)zne^EP^Z+?pBV=z<hW-4y?m
zjZpaQ!|8OayV$n0YQCc~iZ*kvs$a&w39-TYuEM<qh@!K2B45!8Q`e0s$!^ra{Sxja
z<Fix1X#MhF^aRf7{A@kLdZ`@zH14mj&h)|Q8_dfGHx}WapA4lzOd0GO-6wQSc>tIx
zj{htapF~eq7*{WKmEfE`<pbVRlW^sO>jb4oEfmP@k2_0M0+RXxYG3yeK(Ly)(*A4^
znGgK63L^Y~yV0x>3^Lm=bL|&dndSy4Xpn#U_^Jr5ZM{8G$5w(Q>&<5>4EoUV=b`?B
zQ~7X@Mo5X>Yys^YWM>u9XhSyhq)pV~d3gRaaYw$r5G9NVj6J#81KF7kT8JzU{2nNa
z#o9HY(t9?Ss@`J%L6oob-LPDU_8E6{n_q*3sEFHg8U!#}XuWeuCl|_=q|M>qI#gS|
zYy5sC8WAXY!?P@M;PqQ;3Yyp3K+_qu<%#!pXBLlW8mi`i(Lu^X{Pzb?Qr{((3G7>1
z{$jy9&7Tdzx>D|K<3;fE>%8<&stw3(2wFPyFcYe@d6O(ArogEpP;~m#I9j89nz}+r
zgCk06dJ&k*Vt>MmQ_gc4{r(U(s<)H|`6u7+F74nv^KmP&cK;qkDJ*biF**&>DGkH-
ztUjWEv=0^KQL|{A)ND3m{yVt*?U+4!aSN0)b@l{`W)NRoj$VLJDvW=8x+5f52${S}
z_jF_XVOQR|q~XUms9kfft3RKHhP{)ecPKWIzD(o80M>6{IzdG;jQK4WHHOH)B@mG6
zm&L-m))dU2dreYiMMOzLsmp0sdZAfLeX`s?1*A?`7iQu<OmW}#{0qZ%5NeHeAW$U(
zQST<r`k^lHZ+qgw{bK_x<kQ7je<#6@lYUPaG{%tpq}+EUTwkR+glTEJli*NF`H66+
zSzt_AIqv(R96g@=%iW3n2YORVuNZ%>AXk27pT-MIpz+M>obUT2kWBAsNq)T!mD`)d
z(`@so+NScIzjhK>)u(wb+jgN@f@|#g%?>EN0_l3s6X3(EBhhcdrx1Pn1Lq0jCG?VW
z79QNk`DZmbo7cnhLA;FfOgZlw8oj|)gL*N)SeyHtrso*CpV#KK#JdTO0+TWxE%8vk
z&c98=KaGBWjO6R(m;kF);lz=H@lds!!Sd!H{<}<$p*%Dtz_T^>zGx&4+6PAx=!F+h
zZAPHvbM-N(`!><7-W&^ZlYb4Ueh;I|5}y|@S}vmbhi5L2;66{f=AoVt^&sdizW+Ov
zx`}Lg(vu!o#DY5gf^bkY0iC?7y&cikjdG356clD-z+#PkkVAU|tsUlKxojMVj;Q_0
z^b3iGPhE=bGCi9xJ_f&O=oY|R@hmlSPXxS@{On^BzK-v)XEd)JnuS~SGI>85a9!c&
z(OB=o`pLs8A(iYKsP^u#sR(}r^kiH9OJAA=V)e~&UByXYJDv1|fh7de?l31S$gaSc
zh|TwuTk|NQ|HN5E#t``R`LfXizd1lBS)P;dEFt9-?&F@jL7=Im^f<_C4DDY2>MlS*
zL^ZVgoe$vW>?h__o1gTeAF4Jc7OiXWQbRw5ye$a2rVMIKcjwXJSL|O-r>r7bH)$z@
zgF&Fa5|o?$Y8>4Pqexjj)ea4=GlgvSfe?C8fXesP7^-{yVxFyO1!7OFg}&kogymym
zznK1Dz2*PDCymd1RxV>*$$b3To`tjx<m;4p*pz^M+eg=y_Q?hSkB7mvz{^-CwVR@p
zk<tsbn=<R=tO0Q8zv@$AdmvfT?sKgFF+A?1=nRgjit(9Flv0`#99J{l8_?0Iwvl3{
z84#=Xyc6xP3)??z-~QG02l)YmVr9`e;4Sl?Q*Ido=?ZcOr9GS<<G4Di{~!~Rdn){z
zEQTQQ#zqD4Grq?)yLzIXNeED3RGic72hrf&ufFX~uo^4ecD{QW9s4w?vKQO~!@jXQ
z9q9{jnS^gv|K%vosZqH4(V+{XuQ;EY#`mC}tyq;5^EUMC^SP)KI7cX#OMyf4dKb*R
zkTCS(Xh%IG7grg6Rlz>h$1<*%A5Z50{*Bj_Omwp8{;5AKRd7FERo#1d4LCU{#+7g$
z^Ag$Vf0h3#VJqf(>Lo@3a+%KKufcjT>x_A+zwaucCyg`7rl%BL8a&4_;!Xga;FZO;
z7nKmT*#7k(u4lg)b!>C5FMy|N|5c~W3fRc|dGPMN1qiI|kTLddg<#QBSMt*<;M=p`
zyCZ)lfVSb)E%&r~aN1)C@_tnTlA5F%?*ylSGBv?Z`|&tB@Un293{5#0H6}bh&oBiZ
z-j9p;aK7O5m*e%c2?);2nLSv&GYAu058un)F9%Nh{Lrd*Wnj{E_I&`Zi<bW0jT&dx
zpsb|Ts$ZZCCV7QEE6NkVvVhF3=S??w33$Ru_hN86W0H;(@cXgw^b|`?4>Hwb&Ha^@
z5BX(`N$Y0`a9nsnOz$}X*XKBwD}woO)PZV<7IOv2vl_K?1shP6oj7$l?w{nk3fewk
zU$W_Y_7Xdd6_i~!L6~RBg%>NfibU*V5bw{~m9QUzleYN}18}`@xY989ez_kq+v<{7
ziJM5z^UceXtl4mkO4ND4X%bByOeCH7w~THHGaqup{duFUGwaP`q40vz<+-=-EP5#3
zDA2c*1+<pf73Q%Gwa4|d?6om}y|c@axhoS;K^A?2&^ElbJABmz?~TYpy)~8fGNHTM
z_Xod8FJkkS*LwK77`cyj2=JO@Ky~HCSJnkXQ25aPOQR+Bfj!@Lbi#gB>gpU(;jDEy
z+g228E#Zx5!W4%tm#0CcK~|=c;sDOU9Z8W~S%e)YJKnL3G?;rJhFtb<!c*#!M2$hr
z&*WVuAJzR14x+mZ?{5?!e=qJ8;nV@tS95smd1>nZy;lX6t|ZBX4RoQsudAmC=PvWE
zL^_+*qXg=<Cnh+@cGsWVNyjM}ewCJzeCwM)3={F{3H_5;|9&XCRU;AiLr2o%-wmP1
zml*sau5UurqlX{6ClkP5XrS`xIsteN%daQm{cit>dq#NX51R!pZz@J{zF0>G6O|R_
z2*gZ}y3WUg{8Ih1qZOlI{)IgCC)WhH$T_yMwBkO@Yj$tMcndO>H@nQlXAn2d^s=cR
zo(GnjNR2xWgZ@qKhBa*>_>TF{5Y^-01ZO*sf>8nVkT!cW<Im~FZq3gZ58~j}Gxs+~
zF~=f-^g{FD%{ef+WQX>!F2klpHi<cl2!5(z`s^(@$BgsJg5Oju461iUSAJSR)RtA-
z#mghm{`}fA$?jN)p?zuW$ee@LDo<ppz3+kA2kb%$0kLp&#9`7_wE~u(m&>i`5zur9
zY4@snEbvR6K3~b)i?Uud|MkOrg8br6b93B>b&+N$<&DlDqt+MaPA67D_y)rzGGa7n
z-ao^&l(&w~iO41jUckH!ljNKroD1PMb!N40dIVX>)0Wc0Ds<Cl*N%`zLsw${HM{wB
zAf@}P@p*d=IeO=ceAJ1A6Nj?3w0f6-(x~0Ee!d(@krzE|Op5@$GGV9mV_1hkm8+`}
zwF=J~zVm!i3<G}R%>yQpKi~(G&oQ~SP4v;I`CTq|7+6);WRct?LJrkg!yKh`U~i&t
zFIf-8eAmL;=C*SXH!6QK=mO@Ow@2;g_!<h_;)=yA(z7TnZ>g|bYYMrtO{!1Vgurg$
z;YY;54#dGibXmn5hF^En%{jcWev+=ABsgUl9qoB~Gqs<Hgd^Gg9^VcD?auL~1|RGP
zyi^$4X+=PnL%G<tHG`qzZQJaxM!dJ@_5R`WbP?UnN=nM23x*)B)Lja-MRZ!@<mxn@
ze?*6oUlvygf|Cjbclk+1&}|40Ez6leJ#}|O@3CS1$gJGNylXL>;u0}<8rXxj3Yci!
z-vz?u|Ef>9FX?^ko{1q%Dd+HIDP3^McouMYl1j?^k3*=$mj<LprByI_c?RbsE=DQ-
z`~$P(Y;Q(<v9D(L$USMCU%YB7aPT_cC@i+op9z#*fZ}HX87dz}QRftCM#sw@h=}M`
zWykxN9{%;VuW5tm#-ZU4O@lbkiTv8DZnq|wq#^vwJdh2+mYLqiDO<qL&b5dN^Gg>K
zcHCIsr=yp>qAbq~nxRveIyaBr6PE6oT|bR|3GR11oHT74!Q(Wa()F%>P;OuSCj74y
zTv^^aR=;cjOM{P6?0CO*<*o1^2KhFSIL{VgHdha+%V7*7MuX^A9CyDjt_#~9Pjo8J
zVt<jHtzmyN_Wk8f(kE!QqNI!N!*6M-aSrO?uOyO0@F{T^qvh*G7sQp+Q$AM$<Lc^)
z8+A9_qVSryoZ607^G7!a#Va9Y^qcNgn@N~?GMD91G>(j~b%kVnEQfyr7cc#m!8zQ5
zA5xWXFToG%lhlo;@pELNi?|0t``G1JCc-4jCxd|SGdPcG(=}B{fPfZhk~LhCuwT?)
z;hm}?f**(GIKTL;f$1|r6Rx)eV86FwA$GkCHm`_;(&M=(=^1G;hw4>;gt@#Vo<jII
z&-^JK^H_Wz-QZHi`y?%oLly<?1yG6F2&o~KDC5Qn_19LjD1UW3TL$YROkdpmNTEH2
zypGS-c)2el{UEaH_6vE?CX%_oX>$_v+gMFZBvzoQub^w^Q8tVjveM@`Z-WS@W;?~-
z4kW0x&ZeY+>y3VA!2;Ir#|3QiZ~dBwi+30=o;#fl(uOv-KAzczPOn1Oj$0cL(BaEY
z$j<_@WnRi9iy~yM#}O}ls2}|kx;|&5oCUf@LEWre1V~__FQZlIf))&$u3^c75W4IS
znqSLsuBON_aV-KY9|@MX=FfnF)$}(3J?o${tUI>9BnAB-bvZucnhwt{Co@rPb)&1d
zii;J*+CgZOSN{4|8f*>CY|aGrBdhEN4F-%)pOH;%J6N9v2U^JE-%U=yaFj9IZ^3#X
zVSRk(Y(g4r9QfvRsbd*h+FaJnd1m0=?UrSmk9aTjS%CIx(FW{qB70xg-v{+F@~;_k
zQ-IY;CjRYeKNNZ%+i7duL}brZ$LwR1q0!V>^a|Ethmq@A=XcGa7oyJYlBP)zo%qD;
zgC5Rz1KDN!fOW9B!^zKkJ_!zR4X~#06TtoF_4{LX>*xUE$T;g=?6bdB>iPFWCak9l
zi=Ag5#Q7P2xo+wwK>qm@O$V24_$@WfI`DB2mV3_I5k(Rpv%&op*}Z8L&{yTrSb_Ny
z<qkH1SK=|JB=TrTX)zLV*u32EjEK|>CBFNjILyKQ`L3F80xk~L`d&|KKsFkCT@**+
zK;^Q9|DP`_&=08i7D_|8)hg$SX1K19aa?f<pF>vkqe=pkOOWiQ+hL&{3(rMNyBt-U
zkfoCTdc~Cm6mjJ2U+N>VV80$7M=3oA<|`-ESs&G+2WOfjezakqmPGzHr3(a9u=4rK
zN!w2JM!1z#Ff|6B@8Y)&urH2B{ve(vt;43P(68@KF|g3B<!_Dmly$x#o9;%KcXfnA
zo?sdS=Ucf_tzMLam8y$ho!~lZwd9AIhcWOwUHxkf$q)GImbR(d(~FEXwXa?fj=?-$
zwkzDavp{*AUboPG6KqfDaCKmAN}L$mi7PGR@YNwtn{EF%m~1qYHu^+EUe$?*B@|o0
zmoM{FDRBm!88q0)rH+7G<PDnq2Z%7T7PoQFkAU_G1gO5P4~I|srk}rQE}^$OudmF$
z%)vQ6J-Y|W!$B&7_DPs?Kf2UBe^YV}>tKkJWC^li;9Yma8=H5Lk!2rI<8KM<=DnaA
z-U$UBZ<a=9-X1vkgTj{N70xC5Z8LV_O(<M?Z%?`hLulN5gH}d)69r~#DGeEf0+ois
ztO(T>2p`?MYj9%=?@5F7Ph1U!#Z5Pz-oslUvUWraa_3;Yw2|p4eJI4zYIOELUPOP1
z#l@SCSJD22)BV8|p|EVos&J8S3Fp}zq882DK=oXwHYlh=p(IDW{^iAPG)4bgU_4?2
z?NR?Z|E4P#3{0!b+3FXOJPUiY8S5Bqutw^sbp%87cxUlHj}`QGu=(&J-#mDiimXT*
z2E&#As!vI|SNu8F?NRA<eKVtLZ;)Po5|daanUpo{bjNjzM#SOpBrkes8muG^+t2SK
zmC9Mnp;f{4iTlXU1)9!jlqbi++oFc=k(HZp_QwJ|h!m@f|2cxr6`N=K^K^lGX3E8n
z<OF#2?{8>(_yBt0kmMY!-3jhoaW?`UHDRtHlljuIEPPJH1`bnoLh*^d`{DRre`4xj
zVF+n25?QSG2{&woggfoYXK_6t*f)1r?2RMC4GpOt>@&R>d!wbcegV=0dfo&%w?ow*
zxAuqTRXCTG<NYD+0cc$Ml59t^1jkzLS``OZ!uW+d@jgK~A4uuM+e2KfsMouT&eXdS
zGW}(>YVQsqy(_9Y78j?WPW@iPm=f-*6u*ky<t3n@{`E&TC4-QdoZ?d}Q3*mRanBA)
zj)P0AhWy;s6{Kl79VpFJ0XN<@@JxT6gqOj}T!UWAVEBYlIXSEx2-0nA$uU8YMK#S}
z&NdH|hUYRYjS7M1%lE%eTh_q&*ygo38v@i``12zM>-5~YoY;3-1|ap`sf+RwC6JzX
znr`AM=1Qzx(L53{31m(djKmVmJJm?xjXazWdCvFU)dlm=#^4ztI=4PFd$j(x@xNT?
zJ4zn+FsTb&o~OO2@}vV&`<|G;n92q1UXy<b65GJAG4a9~`%bF0&vcbn=i>c;(aCfC
z&FJQfJNGX{q@mrz%{v^CxnOho?Pp1P0=Vk8RN9>C1~(TWZoQ;jcuj3c8)7ttShibV
z*%mINImw9Cl+7HN(KX~g=DQ6Fq*VL_)QM`(obeZ3$IpS!<AOvXSg3gYiLe-eBB86Y
z^%^;#EETu?71uF^YMW>$<~3L`a-G&G$%Ll^&Mzb%)x*N0HzY4t=V5c{dMz7c28fTH
z)!UuyLhXN4p05k60Z;a0%3-c_Q2%H3CQq#!N;@=<XxFqO%e|F7>F_kz9{lx*=H~z8
zKYA}*_*{xURR{3<uzd#|%GDdI34^d^L`jv=w29n)f5;Cw_8p$wa?2v!Uyfp9%+CC&
zBmlG6=*EeFR45@Id?JABP*$Y2*Y4XsNUEyao%T%yC!H58Edm4}_;iOvU0p}PEBw0$
z@{^!L-Y}z%w-{oc-Z*~mNjItt%UuxaN(7npDXxWMrD$D{?nu=)JQv}vz9?9h2$rW~
znqGtzVNO^H$G4<))a>piGPark$2-RwuD%#Y1&6-O{D>JtM@`AxOy?4yYt$r0mth=!
ztv*gNY8nM^6V<Fo7ZQM&$(HYc`$$sj_cWRU!;n1OpL>HU0VqaE6Q)xgkS7Vz?@#<J
z%HX=LS2Gk3s78N!<-rQbFbU9+UMoPy5zUDoF7Xh3gdyAYS~oh&JXc%lN<?N^nz~)b
z<3WwQs<h8z42(z0|9NI$|JCn$U9F}#U`aPPz!p6SB4imM^hJ{>y~N}4VF%oA35U<L
zly3uh|GnQ5ct4~<_|!i23F{B9U1c|MCc?h>>op|I1SF+Zlh>#i2M28y+Ag>@A~~IZ
zMIQe!Wch$w&@Gxcu%cZydj>=>5t5}Fp~v<8h(m2mLo8e)X*uWkF$<{gYsF^0*nq#+
zlFl;N;Jw#`^(hB@Kik4?k!06O^oMTcPbQw%HQ)ZT(t3IZ{mYhS7JGwp*ey5C8Cb?Z
zP>1k#LLb&gGOn*l;B(n=QA_OUi)f(rJ$c!&b_*tEoLpXI&q2;!XMVJ9G-RpVG9F~?
zLSeyzInPW-P|CwxLl&IN;PLvw^Pw+m$oM{8z2mhmWd1&9uW2I^dRfzpGpT3M`Lgph
zu7wqFFQG;tXfP7%faGP*)#N|{MO7rwZlebIn-NZak<k2@`1C>PGQ=*kZ@u5Qh~CX?
zx0lgHLTs*a+7LGZ8D0{RkuKOoC(o}~E+$97Rf7+lZly%z&A51MEU^cujych(FNFhd
z;n<gn(s9JE*21WUbzh4#*Nx(G!{N1J^sI=%G-N4Qj2?F(q6U=*5oj<B8htiSv)0T&
zC0od&_|i>~{Cc2~sVEfOd40zpW-KEQ%f)~8#2+B>K3<-)Dg-V%=}IhOeUO!{UG~cL
zCD>;D*6RK+1imuRG+W0n!N~-d3#VD8p=dqE;>ghuxbm4gwb^MMY9Ec#DA7iu2I(-i
z7o;I@^}p&<wW!pKck=JhDc9P%gZr){VY&Arm#<MsZJk%te(2GFR&*V?`Ua=L<C|ox
z$xRZej%$m@wJ$cnhsb5!(~CHdsOarNTKobCf@z(|c_QqG{kKfhdXegqkH!*R2UvB?
ziENjxfwaQV>cqD}R5)PN;WFO{m-uYeJ{`jP@lAF)iDRQ^R3qK)lSUm>>Aw$RzdekI
zna24du9I+~UFTBs-)fM3c9iS5>=e8fbr;*$F^*1g`Zeq?uYv<l^vw^sE+7u;?oZz%
zn~}f$cJE!B<0P2VQJ35_2|pX+zbM~dh8ugkHAg*g{kVH>{p~UA&z+g6)}CsG?_4rh
zPhegtNm_YITW<nTk51hcrkw+a;GxmCJQc8=``hc5CIRuaQ@p(7fpdL@XtRHlRY0Is
zyA7Z1IIwPhp&P1PL50*t6t7Q}gGZ`jcKXT>ly79VYPQgiM)msWM###cU3c^!*LW8&
zY<{c0+SiVlLuMu>(#!DNX+vy}xe3VF&V;h=%ZAD~!*vDrrJy17Z@v!m7Hg)qp1s0;
zrr%sHnSvR`P$>3g_k-sElxIwzJ-fLGt4l7d`YuH<H(R_ReuDssHz|`mox4CrJ1%Q3
zFb@pHe$_w1=K@u~m|8w*C*tY}ZjCyVi}_Js+?b=9pzr5J;hP2vVCA3uDW4|?_c5>d
zqU5*X^B<{xp~oBWo-;RTfiDL{bpz~Ean2I=qz}IuK9@cDE#B@I&jy{R4zHMwP60&{
z|5}Y%18mS~mv`a32DZ?q^=zX~)a7EhK;PI7qVK$Ztrld#(1l{18?jR;Lod=NENvMj
zYcmd4r)R-~#o|}qhX;_W>gDI|k4unjo{dclMHYnm$7bE}8UzaE)>~C2lc=|p&HOWE
zCL~-IS+@VxitaX9lB6BaN6{ziT)afnVPe%hy=)if_0m@dZ~ehM+!Db66RR}rza4UG
zQXB%m?OaZYUz_M=mav4UQYth#GM3w49Y@OXZ{A(Fj&n+O35@T}z5(U!c86f~d>Bpr
zPV_e$fS`M7gPLP0u#+H{5&m%-j0HVoX?+KQJ5(;cvkE`2yOucdZ4wna=;koZPC)xd
zmXwR#$-vu78pLHf2;QGq0xQ-_V78C#loLDV#m6?UM2e*$VX=ZmQDq_`KW;Q5_6qAJ
ze%~9ua};x{_Be+wJj3;_=A;q3XCiRCy={G1cn;=+`~B#ZYmv=m&FO+?@$mOl@#;X=
zGL$B2FgBA<L*h(a-YbQ8_>xMxI^~8rNuL#xexAm>yZy$sBKzXOlfnPz<DMmm-Q3wb
zpqY<WYgsQ3SjWN3zt;@J(q_?8h-OoR7tXc&?DF~WWGt9!{6DVVI~)t}?c<h6ijs`V
zOc^O6d!CdAk!(T~LPQeUp_GOsd+)vXcA43G@4fe4;k};s{XNg|9>0Hb9QSb_cj><G
z>%7kM{C+=QjuzwFt4J*_sFeJE2MW;=GI-D%1|G4sSKL>z{zaN+v*ch2vDz^%i0p;J
zc-GwA`?G&hKnsK9rsNd5)V0O5)Ex@t;pDVh_Yk6p@Cnn^!~AWHm)ox^Lt%m?sL4II
z1!Y`yFU`Ncf~Z(Lwk&f)VXENQfe-FWzUwgTY7kDKm#sA1#9E=iYdB7-NjZ%Y`3!Hp
za~%MMBGQ}fX}Es)IDa@Cz61_t!|n>f%Sg*t=){|+Az+d-tWEG}5ZOKLy}W#77-a|5
z+$vTGf$dD$8)-W|$VV;jCy~l5>g*O<_>A@OWHYm0iRvam2|aw$b8Q6nZ#b@Bwg`sH
zEsJhW_m|KoSLR{jhz3O9lwQoN5CqJZ(hT#Sk3;yjI<cua_B-(YTcbW22u})Q%+5~F
z!=lZBiY4YT{X5EpOe_6iP}SU>IbjXVC`269Jtjdj`GrFHXMbR$3Y&A0%!g?g1+pss
zWkmh1oG#AZA4Z?6XN{5%A@k?dk)P<+&==X#qH~=7aBVh{{Ayz-3XySZyYX-huHR~<
z`g6e_;({$@9@#A;zYl$%DE$^-NIpSi9Y0Pw{KzD9Zvrg2q&k!^mxs+KT5;Fk4~~g&
zTut+LLxd*M7dlQ%qNgkm{RcVm94}U8SKEFV4IazUX%((S+&Kaw4`#i=D)5%|MV};?
z*J5DezJc=vhsAFU&wE4cpAk0k!UZHTySlqkwTd|Qn>HGjJwY}7s{)Zr7P8Dc9(2pG
z9d<8IoAhO39#6vY<W1^MU}rg1jK=4Yw)~Ij<F7nH<iG0E0VT_Q11%%;JvfZhx84$2
z<VRfQts<4O&b=ezc(oeU##OC5@sER#XDYqdR|2WRLxb(kPSvo%)UC*a#*n1rBmw2l
zAfT_O$47})!Q;q&$Miuv?nAQ6Ez9bm_V9Z;5t=2Wr#x6`5#IxoQ8wzL{eM9&OYx-m
zP%rwoupS|oGXgTCH~PHS%ArDamreP;2RN;@ZKm|%+$Dj}UzKi@L0n0BuI17q2+C*F
zOse*vfWPV5#yO?H-gTtcF>V^k@6qRd`_zb%0^)la9PnNzr}oTIypK^h{H3;{vmd?6
zGnk&=E(XCsuDk)OQK<NmB;-GX{Y7SC%T$ZSAkFeOIQ?xm&=#voJr|jUhW&JjLqZ4!
z_{?-|PWQkY;k=uiY9;XR{jA`_Q$<i&D;N9sato~49XHX9X+pCSmK?T~1t8WexpWTS
zXCLR?pKB?dLkAgQ1QUt5Ag~{Jo*mEkj*z+?@I{TFw!<|?skyVUpFxFu%wrT%$ez~a
zU6==@Rvo(iTD(VgA^vqea2oDCe!?9-wEzwg`doHc7dLw&+TkeH)BiYlxu30F4UCt~
zXFS|8z{qy>lCS?Fs05xofBs1;aIyr#cg_r0zFTox`3&aR6>u1);r^`BSRzd2WIFWT
zGhMTb%tG8D-p@aEccDtfYO9I!X}~w<?Br5D4FyJuDWwJtuy$ybSz$f}?zB(~HwZN$
zQKl=;`o+@Gx1%xkIzuU-aU;%V)dJ@l@K+q^C|iN_057+@11WIq#Oq0po*dZHzQL>c
zyc-hyMDt4`@E&Ni>{wr9C%8!uDAm4OL#6FU+GTzvL$G_)uO~FC@OGGc{5JNPru;4q
z@H&+U3ab=ilS*}<Nk*B$DxCr>93L<Jdx-Zp4Z}^&&C9@89{TI9<RluR(r%R9jDzZq
zp2~wH%;D<vO!4<?2Df`sbmok40Av63*=G>qJn8XXWo8K`cuY)#Q7lY~&J}w2Y{0AV
zX2I5?9tdtPa=jBB3ujKq=f`5-Y}}5T%i0snyYuZ_z4$H`3Qu21&BuFtcis==E4DaC
zc_p{Lj6W6zQ}*_=u1^3N0lobVy;5YgbBy9=QVf{T-&f2s9Ytl*zOB}12!g-ute4<C
zsgF-cZ`{Ij<IFKOw*1NtNK;7IU=fdjt3j!rNlrsZ)c+ppS;xNjA4F$MK172t`yX(7
znGa_rwp*!Wmr=pF*uI&{C}7f^N_vBRup1wL|Jz~d1nmcV*<BftaL4{wqS59gI-llX
zX=q#xzpXQ$3jB_Q`Sq-c;5QpEEy!WNr`U$h>8HLa#E+-#>zzEQGY5myzgon)M<M7c
zF<Gy01bEbIm=h@C{ci3jS_118nDXyAy!tO3=gUU@mOfnvlnkZBme^<5F3=OBY7vg>
zpvt-HjT@lvTHU_Ax`?vA2|Ag-3Ip+*oarnl6H!C|J>jLJYbfWFDqq+AF!<wdl~E@#
z1h-b!g9-YuUZg_7l&>Td-tk^6k(il<jB?GCZMH1@egAtXDJk^-o*$W?MxmlrjbbY<
zN){W2f?cwxq$0l89uo*B9n@We(Pi)32122r`2(p8?oXp&zF3c=DGNyVl2c>aW(ej)
zolWWP9YhS>ec9`jgJ^*1#vewO5b#;|YyR+b70qa+JiRHhf$~Ng=oT)7z(Sw4?hV`r
zDdx~dp7UFT)tjaPGDIP8;$tC)X4NRtGUvNY(YuDk&a()=8wrLz%XznfVeG4`;<Y^H
zyM$iN(mP!*3x*3b54GiR-zhfLQg<nG2$r5{2+5xd1|L-2P?1-K)Y+p=9bQkNJwvO{
z#T0>1pHbo18n6yazvMks5Z?Ds(uCbV8UP;@ZtV)1P9e4HJRHLB2SH`(!e$JeKM*Mx
z-+Pr5gD3+;9i0{@(2D2Kg-Zs0Fp~R~@f`0w#7!xlXzHFq?UJ><76g7U`=dZ_&1@CD
ztRS;yV8I-y>*PmGHhqC1&)%T?WHaIs4f%0Crw7ryT>qo`(HD-G{@QkvUx%qjF<HdX
zqlop}co**<A0V7N9d!ijh$K%x7$wY@1(p}3#j-)(ATh7cN!2ie41EWtxO-PXXOwjQ
z{c|rcka|)d#W99DRQoxmxayI|*=eUsqFx~SU-bzMa!lvHGeUL@tu8@J?_gy9Q%Ig2
ziBwcug8xaLYE<Yv+8(ep2C{P=@^`ohq`uTBo|uz#fTPw^q)A66;b=Lr;V*#>7>=Bl
zpdP4#wHRNM7_2W>KS!!q`?VE5n+~13Ouq`ACYA?8f*ojmaPG5uVl!+?>|GL5>O%+1
zE>xGpM{piV?%^7|k7B<rvm~Hd2T@wDpUA1lfw%zK{heoJz*bX5=490h4UVM_-!gFS
zdK+hYt!^p2;NE+sb7=|bk4%5z)9-;t0qy}09+X1BlG*bi=^h9)?;u*J!#S6iDxDrX
z6oY0%Qu`?e>^C}QZ6Kl0g9e$tn+&ic(4q4qn^MI5h$hST#5mtc#P(lenq(1(^qMQD
z1Yq5vG@-UL=J)Q4I7W@p7QrFn=&`r&rlG7}m#c;w^C#!{zbWe#f{84Js(BdhdoFmN
zptwAM{_JnQBP_@V9jBL9crUb~AEpHQgqlsTB~4GV9heWcB+~O<exuMD<F4_Udl((7
zX@vy;d{8(u^XUAcB`6|vcZ?`&1@(e@9j{w?@cxz69F0*o7)kxSSfh#H&!fDG9h+QG
zcN@KzNk0UW(`5wgC+88zhan+XqHI_t9u+3R+zrFLiq!bR8AyFWWIeizIYxgMs(#_u
zXY;vyEb}tf{cX2&UT@5RSMS#tBuMg+{j+civ9vA}9T~1|g))HA`N!C?kx^vIc&)k4
zV-86wF?8`kIxMu$TkbBmz)tAJLlRg&rg8ZT-xOgg-lJw0`G3Rrs~C;^blOfx`x-m-
z)*JhFk7-a}SKEMi{dAf}ixn8sF-$B_Nr9!8FOy=-@_?J}hyMeQMRez<&DZrin2#5q
z>_9-Y0yW=H=%!zq1Q{eSyh0cUmN79Q4mg+I=c1ghQ^#K@8n-i_TZ)CeLEe$!(-Tnh
z?q{dz<5E=7E3_ie8UyF4qrxA`45E;+VGf!fLuk{>@z;It7?_k@iOIU%1IgbDFVXU>
zqq3^Ggewl1vn!TtaZ_j-2HF0`ZJk;GkMY>RpSm&d>6*Vc5pO19O#L1GMrRq;OZKMs
z#A3i*C{6o2-uH!FZ`4rV#rlXnh8tXTF;JJ=#}_n;>o-I6X61usWM>nUK5;o3g0vhb
zJZeVJSnjMtuG}zuT&Bqk;fMw%x>MII@m}YEJW-_IXbPEf++g7J!@P;F;l$r)7m<qZ
zQBH;*t*DO8#3&*y5;k01Yh1~C(O&0wk;kzJkv_PnVBsGL;msj0hm|IfJS!`gQho)T
zG9eQPag6|uZmY}E(RC>E3^_gL^>jpbMBFm$0p|0cQFrMY{(__|{v0DXG=UDaq#N)&
zi~zc{iN3_}ao7;ZcxxEAhUcr@HHW*xq4@~u9R2M@<TiPOPdaEF?KjkT52l4fjh2ZE
z^W}NCE9&p&ubYEhGzA%s-4BO~seGyxhjGjuyi0qqIt)_==eyWK!a$R#Qn<xq1BQG#
zNol6~fC}!~rZ$9vguqfig8}9a^gj1XB%VS_eeQupwIT4fZ;`Rz$PY~?l0^D7uApB<
z_LaX1LV&`{6BR#-gMaD1yney>-jb#?_|-oIN{&1i-#F0@)+X{E-HpA#+Wl9#T{Z*^
z#>igZN^V7Kd@NjB4vSzUu=AdVEd*+>+7$DDDu7*{Dob(J4fOBT1oKtrAZUo>Sng?@
zLu}`omHSxdA*h|hg;pg9>t*<&;(kn^*j*LI67D$&4>OoBeH93H=Xk$Vd|HJ!{-4Jh
z1D6nk{NcJc1pzRm)vNym&tZkRDbD8R4*?@_qO}oo0NnNsobAaNg{(JiR>tCM=)2~j
z%#L*b|Iyv(nton^=6m*v($33pBk#iD*I)f0o~Uf%x9JkveE-!*+~7OPlQw+I`_>m!
zZXZ-6=g%Q`#?yxbC5l18?W{kQnlD@_On%H?Qw3Y!cpk(tO+%Ux-Q7PWKH&Q$mcWc>
z84AvgS-X0AqRSgg8Wrz-Aaj=^J>%st+8^jNlE56!pT$R{^`83xbMUi{XVMi&+(1l<
zeF5ji1sWyM)A&HO6>WYH?rYf?auz-fE}#HU`qi64UJ!6ThQ#Gw8>)0?|1P|_j!vZg
z8oiO=2}V7x*G<yr;R@AQvd7pm`t*ZNwnWYo#Qv*3B@<gbb7y-3YReSvj|ZPa)3qZF
zhYbm(8fvFLQfyYE8zh^PzI5Zjo*&;)b@`A~vZri2Q+hS9ZQJ=ijU7WiZXL=VkNcrK
zjWS<PqZV`jZ4ONmrhs2QSLSX*3#ikcn4%VRfMcb}HX&F)**X<S@r<Y$T#SAAVkK6A
zYUfG=XIcm9^HctNZK(;U&iuK`bG;8;bUf}gjB`KzCpvyP>NdeI&9XUfya)1@;dJ>@
z-vdpe`%i5=%AiX8@pYao%x~fJ(!#7!BuC=qNgh=Sgrg$J7uTn^m%^@p*d9TGCrBCM
z<BDOJL%M5|d<oua-BveuX@wGf<zM%4o|bObMpzPKD>U8^X;KquMqU}}Yt?qxSLFXI
z?cAqP(4AI1xQ}z4>QjGY467G`_nlIfP2FyA=gYLvyIu^-2kVVBeTCpLI*`OigXf)D
z^mPn7^H7?nUNf0j0I#y{lU3mQ(O67mwZJluj*N(FN?ywYszQ2>pLqVsB&B?Vi>wDp
z%?%&@_AM78*~y;t+P9*re$`02$4y{<hv(A;%^X<F^8a(^^fUy#5-Tf}YXY~4p&||b
z97zAAp<}f;f^$m=mgW71QAd<TkW63}-1)=(Y+^1GCEmLJz$TyznX9j5-F}Dl;#EK^
zFue#Bd$uH|nEzMNQxv;jl>zPYjgvH3=dBTPUZA>h5wWIb8Oq_uCwUru5<icip8^}C
z-q(iVrEE<2ubVi3>y?a<xAinIK2{VBzcPTzX`6h?vF?t6kLQ<`OB*UmxNtcO?}uKI
z2f56zrr<en0LMw?ZhQ}F>WE;O1r@e${eoO6P-^`#+UVanScuhm8Yz?@xeD6*cV8w$
zO*r{|^VoFQ@_CoRrqKlx)D=Rve<uN*9p}574Si@dVKVII+hSDS9Xo5Bmk6A<!<Z`H
z<e;VkOEP!NCvAD7{?}L!>&tZyebbT1MLFZg{XS|hLFu;+ai%A6&_@=1?)=?R^v8Ws
zfE>>o&vwc8v}(rzn=_}}Go>N4t=$lz7dn6#pEnKWDa7G^OO3WjbQJ{nTU1(PI>9Ts
z)VJ&<);p-?)SbrjuE#+?$L*$;(3&fi&h?;Zh(ANJJ4x9CQcwJf;P5&kXIZbb#5n=C
znb|~r4L88<u*jvn#cn8jcBYU;C<>x`xqIXK!Vr7so3OQ*Nko+G@Kdfb63%3G%v>dD
zL~r{#lUT5R?X$>DJ<hyHFuZA&-~VzH=rK=ylc5s(AMEyp&2ZgHuL$^d8gm>erNzY$
zFQaA!y>WtBtkYXk)JD9MP(NH;X&OI+x;{T5d-D$GzK{21NxP+iuZgZ_`1KX|Ksx&)
z^n5t<dziJ*#MVMmnc3SkrWu@z+?{wD*Ol;(luA=v^N{<Ba{aaJ7`#!MPWc`f27#z~
z(u#irI43omPM=?a3nk4Ct(aq*Q<q9jsJ05P+0A)74VR(tvH$LGs!)(qRdoCtj_>D^
z^w+*j;(Xa%_EnO#5I859W=4B?0xoPyJC{-6xr`?p!O5u*2za5;!;-lS|NH;5LX~?W
zXcF&%G}ZHD!Ur*j%lha^?;&6rvr4N?4*|b~64`xRS5i0ne=C}eq8wGD2lwr9eG<o%
zBH~HJKG9%%f&DM=MkNUSR>t$al5aY0Cd;6IkvTEub`p9Jw=7d~C<M;DV(VQYUPZI)
zO&oW*yMSg-AeL-37)&#-5Z&t=g367wQ`CN#d!#Hk+=2V2{+4U;H-}arx>c3$G4|WM
zcwc*i&?^v*3VfL9#d*%3j>`lbdxHCkUvv~HR|4TL-J>|;dF<mhiHMFMErp*G5xaJ`
z{6W)`oS~C;7B2TFwuufdBj?CzzB24Xsw(~W`109R^yWmC(Bru^#LVe6dV$&>PD=GC
zs19JA+?q9eqwhTIKN(MUyoG(f#Ig5xAB>=KMpfb;mn(sHEAPI*jxVHizG>fxm;-S8
zo%F>m1+_BKbyI!zg;#Qo3Z|FV!MDWV#0pmoJRJNN{@C0X?j)!^Yo(aL`Gs5jjIu*u
zaFhKa#cyxeb^Bx9Ejx}(Y$B~Ebk>mMR!P04r8gX|8Q8WPUO{Q%NA&M1BQ(dn^)K(J
zH+-Ca_<&t;3Def?hiLOK|M1Q3wa2MmApW2FwDq6d5>CD-y=bjhXq0U`bmE*9I`*!I
z*6|OA6mj=)$_(3DkjQbFp!z(9jtzLn@AptinO*CZ=)id<4>pJ%RWpr2$R44b?$%+c
zK0~zwCbSCoCz2!X#x0?ZuLMF*0){}~y~a1f9^7XTa#0mAHiDV%zAU@LAk_ITcJQ=f
z9YG;FtHCx0#OL2@A7H;|K+02-$N0W4J=vckm9d6`6`TDg+S=g%ef_ITa2~WZ6uZ08
zxUl^nC9PH<HEVC*BsT`7XVHHO*>L~Mb1<_+fcf4=gzBlne?k4^E8#w?DNvJXol`qf
z0WKbwQtWZQz@sSnZPwGnh(g6d+`g?0s&#0cjn7V_<TgHCHR=ZB72@ia@wg1u6t&gZ
za~t6(^Mk4jQ`un7na3DiTmqJzinC@C1E3{rdR@2x&uPz@D{{mXgU8O8d%)dp#7A#@
z6FowRduC=Lmb(Z>*VD4oj&;M5hN!X!X(15CFPf5C<-$cn59{QUZRnpqMXI=K6LjPq
zT;<Wo0e&U|=cMvX)F6^mPNj+UWhS2{OeC`5HG_@5g+?n-OYk%a+c%-Fb8Ls6?PkJC
zlk%;crVMyo?qwt_*a?RzpBEP^;>UBM<a9At$>77UY*E2E)O@OHVl6EVB>wX`u>a5J
z;II5#A0>+os%L%vUO3=0GPcw{`G@3+R1m?R<*k%jP`C0*V>mm8ntb#Qe&0DE_4;<v
zG3L@*Bo;LK$%S|vf)yp%Bh9wp-@PaEKe0bR>e@}E9nL2B5%M%E)V2-&cy9*fd>Vo2
zW8-|?RC6$N<_|w@Fz%zr>qj7J6@F}L*_7T}LWQEf)8@R*U^{$N<ph4exn4bAiq`7F
z`jq^5PKydSKH9=kQQM94KgPH3eJKQs_sMSRVWn_nWub;eZxjexW{7TL-Q>ig&a=TR
z>`%UKW2xKLgVG354)yIKblD}TM6sa|&bt5m;;DyqWN#I!?)KNAC-PVPboBB2VyS5m
z8<qi|e%J=sw|2rmL;7aal@9}_S2OB#s^A!LuG!Z8DHtXrdA^gA2U#-Lrpy`J;Z*5x
zk+OIrV)lp!f)6<m%s4nwUE2di`Nt!89M@38yJyLUI@uskTy5N}o{a`#oC8!|bfJVs
zr3XI3nIQR}_oM4SKd;<0`gQ-b3VbWk8CsN7K^+bsiB5jKB9-*V`&qwe4UksfIibcq
zhCCFGb?2w70Gn@pJW)_J8lo_qBVihcC_+op{-J)Ty{($HT{jK#a+wqL7EPd2^(Xho
z?K(($lsw5efc?-9nbZgG7lQ>=s;J=G5>T`Y(ILV)*Nr{wS2IoKA>~`C#oJpYuy?j+
zOzm(ldY}Bgm)4*FML7z-vL?<0Pwrh~`od|{{Uwa@Pg*?+vL<=_KmNLAo0089%GjsC
zT~YLq3Ufi%48*4~KLq~s`|1DZ=ZuW-(_9B-xYfRxd%WN|6qkO;2szFrrIElQ<9VnK
z2q^UgXBI|L&&l5+hmQOO&S~b`okq1NW%;YRB;z<-DIe%&+)oE40geon{ArvUwp!v_
z(Tsn8$41STbddVb-}AqDkE}<2e9_fB2V7|dft@5`s9wgRM?Cndl=Oc+FMBm6l#Tf|
zs=D+v+BNGU6kRr|jt;sib^X7d7eJ&_J+CE)PCh&J+b&uehL_^r%6VUvx_v`Y{{Q=G
z{r~?YAoySIDPR0P1(|;hqMACV+;nanpKJV-k4_Ls1)h2o&O`J774He$T@F)2YWl~r
zgc-M>H$3H&*0UOLc>nB_OUW2|Qpp&@dKB|aMb=LIZL5Mr!E*X$|74guCe8eqsT=MD
z>VNXv?Lq84I_HIOe$(&Gs)eebUBEVW_p3MV3yuao)1_-_N82J-H0%r7;H9D1sT%kV
z%8#sfh>uR<94N~)HU4JUAC;a^he2RH)Mlz6Gmp0a_#KiHuZ3KxFsH>)oZqq;<EGzT
z2%n5kFh`n{fr*=Ld_2C_YVHhVKhNud5p?K^2|h=kU8WHu9&Cl`Ta*dfqfN*o<d&`G
zN(rdsB&mPQ9)$<;Mn=zX52HGvkMM<}1k_$;n7C(6!~0;Do5GLkA>ij(>FImLz*J2<
zTFcoB@=WQK_W0F(0uogY#~`p+c68S48-Za`jp{eg=inBL;FD3ZLhL`0lKCe%14MW9
zcucSLVLq{4(gWQBxarYhAVl7V?xd&^EH5-dr|>h4UorXcV*4ZQ#beW`QIl=<JU(Cb
z_~d!_it?ZgyKEl5!aBD8u>5x49+XgR!22yf7e25#N@<qhJ$O(?otkF?qAd95Ax)P1
zfB*h-UA%tGoeQvVgRM08b2fPDNPd?ks)4E$H;U&1)3E9qJnF)q4Nv|B#-uo9BNnc*
zcccxSD8iY@h+PJA<ub{C+$_XCnyb>jnb($(=QpGI`SuK;Q+hgo68oT|W33ssb=#n1
zt=gCz?|IIrh$?AQtb#&D?sW_OPN)kWt0&k`1N&~`$1Gw?z|D0mRY!ISJeq3>=NnRi
z*ZEYk%xVTSF;w}Cd33>%z9&B=ex`s8KY`3(Qa%v=)M8ZQ>p)M*-Dq_7lYniajrjPv
z2;^{j&zh=d1w~LBUk#H?f`|JCfz+G5z$bh2SuO$gVbeWZ>*R|EIjxN+*X@T8i*4|x
z7|Af2j*a|&EhrBB?F@g+|JZ;pzA^RFnk{HZq&BHXEEejnjj5{V4!~qV+fbb>o`dVe
zdtAK|3$|(dUBge;;m#I&aPrS_q)~I(-%>3GVk2lS^&eh=??NIbqIV|Y{&Y?BiR5T#
z>n@@UbHMokoUW8wG+00V_22R6&(T1ssim=Ws25UAq^UGYXW;F$=n*oAhRDG$n?~xZ
z&`h%=?mCI{s)ueGl-!R3zt^u^3ow_$q4TZfsVK~o0+s`5%}9{+XK=Q`x(?$PN*B~g
zS73u-`;;6P)}Qf*k~ED>0J8^`<pB*=$(!@DzF>+3VFi|}F7Lb0P4b!VF2zOYRGhRD
zcX|Z)ygnaSU5B}V+g~1t^sE5$Fonm@Ld;9pz4XEAO$L1XyLy2>WeK%z@7HB3hr^j{
z-|6VcC7^lv@;NKc4|r8y#JshQ`-Lm<_m8g)AgL2^v63I=fL-cnM|*G>WKx^$Jor40
zqFCsIRqqUe+HEIFg6&Yy<`}%?8ovQ?#|(cj&-TE*hXvGf<#-?RE|~4H%{;h<OwJRk
zEg>S_NRiR6p%9$w?|INMf_k+(PDj6*Lt5d*8gH;}`l+S8hVHo`XyGNI{rk8Yxhy+X
z^gauPy)$CPeMIYUmi~$}S=SV_Q0aAcXote0aHh>b>pWUtP25$MpMwNXDro^m%n>RM
zs(y7e9(-J5Ni}djhr8}ftSIhZxX!z>bYot&UsQw5m|YGm+>w#x#Jq&{UdgF0t9eA(
z(ig~@Fp4sTFC7%&{fy`p4^?lH67<|`<vZyZo<GY^DJvfjftM_4gOc16KzWG%{POV;
zAo=y-{kN?k$X88p@r|BG7e~u7RY%qk&wk@qj<Z1^ziN>p@7snRCOuT7#5#@_DW~NQ
zdj`UXq+9%_59VOD{g9;1`*c*&?RmvLDgaJ@3{Dd9!TCSr#aHfPE>W=fAB#_Un2Y!7
zt+I#aI5HyN^k=8SIYpx1EfpU7L)NOmTv7+-;gyqK?;TqP))l&uib6jqmix6d@N@{0
zw(oF!3dTA>&${l=yMFNgQ7K#b$vLRrqh>@zn0HJ;tg@xz3->;^3%#aYh75&cdo#Gd
zQ+m0+YoqQ98#cw;(^~B)2G(-ME{`ID?ddb6IX>`jr?x=xlpnfyEt2&95#0ZFJ_$Z1
zgZDH4scZjRpHg}EW&|X0ZiGJl{a<JdI_y3c$WH7-<THJ-kwGH}Q-67wK~Mv=JiPy!
zmUa(IzsH^pZ`FXlsE8uN!Wc?<ZmAMhIRzT0$>gtLy)!B0YWcsgc63cw#XNbW6|6qm
zTc2JXgfE7gk?u_MC?-$2?gDEo>~L!sFF&e<QQ_*VK0~Q+WHzLM_jfbwh*LbRINyT=
z1j^4@PK>~Eos3KPD_jqGq<<BYwZe((bYd<CjY#&w4PmxJf5A>vvr9l7&xOmU61yug
zulJzQ$e<SIbhQ`;F{f3dj!`oC_q0h^*O>e0tZNyhUe<Gx#XJ=E9`2Q!cjn--vGfg3
zJfEU(>-_4j(GC0qHAj{iXMyJ5uCEj34E;<_Y;UZeM$*rJdcbTWT6Gi<(eW*W*HQW!
zBa4f0ykV<@BCHp2Q$9|ev@C>SqLs-innEO`CrcCay&K&LRf+$6yb!EtxNrGl{X^p6
zqa-VAJurB?uQ66HA0#wgE1XhCflR|aUGv!xY8A+(5#-MY)|!h7l!v>a%DI7cp0pTt
zl0|O|;rmvI=5g_u(j53mG(oz{gXcIDbKZZCWB-n;m*{?h8M-)UTv&|veQaD^TtZRV
z@UJ~#Z;l$*SEV0rr~MkiMn>quwddK;%7%_S5X5}C&QBI<cd)Ph-gS!?vsoZDtgI0I
zeFVHMgx}j5Vcw9X*Gj!r77*_q{S6t-z^Tc=_s(ktq_<9;d_I{8J_omN5sBgXW4)@}
z3${+oi#wek<dF$69?GvziR1bsCpH>*YY9x8rqV8c$%Lp&8EsiZ)gY>;FZV8f3ff~h
zs@=b&<2_h!&ndj8vZq$PqjYfrycZ5E?c~!T$cb2o4)fHS{YZSChqb|49{;E$_JJiA
zGp7^s&R~5lHLndrKRU-RdH0593jF1=ZaC{O0ozxnf<M%iAW`#@+BTJB_|Q<+B@(s)
zgI~8aV!fLY87Fm$M1B$&hJ-O+QpNKOBJ<OY;&W&#JdaK#C<(~6%vI)DhmbgBeyPFr
zVPx)e$(Q_jBKVcDQWH9RqwzM6r`DmX=;)27EHvNZAyS1Yah-kxBKBl$eU|aL(D69|
zy^jU1n8ExHrzg<gkKfZN+{%Iag!ZquMKRD_zFK~sa1~N=N|h?sme98CQ_*_OXka+6
z<2iDx2Lhar4ZofnK`I2hYth%EL2A=M`>$di?px<4+Hrj+JgG^jCmaoF>9LRfPL3k;
z6Sd|muZLll_iO+=Pb3V+{ox<R_rfX7_EJfgVss{_&iDgoB=}XRmJ27&!Sf5t`^@Xp
z$Rv;%<>g0!CGWB&nSBLJ`(6x~8CXXPgCDLE*@eN87^^l<+_wonxRdt>u<ucjLr?Q!
zC^Uu`(%xfU2SVLzKkd&>0q?~OL;K^Q@H6A5r6J~C-s=(H;KaEtw<=%f?Gc9plNJyA
z+1U~FV$b0fukr?({<?ZbU>)bXaZ)>9_85a+bwR1}gF%@5N9uPcDi~<=U6B#KPZS!?
zsZQRkgOOsRq$iZYz;$Q$vmM1c&@*VpTZerC;oPJN$DklEx*7N>i*p{V;`+?4NM#{9
zrzTwi=^#9(sBuw$it|i^v@6IX$AIYEs`Z9nAf&Au?GafIKo`&Z*jlPJpbUKuviyOd
z3;OV{rX3yQi|gSLTtz=WPZMoy2fz=XFgDr9d60?Sytie%1`9JZ*{Y@iP|U%yW%9TO
zzRNa*eCb<5-Jfk_zB2|u-So_*q|-}iP~at+#hj|!Hn+-R&IJIojD0-8P!;wuyM)Rl
zO`(9m@goNG{_yaAbZB$i1`GsTWBR(=56}88)p)!3L6qR3`&3!uAV6N8aAOGjgp&V!
z45aacvfoBOR>x=HqdYIU_k$IbMSczoo%~?Fz55n7_U}DX>1GwwUxI-J()~kozVJ_e
zkBA{`5EhPZ??(&{g5cpZyQ>nu*k6#Z(v3Mp@7DdliC`b$#HRSP{TW~A&C2=hB|HwU
z0@DS4&8sM6#`NOmAz$!y?KOJ-cL-fezp+GnAM^ir39ocvKghcR@08=l>%hNVB6EBd
z&krgWd1i1v-ID+K&Cg#jU%jr<(a5C+&CY+kno{Bg8LBkQw^EnTp;H!;>U?9!O<D4z
zewG&;{;&EpCjUsG4A-Y5X{o$&ocBhoSEsNfb4cn}kSd>jsx7(~Mr-$WN)2YDOU@lk
z>;Y+s&S?8=HMnX~k5AzGRG#iU%Ox@m=hEcRH>Dx4O1lz}gZIw&h^S{v)*3){c-lbT
z5c{U>FTLbt=|EGjYyGFyY9VA~M)NjFBb;edAWarZ14@OZY?|l_SjoGUwN1MOI``~N
zU;pSqT(9)^4~LWj%Wzw|RbUIwp_sdS#eD@<B^Xx|V@qJO3I>gBux{p9L|aloBO(te
zUR0hdhT@&%z|qxd6jH|98^qU$#sn%#_lt_bCC8BXF!oV$3H6xX(CmWxp3w&-8AWjB
zYgtT+<0zoW{KYF7Lr8y8<<`lVLby%z@#HzLTon1h(SsnY8*yI0LFcSq2*n1`=12cc
z<Gh-rw&c!6%q6d~8{#ei3>|zhNP*|v<I=V@I48sPl)(8@5&1y;OF7k*z83N7T_ah2
znvAjz>0Dsb$On0gza_VAtHABmgE!1*3WPX*s5MyT!19jhdNBUH+&pQ2oXoZdKK7ku
zru&eMd134Gt(vXqLSyz`O@9-FxkSIVyO9ZX#?q&axmMwQ*vsL;olc<WOt|DTnE`)`
z-Al=vyI^gTFUMDC2Cf2)ki)xl7!CcHac9d1dOzz#Mz>GGgQxdvgB8*-r=ESxwPg`R
zli0H?QWhb>ByRGPP&#}oum7lu_vyzU#@b1DmLTf*hs1vdQbCtYO*<0Ls}~%H))TAe
zP}Znz|KA$yBRy^Zv@~b~*c+-iHm6!q*26qi8iQ1jIqXgwk%)8k%0D49=^=Dzn7sbz
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%0DUvn#eA(2}b#n#w<b{vl5r_e%TN=i*%M0+qTr|`D
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%0D^*=K)V4EZt?A}
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%0AI}Wu1KBnc
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%0A$QIwb)lUwythxe<@sfLe=z@AL|<m<@-`*3?k9H
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%0DBMk?=^R=VA`0vk5
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%0DB_ZM6eKwp(8S^WPR)w({k_OmwCrBQ
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


From 0d5e323d97abc2cb0a167daef2772e7f22da14d4 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 20 Jun 2023 16:18:21 -0400
Subject: [PATCH 052/362] removes ipywidgets dependency

---
 py4DSTEM/utils/configuration_checker.py | 2 --
 setup.py                                | 1 -
 2 files changed, 3 deletions(-)

diff --git a/py4DSTEM/utils/configuration_checker.py b/py4DSTEM/utils/configuration_checker.py
index 859443723..0ccf633fc 100644
--- a/py4DSTEM/utils/configuration_checker.py
+++ b/py4DSTEM/utils/configuration_checker.py
@@ -15,7 +15,6 @@
         'gdown',
         'h5py',
         'ipyparallel',
-        'ipywidgets',
         'jax',
         'matplotlib',
         'mp_api',
@@ -42,7 +41,6 @@
         'matplotlib',
         'skimage',
         'sklearn',
-        'ipywidgets',
         'tqdm',
         'dill',
         'gdown',
diff --git a/setup.py b/setup.py
index 06c85ea70..e3bc5b568 100644
--- a/setup.py
+++ b/setup.py
@@ -30,7 +30,6 @@
         'matplotlib >= 3.2.2',
         'scikit-image >= 0.17.2',
         'scikit-learn >= 0.23.2',
-        'ipywidgets >= 7.6.3',
         'tqdm >= 4.46.1',
         'dill >= 0.3.3',
         'gdown >= 4.4.0',

From 4f8f781e267ecb260c1982820ae64ae53e0b94cb Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Tue, 20 Jun 2023 16:08:48 -0700
Subject: [PATCH 053/362] re-introducing Fourier probe amplitude fixing

---
 .../iterative_ptychographic_constraints.py    | 31 +++++++
 .../iterative_singleslice_ptychography.py     | 80 ++++++++++++-------
 2 files changed, 80 insertions(+), 31 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
index 10b24eb78..274e86f39 100644
--- a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
+++ b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
@@ -486,6 +486,37 @@ def _probe_fourier_amplitude_constraint(
 
         return updated_probe * normalization
 
+    def _probe_aperture_constraint(
+        self,
+        current_probe,
+        initial_probe_aperture,
+    ):
+        """
+        Ptychographic constraint to fix Fourier amplitude to initial aperture.
+
+        Parameters
+        ----------
+        current_probe: np.ndarray
+            Current positions estimate
+
+        Returns
+        --------
+        constrained_probe: np.ndarray
+            Constrained probe estimate
+        """
+        xp = self._xp
+
+        current_probe_sum = xp.sum(xp.abs(current_probe) ** 2)
+        current_probe_fft_phase = xp.angle(xp.fft.fft2(current_probe))
+
+        updated_probe = xp.fft.ifft2(
+            xp.exp(1j * current_probe_fft_phase) * initial_probe_aperture
+        )
+        updated_probe_sum = xp.sum(xp.abs(updated_probe) ** 2)
+        normalization = xp.sqrt(current_probe_sum / updated_probe_sum)
+
+        return updated_probe * normalization
+
     def _probe_residual_aberration_filtering_constraint(
         self,
         current_probe,
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index 1cf9e4e44..7f40995d9 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -427,6 +427,7 @@ def preprocess(
                 self._probe = xp.asarray(self._probe, dtype=xp.complex64)
 
         self._probe_initial = self._probe.copy()
+        self._probe_initial_aperture = xp.abs(xp.fft.fft2(self._probe))
 
         self._known_aberrations_array = ComplexProbe(
             energy=self._energy,
@@ -980,11 +981,13 @@ def _constraints(
         probe_gaussian_filter,
         probe_gaussian_filter_sigma,
         probe_gaussian_filter_fix_amplitude,
-        fix_probe_amplitude,
-        fix_probe_amplitude_relative_radius,
-        fix_probe_amplitude_relative_width,
-        fix_probe_fourier_amplitude,
-        fix_probe_fourier_amplitude_threshold,
+        constrain_probe_amplitude,
+        constrain_probe_amplitude_relative_radius,
+        constrain_probe_amplitude_relative_width,
+        constrain_probe_fourier_amplitude,
+        constrain_probe_fourier_amplitude_threshold,
+        fix_probe_aperture,
+        initial_probe_aperture,
         fix_positions,
         global_affine_transformation,
         gaussian_filter,
@@ -1020,17 +1023,21 @@ def _constraints(
             Standard deviation of gaussian kernel in A^-1
         probe_gaussian_filter_fix_amplitude: bool
             If True, only the probe phase is smoothed
-        fix_probe_amplitude: bool
+        constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
-        fix_probe_amplitude_relative_radius: float
+        constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
-        fix_probe_amplitude_relative_width: float
+        constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        fix_probe_fourier_amplitude: bool
+        constrain_probe_fourier_amplitude: bool
             If True, probe fourier amplitude is constrained by top hat function
-        fix_probe_fourier_amplitude_threshold: float
+        constrain_probe_fourier_amplitude_threshold: float
             Threshold value for current probe fourier mask. Value should
             be between 0 and 1, where higher values provide the most masking.
+        fix_probe_aperture: bool,
+            If True, probe Fourier amplitude is replaced by initial probe aperture.
+        initial_probe_aperture: np.ndarray,
+            Initial probe aperture to use in replacing probe Fourier amplitude.
         fix_positions: bool
             If True, positions are not updated
         gaussian_filter: bool
@@ -1102,17 +1109,22 @@ def _constraints(
         if symmetrize_probe:
             current_probe = self._probe_radial_symmetrization_constraint(current_probe)
 
-        if fix_probe_amplitude:
+        if fix_probe_aperture:
+            current_probe = self._probe_aperture_constraint(
+                current_probe,
+                initial_probe_aperture,
+            )
+        elif constrain_probe_amplitude:
             current_probe = self._probe_amplitude_constraint(
                 current_probe,
-                fix_probe_amplitude_relative_radius,
-                fix_probe_amplitude_relative_width,
+                constrain_probe_amplitude_relative_radius,
+                constrain_probe_amplitude_relative_width,
             )
-        elif fix_probe_fourier_amplitude:
+        elif constrain_probe_fourier_amplitude:
             current_probe = self._probe_fourier_amplitude_constraint(
                 current_probe,
-                fix_probe_fourier_amplitude_threshold,
-                fix_probe_amplitude_relative_width,
+                constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_amplitude_relative_width,
             )
 
         if not fix_positions:
@@ -1140,12 +1152,13 @@ def reconstruct(
         pure_phase_object_iter: int = 0,
         fix_com: bool = True,
         fix_probe_iter: int = 0,
+        fix_probe_aperture_iter: int = 0,
         symmetrize_probe_iter: int = 0,
-        fix_probe_amplitude_iter: int = 0,
-        fix_probe_amplitude_relative_radius: float = 0.5,
-        fix_probe_amplitude_relative_width: float = 0.05,
-        fix_probe_fourier_amplitude_iter: int = 0,
-        fix_probe_fourier_amplitude_threshold: float = 0.9,
+        constrain_probe_amplitude_iter: int = 0,
+        constrain_probe_amplitude_relative_radius: float = 0.5,
+        constrain_probe_amplitude_relative_width: float = 0.05,
+        constrain_probe_fourier_amplitude_iter: int = 0,
+        constrain_probe_fourier_amplitude_threshold: float = 0.9,
         fix_positions_iter: int = np.inf,
         constrain_position_distance: float = None,
         global_affine_transformation: bool = True,
@@ -1199,17 +1212,19 @@ def reconstruct(
             If True, fixes center of mass of probe
         fix_probe_iter: int, optional
             Number of iterations to run with a fixed probe before updating probe estimate
+        fix_probe_aperture_iter: int, optional
+            Number of iterations to run with a fixed probe Fourier amplitude before updating probe estimate
         symmetrize_probe_iter: int, optional
             Number of iterations to run before radially-averaging the probe
-        fix_probe_amplitude: bool
+        constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
-        fix_probe_amplitude_relative_radius: float
+        constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
-        fix_probe_amplitude_relative_width: float
+        constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        fix_probe_fourier_amplitude: bool
+        constrain_probe_fourier_amplitude: bool
             If True, probe fourier amplitude is constrained by top hat function
-        fix_probe_fourier_amplitude_threshold: float
+        constrain_probe_fourier_amplitude_threshold: float
             Threshold value for current probe fourier mask. Value should
             be between 0 and 1, where higher values provide the most masking.
         fix_positions_iter: int, optional
@@ -1545,13 +1560,16 @@ def reconstruct(
                 and probe_gaussian_filter_sigma is not None,
                 probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
                 probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
-                fix_probe_amplitude=a0 < fix_probe_amplitude_iter
+                constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                 and a0 >= fix_probe_iter,
-                fix_probe_amplitude_relative_radius=fix_probe_amplitude_relative_radius,
-                fix_probe_amplitude_relative_width=fix_probe_amplitude_relative_width,
-                fix_probe_fourier_amplitude=a0 < fix_probe_fourier_amplitude_iter
+                constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
+                constrain_probe_amplitude_relative_width=constrain_probe_amplitude_relative_width,
+                constrain_probe_fourier_amplitude=a0
+                < constrain_probe_fourier_amplitude_iter
                 and a0 >= fix_probe_iter,
-                fix_probe_fourier_amplitude_threshold=fix_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                fix_probe_aperture=a0 < fix_probe_aperture_iter,
+                initial_probe_aperture=self._probe_initial_aperture,
                 fix_positions=a0 < fix_positions_iter,
                 global_affine_transformation=global_affine_transformation,
                 gaussian_filter=a0 < gaussian_filter_iter

From 72171c40246a68ff39d1acd36e91ae26c576b9e6 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 20 Jun 2023 19:18:11 -0400
Subject: [PATCH 054/362] renames io test dir

---
 .../test_realslice_read.py                                        | 0
 .../test_single_object_io.py                                      | 0
 test/{test_native_readwrite => test_native_io}/test_v0_13.py      | 0
 test/{test_native_readwrite => test_native_io}/test_v0_14.py      | 0
 test/{test_native_readwrite => test_native_io}/test_v0_9.py       | 0
 5 files changed, 0 insertions(+), 0 deletions(-)
 rename test/{test_native_readwrite => test_native_io}/test_realslice_read.py (100%)
 rename test/{test_native_readwrite => test_native_io}/test_single_object_io.py (100%)
 rename test/{test_native_readwrite => test_native_io}/test_v0_13.py (100%)
 rename test/{test_native_readwrite => test_native_io}/test_v0_14.py (100%)
 rename test/{test_native_readwrite => test_native_io}/test_v0_9.py (100%)

diff --git a/test/test_native_readwrite/test_realslice_read.py b/test/test_native_io/test_realslice_read.py
similarity index 100%
rename from test/test_native_readwrite/test_realslice_read.py
rename to test/test_native_io/test_realslice_read.py
diff --git a/test/test_native_readwrite/test_single_object_io.py b/test/test_native_io/test_single_object_io.py
similarity index 100%
rename from test/test_native_readwrite/test_single_object_io.py
rename to test/test_native_io/test_single_object_io.py
diff --git a/test/test_native_readwrite/test_v0_13.py b/test/test_native_io/test_v0_13.py
similarity index 100%
rename from test/test_native_readwrite/test_v0_13.py
rename to test/test_native_io/test_v0_13.py
diff --git a/test/test_native_readwrite/test_v0_14.py b/test/test_native_io/test_v0_14.py
similarity index 100%
rename from test/test_native_readwrite/test_v0_14.py
rename to test/test_native_io/test_v0_14.py
diff --git a/test/test_native_readwrite/test_v0_9.py b/test/test_native_io/test_v0_9.py
similarity index 100%
rename from test/test_native_readwrite/test_v0_9.py
rename to test/test_native_io/test_v0_9.py

From 0770cd5e95e47ec501f368a8459f97e3bb33c74a Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Wed, 21 Jun 2023 01:54:45 -0400
Subject: [PATCH 055/362] rms RootedNode

---
 docs/source/api/emd.rst      | 3 +--
 py4DSTEM/classes/datacube.py | 7 ++++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/docs/source/api/emd.rst b/docs/source/api/emd.rst
index 660f9777f..8e4223496 100644
--- a/docs/source/api/emd.rst
+++ b/docs/source/api/emd.rst
@@ -12,7 +12,6 @@ Classes
 .. autoclass:: emdfile.PointList
 .. autoclass:: emdfile.PointListArray
 .. autoclass:: emdfile.Root
-.. autoclass:: emdfile.RootedNode
 
 
 Functions
@@ -26,4 +25,4 @@ Functions
 .. autofunction:: emdfile.read
 .. autofunction:: emdfile.save
 .. autofunction:: emdfile.set_author
-.. autofunction:: emdfile.tqdmnd
\ No newline at end of file
+.. autofunction:: emdfile.tqdmnd
diff --git a/py4DSTEM/classes/datacube.py b/py4DSTEM/classes/datacube.py
index 3f2edcf62..169b5fa07 100644
--- a/py4DSTEM/classes/datacube.py
+++ b/py4DSTEM/classes/datacube.py
@@ -3,11 +3,11 @@
 from typing import Optional,Union
 import numpy as np
 
-from emdfile import Array,RootedNode
+from emdfile import Array
 from py4DSTEM.classes import Data, Calibration
 from py4DSTEM.classes.methods import DataCubeMethods
 
-class DataCube(Array,RootedNode,Data,DataCubeMethods):
+class DataCube(Array,Data,DataCubeMethods):
     """
     Storage and processing methods for 4D-STEM datasets.
     """
@@ -53,7 +53,8 @@ def __init__(
         )
 
         # set up EMD tree
-        RootedNode.__init__(self)
+        root = Root( name = name+"_root" )
+        root.add( self )
 
         # set up calibration
         self._setup_calibration( calibration )

From 447822f3603ec227ee031d29d05af64a32a7f3f4 Mon Sep 17 00:00:00 2001
From: gvarnavi <gvarnavi@mit.edu>
Date: Wed, 21 Jun 2023 09:40:28 -0700
Subject: [PATCH 056/362] Fourier probe amplitude fixing in rest of classes

---
 .../iterative_mixedstate_ptychography.py      | 69 +++++++------
 .../iterative_multislice_ptychography.py      | 80 ++++++++++------
 .../iterative_overlap_magnetic_tomography.py  | 94 +++++++++++-------
 .../phase/iterative_overlap_tomography.py     | 96 +++++++++++--------
 .../iterative_simultaneous_ptychography.py    | 80 ++++++++++------
 5 files changed, 255 insertions(+), 164 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
index 4b2187a15..afa565871 100644
--- a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
@@ -459,6 +459,7 @@ def preprocess(
             self._probe = xp.asarray(self._probe, dtype=xp.complex64)
 
         self._probe_initial = self._probe.copy()
+        self._probe_initial_aperture = None  # Doesn't really make sense for mixed-state
 
         self._known_aberrations_array = ComplexProbe(
             energy=self._energy,
@@ -1083,11 +1084,13 @@ def _constraints(
         probe_gaussian_filter,
         probe_gaussian_filter_sigma,
         probe_gaussian_filter_fix_amplitude,
-        fix_probe_amplitude,
-        fix_probe_amplitude_relative_radius,
-        fix_probe_amplitude_relative_width,
-        fix_probe_fourier_amplitude,
-        fix_probe_fourier_amplitude_threshold,
+        constrain_probe_amplitude,
+        constrain_probe_amplitude_relative_radius,
+        constrain_probe_amplitude_relative_width,
+        constrain_probe_fourier_amplitude,
+        constrain_probe_fourier_amplitude_threshold,
+        fix_probe_aperture,
+        initial_probe_aperture,
         fix_positions,
         global_affine_transformation,
         gaussian_filter,
@@ -1124,17 +1127,21 @@ def _constraints(
             If True, only the probe phase is smoothed
         symmetrize_probe: bool
             If True, the probe is radially-averaged
-        fix_probe_amplitude: bool
+        constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
-        fix_probe_amplitude_relative_radius: float
+        constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
-        fix_probe_amplitude_relative_width: float
+        constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        fix_probe_fourier_amplitude: bool
+        constrain_probe_fourier_amplitude: bool
             If True, probe fourier amplitude is constrained by top hat function
-        fix_probe_fourier_amplitude_threshold: float
+        constrain_probe_fourier_amplitude_threshold: float
             Threshold value for current probe fourier mask. Value should
             be between 0 and 1, where higher values provide the most masking.
+        fix_probe_aperture: bool,
+            If True, probe fourier amplitude is replaced by initial probe aperture.
+        initial_probe_aperture: np.ndarray
+            initial probe aperture to use in replacing probe fourier amplitude
         fix_positions: bool
             If True, positions are not updated
         gaussian_filter: bool
@@ -1203,9 +1210,11 @@ def _constraints(
             raise NotImplementedError()
         if symmetrize_probe:
             raise NotImplementedError()
-        if fix_probe_amplitude:
+        if fix_probe_aperture:
             raise NotImplementedError()
-        elif fix_probe_fourier_amplitude:
+        elif constrain_probe_amplitude:
+            raise NotImplementedError()
+        elif constrain_probe_fourier_amplitude:
             raise NotImplementedError()
 
         if orthogonalize_probe:
@@ -1237,12 +1246,13 @@ def reconstruct(
         fix_com: bool = True,
         orthogonalize_probe: bool = True,
         fix_probe_iter: int = 0,
+        fix_probe_aperture_iter: int = 0,
         symmetrize_probe_iter: int = 0,
-        fix_probe_amplitude_iter: int = 0,
-        fix_probe_amplitude_relative_radius: float = 0.5,
-        fix_probe_amplitude_relative_width: float = 0.05,
-        fix_probe_fourier_amplitude_iter: int = 0,
-        fix_probe_fourier_amplitude_threshold: float = 0.9,
+        constrain_probe_amplitude_iter: int = 0,
+        constrain_probe_amplitude_relative_radius: float = 0.5,
+        constrain_probe_amplitude_relative_width: float = 0.05,
+        constrain_probe_fourier_amplitude_iter: int = 0,
+        constrain_probe_fourier_amplitude_threshold: float = 0.9,
         fix_positions_iter: int = np.inf,
         global_affine_transformation: bool = True,
         gaussian_filter_sigma: float = None,
@@ -1295,17 +1305,19 @@ def reconstruct(
             If True, fixes center of mass of probe
         fix_probe_iter: int, optional
             Number of iterations to run with a fixed probe before updating probe estimate
+        fix_probe_aperture_iter: int, optional
+            Number of iterations to run with a fixed probe fourier amplitude before updating probe estimate
         symmetrize_probe_iter: int, optional
             Number of iterations to run before radially-averaging the probe
-        fix_probe_amplitude: bool
+        constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
-        fix_probe_amplitude_relative_radius: float
+        constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
-        fix_probe_amplitude_relative_width: float
+        constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        fix_probe_fourier_amplitude: bool
+        constrain_probe_fourier_amplitude: bool
             If True, probe fourier amplitude is constrained by top hat function
-        fix_probe_fourier_amplitude_threshold: float
+        constrain_probe_fourier_amplitude_threshold: float
             Threshold value for current probe fourier mask. Value should
             be between 0 and 1, where higher values provide the most masking.
         fix_positions_iter: int, optional
@@ -1637,13 +1649,16 @@ def reconstruct(
                 and probe_gaussian_filter_sigma is not None,
                 probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
                 probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
-                fix_probe_amplitude=a0 < fix_probe_amplitude_iter
+                constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                 and a0 >= fix_probe_iter,
-                fix_probe_amplitude_relative_radius=fix_probe_amplitude_relative_radius,
-                fix_probe_amplitude_relative_width=fix_probe_amplitude_relative_width,
-                fix_probe_fourier_amplitude=a0 < fix_probe_fourier_amplitude_iter
+                constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
+                constrain_probe_amplitude_relative_width=constrain_probe_amplitude_relative_width,
+                constrain_probe_fourier_amplitude=a0
+                < constrain_probe_fourier_amplitude_iter
                 and a0 >= fix_probe_iter,
-                fix_probe_fourier_amplitude_threshold=fix_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                fix_probe_aperture=a0 < fix_probe_aperture_iter,
+                initial_probe_aperture=self._probe_initial_aperture,
                 fix_positions=a0 < fix_positions_iter,
                 global_affine_transformation=global_affine_transformation,
                 gaussian_filter=a0 < gaussian_filter_iter
diff --git a/py4DSTEM/process/phase/iterative_multislice_ptychography.py b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
index ce8d13325..a67bd93e9 100644
--- a/py4DSTEM/process/phase/iterative_multislice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
@@ -521,6 +521,7 @@ def preprocess(
                 self._probe = xp.asarray(self._probe, dtype=xp.complex64)
 
         self._probe_initial = self._probe.copy()
+        self._probe_initial_aperture = xp.abs(xp.fft.fft2(self._probe))
 
         self._known_aberrations_array = ComplexProbe(
             energy=self._energy,
@@ -1432,11 +1433,13 @@ def _constraints(
         probe_gaussian_filter,
         probe_gaussian_filter_sigma,
         probe_gaussian_filter_fix_amplitude,
-        fix_probe_amplitude,
-        fix_probe_amplitude_relative_radius,
-        fix_probe_amplitude_relative_width,
-        fix_probe_fourier_amplitude,
-        fix_probe_fourier_amplitude_threshold,
+        constrain_probe_amplitude,
+        constrain_probe_amplitude_relative_radius,
+        constrain_probe_amplitude_relative_width,
+        constrain_probe_fourier_amplitude,
+        constrain_probe_fourier_amplitude_threshold,
+        fix_probe_aperture,
+        initial_probe_aperture,
         fix_positions,
         global_affine_transformation,
         gaussian_filter,
@@ -1477,17 +1480,21 @@ def _constraints(
             Standard deviation of gaussian kernel in A^-1
         probe_gaussian_filter_fix_amplitude: bool
             If True, only the probe phase is smoothed
-        fix_probe_amplitude: bool
+        constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
-        fix_probe_amplitude_relative_radius: float
+        constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
-        fix_probe_amplitude_relative_width: float
+        constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        fix_probe_fourier_amplitude: bool
+        constrain_probe_fourier_amplitude: bool
             If True, probe fourier amplitude is constrained by top hat function
-        fix_probe_fourier_amplitude_threshold: float
+        constrain_probe_fourier_amplitude_threshold: float
             Threshold value for current probe fourier mask. Value should
             be between 0 and 1, where higher values provide the most masking.
+        fix_probe_aperture: bool
+            If True, probe Fourier amplitude is replaced by initial_probe_aperture
+        initial_probe_aperture: np.ndarray
+            Initial probe aperture to use in replacing probe Fourier amplitude
         fix_positions: bool
             If True, positions are not updated
         gaussian_filter: bool
@@ -1589,17 +1596,22 @@ def _constraints(
         if symmetrize_probe:
             current_probe = self._probe_radial_symmetrization_constraint(current_probe)
 
-        if fix_probe_amplitude:
+        if fix_probe_aperture:
+            current_probe = self._probe_aperture_constraint(
+                current_probe,
+                initial_probe_aperture,
+            )
+        elif constrain_probe_amplitude:
             current_probe = self._probe_amplitude_constraint(
                 current_probe,
-                fix_probe_amplitude_relative_radius,
-                fix_probe_amplitude_relative_width,
+                constrain_probe_amplitude_relative_radius,
+                constrain_probe_amplitude_relative_width,
             )
-        elif fix_probe_fourier_amplitude:
+        elif constrain_probe_fourier_amplitude:
             current_probe = self._probe_fourier_amplitude_constraint(
                 current_probe,
-                fix_probe_fourier_amplitude_threshold,
-                fix_probe_amplitude_relative_width,
+                constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_amplitude_relative_width,
             )
 
         if not fix_positions:
@@ -1626,12 +1638,13 @@ def reconstruct(
         positions_step_size: float = 0.9,
         fix_com: bool = True,
         fix_probe_iter: int = 0,
+        fix_probe_aperture_iter: int = 0,
         symmetrize_probe_iter: int = 0,
-        fix_probe_amplitude_iter: int = 0,
-        fix_probe_amplitude_relative_radius: float = 0.5,
-        fix_probe_amplitude_relative_width: float = 0.05,
-        fix_probe_fourier_amplitude_iter: int = 0,
-        fix_probe_fourier_amplitude_threshold: float = 0.9,
+        constrain_probe_amplitude_iter: int = 0,
+        constrain_probe_amplitude_relative_radius: float = 0.5,
+        constrain_probe_amplitude_relative_width: float = 0.05,
+        constrain_probe_fourier_amplitude_iter: int = 0,
+        constrain_probe_fourier_amplitude_threshold: float = 0.9,
         fix_positions_iter: int = np.inf,
         constrain_position_distance: float = None,
         global_affine_transformation: bool = True,
@@ -1692,17 +1705,19 @@ def reconstruct(
             If True, fixes center of mass of probe
         fix_probe_iter: int, optional
             Number of iterations to run with a fixed probe before updating probe estimate
+        fix_probe_aperture_iter: int, optional
+            Number of iterations to run with a fixed probe Fourier amplitude before updating probe estimate
         symmetrize_probe_iter: int, optional
             Number of iterations to run before radially-averaging the probe
-        fix_probe_amplitude: bool
+        constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
-        fix_probe_amplitude_relative_radius: float
+        constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
-        fix_probe_amplitude_relative_width: float
+        constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        fix_probe_fourier_amplitude: bool
+        constrain_probe_fourier_amplitude: bool
             If True, probe fourier amplitude is constrained by top hat function
-        fix_probe_fourier_amplitude_threshold: float
+        constrain_probe_fourier_amplitude_threshold: float
             Threshold value for current probe fourier mask. Value should
             be between 0 and 1, where higher values provide the most masking.
         fix_positions_iter: int, optional
@@ -2049,13 +2064,16 @@ def reconstruct(
                 and probe_gaussian_filter_sigma is not None,
                 probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
                 probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
-                fix_probe_amplitude=a0 < fix_probe_amplitude_iter
+                constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                 and a0 >= fix_probe_iter,
-                fix_probe_amplitude_relative_radius=fix_probe_amplitude_relative_radius,
-                fix_probe_amplitude_relative_width=fix_probe_amplitude_relative_width,
-                fix_probe_fourier_amplitude=a0 < fix_probe_fourier_amplitude_iter
+                constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
+                constrain_probe_amplitude_relative_width=constrain_probe_amplitude_relative_width,
+                constrain_probe_fourier_amplitude=a0
+                < constrain_probe_fourier_amplitude_iter
                 and a0 >= fix_probe_iter,
-                fix_probe_fourier_amplitude_threshold=fix_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                fix_probe_aperture=a0 < fix_probe_aperture_iter,
+                initial_probe_aperture=self._probe_initial_aperture,
                 fix_positions=a0 < fix_positions_iter,
                 global_affine_transformation=global_affine_transformation,
                 gaussian_filter=a0 < gaussian_filter_iter
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 3c33d46f5..92905cac2 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -707,6 +707,7 @@ def preprocess(
                 self._probe = xp.asarray(self._probe, dtype=xp.complex64)
 
         self._probe_initial = self._probe.copy()
+        self._probe_initial_aperture = xp.abs(xp.fft.fft2(self._probe))
 
         self._known_aberrations_array = ComplexProbe(
             energy=self._energy,
@@ -1662,11 +1663,13 @@ def _constraints(
         probe_gaussian_filter,
         probe_gaussian_filter_sigma,
         probe_gaussian_filter_fix_amplitude,
-        fix_probe_amplitude,
-        fix_probe_amplitude_relative_radius,
-        fix_probe_amplitude_relative_width,
-        fix_probe_fourier_amplitude,
-        fix_probe_fourier_amplitude_threshold,
+        constrain_probe_amplitude,
+        constrain_probe_amplitude_relative_radius,
+        constrain_probe_amplitude_relative_width,
+        constrain_probe_fourier_amplitude,
+        constrain_probe_fourier_amplitude_threshold,
+        fix_probe_aperture,
+        initial_probe_aperture,
         fix_positions,
         global_affine_transformation,
         gaussian_filter,
@@ -1704,17 +1707,21 @@ def _constraints(
             Standard deviation of gaussian kernel in A^-1
         probe_gaussian_filter_fix_amplitude: bool
             If True, only the probe phase is smoothed
-        fix_probe_amplitude: bool
+        constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
-        fix_probe_amplitude_relative_radius: float
+        constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
-        fix_probe_amplitude_relative_width: float
+        constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        fix_probe_fourier_amplitude: bool
+        constrain_probe_fourier_amplitude: bool
             If True, probe fourier amplitude is constrained by top hat function
-        fix_probe_fourier_amplitude_threshold: float
+        constrain_probe_fourier_amplitude_threshold: float
             Threshold value for current probe fourier mask. Value should
             be between 0 and 1, where higher values provide the most masking.
+        fix_probe_aperture: bool,
+            If True, probe Fourier amplitude is replaced by initial probe aperture.
+        initial_probe_aperture: np.ndarray,
+            Initial probe aperture to use in replacing probe Fourier amplitude.
         fix_positions: bool
             If True, positions are not updated
         gaussian_filter: bool
@@ -1813,17 +1820,22 @@ def _constraints(
         if symmetrize_probe:
             current_probe = self._probe_radial_symmetrization_constraint(current_probe)
 
-        if fix_probe_amplitude:
+        if fix_probe_aperture:
+            current_probe = self._probe_aperture_constraint(
+                current_probe,
+                initial_probe_aperture,
+            )
+        elif constrain_probe_amplitude:
             current_probe = self._probe_amplitude_constraint(
                 current_probe,
-                fix_probe_amplitude_relative_radius,
-                fix_probe_amplitude_relative_width,
+                constrain_probe_amplitude_relative_radius,
+                constrain_probe_amplitude_relative_width,
             )
-        elif fix_probe_fourier_amplitude:
+        elif constrain_probe_fourier_amplitude:
             current_probe = self._probe_fourier_amplitude_constraint(
                 current_probe,
-                fix_probe_fourier_amplitude_threshold,
-                fix_probe_amplitude_relative_width,
+                constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_amplitude_relative_width,
             )
 
         if not fix_positions:
@@ -1850,12 +1862,13 @@ def reconstruct(
         positions_step_size: float = 0.9,
         fix_com: bool = True,
         fix_probe_iter: int = 0,
+        fix_probe_aperture_iter: int = 0,
         symmetrize_probe_iter: int = 0,
-        fix_probe_amplitude_iter: int = 0,
-        fix_probe_amplitude_relative_radius: float = 0.5,
-        fix_probe_amplitude_relative_width: float = 0.05,
-        fix_probe_fourier_amplitude_iter: int = 0,
-        fix_probe_fourier_amplitude_threshold: float = 0.9,
+        constrain_probe_amplitude_iter: int = 0,
+        constrain_probe_amplitude_relative_radius: float = 0.5,
+        constrain_probe_amplitude_relative_width: float = 0.05,
+        constrain_probe_fourier_amplitude_iter: int = 0,
+        constrain_probe_fourier_amplitude_threshold: float = 0.9,
         fix_positions_iter: int = np.inf,
         constrain_position_distance: float = None,
         global_affine_transformation: bool = True,
@@ -1912,17 +1925,19 @@ def reconstruct(
             If True, fixes center of mass of probe
         fix_probe_iter: int, optional
             Number of iterations to run with a fixed probe before updating probe estimate
+        fix_probe_aperture_iter: int, optional
+            Number of iterations to run with a fixed probe Fourier amplitude before updating probe estimate
         symmetrize_probe_iter: int, optional
             Number of iterations to run before radially-averaging the probe
-        fix_probe_amplitude: bool
+        constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
-        fix_probe_amplitude_relative_radius: float
+        constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
-        fix_probe_amplitude_relative_width: float
+        constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        fix_probe_fourier_amplitude: bool
+        constrain_probe_fourier_amplitude: bool
             If True, probe fourier amplitude is constrained by top hat function
-        fix_probe_fourier_amplitude_threshold: float
+        constrain_probe_fourier_amplitude_threshold: float
             Threshold value for current probe fourier mask. Value should
             be between 0 and 1, where higher values provide the most masking.
         fix_positions_iter: int, optional
@@ -2398,14 +2413,16 @@ def reconstruct(
                         and probe_gaussian_filter_sigma is not None,
                         probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
                         probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
-                        fix_probe_amplitude=a0 < fix_probe_amplitude_iter
+                        constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                         and a0 >= fix_probe_iter,
-                        fix_probe_amplitude_relative_radius=fix_probe_amplitude_relative_radius,
-                        fix_probe_amplitude_relative_width=fix_probe_amplitude_relative_width,
-                        fix_probe_fourier_amplitude=a0
-                        < fix_probe_fourier_amplitude_iter
+                        constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
+                        constrain_probe_amplitude_relative_width=constrain_probe_amplitude_relative_width,
+                        constrain_probe_fourier_amplitude=a0
+                        < constrain_probe_fourier_amplitude_iter
                         and a0 >= fix_probe_iter,
-                        fix_probe_fourier_amplitude_threshold=fix_probe_fourier_amplitude_threshold,
+                        constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                        fix_probe_aperture=a0 < fix_probe_aperture_iter,
+                        initial_probe_aperture=self._probe_initial_aperture,
                         fix_positions=a0 < fix_positions_iter,
                         global_affine_transformation=global_affine_transformation,
                         gaussian_filter=a0 < gaussian_filter_iter
@@ -2450,13 +2467,16 @@ def reconstruct(
                     and probe_gaussian_filter_sigma is not None,
                     probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
                     probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
-                    fix_probe_amplitude=a0 < fix_probe_amplitude_iter
+                    constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                     and a0 >= fix_probe_iter,
-                    fix_probe_amplitude_relative_radius=fix_probe_amplitude_relative_radius,
-                    fix_probe_amplitude_relative_width=fix_probe_amplitude_relative_width,
-                    fix_probe_fourier_amplitude=a0 < fix_probe_fourier_amplitude_iter
+                    constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
+                    constrain_probe_amplitude_relative_width=constrain_probe_amplitude_relative_width,
+                    constrain_probe_fourier_amplitude=a0
+                    < constrain_probe_fourier_amplitude_iter
                     and a0 >= fix_probe_iter,
-                    fix_probe_fourier_amplitude_threshold=fix_probe_fourier_amplitude_threshold,
+                    constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                    fix_probe_aperture=a0 < fix_probe_aperture_iter,
+                    initial_probe_aperture=self._probe_initial_aperture,
                     fix_positions=True,
                     global_affine_transformation=global_affine_transformation,
                     gaussian_filter=a0 < gaussian_filter_iter
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index 4a64f17af..6166640f4 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -616,6 +616,7 @@ def preprocess(
                 self._probe = xp.asarray(self._probe, dtype=xp.complex64)
 
         self._probe_initial = self._probe.copy()
+        self._probe_initial_aperture = xp.abs(xp.fft.fft2(self._probe))
 
         self._known_aberrations_array = ComplexProbe(
             energy=self._energy,
@@ -1510,11 +1511,13 @@ def _constraints(
         probe_gaussian_filter,
         probe_gaussian_filter_sigma,
         probe_gaussian_filter_fix_amplitude,
-        fix_probe_amplitude,
-        fix_probe_amplitude_relative_radius,
-        fix_probe_amplitude_relative_width,
-        fix_probe_fourier_amplitude,
-        fix_probe_fourier_amplitude_threshold,
+        constrain_probe_amplitude,
+        constrain_probe_amplitude_relative_radius,
+        constrain_probe_amplitude_relative_width,
+        constrain_probe_fourier_amplitude,
+        constrain_probe_fourier_amplitude_threshold,
+        fix_probe_aperture,
+        initial_probe_aperture,
         fix_positions,
         global_affine_transformation,
         gaussian_filter,
@@ -1548,17 +1551,21 @@ def _constraints(
             Standard deviation of gaussian kernel in A^-1
         probe_gaussian_filter_fix_amplitude: bool
             If True, only the probe phase is smoothed
-        fix_probe_amplitude: bool
+        constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
-        fix_probe_amplitude_relative_radius: float
+        constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
-        fix_probe_amplitude_relative_width: float
+        constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        fix_probe_fourier_amplitude: bool
+        constrain_probe_fourier_amplitude: bool
             If True, probe fourier amplitude is constrained by top hat function
-        fix_probe_fourier_amplitude_threshold: float
+        constrain_probe_fourier_amplitude_threshold: float
             Threshold value for current probe fourier mask. Value should
             be between 0 and 1, where higher values provide the most masking.
+        fix_probe_aperture: bool,
+            If True, probe Fourier amplitude is replaced by initial probe aperture.
+        initial_probe_aperture: np.ndarray,
+            Initial probe aperture to use in replacing probe Fourier amplitude.
         fix_positions: bool
             If True, positions are not updated
         gaussian_filter: bool
@@ -1626,17 +1633,22 @@ def _constraints(
         if symmetrize_probe:
             current_probe = self._probe_radial_symmetrization_constraint(current_probe)
 
-        if fix_probe_amplitude:
+        if fix_probe_aperture:
+            current_probe = self._probe_aperture_constraint(
+                current_probe,
+                initial_probe_aperture,
+            )
+        elif constrain_probe_amplitude:
             current_probe = self._probe_amplitude_constraint(
                 current_probe,
-                fix_probe_amplitude_relative_radius,
-                fix_probe_amplitude_relative_width,
+                constrain_probe_amplitude_relative_radius,
+                constrain_probe_amplitude_relative_width,
             )
-        elif fix_probe_fourier_amplitude:
+        elif constrain_probe_fourier_amplitude:
             current_probe = self._probe_fourier_amplitude_constraint(
                 current_probe,
-                fix_probe_fourier_amplitude_threshold,
-                fix_probe_amplitude_relative_width,
+                constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_amplitude_relative_width,
             )
 
         if not fix_positions:
@@ -1663,12 +1675,13 @@ def reconstruct(
         positions_step_size: float = 0.9,
         fix_com: bool = True,
         fix_probe_iter: int = 0,
+        fix_probe_aperture_iter: int = 0,
         symmetrize_probe_iter: int = 0,
-        fix_probe_amplitude_iter: int = 0,
-        fix_probe_amplitude_relative_radius: float = 0.5,
-        fix_probe_amplitude_relative_width: float = 0.05,
-        fix_probe_fourier_amplitude_iter: int = 0,
-        fix_probe_fourier_amplitude_threshold: float = 0.9,
+        constrain_probe_amplitude_iter: int = 0,
+        constrain_probe_amplitude_relative_radius: float = 0.5,
+        constrain_probe_amplitude_relative_width: float = 0.05,
+        constrain_probe_fourier_amplitude_iter: int = 0,
+        constrain_probe_fourier_amplitude_threshold: float = 0.9,
         fix_positions_iter: int = np.inf,
         constrain_position_distance: float = None,
         global_affine_transformation: bool = True,
@@ -1722,17 +1735,19 @@ def reconstruct(
             If True, fixes center of mass of probe
         fix_probe_iter: int, optional
             Number of iterations to run with a fixed probe before updating probe estimate
+        fix_probe_aperture_iter: int, optional
+            Number of iterations to run with a fixed probe Fourier amplitude before updating probe estimate
         symmetrize_probe_iter: int, optional
-            Number of iterations to run with a fixed probe before updating probe estimate
-        fix_probe_amplitude: bool
+            Number of iterations to run before radially-averaging the probe
+        constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
-        fix_probe_amplitude_relative_radius: float
+        constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
-        fix_probe_amplitude_relative_width: float
+        constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        fix_probe_fourier_amplitude: bool
+        constrain_probe_fourier_amplitude: bool
             If True, probe fourier amplitude is constrained by top hat function
-        fix_probe_fourier_amplitude_threshold: float
+        constrain_probe_fourier_amplitude_threshold: float
             Threshold value for current probe fourier mask. Value should
             be between 0 and 1, where higher values provide the most masking.
         fix_positions_iter: int, optional
@@ -2127,14 +2142,16 @@ def reconstruct(
                         and probe_gaussian_filter_sigma is not None,
                         probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
                         probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
-                        fix_probe_amplitude=a0 < fix_probe_amplitude_iter
+                        constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                         and a0 >= fix_probe_iter,
-                        fix_probe_amplitude_relative_radius=fix_probe_amplitude_relative_radius,
-                        fix_probe_amplitude_relative_width=fix_probe_amplitude_relative_width,
-                        fix_probe_fourier_amplitude=a0
-                        < fix_probe_fourier_amplitude_iter
+                        constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
+                        constrain_probe_amplitude_relative_width=constrain_probe_amplitude_relative_width,
+                        constrain_probe_fourier_amplitude=a0
+                        < constrain_probe_fourier_amplitude_iter
                         and a0 >= fix_probe_iter,
-                        fix_probe_fourier_amplitude_threshold=fix_probe_fourier_amplitude_threshold,
+                        constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                        fix_probe_aperture=a0 < fix_probe_aperture_iter,
+                        initial_probe_aperture=self._probe_initial_aperture,
                         fix_positions=a0 < fix_positions_iter,
                         global_affine_transformation=global_affine_transformation,
                         gaussian_filter=a0 < gaussian_filter_iter
@@ -2174,13 +2191,16 @@ def reconstruct(
                     and probe_gaussian_filter_sigma is not None,
                     probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
                     probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
-                    fix_probe_amplitude=a0 < fix_probe_amplitude_iter
+                    constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                     and a0 >= fix_probe_iter,
-                    fix_probe_amplitude_relative_radius=fix_probe_amplitude_relative_radius,
-                    fix_probe_amplitude_relative_width=fix_probe_amplitude_relative_width,
-                    fix_probe_fourier_amplitude=a0 < fix_probe_fourier_amplitude_iter
+                    constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
+                    constrain_probe_amplitude_relative_width=constrain_probe_amplitude_relative_width,
+                    constrain_probe_fourier_amplitude=a0
+                    < constrain_probe_fourier_amplitude_iter
                     and a0 >= fix_probe_iter,
-                    fix_probe_fourier_amplitude_threshold=fix_probe_fourier_amplitude_threshold,
+                    constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                    fix_probe_aperture=a0 < fix_probe_aperture_iter,
+                    initial_probe_aperture=self._probe_initial_aperture,
                     fix_positions=True,
                     global_affine_transformation=global_affine_transformation,
                     gaussian_filter=a0 < gaussian_filter_iter
diff --git a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
index e872bc42e..da358e089 100644
--- a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
@@ -694,6 +694,7 @@ def preprocess(
                 self._probe = xp.asarray(self._probe, dtype=xp.complex64)
 
         self._probe_initial = self._probe.copy()
+        self._probe_initial_aperture = xp.abs(xp.fft.fft2(self._probe))
 
         self._known_aberrations_array = ComplexProbe(
             energy=self._energy,
@@ -2181,11 +2182,13 @@ def _constraints(
         probe_gaussian_filter,
         probe_gaussian_filter_sigma,
         probe_gaussian_filter_fix_amplitude,
-        fix_probe_amplitude,
-        fix_probe_amplitude_relative_radius,
-        fix_probe_amplitude_relative_width,
-        fix_probe_fourier_amplitude,
-        fix_probe_fourier_amplitude_threshold,
+        constrain_probe_amplitude,
+        constrain_probe_amplitude_relative_radius,
+        constrain_probe_amplitude_relative_width,
+        constrain_probe_fourier_amplitude,
+        constrain_probe_fourier_amplitude_threshold,
+        fix_probe_aperture,
+        initial_probe_aperture,
         fix_positions,
         global_affine_transformation,
         gaussian_filter,
@@ -2219,17 +2222,21 @@ def _constraints(
             If True, probe CoM is fixed to the center
         symmetrize_probe: bool
             If True, the probe is radially-averaged
-        fix_probe_amplitude: bool
+        constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
-        fix_probe_amplitude_relative_radius: float
+        constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
-        fix_probe_amplitude_relative_width: float
+        constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        fix_probe_fourier_amplitude: bool
+        constrain_probe_fourier_amplitude: bool
             If True, probe fourier amplitude is constrained by top hat function
-        fix_probe_fourier_amplitude_threshold: float
+        constrain_probe_fourier_amplitude_threshold: float
             Threshold value for current probe fourier mask. Value should
             be between 0 and 1, where higher values provide the most masking.
+        fix_probe_aperture: bool,
+            If True, probe Fourier amplitude is replaced by initial probe aperture.
+        initial_probe_aperture: np.ndarray,
+            Initial probe aperture to use in replacing probe Fourier amplitude.
         fix_positions: bool
             If True, positions are not updated
         gaussian_filter: bool
@@ -2335,17 +2342,22 @@ def _constraints(
         if symmetrize_probe:
             current_probe = self._probe_radial_symmetrization_constraint(current_probe)
 
-        if fix_probe_amplitude:
+        if fix_probe_aperture:
+            current_probe = self._probe_aperture_constraint(
+                current_probe,
+                initial_probe_aperture,
+            )
+        elif constrain_probe_amplitude:
             current_probe = self._probe_amplitude_constraint(
                 current_probe,
-                fix_probe_amplitude_relative_radius,
-                fix_probe_amplitude_relative_width,
+                constrain_probe_amplitude_relative_radius,
+                constrain_probe_amplitude_relative_width,
             )
-        elif fix_probe_fourier_amplitude:
+        elif constrain_probe_fourier_amplitude:
             current_probe = self._probe_fourier_amplitude_constraint(
                 current_probe,
-                fix_probe_fourier_amplitude_threshold,
-                fix_probe_amplitude_relative_width,
+                constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_amplitude_relative_width,
             )
 
         if not fix_positions:
@@ -2374,12 +2386,13 @@ def reconstruct(
         fix_com: bool = True,
         fix_probe_iter: int = 0,
         warmup_iter: int = 0,
+        fix_probe_aperture_iter: int = 0,
         symmetrize_probe_iter: int = 0,
-        fix_probe_amplitude_iter: int = 0,
-        fix_probe_amplitude_relative_radius: float = 0.5,
-        fix_probe_amplitude_relative_width: float = 0.05,
-        fix_probe_fourier_amplitude_iter: int = 0,
-        fix_probe_fourier_amplitude_threshold: float = 0.9,
+        constrain_probe_amplitude_iter: int = 0,
+        constrain_probe_amplitude_relative_radius: float = 0.5,
+        constrain_probe_amplitude_relative_width: float = 0.05,
+        constrain_probe_fourier_amplitude_iter: int = 0,
+        constrain_probe_fourier_amplitude_threshold: float = 0.9,
         fix_positions_iter: int = np.inf,
         constrain_position_distance: float = None,
         global_affine_transformation: bool = True,
@@ -2436,17 +2449,19 @@ def reconstruct(
             If True, fixes center of mass of probe
         fix_probe_iter: int, optional
             Number of iterations to run with a fixed probe before updating probe estimate
+        fix_probe_aperture_iter: int, optional
+            Number of iterations to run with a fixed probe Fourier amplitude before updating probe estimate
         symmetrize_probe_iter: int, optional
             Number of iterations to run before radially-averaging the probe
-        fix_probe_amplitude: bool
+        constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
-        fix_probe_amplitude_relative_radius: float
+        constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
-        fix_probe_amplitude_relative_width: float
+        constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        fix_probe_fourier_amplitude: bool
+        constrain_probe_fourier_amplitude: bool
             If True, probe fourier amplitude is constrained by top hat function
-        fix_probe_fourier_amplitude_threshold: float
+        constrain_probe_fourier_amplitude_threshold: float
             Threshold value for current probe fourier mask. Value should
             be between 0 and 1, where higher values provide the most masking.
         fix_positions_iter: int, optional
@@ -2811,13 +2826,16 @@ def reconstruct(
                 and probe_gaussian_filter_sigma is not None,
                 probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
                 probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
-                fix_probe_amplitude=a0 < fix_probe_amplitude_iter
+                constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                 and a0 >= fix_probe_iter,
-                fix_probe_amplitude_relative_radius=fix_probe_amplitude_relative_radius,
-                fix_probe_amplitude_relative_width=fix_probe_amplitude_relative_width,
-                fix_probe_fourier_amplitude=a0 < fix_probe_fourier_amplitude_iter
+                constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
+                constrain_probe_amplitude_relative_width=constrain_probe_amplitude_relative_width,
+                constrain_probe_fourier_amplitude=a0
+                < constrain_probe_fourier_amplitude_iter
                 and a0 >= fix_probe_iter,
-                fix_probe_fourier_amplitude_threshold=fix_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                fix_probe_aperture=a0 < fix_probe_aperture_iter,
+                initial_probe_aperture=self._probe_initial_aperture,
                 fix_positions=a0 < fix_positions_iter,
                 global_affine_transformation=global_affine_transformation,
                 warmup_iteration=a0 < warmup_iter,

From a4f1b33478669a932cf72f37ab9e741f39b4ee5a Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Thu, 22 Jun 2023 08:04:38 -0400
Subject: [PATCH 057/362] abTEM 2D, text reformat, array docs

---
 py4DSTEM/io/filereaders/read_abTEM.py         |  60 ++--
 py4DSTEM/io/importfile.py                     |  24 +-
 .../legacy/legacy13/v13_emd_classes/array.py  |   6 +-
 py4DSTEM/io/parsefiletype.py                  |  32 +-
 py4DSTEM/io/read.py                           |  92 ++---
 py4DSTEM/process/virtualdiffraction.py        | 198 ++++++-----
 py4DSTEM/process/virtualimage.py              | 323 +++++++++---------
 7 files changed, 396 insertions(+), 339 deletions(-)

diff --git a/py4DSTEM/io/filereaders/read_abTEM.py b/py4DSTEM/io/filereaders/read_abTEM.py
index 1008bcc0e..af0c71c63 100644
--- a/py4DSTEM/io/filereaders/read_abTEM.py
+++ b/py4DSTEM/io/filereaders/read_abTEM.py
@@ -1,5 +1,5 @@
 import h5py
-from py4DSTEM.classes import DataCube
+from py4DSTEM.classes import DataCube, VirtualDiffraction, VirtualImage
 
 
 def read_abTEM(
@@ -8,7 +8,7 @@ def read_abTEM(
     binfactor: int = 1,
 ):
     """
-    File reader for abTEM 4D-STEM datasets
+    File reader for abTEM datasets
     Args:
         filename: str with path to  file
         mem (str):  Must be "RAM" or "MEMMAP". Specifies how the data is
@@ -30,29 +30,39 @@ def read_abTEM(
             datasets[key] = f.get(key)[()]
 
     data = datasets["array"]
-    assert len(data.shape) == 4, "reader is for 4D-STEM datasets only"
-
-    datacube = DataCube(data=data)
-
     sampling = datasets["sampling"]
     units = datasets["units"]
 
-    datacube.calibration.set_R_pixel_size(sampling[0])
-    if sampling[0] != sampling[1]:
-        print(
-            "Warning: py4DSTEM currently only handles uniform x,y sampling. Setting sampling with x calibration"
-        )
-    datacube.calibration.set_Q_pixel_size(sampling[2])
-    if sampling[2] != sampling[3]:
-        print(
-            "Warning: py4DSTEM currently only handles uniform qx,qy sampling. Setting sampling with qx calibration"
-        )
-
-    if units[0] == b"\xc3\x85":
-        datacube.calibration.set_R_pixel_units("A")
-    else:
-        datacube.calibration.set_R_pixel_units(units[0].decode("utf-8"))
-
-    datacube.calibration.set_Q_pixel_units(units[2].decode("utf-8"))
-
-    return datacube
+    if len(data.shape) == 4:
+
+        datacube = DataCube(data=data)
+
+        datacube.calibration.set_R_pixel_size(sampling[0])
+        if sampling[0] != sampling[1]:
+            print(
+                "Warning: py4DSTEM currently only handles uniform x,y sampling. Setting sampling with x calibration"
+            )
+        datacube.calibration.set_Q_pixel_size(sampling[2])
+        if sampling[2] != sampling[3]:
+            print(
+                "Warning: py4DSTEM currently only handles uniform qx,qy sampling. Setting sampling with qx calibration"
+            )
+
+        if units[0] == b"\xc3\x85":
+            datacube.calibration.set_R_pixel_units("A")
+        else:
+            datacube.calibration.set_R_pixel_units(units[0].decode("utf-8"))
+
+        datacube.calibration.set_Q_pixel_units(units[2].decode("utf-8"))
+
+        return datacube
+
+    elif len(data.shape) == 2:
+        if units[0] == b"mrad":
+            diffraction = VirtualDiffraction(data=data)
+            # TODO, calibrations for 2D
+            return diffraction
+        elif units[0] == b"\xc3\x85":
+            image = VirtualImage(data=data)
+            # TODO calibrations for 2D
+            return image
diff --git a/py4DSTEM/io/importfile.py b/py4DSTEM/io/importfile.py
index 98ef05238..20a3759a2 100644
--- a/py4DSTEM/io/importfile.py
+++ b/py4DSTEM/io/importfile.py
@@ -1,18 +1,18 @@
 # Reader functions for non-native file types
 
 import pathlib
-from os.path import exists, splitext
-from typing import Union, Optional
+from os.path import exists
+from typing import Optional, Union
 
-from py4DSTEM.io.parsefiletype import _parse_filetype
 from py4DSTEM.io.filereaders import (
-    read_empad,
-    read_dm,
-    read_gatan_K2_bin,
     load_mib,
+    read_abTEM,
     read_arina,
-    read_abTEM
+    read_dm,
+    read_empad,
+    read_gatan_K2_bin,
 )
+from py4DSTEM.io.parsefiletype import _parse_filetype
 
 
 def import_file(
@@ -56,9 +56,7 @@ def import_file(
         "RAM",
         "MEMMAP",
     ], 'Error: argument mem must be either "RAM" or "MEMMAP"'
-    assert isinstance(
-        binfactor, int
-    ), "Error: argument binfactor must be an integer"
+    assert isinstance(binfactor, int), "Error: argument binfactor must be an integer"
     assert binfactor >= 1, "Error: binfactor must be >= 1"
     if binfactor > 1:
         assert (
@@ -67,8 +65,10 @@ def import_file(
 
     filetype = _parse_filetype(filepath) if filetype is None else filetype
 
-    if filetype in ('emd', 'legacy'):
-        raise Exception("EMD file or py4DSTEM detected - use py4DSTEM.read, not py4DSTEM.import_file!")
+    if filetype in ("emd", "legacy"):
+        raise Exception(
+            "EMD file or py4DSTEM detected - use py4DSTEM.read, not py4DSTEM.import_file!"
+        )
     assert filetype in [
         "dm",
         "empad",
diff --git a/py4DSTEM/io/legacy/legacy13/v13_emd_classes/array.py b/py4DSTEM/io/legacy/legacy13/v13_emd_classes/array.py
index 4b385a694..8b20779f8 100644
--- a/py4DSTEM/io/legacy/legacy13/v13_emd_classes/array.py
+++ b/py4DSTEM/io/legacy/legacy13/v13_emd_classes/array.py
@@ -322,8 +322,10 @@ def set_dim(
         values for the n'th dim vector.
         Accepts:
             n (int): specifies which dim vector
-            dim (list or array): length must be either 2, or equal to the
-                length of the n'th axis of the data array
+            dim (list or array): length must be either 1 or 2, or equal to the
+                length of the n'th axis of the data array. If length is 1 specifies step
+                size of dim vector and starts at 0. If length is 2, specifies start
+                and step of dim vector.
             units (Optional, str):
             name: (Optional, str):
         """
diff --git a/py4DSTEM/io/parsefiletype.py b/py4DSTEM/io/parsefiletype.py
index ab7529ec6..8d5870944 100644
--- a/py4DSTEM/io/parsefiletype.py
+++ b/py4DSTEM/io/parsefiletype.py
@@ -1,12 +1,14 @@
 # File parser utility
 
 from os.path import splitext
-import py4DSTEM.io.legacy as legacy
+
 import emdfile as emd
 import h5py
+import py4DSTEM.io.legacy as legacy
+
 
 def _parse_filetype(fp):
-    """ 
+    """
     Accepts a path to a data file, and returns the file type as a string.
     """
     _, fext = splitext(fp)
@@ -28,7 +30,7 @@ def _parse_filetype(fp):
 
         elif _is_abTEM(fp):
             return "abTEM"
-            
+
     elif fext in [
         ".dm",
         ".dm3",
@@ -36,42 +38,42 @@ def _parse_filetype(fp):
     ]:
         return "dm"
     elif fext in [".raw"]:
-       return "empad"
+        return "empad"
     elif fext in [".mrc"]:
-       return "mrc_relativity"
+        return "mrc_relativity"
     elif fext in [".gtg", ".bin"]:
-       return "gatan_K2_bin"
+        return "gatan_K2_bin"
     elif fext in [".kitware_counted"]:
-       return "kitware_counted"
+        return "kitware_counted"
     elif fext in [".mib", ".MIB"]:
         return "mib"
     else:
         raise Exception(f"Unrecognized file extension {fext}.")
 
+
 def _is_arina(filepath):
     """
     Check if an h5 file is an Arina file.
     """
-    with h5py.File(filepath,'r') as f:
+    with h5py.File(filepath, "r") as f:
         try:
-            assert("entry" in f.keys())
+            assert "entry" in f.keys()
         except AssertionError:
             return False
         try:
-            assert("NX_class" in f["entry"].attrs.keys())
+            assert "NX_class" in f["entry"].attrs.keys()
         except AssertionError:
             return False
     return True
 
+
 def _is_abTEM(filepath):
     """
-    Check if an h5 file is an abTEM file. 
+    Check if an h5 file is an abTEM file.
     """
-    with h5py.File(filepath,'r') as f:
+    with h5py.File(filepath, "r") as f:
         try:
-            assert("array" in f.keys())
+            assert "array" in f.keys()
         except AssertionError:
             return False
     return True
-
-
diff --git a/py4DSTEM/io/read.py b/py4DSTEM/io/read.py
index 82815779f..de7359ce8 100644
--- a/py4DSTEM/io/read.py
+++ b/py4DSTEM/io/read.py
@@ -1,24 +1,21 @@
 # Reader for native files
 
-from pathlib import Path
 from os.path import exists
-from typing import Optional,Union
+from pathlib import Path
+from typing import Optional, Union
 
-import py4DSTEM
 import emdfile as emd
-from py4DSTEM.io.parsefiletype import _parse_filetype
 import py4DSTEM.io.legacy as legacy
-
-
+from py4DSTEM.io.parsefiletype import _parse_filetype
 
 
 def read(
-    filepath: Union[str,Path],
+    filepath: Union[str, Path],
     datapath: Optional[str] = None,
-    tree: Optional[Union[bool,str]] = True,
+    tree: Optional[Union[bool, str]] = True,
     verbose: Optional[bool] = False,
     **kwargs,
-    ):
+):
     """
     A file reader for native py4DSTEM / EMD files.  To read non-native
     formats, use `py4DSTEM.import_file`.
@@ -65,85 +62,90 @@ def read(
     # parse filetype
     er1 = f"filepath must be a string or Path, not {type(filepath)}"
     er2 = f"specified filepath '{filepath}' does not exist"
-    assert(isinstance(filepath, (str,Path) )), er1
-    assert(exists(filepath)), er2
+    assert isinstance(filepath, (str, Path)), er1
+    assert exists(filepath), er2
 
     filetype = _parse_filetype(filepath)
-    assert filetype in ('emd', 'legacy'), f"`py4DSTEM.read` loads native HDF5 formatted files, but a file of type {filetype} was detected.  Try loading it using py4DSTEM.import_file"
-
+    assert filetype in (
+        "emd",
+        "legacy",
+    ), f"`py4DSTEM.read` loads native HDF5 formatted files, but a file of type {filetype} was detected.  Try loading it using py4DSTEM.import_file"
 
     # EMD 1.0 formatted files (py4DSTEM v0.14+)
     if filetype == "emd":
         version = emd._get_EMD_version(filepath)
-        if verbose: print(f"EMD version {version[0]}.{version[1]}.{version[2]} detected. Reading...")
-        assert emd._version_is_geq(version,(1,0,0)), f"EMD version {version} detected. Expected version >= 1.0.0"
-        data = emd.read(
-            filepath,
-            emdpath = datapath,
-            tree = tree
-        )
-        if verbose: print("Done.")
+        if verbose:
+            print(
+                f"EMD version {version[0]}.{version[1]}.{version[2]} detected. Reading..."
+            )
+        assert emd._version_is_geq(
+            version, (1, 0, 0)
+        ), f"EMD version {version} detected. Expected version >= 1.0.0"
+        data = emd.read(filepath, emdpath=datapath, tree=tree)
+        if verbose:
+            print("Done.")
         return data
 
-
     # legacy py4DSTEM files (v <= 0.13)
     else:
-        assert filetype == "legacy", "path points to an H5 file which is neither an EMD 1.0+ file, nor a recognized legacy py4DSTEM file."
-
+        assert (
+            filetype == "legacy"
+        ), "path points to an H5 file which is neither an EMD 1.0+ file, nor a recognized legacy py4DSTEM file."
 
         # read v13
         if legacy.is_py4DSTEM_version13(filepath):
 
             # load the data
-            if verbose: print(f"Legacy py4DSTEM version 13 file detected. Reading...")
-            kwargs['root'] = datapath
-            kwargs['tree'] = tree
+            if verbose:
+                print("Legacy py4DSTEM version 13 file detected. Reading...")
+            kwargs["root"] = datapath
+            kwargs["tree"] = tree
             data = legacy.read_legacy13(
                 filepath=filepath,
                 **kwargs,
             )
-            if verbose: print("Done.")
+            if verbose:
+                print("Done.")
             return data
 
-
         # read <= v12
         else:
 
             # parse the root/data_id from the datapath arg
             if datapath is not None:
-                datapath = datapath.split('/')
+                datapath = datapath.split("/")
                 try:
-                    datapath.remove('')
+                    datapath.remove("")
                 except ValueError:
                     pass
                 rootgroup = datapath[0]
-                if len(datapath)>1:
-                    datapath = '/'.join(rootgroup[1:])
+                if len(datapath) > 1:
+                    datapath = "/".join(rootgroup[1:])
                 else:
                     datapath = None
             else:
                 rootgroups = legacy.get_py4DSTEM_topgroups(filepath)
-                if len(rootgroups)>1:
-                    print('multiple root groups in a legacy file found - returning list of root names; please pass one as `datapath`')
+                if len(rootgroups) > 1:
+                    print(
+                        "multiple root groups in a legacy file found - returning list of root names; please pass one as `datapath`"
+                    )
                     return rootgroups
-                elif len(rootgroups)==0:
-                    raise Exception('No rootgroups found')
+                elif len(rootgroups) == 0:
+                    raise Exception("No rootgroups found")
                 else:
                     rootgroup = rootgroups[0]
                     datapath = None
 
-
             # load the data
-            if verbose: print(f"Legacy py4DSTEM version <= 12 file detected. Reading...")
-            kwargs['topgroup'] = rootgroup
+            if verbose:
+                print("Legacy py4DSTEM version <= 12 file detected. Reading...")
+            kwargs["topgroup"] = rootgroup
             if datapath is not None:
-                kwargs['data_id'] = datapath
+                kwargs["data_id"] = datapath
             data = legacy.read_legacy12(
                 filepath=filepath,
                 **kwargs,
             )
-            if verbose: print("Done.")
+            if verbose:
+                print("Done.")
             return data
-
-
-
diff --git a/py4DSTEM/process/virtualdiffraction.py b/py4DSTEM/process/virtualdiffraction.py
index ba31b778a..b54aed65d 100644
--- a/py4DSTEM/process/virtualdiffraction.py
+++ b/py4DSTEM/process/virtualdiffraction.py
@@ -3,17 +3,18 @@
 import numpy as np
 from emdfile import tqdmnd
 
+
 def get_virtual_diffraction(
     datacube,
     method,
-    mode = None,
-    geometry = None,
-    calibrated = False,
-    shift_center = False,
-    verbose = True,
-    return_mask = False,
+    mode=None,
+    geometry=None,
+    calibrated=False,
+    shift_center=False,
+    verbose=True,
+    return_mask=False,
 ):
-    '''
+    """
     Function to calculate virtual diffraction
 
     Args:
@@ -58,36 +59,54 @@ def get_virtual_diffraction(
 
     Returns:
         (2D array): the diffraction image
-    '''
+    """
 
-    assert method in ('max', 'median', 'mean'),\
-        'check doc strings for supported types'
+    assert method in ("max", "median", "mean"), "check doc strings for supported types"
 
-    #create mask
+    # create mask
     if mode is not None:
         use_all_points = False
 
         from py4DSTEM.process.virtualimage import make_detector
-        assert mode in ('point', 'circle', 'circular', 'annulus', 'annular', 'rectangle', 'square', 'rectangular', 'mask'),\
-        'check doc strings for supported modes'
+
+        assert mode in (
+            "point",
+            "circle",
+            "circular",
+            "annulus",
+            "annular",
+            "rectangle",
+            "square",
+            "rectangular",
+            "mask",
+        ), "check doc strings for supported modes"
         g = geometry
 
         if calibrated == True:
-            assert datacube.calibration['R_pixel_units'] == 'A', \
-                'check datacube.calibration. datacube must be calibrated in A to use `calibrated=True`'
-
-            unit_conversion = datacube.calibration['R_pixel_size']
-            if mode == 'point':
-                g = (g[0]/unit_conversion, g[1]/unit_conversion)
-            if mode in('circle', 'circular'):
-                g = ((g[0][0]/unit_conversion, g[0][1]/unit_conversion),
-                    (g[1]/unit_conversion))
-            if mode in('annulus', 'annular'):
-                g = ((g[0][0]/unit_conversion, g[0][1]/unit_conversion),
-                    (g[1][0]/unit_conversion, g[1][1]/unit_conversion))
-            if mode in('rectangle', 'square', 'rectangular') :
-                g = (g[0]/unit_conversion, g[1]/unit_conversion,
-                     g[2]/unit_conversion, g[3]/unit_conversion)
+            assert (
+                datacube.calibration["R_pixel_units"] == "A"
+            ), "check datacube.calibration. datacube must be calibrated in A to use `calibrated=True`"
+
+            unit_conversion = datacube.calibration["R_pixel_size"]
+            if mode == "point":
+                g = (g[0] / unit_conversion, g[1] / unit_conversion)
+            if mode in ("circle", "circular"):
+                g = (
+                    (g[0][0] / unit_conversion, g[0][1] / unit_conversion),
+                    (g[1] / unit_conversion),
+                )
+            if mode in ("annulus", "annular"):
+                g = (
+                    (g[0][0] / unit_conversion, g[0][1] / unit_conversion),
+                    (g[1][0] / unit_conversion, g[1][1] / unit_conversion),
+                )
+            if mode in ("rectangle", "square", "rectangular"):
+                g = (
+                    g[0] / unit_conversion,
+                    g[1] / unit_conversion,
+                    g[2] / unit_conversion,
+                    g[3] / unit_conversion,
+                )
 
         # Get mask
         mask = make_detector(datacube.Rshape, mode, g)
@@ -99,7 +118,7 @@ def get_virtual_diffraction(
         else:
             mask_is_boolean = False
 
-    #if no mask 
+    # if no mask
     else:
         mask = np.ones(datacube.Rshape, dtype=bool)
         mask_indices = np.nonzero(mask)
@@ -117,48 +136,62 @@ def get_virtual_diffraction(
 
         # ...for the whole pattern
         if use_all_points:
-            if method == 'mean':
-                virtual_diffraction = np.mean(datacube.data, axis=(0,1))
-            elif method == 'max':
-                virtual_diffraction = np.max(datacube.data, axis=(0,1))
+            if method == "mean":
+                virtual_diffraction = np.mean(datacube.data, axis=(0, 1))
+            elif method == "max":
+                virtual_diffraction = np.max(datacube.data, axis=(0, 1))
             else:
-                virtual_diffraction = np.median(datacube.data, axis=(0,1))
+                virtual_diffraction = np.median(datacube.data, axis=(0, 1))
 
         # ...for boolean masks
         elif mask_is_boolean:
-            if method == 'mean':
-                virtual_diffraction = np.mean(datacube.data[mask_indices[0],mask_indices[1],:,:], axis=0)
-            elif method == 'max':
-                virtual_diffraction = np.max(datacube.data[mask_indices[0],mask_indices[1],:,:], axis=0)
+            if method == "mean":
+                virtual_diffraction = np.mean(
+                    datacube.data[mask_indices[0], mask_indices[1], :, :], axis=0
+                )
+            elif method == "max":
+                virtual_diffraction = np.max(
+                    datacube.data[mask_indices[0], mask_indices[1], :, :], axis=0
+                )
             else:
-                virtual_diffraction = np.median(datacube.data[mask_indices[0],mask_indices[1],:,:], axis=0)
+                virtual_diffraction = np.median(
+                    datacube.data[mask_indices[0], mask_indices[1], :, :], axis=0
+                )
 
         # ...for floating point masks
         else:
-            if mask.dtype == 'complex':
-                virtual_diffraction = np.zeros(datacube.Qshape, dtype = 'complex')
+            if mask.dtype == "complex":
+                virtual_diffraction = np.zeros(datacube.Qshape, dtype="complex")
             else:
                 virtual_diffraction = np.zeros(datacube.Qshape)
-            for qx,qy in tqdmnd(
+            for qx, qy in tqdmnd(
                 datacube.Q_Nx,
                 datacube.Q_Ny,
-                disable = not verbose,
+                disable=not verbose,
             ):
-                if method == 'mean':
-                    virtual_diffraction[qx,qy] = np.sum( np.squeeze(datacube.data[:,:,qx,qy])*mask )
-                elif method == 'max':
-                    virtual_diffraction[qx,qy] = np.max( np.squeeze(datacube.data[:,:,qx,qy])*mask )
-                elif method == 'median':
-                    virtual_diffraction[qx,qy] = np.median( np.squeeze(datacube.data[:,:,qx,qy])*mask )
+                if method == "mean":
+                    virtual_diffraction[qx, qy] = np.sum(
+                        np.squeeze(datacube.data[:, :, qx, qy]) * mask
+                    )
+                elif method == "max":
+                    virtual_diffraction[qx, qy] = np.max(
+                        np.squeeze(datacube.data[:, :, qx, qy]) * mask
+                    )
+                elif method == "median":
+                    virtual_diffraction[qx, qy] = np.median(
+                        np.squeeze(datacube.data[:, :, qx, qy]) * mask
+                    )
 
         # norm by weighting term for means
-        if method == 'mean' and not use_all_points:
+        if method == "mean" and not use_all_points:
             virtual_diffraction /= np.sum(mask)
 
     # ...with center shifting
     else:
-        assert method in ('max', 'mean'),\
-            "only 'mean' and 'max' are supported for center-shifted virtual diffraction"
+        assert method in (
+            "max",
+            "mean",
+        ), "only 'mean' and 'max' are supported for center-shifted virtual diffraction"
 
         # Get calibration metadata
         assert datacube.calibration.get_origin(), "origin needs to be calibrated"
@@ -166,58 +199,65 @@ def get_virtual_diffraction(
         x0_mean, y0_mean = datacube.calibration.get_origin_mean()
 
         # get shifts
-        qx_shift = (x0_mean-x0).round().astype(int)
-        qy_shift = (y0_mean-y0).round().astype(int)
-
+        qx_shift = (x0_mean - x0).round().astype(int)
+        qy_shift = (y0_mean - y0).round().astype(int)
 
         # compute...
 
         # ...for boolean masks / whole datacubes
         if mask_is_boolean or use_all_points:
             virtual_diffraction = np.zeros(datacube.Qshape)
-            for rx,ry in zip(mask_indices[0],mask_indices[1]):
+            for rx, ry in zip(mask_indices[0], mask_indices[1]):
                 # get shifted DP
                 DP = np.roll(
-                    datacube.data[rx,ry, :,:,],
-                    (qx_shift[rx,ry], qy_shift[rx,ry]),
-                    axis=(0,1),
-                    )
+                    datacube.data[
+                        rx,
+                        ry,
+                        :,
+                        :,
+                    ],
+                    (qx_shift[rx, ry], qy_shift[rx, ry]),
+                    axis=(0, 1),
+                )
                 # compute
-                if method == 'mean':
+                if method == "mean":
                     virtual_diffraction += DP
-                elif method == 'max':
+                elif method == "max":
                     virtual_diffraction = np.maximum(virtual_diffraction, DP)
-            if method == 'mean':
+            if method == "mean":
                 virtual_diffraction /= len(mask_indices[0])
 
         # ...for floating point masks
         else:
-            if mask.dtype == 'complex':
-                virtual_diffraction = np.zeros(datacube.Qshape, dtype = 'complex')
+            if mask.dtype == "complex":
+                virtual_diffraction = np.zeros(datacube.Qshape, dtype="complex")
             else:
                 virtual_diffraction = np.zeros(datacube.Qshape)
-            for rx,ry in tqdmnd(
+            for rx, ry in tqdmnd(
                 datacube.R_Nx,
                 datacube.R_Ny,
-                disable = not verbose,
+                disable=not verbose,
             ):
                 # get shifted DP
                 DP = np.roll(
-                    datacube.data[rx,ry, :,:,],
-                    (qx_shift[rx,ry], qy_shift[rx,ry]),
-                    axis=(0,1),
-                    )
+                    datacube.data[
+                        rx,
+                        ry,
+                        :,
+                        :,
+                    ],
+                    (qx_shift[rx, ry], qy_shift[rx, ry]),
+                    axis=(0, 1),
+                )
                 # compute
-                w = mask[rx,ry]
+                w = mask[rx, ry]
                 if w > 0:
-                    if method == 'mean':
-                        virtual_diffraction += DP*w
-                    elif method == 'max':
-                        virtual_diffraction = np.maximum(virtual_diffraction, DP*w)
-            if method == 'mean':
+                    if method == "mean":
+                        virtual_diffraction += DP * w
+                    elif method == "max":
+                        virtual_diffraction = np.maximum(virtual_diffraction, DP * w)
+            if method == "mean":
                 virtual_diffraction /= np.sum(mask)
 
     # return
     return virtual_diffraction
-
-
diff --git a/py4DSTEM/process/virtualimage.py b/py4DSTEM/process/virtualimage.py
index 1c5e5e1da..cb50da774 100644
--- a/py4DSTEM/process/virtualimage.py
+++ b/py4DSTEM/process/virtualimage.py
@@ -1,22 +1,23 @@
 # Functions for generating virtual images
-import numpy as np
 import dask.array as da
+import numpy as np
 from emdfile import tqdmnd
 from py4DSTEM.classes import Calibration
 
+
 def get_virtual_image(
     datacube,
     mode,
     geometry,
-    centered = False,
-    calibrated = False,
-    shift_center = False,
-    verbose = True,
-    dask = False,
-    return_mask = False,
-    test_config = False
+    centered=False,
+    calibrated=False,
+    shift_center=False,
+    verbose=True,
+    dask=False,
+    return_mask=False,
+    test_config=False,
 ):
-    '''
+    """
     Function to calculate virtual image
 
     Args:
@@ -72,25 +73,30 @@ def get_virtual_image(
 
     Returns:
         (2D array) virtual image
-    '''
+    """
 
-    assert mode in ('point', 'circle', 'circular', 'annulus', 'annular', 'rectangle', 'square', 'rectangular', 'mask'),\
-    'check doc strings for supported modes'
+    assert mode in (
+        "point",
+        "circle",
+        "circular",
+        "annulus",
+        "annular",
+        "rectangle",
+        "square",
+        "rectangular",
+        "mask",
+    ), "check doc strings for supported modes"
     if shift_center == True:
         assert centered, "centered must be True if shift_center is True"
     if test_config:
-        for x,y in zip(['centered','calibrated','shift_center'],
-                       [centered,calibrated,shift_center]):
+        for x, y in zip(
+            ["centered", "calibrated", "shift_center"],
+            [centered, calibrated, shift_center],
+        ):
             print(f"{x} = {y}")
 
     # Get geometry
-    g = get_calibrated_geometry(
-        datacube,
-        mode,
-        geometry,
-        centered,
-        calibrated
-    )
+    g = get_calibrated_geometry(datacube, mode, geometry, centered, calibrated)
 
     # Get mask
     mask = make_detector(datacube.Qshape, mode, g)
@@ -98,22 +104,25 @@ def get_virtual_image(
     if return_mask == True and shift_center == False:
         return mask
 
-
     # Calculate images
 
     # no center shifting
     if shift_center == False:
-        # dask 
+        # dask
         if dask == True:
 
             # set up a generalized universal function for dask distribution
-            def _apply_mask_dask(datacube,mask):
-                virtual_image = np.sum(np.multiply(datacube.data,mask), dtype=np.float64)
+            def _apply_mask_dask(datacube, mask):
+                virtual_image = np.sum(
+                    np.multiply(datacube.data, mask), dtype=np.float64
+                )
+
             apply_mask_dask = da.as_gufunc(
-                _apply_mask_dask,signature='(i,j),(i,j)->()',
+                _apply_mask_dask,
+                signature="(i,j),(i,j)->()",
                 output_dtypes=np.float64,
-                axes=[(2,3),(0,1),()],
-                vectorize=True
+                axes=[(2, 3), (0, 1), ()],
+                vectorize=True,
             )
 
             # compute
@@ -123,69 +132,57 @@ def _apply_mask_dask(datacube,mask):
         else:
 
             # compute
-            if mask.dtype == 'complex':
-                virtual_image = np.zeros(datacube.Rshape, dtype = 'complex')
+            if mask.dtype == "complex":
+                virtual_image = np.zeros(datacube.Rshape, dtype="complex")
             else:
                 virtual_image = np.zeros(datacube.Rshape)
-            for rx,ry in tqdmnd(
+            for rx, ry in tqdmnd(
                 datacube.R_Nx,
                 datacube.R_Ny,
-                disable = not verbose,
+                disable=not verbose,
             ):
-                virtual_image[rx,ry] = np.sum(datacube.data[rx,ry]*mask)
+                virtual_image[rx, ry] = np.sum(datacube.data[rx, ry] * mask)
 
     # with center shifting
     else:
 
         # get shifts
         assert datacube.calibration.get_origin_shift(), "origin need to be calibrated"
-        qx_shift,qy_shift = datacube.calibration.get_origin_shift()
+        qx_shift, qy_shift = datacube.calibration.get_origin_shift()
         qx_shift = qx_shift.round().astype(int)
         qy_shift = qy_shift.round().astype(int)
 
         # if return_mask is True, skip computation
         if return_mask is not False:
             try:
-                rx,ry = return_mask
+                rx, ry = return_mask
             except TypeError:
-                raise Exception("when `shift_center` is True, return_mask must be a 2-tuple of ints or False")
+                raise Exception(
+                    "when `shift_center` is True, return_mask must be a 2-tuple of ints or False"
+                )
             # get shifted mask
-            _mask = np.roll(
-                mask,
-                (qx_shift[rx,ry], qy_shift[rx,ry]),
-                axis=(0,1)
-            )
+            _mask = np.roll(mask, (qx_shift[rx, ry], qy_shift[rx, ry]), axis=(0, 1))
             return _mask
 
         # compute
-        if mask.dtype == 'complex':
-            virtual_image = np.zeros(datacube.Rshape, dtype = 'complex')
+        if mask.dtype == "complex":
+            virtual_image = np.zeros(datacube.Rshape, dtype="complex")
         else:
             virtual_image = np.zeros(datacube.Rshape)
 
-        for rx,ry in tqdmnd(
+        for rx, ry in tqdmnd(
             datacube.R_Nx,
             datacube.R_Ny,
-            disable = not verbose,
+            disable=not verbose,
         ):
             # get shifted mask
-            _mask = np.roll(
-                mask,
-                (qx_shift[rx,ry], qy_shift[rx,ry]),
-                axis=(0,1)
-            )
-            virtual_image[rx,ry] = np.sum(datacube.data[rx,ry]*_mask)
+            _mask = np.roll(mask, (qx_shift[rx, ry], qy_shift[rx, ry]), axis=(0, 1))
+            virtual_image[rx, ry] = np.sum(datacube.data[rx, ry] * _mask)
 
     return virtual_image
 
 
-def get_calibrated_geometry(
-    calibration,
-    mode,
-    geometry,
-    centered,
-    calibrated
-    ):
+def get_calibrated_geometry(calibration, mode, geometry, centered, calibrated):
     """
     Determine the detector geometry in pixels, given some mode and geometry
     in calibrated units, where the calibration state is specified by {
@@ -213,9 +210,13 @@ def get_calibrated_geometry(
     else:
         try:
             cal = calibration.calibration
-            assert isinstance(cal, Calibration), "`calibration.calibration` must be a Calibration instance"
+            assert isinstance(
+                cal, Calibration
+            ), "`calibration.calibration` must be a Calibration instance"
         except AttributeError:
-            raise Exception("`calibration` must either be a Calibration instance or have a .calibration attribute")
+            raise Exception(
+                "`calibration` must either be a Calibration instance or have a .calibration attribute"
+            )
 
     # Get calibration metadata
     if centered:
@@ -223,46 +224,53 @@ def get_calibrated_geometry(
         x0_mean, y0_mean = cal.get_origin_mean()
 
     if calibrated:
-        assert cal['Q_pixel_units'] == 'A^-1', \
-        'check calibration - must be calibrated in A^-1 to use `calibrated=True`'
+        assert (
+            cal["Q_pixel_units"] == "A^-1"
+        ), "check calibration - must be calibrated in A^-1 to use `calibrated=True`"
         unit_conversion = cal.get_Q_pixel_size()
 
-
     # Convert units into detector pixels
 
     # Shift center
     if centered == True:
-        if mode == 'point':
+        if mode == "point":
             g = (g[0] + x0_mean, g[1] + y0_mean)
-        if mode in('circle', 'circular', 'annulus', 'annular'):
+        if mode in ("circle", "circular", "annulus", "annular"):
             g = ((g[0][0] + x0_mean, g[0][1] + y0_mean), g[1])
-        if mode in('rectangle', 'square', 'rectangular') :
-             g = (g[0] + x0_mean, g[1] + x0_mean, g[2] + y0_mean, g[3] + y0_mean)
+        if mode in ("rectangle", "square", "rectangular"):
+            g = (g[0] + x0_mean, g[1] + x0_mean, g[2] + y0_mean, g[3] + y0_mean)
 
     # Scale by the detector pixel size
     if calibrated == True:
-        if mode == 'point':
-            g = (g[0]/unit_conversion, g[1]/unit_conversion)
-        if mode in('circle', 'circular'):
-            g = ((g[0][0]/unit_conversion, g[0][1]/unit_conversion),
-                (g[1]/unit_conversion))
-        if mode in('annulus', 'annular'):
-            g = ((g[0][0]/unit_conversion, g[0][1]/unit_conversion),
-                (g[1][0]/unit_conversion, g[1][1]/unit_conversion))
-        if mode in('rectangle', 'square', 'rectangular') :
-            g = (g[0]/unit_conversion, g[1]/unit_conversion,
-                 g[2]/unit_conversion, g[3]/unit_conversion)
+        if mode == "point":
+            g = (g[0] / unit_conversion, g[1] / unit_conversion)
+        if mode in ("circle", "circular"):
+            g = (
+                (g[0][0] / unit_conversion, g[0][1] / unit_conversion),
+                (g[1] / unit_conversion),
+            )
+        if mode in ("annulus", "annular"):
+            g = (
+                (g[0][0] / unit_conversion, g[0][1] / unit_conversion),
+                (g[1][0] / unit_conversion, g[1][1] / unit_conversion),
+            )
+        if mode in ("rectangle", "square", "rectangular"):
+            g = (
+                g[0] / unit_conversion,
+                g[1] / unit_conversion,
+                g[2] / unit_conversion,
+                g[3] / unit_conversion,
+            )
 
     return g
 
 
-
 def make_detector(
     shape,
     mode,
     geometry,
 ):
-    '''
+    """
     Function to return 2D mask
 
     Args:
@@ -291,31 +299,38 @@ def make_detector(
 
     Returns:
         virtual detector in the form of a 2D mask (array)
-    '''
+    """
     g = geometry
 
-    #point mask 
-    if mode == 'point':
-        assert(isinstance(g,tuple) and len(g)==2), 'specify qx and qy as tuple (qx, qy)'
+    # point mask
+    if mode == "point":
+        assert (
+            isinstance(g, tuple) and len(g) == 2
+        ), "specify qx and qy as tuple (qx, qy)"
         mask = np.zeros(shape, dtype=bool)
 
         qx = int(g[0])
         qy = int(g[1])
 
-        mask[qx,qy] = 1
+        mask[qx, qy] = 1
 
-    #circular mask
-    if mode in('circle', 'circular'):
-        assert(isinstance(g,tuple) and len(g)==2 and len(g[0])==2 and isinstance(g[1],(float,int))), \
-        'specify qx, qy, radius_i as ((qx, qy), radius)'
+    # circular mask
+    if mode in ("circle", "circular"):
+        assert (
+            isinstance(g, tuple)
+            and len(g) == 2
+            and len(g[0]) == 2
+            and isinstance(g[1], (float, int))
+        ), "specify qx, qy, radius_i as ((qx, qy), radius)"
 
         qxa, qya = np.indices(shape)
         mask = (qxa - g[0][0]) ** 2 + (qya - g[0][1]) ** 2 < g[1] ** 2
 
-    #annular mask 
-    if mode in('annulus', 'annular'):
-        assert(isinstance(g,tuple) and len(g)==2 and len(g[0])==2 and len(g[1])==2), \
-        'specify qx, qy, radius_i, radius_0 as ((qx, qy), (radius_i, radius_o))'
+    # annular mask
+    if mode in ("annulus", "annular"):
+        assert (
+            isinstance(g, tuple) and len(g) == 2 and len(g[0]) == 2 and len(g[1]) == 2
+        ), "specify qx, qy, radius_i, radius_0 as ((qx, qy), (radius_i, radius_o))"
 
         assert g[1][1] > g[1][0], "Inner radius must be smaller than outer radius"
 
@@ -324,10 +339,11 @@ def make_detector(
         mask2 = (qxa - g[0][0]) ** 2 + (qya - g[0][1]) ** 2 < g[1][1] ** 2
         mask = np.logical_and(mask1, mask2)
 
-    #rectangle mask 
-    if mode in('rectangle', 'square', 'rectangular') :
-        assert(isinstance(g,tuple) and len(g)==4), \
-       'specify x_min, x_max, y_min, y_max as (x_min, x_max, y_min, y_max)'
+    # rectangle mask
+    if mode in ("rectangle", "square", "rectangular"):
+        assert (
+            isinstance(g, tuple) and len(g) == 4
+        ), "specify x_min, x_max, y_min, y_max as (x_min, x_max, y_min, y_max)"
         mask = np.zeros(shape, dtype=bool)
 
         xmin = int(np.round(g[0]))
@@ -337,13 +353,14 @@ def make_detector(
 
         mask[xmin:xmax, ymin:ymax] = 1
 
-    #flexible mask
-    if mode == 'mask':
-        assert type(g) == np.ndarray, '`geometry` type should be `np.ndarray`'
-        assert (g.shape == shape), 'mask and diffraction pattern shapes do not match'
+    # flexible mask
+    if mode == "mask":
+        assert type(g) == np.ndarray, "`geometry` type should be `np.ndarray`"
+        assert g.shape == shape, "mask and diffraction pattern shapes do not match"
         mask = g
     return mask
 
+
 def make_bragg_mask(
     Qshape,
     g1,
@@ -351,10 +368,10 @@ def make_bragg_mask(
     radius,
     origin,
     max_q,
-    return_sum = True,
+    return_sum=True,
     **kwargs,
-    ):
-    '''
+):
+    """
     Creates and returns a mask consisting of circular disks
     about the points of a 2D lattice.
 
@@ -370,61 +387,49 @@ def make_bragg_mask(
 
     Returns:
         (2 or 3D array) the mask
-    '''
+    """
     nas = np.asarray
-    g1,g2,origin = nas(g1),nas(g2),nas(origin)
+    g1, g2, origin = nas(g1), nas(g2), nas(origin)
 
     # Get N,M, the maximum indices to tile out to
     L1 = np.sqrt(np.sum(g1**2))
-    H = int(max_q/L1) + 1
-    L2 = np.hypot(-g2[0]*g1[1],g2[1]*g1[0])/np.sqrt(np.sum(g1**2))
-    K = int(max_q/L2) + 1
+    H = int(max_q / L1) + 1
+    L2 = np.hypot(-g2[0] * g1[1], g2[1] * g1[0]) / np.sqrt(np.sum(g1**2))
+    K = int(max_q / L2) + 1
 
     # Compute number of points
     N = 0
-    for h in range(-H,H+1):
-        for k in range(-K,K+1):
-            v = h*g1 + k*g2
+    for h in range(-H, H + 1):
+        for k in range(-K, K + 1):
+            v = h * g1 + k * g2
             if np.sqrt(v.dot(v)) < max_q:
                 N += 1
 
-    #create mask
+    # create mask
     mask = np.zeros((Qshape[0], Qshape[1], N), dtype=bool)
     N = 0
-    for h in range(-H,H+1):
-        for k in range(-K,K+1):
-            v = h*g1 + k*g2
+    for h in range(-H, H + 1):
+        for k in range(-K, K + 1):
+            v = h * g1 + k * g2
             if np.sqrt(v.dot(v)) < max_q:
                 center = origin + v
-                mask[:,:,N] = make_detector(
+                mask[:, :, N] = make_detector(
                     Qshape,
-                    mode = 'circle',
-                    geometry = (center, radius),
+                    mode="circle",
+                    geometry=(center, radius),
                 )
                 N += 1
 
-
     if return_sum:
-        mask = np.sum(mask, axis = 2)
+        mask = np.sum(mask, axis=2)
     return mask
 
 
-
-
-
-
-
-
-
-
-
-
-
 def get_virtual_image_pointlistarray(
     peaks,
-    mode = None,
-    geometry = None,
-    ):
+    mode=None,
+    geometry=None,
+):
     """
     Make a virtual image from a pointlist array.
     TODO - implement more virtual detectors.
@@ -451,62 +456,58 @@ def get_virtual_image_pointlistarray(
     if mode is None:
         if geometry is None:
             center = None
-            radial_range = np.array((0,np.inf))
+            radial_range = np.array((0, np.inf))
         else:
             if len(geometry[0]) == 0:
                 center = None
             else:
                 center = np.array(geometry[0])
             if isinstance(geometry[1], int) or isinstance(geometry[1], float):
-                radial_range = np.array((0,geometry[1]))
+                radial_range = np.array((0, geometry[1]))
             elif len(geometry[1]) == 0:
                 radial_range = None
             else:
                 radial_range = np.array(geometry[1])
-    elif mode == 'circular' or mode == 'circle':
-        radial_range = np.array((0,geometry[1]))
+    elif mode == "circular" or mode == "circle":
+        radial_range = np.array((0, geometry[1]))
         if len(geometry[0]) == 0:
-                center = None
+            center = None
         else:
             center = np.array(geometry[0])
-    elif mode == 'annular' or mode == 'annulus':
+    elif mode == "annular" or mode == "annulus":
         radial_range = np.array(geometry[1])
         if len(geometry[0]) == 0:
-                center = None
+            center = None
         else:
             center = np.array(geometry[0])
 
-
-
     # init
     im_virtual = np.zeros(peaks.shape)
 
     # Generate image
-    for rx,ry in tqdmnd(peaks.shape[0],peaks.shape[1]):
-        p = peaks.get_pointlist(rx,ry)
+    for rx, ry in tqdmnd(peaks.shape[0], peaks.shape[1]):
+        p = peaks.get_pointlist(rx, ry)
         if p.data.shape[0] > 0:
             if radial_range is None:
-                im_virtual[rx,ry] = np.sum(p.data['intensity'])
+                im_virtual[rx, ry] = np.sum(p.data["intensity"])
             else:
                 if center is None:
-                    qr = np.hypot(p.data['qx'],p.data['qy'])
+                    qr = np.hypot(p.data["qx"], p.data["qy"])
                 else:
-                    qr = np.hypot(p.data['qx'] - center[0],p.data['qy'] - center[1])
-                sub = np.logical_and(
-                    qr >= radial_range[0],
-                    qr <  radial_range[1])
+                    qr = np.hypot(p.data["qx"] - center[0], p.data["qy"] - center[1])
+                sub = np.logical_and(qr >= radial_range[0], qr < radial_range[1])
                 if np.sum(sub) > 0:
-                    im_virtual[rx,ry] = np.sum(p.data['intensity'][sub])
+                    im_virtual[rx, ry] = np.sum(p.data["intensity"][sub])
 
     return im_virtual
 
 
 def get_virtual_image_braggvectors(
     bragg_peaks,
-    mode = None,
-    geometry = None,
-    ):
-    '''
+    mode=None,
+    geometry=None,
+):
+    """
     Function to calculate virtual images from braggvectors / pointlist arrays.
     TODO - implement these detectors for braggvectors
 
@@ -526,12 +527,12 @@ def get_virtual_image_braggvectors(
 
     Returns:
         im_virtual (2D numpy array): the calculated virtual image
-    '''
+    """
 
     virtual_image = get_virtual_image_pointlistarray(
         bragg_peaks.vectors,
-        mode = mode,
-        geometry = geometry,
-        )
+        mode=mode,
+        geometry=geometry,
+    )
 
     return virtual_image

From fb51d2ed0fe3147942051410082f34ca5712063a Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <37132012+sezelt@users.noreply.github.com>
Date: Thu, 22 Jun 2023 09:59:04 -0400
Subject: [PATCH 058/362] update python version spec

---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index 710f20a8a..bc206e901 100644
--- a/setup.py
+++ b/setup.py
@@ -21,7 +21,7 @@
     author_email='ben.savitzky@gmail.com',
     license='GNU GPLv3',
     keywords="STEM 4DSTEM",
-    python_requires='>=3.9,<=3.11.3',
+    python_requires='>=3.9,<3.12',
     install_requires=[
         'numpy >= 1.19',
         'scipy >= 1.5.2',

From 2a5f5b481dfde642716965cb872f20f9d2aa3b92 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Thu, 22 Jun 2023 11:14:03 -0400
Subject: [PATCH 059/362] rms RootedNode

---
 py4DSTEM/classes/datacube.py   | 4 ++--
 py4DSTEM/io/sample_file_ids.py | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/py4DSTEM/classes/datacube.py b/py4DSTEM/classes/datacube.py
index 169b5fa07..d5738e466 100644
--- a/py4DSTEM/classes/datacube.py
+++ b/py4DSTEM/classes/datacube.py
@@ -3,7 +3,7 @@
 from typing import Optional,Union
 import numpy as np
 
-from emdfile import Array
+from emdfile import Array,Root
 from py4DSTEM.classes import Data, Calibration
 from py4DSTEM.classes.methods import DataCubeMethods
 
@@ -54,7 +54,7 @@ def __init__(
 
         # set up EMD tree
         root = Root( name = name+"_root" )
-        root.add( self )
+        root.tree( self )
 
         # set up calibration
         self._setup_calibration( calibration )
diff --git a/py4DSTEM/io/sample_file_ids.py b/py4DSTEM/io/sample_file_ids.py
index b42b7eccc..277f06f47 100644
--- a/py4DSTEM/io/sample_file_ids.py
+++ b/py4DSTEM/io/sample_file_ids.py
@@ -48,9 +48,9 @@
         'vac_probe.h5',
         '1QTcSKzZjHZd1fDimSI_q9_WsAU25NIXe',
     ),
-    'small_dm3' : (
-        'small_dm3.dm3',
-        '1RxI1QY6vYMDqqMVPt5GBN6Q_iCwHFU4B'
+    'small_dm3_3Dstack' : (
+        'small_dm3_3Dstack.dm3',
+        '1B-xX3F65JcWzAg0v7f1aVwnawPIfb5_o'
     ),
     'FCU-Net' : (
         'filename.name',
@@ -74,7 +74,7 @@
         'vac_probe',
     ),
     'io_test_data' : (
-        'small_dm3',
+        'small_dm3_3Dstack',
         'vac_probe',
     ),
 }

From d3e346c8f764999b616f08f4f9e5724562dffc76 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Thu, 22 Jun 2023 11:18:32 -0400
Subject: [PATCH 060/362] bumps emdfile to 0.0.9

---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index e3bc5b568..2f1e15a63 100644
--- a/setup.py
+++ b/setup.py
@@ -35,7 +35,7 @@
         'gdown >= 4.4.0',
         'dask >= 2.3.0',
         'distributed >= 2.3.0',
-        'emdfile >= 0.0.6',
+        'emdfile >= 0.0.9',
         ],
     extras_require={
         'ipyparallel': ['ipyparallel >= 6.2.4', 'dill >= 0.3.3'],

From 6f9664efa3610f197cc487c83cfa78b56aa3750b Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Thu, 22 Jun 2023 11:37:35 -0400
Subject: [PATCH 061/362] renames build-flake.yml

---
 .github/workflows/{python-app.yml => build-flake.yml} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename .github/workflows/{python-app.yml => build-flake.yml} (100%)

diff --git a/.github/workflows/python-app.yml b/.github/workflows/build-flake.yml
similarity index 100%
rename from .github/workflows/python-app.yml
rename to .github/workflows/build-flake.yml

From 547dddef9cf742bd4c2573ab5c74d625965fd6a1 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Thu, 22 Jun 2023 11:48:22 -0400
Subject: [PATCH 062/362] restructures test/

---
 test/{test_classes => }/test_braggvectors.py  |  0
 test/test_calibration.py                      | 40 +++++++++++++++++
 test/{test_classes => }/test_crystal.py       |  0
 test/{test_classes => }/test_datacube.py      |  3 +-
 test/test_native_io/test_calibration_io.py    | 44 +++++++++++++++++++
 .../test_dm.py                                |  0
 6 files changed, 85 insertions(+), 2 deletions(-)
 rename test/{test_classes => }/test_braggvectors.py (100%)
 create mode 100644 test/test_calibration.py
 rename test/{test_classes => }/test_crystal.py (100%)
 rename test/{test_classes => }/test_datacube.py (92%)
 create mode 100644 test/test_native_io/test_calibration_io.py
 rename test/{test_fileimport => test_nonnative_io}/test_dm.py (100%)

diff --git a/test/test_classes/test_braggvectors.py b/test/test_braggvectors.py
similarity index 100%
rename from test/test_classes/test_braggvectors.py
rename to test/test_braggvectors.py
diff --git a/test/test_calibration.py b/test/test_calibration.py
new file mode 100644
index 000000000..f95ecdbfd
--- /dev/null
+++ b/test/test_calibration.py
@@ -0,0 +1,40 @@
+import py4DSTEM
+import numpy as np
+from os.path import join
+
+# set filepath
+path = py4DSTEM._TESTPATH + "/io_test_data/small_dm3_3Dstack.dm3"
+
+
+
+class TestDataCube:
+
+    # setup/teardown
+    def setup_class(cls):
+
+        # Read sim Au datacube
+        datacube = py4DSTEM.import_file(path)
+        datacube = py4DSTEM.DataCube(
+            data=datacube.data.reshape((10,10,512,512))
+        )
+        cls.datacube = datacube
+
+    # tests
+
+    def test_binning_default_dtype(self):
+
+        dtype = self.datacube.data.dtype
+        assert(dtype == np.uint16)
+
+        self.datacube.bin_Q(2)
+
+        assert(self.datacube.data.dtype == dtype)
+
+        new_dtype = np.uint32
+        self.datacube.bin_Q(2, dtype=new_dtype)
+
+        assert(self.datacube.data.dtype == new_dtype)
+        assert(self.datacube.data.dtype != dtype)
+
+        pass
+
diff --git a/test/test_classes/test_crystal.py b/test/test_crystal.py
similarity index 100%
rename from test/test_classes/test_crystal.py
rename to test/test_crystal.py
diff --git a/test/test_classes/test_datacube.py b/test/test_datacube.py
similarity index 92%
rename from test/test_classes/test_datacube.py
rename to test/test_datacube.py
index 57a225abb..f95ecdbfd 100644
--- a/test/test_classes/test_datacube.py
+++ b/test/test_datacube.py
@@ -3,8 +3,7 @@
 from os.path import join
 
 # set filepath
-path = join(py4DSTEM._TESTPATH, "small_dm3.dm3")
-
+path = py4DSTEM._TESTPATH + "/io_test_data/small_dm3_3Dstack.dm3"
 
 
 
diff --git a/test/test_native_io/test_calibration_io.py b/test/test_native_io/test_calibration_io.py
new file mode 100644
index 000000000..7aaa42d30
--- /dev/null
+++ b/test/test_native_io/test_calibration_io.py
@@ -0,0 +1,44 @@
+import py4DSTEM
+import numpy as np
+from os.path import join
+
+# set filepath
+path = join(py4DSTEM._TESTPATH, "filename")
+
+
+
+class TestCalibrationIO:
+
+
+
+    def test_datacube_cal_io(self):
+        # TODO
+        # make a datacube
+        # modify its calibration
+        # save
+        # load the datacube
+        # check its calibration
+        assert 0
+        pass
+
+
+    def test_datacube_child_node(self):
+        # TODO
+        # make a datacube
+        # make a child node
+        # confirm calibrations are the same
+        # modify the calibration
+        # save
+        # load the datacube
+        # check its calibration
+        # load just the child node
+        # check its calibration
+        assert 0
+        pass
+
+
+
+
+
+
+
diff --git a/test/test_fileimport/test_dm.py b/test/test_nonnative_io/test_dm.py
similarity index 100%
rename from test/test_fileimport/test_dm.py
rename to test/test_nonnative_io/test_dm.py

From 11dc963c40c399a00e220703d39baadd05ef1224 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Thu, 22 Jun 2023 12:13:25 -0400
Subject: [PATCH 063/362] updates to test files

---
 py4DSTEM/io/sample_file_ids.py | 5 +++++
 test/gettestdata.py            | 3 +++
 2 files changed, 8 insertions(+)

diff --git a/py4DSTEM/io/sample_file_ids.py b/py4DSTEM/io/sample_file_ids.py
index 277f06f47..b53d63621 100644
--- a/py4DSTEM/io/sample_file_ids.py
+++ b/py4DSTEM/io/sample_file_ids.py
@@ -56,6 +56,11 @@
         'filename.name',
         '1-KX0saEYfhZ9IJAOwabH38PCVtfXidJi',
     ),
+    'small_datacube' : (
+        'small_datacube.dm4',
+        # TODO - change this file to something smaller - ideally e.g. shape (4,8,256,256) ~= 4.2MB'
+        '1QTcSKzZjHZd1fDimSI_q9_WsAU25NIXe'
+    ),
 }
 
 # collections of files
diff --git a/test/gettestdata.py b/test/gettestdata.py
index eb5e7c5a8..92e3e93e0 100644
--- a/test/gettestdata.py
+++ b/test/gettestdata.py
@@ -19,6 +19,7 @@
 data_options = [
     'tutorials',
     'io',
+    'basic'
 ]
 
 # Add arguments
@@ -54,6 +55,8 @@
     data = 'tutorials'
 elif args.data == 'io':
     data = 'io_test_data'
+elif args.data == 'basic':
+    data = 'small_datacube'
 else:
     raise Exception(f"invalid data choice, {parser.data}")
 

From c1e2cf16c02ef18570cc50e2acd1796f853b6448 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Thu, 22 Jun 2023 14:13:54 -0400
Subject: [PATCH 064/362] updates, mv root/cal logic to Data

---
 py4DSTEM/classes/data.py          | 19 +++++++-
 py4DSTEM/classes/datacube.py      | 15 ++++---
 test/gettestdata.py               |  9 +++-
 test/test_calibration.py          | 74 ++++++++++++++++++++++---------
 test/test_datacube.py             |  7 +--
 test/test_nonnative_io/test_dm.py | 12 +++--
 6 files changed, 98 insertions(+), 38 deletions(-)

diff --git a/py4DSTEM/classes/data.py b/py4DSTEM/classes/data.py
index 194d5af35..5794b9963 100644
--- a/py4DSTEM/classes/data.py
+++ b/py4DSTEM/classes/data.py
@@ -3,16 +3,29 @@
 
 import warnings
 
-from emdfile import Node
+from emdfile import Node, Root
 from py4DSTEM.classes import Calibration
 
 
 class Data:
 
-    def __init__(self):
+    def __init__(
+        self,
+        setup_tree = True,
+        calibration = None
+        ):
         assert(isinstance(self,Node)), "Data instances must alse inherit from Node"
         pass
 
+        if setup_tree:
+            # set up EMD tree
+            root = Root( name = self.name+"_root" )
+            root.tree( self )
+
+            # set up calibration
+            calibration = Calibration() if calibration is None else calibration
+            self._setup_calibration( calibration )
+
 
     # calibration
 
@@ -21,8 +34,10 @@ def calibration(self):
         try:
             return self.root.metadata['calibration']
         except KeyError:
+            warnings.warn("No calibration metadata found in root, returning None")
             return None
         except AttributeError:
+            warnings.warn("No root or root metadata found, returning None")
             return None
 
     @calibration.setter
diff --git a/py4DSTEM/classes/datacube.py b/py4DSTEM/classes/datacube.py
index d5738e466..964a89ff0 100644
--- a/py4DSTEM/classes/datacube.py
+++ b/py4DSTEM/classes/datacube.py
@@ -16,8 +16,9 @@ def __init__(
         self,
         data: np.ndarray,
         name: Optional[str] = 'datacube',
-        calibration: Optional[Union[Calibration,None]] = None,
         slicelabels: Optional[Union[bool,list]] = None,
+        setup_tree: Optional[bool] = True,
+        calibration: Optional[Union[Calibration,None]] = None,
         ):
         """
         Accepts:
@@ -52,12 +53,12 @@ def __init__(
             slicelabels = slicelabels
         )
 
-        # set up EMD tree
-        root = Root( name = name+"_root" )
-        root.tree( self )
-
-        # set up calibration
-        self._setup_calibration( calibration )
+        # initialize as Data
+        Data.__init__(
+            self,
+            setup_tree,
+            calibration
+        )
 
         # cartesian coords
         # TODO - tmp hack, needs to be refactored -
diff --git a/test/gettestdata.py b/test/gettestdata.py
index 92e3e93e0..a370cdcc1 100644
--- a/test/gettestdata.py
+++ b/test/gettestdata.py
@@ -68,7 +68,14 @@
     verbose = args.verbose
 )
 
-
+# Always download the basic datacube
+if args.data is not 'basic':
+    download(
+        'small_datacube',
+        destination = testpath,
+        overwrite = args.overwrite,
+        verbose = args.verbose
+    )
 
 
 
diff --git a/test/test_calibration.py b/test/test_calibration.py
index f95ecdbfd..eb600fa3a 100644
--- a/test/test_calibration.py
+++ b/test/test_calibration.py
@@ -1,40 +1,74 @@
 import py4DSTEM
+from py4DSTEM import Calibration
 import numpy as np
-from os.path import join
+from os import mkdir, remove, rmdir
+from os.path import join, exists
 
-# set filepath
-path = py4DSTEM._TESTPATH + "/io_test_data/small_dm3_3Dstack.dm3"
+# set filepaths
+path_datacube = join(py4DSTEM._TESTPATH, "small_datacube.dm4")
+path_3Darray = join(py4DSTEM._TESTPATH, "io_test_data/small_dm3_3Dstack.dm3")
 
+path_out_dir = join(py4DSTEM._TESTPATH, "test_outputs")
+path_out = join(path_out_dir, "test_calibration.h5")
 
 
-class TestDataCube:
+class TestCalibration:
+
+    # setup
 
-    # setup/teardown
     def setup_class(cls):
+        if not exists(path_out_dir):
+            mkdir(path_out_dir)
+
+    def teardown_class(cls):
+        if exists(path_out_dir):
+            rmdir(path_out_dir)
+
+    def teardown_method(self):
+        if exists(path_out):
+            remove(path_out)
+
+
+    # test
+
+    def test_imported_datacube_calibration(self):
+
+        datacube = py4DSTEM.import_file(path_datacube)
+
+        assert(hasattr(datacube,'calibration'))
+        assert(isinstance(datacube.calibration,Calibration))
+        assert(hasattr(datacube,'root'))
+        assert(isinstance(datacube.root,py4DSTEM.Root))
+
+
+    def test_instantiated_datacube_calibration(self):
 
-        # Read sim Au datacube
-        datacube = py4DSTEM.import_file(path)
         datacube = py4DSTEM.DataCube(
-            data=datacube.data.reshape((10,10,512,512))
+            data = np.ones((4,8,128,128))
         )
-        cls.datacube = datacube
 
-    # tests
+        assert(hasattr(datacube,'calibration'))
+        assert(isinstance(datacube.calibration,Calibration))
+        assert(hasattr(datacube,'root'))
+        assert(isinstance(datacube.root,py4DSTEM.Root))
+
+        datacube.calibration.set_Q_pixel_size(10)
+
+        py4DSTEM.save(
+            path_out,
+            datacube
+        )
 
-    def test_binning_default_dtype(self):
+        new_datacube = py4DSTEM.read(path_out)
 
-        dtype = self.datacube.data.dtype
-        assert(dtype == np.uint16)
+        assert(hasattr(new_datacube,'calibration'))
+        assert(isinstance(new_datacube.calibration,Calibration))
+        assert(hasattr(new_datacube,'root'))
+        assert(isinstance(new_datacube.root,py4DSTEM.Root))
 
-        self.datacube.bin_Q(2)
+        assert(new_datacube.calibration.get_Q_pixel_size() == 10)
 
-        assert(self.datacube.data.dtype == dtype)
 
-        new_dtype = np.uint32
-        self.datacube.bin_Q(2, dtype=new_dtype)
 
-        assert(self.datacube.data.dtype == new_dtype)
-        assert(self.datacube.data.dtype != dtype)
 
-        pass
 
diff --git a/test/test_datacube.py b/test/test_datacube.py
index f95ecdbfd..7e0f29188 100644
--- a/test/test_datacube.py
+++ b/test/test_datacube.py
@@ -3,7 +3,7 @@
 from os.path import join
 
 # set filepath
-path = py4DSTEM._TESTPATH + "/io_test_data/small_dm3_3Dstack.dm3"
+path = py4DSTEM._TESTPATH + "/small_datacube.dm4"
 
 
 
@@ -12,11 +12,8 @@ class TestDataCube:
     # setup/teardown
     def setup_class(cls):
 
-        # Read sim Au datacube
+        # Read datacube
         datacube = py4DSTEM.import_file(path)
-        datacube = py4DSTEM.DataCube(
-            data=datacube.data.reshape((10,10,512,512))
-        )
         cls.datacube = datacube
 
     # tests
diff --git a/test/test_nonnative_io/test_dm.py b/test/test_nonnative_io/test_dm.py
index 18bab1fbd..9fd311579 100644
--- a/test/test_nonnative_io/test_dm.py
+++ b/test/test_nonnative_io/test_dm.py
@@ -4,15 +4,21 @@
 
 
 # Set filepaths
-filepath_dm = join(py4DSTEM._TESTPATH, "small_dm3.dm3")
+filepath_dm4_datacube = join(py4DSTEM._TESTPATH, "small_datacube.dm4")
+filepath_dm3_3Dstack = join(py4DSTEM._TESTPATH, "io_test_data/small_dm3_3Dstack.dm3")
 
 
+def test_dmfile_datacube():
+    data = py4DSTEM.import_file( filepath_dm4_datacube )
+    assert isinstance(data, emdfile.Array)
+    assert isinstance(data, py4DSTEM.DataCube)
+
 def test_dmfile_3Darray():
-    data = py4DSTEM.import_file( filepath_dm )
+    data = py4DSTEM.import_file( filepath_dm3_3Dstack )
     assert isinstance(data, emdfile.Array)
 
 
 # TODO
-# def test_dmfile_4Darray():
 # def test_dmfile_multiple_datablocks():
+# def test_dmfile_2Darray
 

From 5f1488d59661582b82021fc6d6b0e4f961a7b7cf Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Thu, 22 Jun 2023 14:40:37 -0400
Subject: [PATCH 065/362] restructures data/classes mods

---
 py4DSTEM/__init__.py                          |  10 +-
 py4DSTEM/classes/__init__.py                  |   6 -
 py4DSTEM/classes/datacube.py                  | 248 -----------------
 py4DSTEM/classes/methods/__init__.py          |   1 -
 py4DSTEM/classes/probe.py                     |   2 +-
 py4DSTEM/classes/virtualdiffraction.py        |   2 +-
 py4DSTEM/classes/virtualimage.py              |   2 +-
 py4DSTEM/data/__init__.py                     |   9 +
 py4DSTEM/{classes => data}/calibration.py     |   2 +-
 py4DSTEM/{classes => data}/data.py            |   2 +-
 .../datacube_methods.py => data/datacube.py}  | 250 +++++++++++++++++-
 py4DSTEM/data/datacube_methods.py             |   4 +
 .../{classes => data}/diffractionslice.py     |   2 +-
 .../propagating_calibration.py                |   0
 py4DSTEM/{classes => data}/qpoints.py         |   2 +-
 py4DSTEM/{classes => data}/realslice.py       |   2 +-
 py4DSTEM/io/filereaders/empad.py              |   2 +-
 py4DSTEM/io/filereaders/read_K2.py            |   2 +-
 py4DSTEM/io/filereaders/read_dm.py            |   2 +-
 py4DSTEM/io/filereaders/read_mib.py           |   2 +-
 py4DSTEM/io/legacy/legacy12/read_v0_12.py     |   2 +-
 py4DSTEM/io/legacy/legacy12/read_v0_5.py      |   2 +-
 py4DSTEM/io/legacy/legacy12/read_v0_6.py      |   2 +-
 py4DSTEM/io/legacy/legacy12/read_v0_7.py      |   2 +-
 py4DSTEM/io/legacy/legacy12/read_v0_9.py      |   2 +-
 py4DSTEM/io/legacy/legacy13/v13_to_14.py      |   8 +-
 py4DSTEM/process/calibration/origin.py        |   2 +-
 py4DSTEM/process/classification/classutils.py |   2 +-
 py4DSTEM/process/diffraction/crystal_ACOM.py  |   2 +-
 .../process/diskdetection/braggvectors.py     |   2 +-
 .../process/diskdetection/diskdetection.py    |   2 +-
 .../diskdetection/diskdetection_aiml.py       |   2 +-
 .../diskdetection/diskdetection_aiml_cuda.py  |   3 +-
 .../diskdetection/diskdetection_parallel.py   |   2 +-
 .../diskdetection_parallel_new.py             |   2 +-
 py4DSTEM/process/latticevectors/fit.py        |   2 +-
 py4DSTEM/process/latticevectors/strain.py     |   2 +-
 .../process/phase/iterative_base_class.py     |   2 +-
 py4DSTEM/process/phase/iterative_dpc.py       |   2 +-
 .../iterative_singleslice_ptychography.py     |   2 +-
 py4DSTEM/process/polar/polar_datacube.py      |   2 +-
 py4DSTEM/process/probe/probe.py               |   3 +-
 py4DSTEM/process/virtualimage.py              |   2 +-
 py4DSTEM/visualize/show.py                    |   2 +-
 py4DSTEM/visualize/virtualimage.py            |   2 +-
 py4DSTEM/visualize/vis_special.py             |   2 +-
 46 files changed, 307 insertions(+), 305 deletions(-)
 delete mode 100644 py4DSTEM/classes/datacube.py
 create mode 100644 py4DSTEM/data/__init__.py
 rename py4DSTEM/{classes => data}/calibration.py (99%)
 rename py4DSTEM/{classes => data}/data.py (97%)
 rename py4DSTEM/{classes/methods/datacube_methods.py => data/datacube.py} (90%)
 create mode 100644 py4DSTEM/data/datacube_methods.py
 rename py4DSTEM/{classes => data}/diffractionslice.py (97%)
 rename py4DSTEM/{classes => data}/propagating_calibration.py (100%)
 rename py4DSTEM/{classes => data}/qpoints.py (97%)
 rename py4DSTEM/{classes => data}/realslice.py (97%)

diff --git a/py4DSTEM/__init__.py b/py4DSTEM/__init__.py
index dc4f765ae..f01604896 100644
--- a/py4DSTEM/__init__.py
+++ b/py4DSTEM/__init__.py
@@ -14,17 +14,19 @@
 )
 
 # processing classes
-from py4DSTEM.classes import (
+from py4DSTEM.data import (
     DataCube,
     DiffractionSlice,
     RealSlice,
-    VirtualDiffraction,
-    VirtualImage,
-    Probe,
     QPoints,
     Calibration,
     Data,
 )
+from py4DSTEM.classes import (
+    VirtualDiffraction,
+    VirtualImage,
+    Probe,
+)
 from py4DSTEM.process.diskdetection import (
     BraggVectors,
     BraggVectorMap,
diff --git a/py4DSTEM/classes/__init__.py b/py4DSTEM/classes/__init__.py
index 27ea3e353..d97b413d9 100644
--- a/py4DSTEM/classes/__init__.py
+++ b/py4DSTEM/classes/__init__.py
@@ -1,13 +1,7 @@
 _emd_hook = True
 
-from py4DSTEM.classes.calibration import Calibration
-from py4DSTEM.classes.data import Data
-from py4DSTEM.classes.datacube import DataCube
-from py4DSTEM.classes.diffractionslice import DiffractionSlice
-from py4DSTEM.classes.realslice import RealSlice
 from py4DSTEM.classes.probe import Probe
 from py4DSTEM.classes.virtualdiffraction import VirtualDiffraction
 from py4DSTEM.classes.virtualimage import VirtualImage
-from py4DSTEM.classes.qpoints import QPoints
 
 
diff --git a/py4DSTEM/classes/datacube.py b/py4DSTEM/classes/datacube.py
deleted file mode 100644
index 964a89ff0..000000000
--- a/py4DSTEM/classes/datacube.py
+++ /dev/null
@@ -1,248 +0,0 @@
-# Defines the DataCube class, which stores 4D-STEM datacubes
-
-from typing import Optional,Union
-import numpy as np
-
-from emdfile import Array,Root
-from py4DSTEM.classes import Data, Calibration
-from py4DSTEM.classes.methods import DataCubeMethods
-
-class DataCube(Array,Data,DataCubeMethods):
-    """
-    Storage and processing methods for 4D-STEM datasets.
-    """
-
-    def __init__(
-        self,
-        data: np.ndarray,
-        name: Optional[str] = 'datacube',
-        slicelabels: Optional[Union[bool,list]] = None,
-        setup_tree: Optional[bool] = True,
-        calibration: Optional[Union[Calibration,None]] = None,
-        ):
-        """
-        Accepts:
-            data (np.ndarray): the data
-            name (str): the name of the datacube
-            calibration (None or Calibration or 'pass'): default (None)
-                creates and attaches a new Calibration instance to root
-                metadata, or, passing a Calibration instance uses this instead.
-                'skip' is for internal use for the reader
-            slicelabels (None or list): names for slices if this is a
-                stack of datacubes
-
-        Returns:
-            A new DataCube instance.
-        """
-
-        # initialize DataCubeMethods
-        super(DataCubeMethods).__init__()
-
-        # initialize as an Array
-        Array.__init__(
-            self,
-            data = data,
-            name = name,
-            units = 'pixel intensity',
-            dim_names = [
-                'Rx',
-                'Ry',
-                'Qx',
-                'Qy'
-            ],
-            slicelabels = slicelabels
-        )
-
-        # initialize as Data
-        Data.__init__(
-            self,
-            setup_tree,
-            calibration
-        )
-
-        # cartesian coords
-        # TODO - tmp hack, needs to be refactored -
-        # this will break when preprocess methods are called
-        self.qyy,self.qxx = np.meshgrid(
-            np.arange(0,self.Q_Ny),
-            np.arange(0,self.Q_Nx)
-        )
-
-        # polar coords
-        self.polar = None
-
-
-
-    def _setup_calibration(self, cal):
-        """
-        Ensures that a calibration instance exists. Passing None
-        makes a new Calibration instance, puts it in root.calibration, and
-        makes a two way link. Passing a Calibration instance attaches that
-        instance. `'skip'` does nothing (internal use, on read from file).
-        """
-        if cal is None:
-            self.calibration = Calibration( datacube = self )
-        elif cal == 'skip':
-            pass
-        else:
-            assert(isinstance(cal, Calibration)), "`calibration` must be a Calibration instance, not type f{type(cal)}"
-            self.calibration = cal
-            cal._datacube = self
-
-
-    def copy(self):
-        """
-        Copys datacube
-        """
-        from py4DSTEM import DataCube
-        new_datacube = DataCube(
-            data = self.data.copy(),
-            name = self.name,
-            calibration = self.calibration.copy(),
-            slicelabels = self.slicelabels,
-        )
-
-        Qpixsize  = new_datacube.calibration.get_Q_pixel_size()
-        Qpixunits = new_datacube.calibration.get_Q_pixel_units()
-        Rpixsize  = new_datacube.calibration.get_R_pixel_size()
-        Rpixunits = new_datacube.calibration.get_R_pixel_units()
-        
-        new_datacube.set_dim(
-            0,
-            [0,Rpixsize],
-            units = Rpixunits,
-            name = 'Rx'
-        )
-        new_datacube.set_dim(
-            1,
-            [0,Rpixsize],
-            units = Rpixunits,
-            name = 'Ry'
-        )
-
-        new_datacube.set_dim(
-            2,
-            [0,Qpixsize],
-            units = Qpixunits,
-            name = 'Qx'
-        )
-        new_datacube.set_dim(
-            3,
-            [0,Qpixsize],
-            units = Qpixunits,
-            name = 'Qy'
-        )
-
-        return new_datacube
-
-
-    # properties
-
-
-    ## pixel size / units
-
-    # Q 
-    @property
-    def Q_pixel_size(self):
-        return self.calibration.get_Q_pixel_size()
-    @property
-    def Q_pixel_units(self):
-        return self.calibration.get_Q_pixel_units()
-
-    # R
-    @property
-    def R_pixel_size(self):
-        return self.calibration.get_R_pixel_size()
-    @property
-    def R_pixel_units(self):
-        return self.calibration.get_R_pixel_units()
-
-    # aliases
-    qpixsize = Q_pixel_size
-    qpixunit = Q_pixel_units
-    rpixsize = R_pixel_size
-    rpixunit = R_pixel_units
-
-
-    ## shape
-
-    # FOV
-    @property
-    def R_Nx(self):
-        return self.data.shape[0]
-    @property
-    def R_Ny(self):
-        return self.data.shape[1]
-    @property
-    def Q_Nx(self):
-        return self.data.shape[2]
-    @property
-    def Q_Ny(self):
-        return self.data.shape[3]
-
-    @property
-    def Rshape(self):
-        return (self.data.shape[0],self.data.shape[1])
-    @property
-    def Qshape(self):
-        return (self.data.shape[2],self.data.shape[3])
-
-    @property
-    def R_N(self):
-        return self.R_Nx*self.R_Ny
-
-    # aliases
-    qnx = Q_Nx
-    qny = Q_Ny
-    rnx = R_Nx
-    rny = R_Ny
-    rshape = Rshape
-    qshape = Qshape
-    rn = R_N
-
-
-
-
-
-    # HDF5 i/o
-
-    # to_h5 is inherited from Array
-
-    # read
-    @classmethod
-    def _get_constructor_args(cls,group):
-        """ Construct a datacube with no calibration / metadata
-        """
-        # We only need some of the Array constructors;
-        # dim vector/units are passed through when Calibration
-        # is loaded, and the runtim dim vectors are then set
-        # in _add_root_links
-        ar_args = Array._get_constructor_args(group)
-
-        args = {
-            'data': ar_args['data'],
-            'name': ar_args['name'],
-            'slicelabels': ar_args['slicelabels'],
-            'calibration': 'skip'
-        }
-
-        return args
-
-
-    def _add_root_links(self,group):
-        """ When reading from file, link to calibration metadata,
-        then use it to populate the datacube dim vectors
-        """
-        # Link to the datacube
-        self.calibration._datacube = self
-
-        # Populate dim vectors
-        self.calibration.set_Q_pixel_size( self.calibration.get_Q_pixel_size() )
-        self.calibration.set_R_pixel_size( self.calibration.get_R_pixel_size() )
-        self.calibration.set_Q_pixel_units( self.calibration.get_Q_pixel_units() )
-        self.calibration.set_R_pixel_units( self.calibration.get_R_pixel_units() )
-
-        return
-
-
-
diff --git a/py4DSTEM/classes/methods/__init__.py b/py4DSTEM/classes/methods/__init__.py
index ab06bce4e..a2455dba3 100644
--- a/py4DSTEM/classes/methods/__init__.py
+++ b/py4DSTEM/classes/methods/__init__.py
@@ -1,3 +1,2 @@
-from py4DSTEM.classes.methods.datacube_methods import DataCubeMethods
 from py4DSTEM.classes.methods.probe_methods import ProbeMethods
 
diff --git a/py4DSTEM/classes/probe.py b/py4DSTEM/classes/probe.py
index fc6dade97..53eaa3298 100644
--- a/py4DSTEM/classes/probe.py
+++ b/py4DSTEM/classes/probe.py
@@ -1,5 +1,5 @@
 
-from py4DSTEM.classes import DiffractionSlice, Data
+from py4DSTEM.data import DiffractionSlice, Data
 from py4DSTEM.classes.methods import ProbeMethods
 
 from typing import Optional
diff --git a/py4DSTEM/classes/virtualdiffraction.py b/py4DSTEM/classes/virtualdiffraction.py
index 9d1bb4317..3831bbefe 100644
--- a/py4DSTEM/classes/virtualdiffraction.py
+++ b/py4DSTEM/classes/virtualdiffraction.py
@@ -2,7 +2,7 @@
 from typing import Optional
 import numpy as np
 
-from py4DSTEM.classes import DiffractionSlice,Data
+from py4DSTEM.data import DiffractionSlice,Data
 
 
 
diff --git a/py4DSTEM/classes/virtualimage.py b/py4DSTEM/classes/virtualimage.py
index a14d83e99..8a9bf8c9e 100644
--- a/py4DSTEM/classes/virtualimage.py
+++ b/py4DSTEM/classes/virtualimage.py
@@ -2,7 +2,7 @@
 from typing import Optional
 import numpy as np
 
-from py4DSTEM.classes import RealSlice,Data
+from py4DSTEM.data import RealSlice,Data
 
 
 
diff --git a/py4DSTEM/data/__init__.py b/py4DSTEM/data/__init__.py
new file mode 100644
index 000000000..f8cd284e5
--- /dev/null
+++ b/py4DSTEM/data/__init__.py
@@ -0,0 +1,9 @@
+_emd_hook = True
+
+from py4DSTEM.data.calibration import Calibration
+from py4DSTEM.data.data import Data
+from py4DSTEM.data.datacube import DataCube
+from py4DSTEM.data.diffractionslice import DiffractionSlice
+from py4DSTEM.data.realslice import RealSlice
+from py4DSTEM.data.qpoints import QPoints
+
diff --git a/py4DSTEM/classes/calibration.py b/py4DSTEM/data/calibration.py
similarity index 99%
rename from py4DSTEM/classes/calibration.py
rename to py4DSTEM/data/calibration.py
index dbeef3e2b..e96d61e8b 100644
--- a/py4DSTEM/classes/calibration.py
+++ b/py4DSTEM/data/calibration.py
@@ -5,7 +5,7 @@
 from typing import Optional
 
 from emdfile import Metadata
-from py4DSTEM.classes.propagating_calibration import propagating_calibration
+from py4DSTEM.data.propagating_calibration import propagating_calibration
 
 class Calibration(Metadata):
     """
diff --git a/py4DSTEM/classes/data.py b/py4DSTEM/data/data.py
similarity index 97%
rename from py4DSTEM/classes/data.py
rename to py4DSTEM/data/data.py
index 5794b9963..0f6d10d52 100644
--- a/py4DSTEM/classes/data.py
+++ b/py4DSTEM/data/data.py
@@ -4,7 +4,7 @@
 import warnings
 
 from emdfile import Node, Root
-from py4DSTEM.classes import Calibration
+from py4DSTEM.data import Calibration
 
 
 class Data:
diff --git a/py4DSTEM/classes/methods/datacube_methods.py b/py4DSTEM/data/datacube.py
similarity index 90%
rename from py4DSTEM/classes/methods/datacube_methods.py
rename to py4DSTEM/data/datacube.py
index bf347e5ae..514424c1d 100644
--- a/py4DSTEM/classes/methods/datacube_methods.py
+++ b/py4DSTEM/data/datacube.py
@@ -1,18 +1,258 @@
-# Functions to become DataCube methods
+# Defines the DataCube class, which stores 4D-STEM datacubes
 
 import numpy as np
 from scipy.ndimage import distance_transform_edt, binary_fill_holes, gaussian_filter1d
 from scipy.interpolate import interp1d
+from typing import Optional,Union
 
-from emdfile import Array, Metadata, Node
+from emdfile import Array, Metadata, Node, Root
+from py4DSTEM.data import Data, Calibration
 
 
 
-class DataCubeMethods:
+
+class DataCube(Array,Data):
     """
-    A container for DataCube object instance methods.
+    Storage and processing methods for 4D-STEM datasets.
     """
 
+    def __init__(
+        self,
+        data: np.ndarray,
+        name: Optional[str] = 'datacube',
+        slicelabels: Optional[Union[bool,list]] = None,
+        setup_tree: Optional[bool] = True,
+        calibration: Optional[Union[Calibration,None]] = None,
+        ):
+        """
+        Accepts:
+            data (np.ndarray): the data
+            name (str): the name of the datacube
+            calibration (None or Calibration or 'pass'): default (None)
+                creates and attaches a new Calibration instance to root
+                metadata, or, passing a Calibration instance uses this instead.
+                'skip' is for internal use for the reader
+            slicelabels (None or list): names for slices if this is a
+                stack of datacubes
+
+        Returns:
+            A new DataCube instance.
+        """
+
+        # initialize DataCubeMethods
+        super(DataCubeMethods).__init__()
+
+        # initialize as an Array
+        Array.__init__(
+            self,
+            data = data,
+            name = name,
+            units = 'pixel intensity',
+            dim_names = [
+                'Rx',
+                'Ry',
+                'Qx',
+                'Qy'
+            ],
+            slicelabels = slicelabels
+        )
+
+        # initialize as Data
+        Data.__init__(
+            self,
+            setup_tree,
+            calibration
+        )
+
+        # cartesian coords
+        # TODO - tmp hack, needs to be refactored -
+        # this will break when preprocess methods are called
+        self.qyy,self.qxx = np.meshgrid(
+            np.arange(0,self.Q_Ny),
+            np.arange(0,self.Q_Nx)
+        )
+
+        # polar coords
+        self.polar = None
+
+
+
+    def _setup_calibration(self, cal):
+        """
+        Ensures that a calibration instance exists. Passing None
+        makes a new Calibration instance, puts it in root.calibration, and
+        makes a two way link. Passing a Calibration instance attaches that
+        instance. `'skip'` does nothing (internal use, on read from file).
+        """
+        if cal is None:
+            self.calibration = Calibration( datacube = self )
+        elif cal == 'skip':
+            pass
+        else:
+            assert(isinstance(cal, Calibration)), "`calibration` must be a Calibration instance, not type f{type(cal)}"
+            self.calibration = cal
+            cal._datacube = self
+
+
+    def copy(self):
+        """
+        Copys datacube
+        """
+        from py4DSTEM import DataCube
+        new_datacube = DataCube(
+            data = self.data.copy(),
+            name = self.name,
+            calibration = self.calibration.copy(),
+            slicelabels = self.slicelabels,
+        )
+
+        Qpixsize  = new_datacube.calibration.get_Q_pixel_size()
+        Qpixunits = new_datacube.calibration.get_Q_pixel_units()
+        Rpixsize  = new_datacube.calibration.get_R_pixel_size()
+        Rpixunits = new_datacube.calibration.get_R_pixel_units()
+
+        new_datacube.set_dim(
+            0,
+            [0,Rpixsize],
+            units = Rpixunits,
+            name = 'Rx'
+        )
+        new_datacube.set_dim(
+            1,
+            [0,Rpixsize],
+            units = Rpixunits,
+            name = 'Ry'
+        )
+
+        new_datacube.set_dim(
+            2,
+            [0,Qpixsize],
+            units = Qpixunits,
+            name = 'Qx'
+        )
+        new_datacube.set_dim(
+            3,
+            [0,Qpixsize],
+            units = Qpixunits,
+            name = 'Qy'
+        )
+
+        return new_datacube
+
+
+    # properties
+
+
+    ## pixel size / units
+
+    # Q 
+    @property
+    def Q_pixel_size(self):
+        return self.calibration.get_Q_pixel_size()
+    @property
+    def Q_pixel_units(self):
+        return self.calibration.get_Q_pixel_units()
+
+    # R
+    @property
+    def R_pixel_size(self):
+        return self.calibration.get_R_pixel_size()
+    @property
+    def R_pixel_units(self):
+        return self.calibration.get_R_pixel_units()
+
+    # aliases
+    qpixsize = Q_pixel_size
+    qpixunit = Q_pixel_units
+    rpixsize = R_pixel_size
+    rpixunit = R_pixel_units
+
+
+    ## shape
+
+    # FOV
+    @property
+    def R_Nx(self):
+        return self.data.shape[0]
+    @property
+    def R_Ny(self):
+        return self.data.shape[1]
+    @property
+    def Q_Nx(self):
+        return self.data.shape[2]
+    @property
+    def Q_Ny(self):
+        return self.data.shape[3]
+
+    @property
+    def Rshape(self):
+        return (self.data.shape[0],self.data.shape[1])
+    @property
+    def Qshape(self):
+        return (self.data.shape[2],self.data.shape[3])
+
+    @property
+    def R_N(self):
+        return self.R_Nx*self.R_Ny
+
+    # aliases
+    qnx = Q_Nx
+    qny = Q_Ny
+    rnx = R_Nx
+    rny = R_Ny
+    rshape = Rshape
+    qshape = Qshape
+    rn = R_N
+
+
+
+
+
+    # I/O
+
+    # to_h5 is inherited from Array
+
+    # read
+    @classmethod
+    def _get_constructor_args(cls,group):
+        """ Construct a datacube with no calibration / metadata
+        """
+        # We only need some of the Array constructors;
+        # dim vector/units are passed through when Calibration
+        # is loaded, and the runtim dim vectors are then set
+        # in _add_root_links
+        ar_args = Array._get_constructor_args(group)
+
+        args = {
+            'data': ar_args['data'],
+            'name': ar_args['name'],
+            'slicelabels': ar_args['slicelabels'],
+            'calibration': 'skip'
+        }
+
+        return args
+
+
+    def _add_root_links(self,group):
+        """ When reading from file, link to calibration metadata,
+        then use it to populate the datacube dim vectors
+        """
+        # Link to the datacube
+        self.calibration._datacube = self
+
+        # Populate dim vectors
+        self.calibration.set_Q_pixel_size( self.calibration.get_Q_pixel_size() )
+        self.calibration.set_R_pixel_size( self.calibration.get_R_pixel_size() )
+        self.calibration.set_Q_pixel_units( self.calibration.get_Q_pixel_units() )
+        self.calibration.set_R_pixel_units( self.calibration.get_R_pixel_units() )
+
+        return
+
+
+
+
+    # Class methods
+
     def add(
         self,
         data,
@@ -1667,5 +1907,3 @@ def get_braggmask(
 
 
 
-
-
diff --git a/py4DSTEM/data/datacube_methods.py b/py4DSTEM/data/datacube_methods.py
new file mode 100644
index 000000000..fd40910d9
--- /dev/null
+++ b/py4DSTEM/data/datacube_methods.py
@@ -0,0 +1,4 @@
+
+
+
+
diff --git a/py4DSTEM/classes/diffractionslice.py b/py4DSTEM/data/diffractionslice.py
similarity index 97%
rename from py4DSTEM/classes/diffractionslice.py
rename to py4DSTEM/data/diffractionslice.py
index 9f75dc43d..ece658adc 100644
--- a/py4DSTEM/classes/diffractionslice.py
+++ b/py4DSTEM/data/diffractionslice.py
@@ -2,7 +2,7 @@
 # diffraction-shaped data
 
 from emdfile import Array
-from py4DSTEM.classes import Data
+from py4DSTEM.data import Data
 
 from typing import Optional,Union
 import numpy as np
diff --git a/py4DSTEM/classes/propagating_calibration.py b/py4DSTEM/data/propagating_calibration.py
similarity index 100%
rename from py4DSTEM/classes/propagating_calibration.py
rename to py4DSTEM/data/propagating_calibration.py
diff --git a/py4DSTEM/classes/qpoints.py b/py4DSTEM/data/qpoints.py
similarity index 97%
rename from py4DSTEM/classes/qpoints.py
rename to py4DSTEM/data/qpoints.py
index 62788f518..c29127406 100644
--- a/py4DSTEM/classes/qpoints.py
+++ b/py4DSTEM/data/qpoints.py
@@ -1,7 +1,7 @@
 # Defines the QPoints class, which stores PointLists with fields 'qx','qy','intensity'
 
 from emdfile import PointList
-from py4DSTEM.classes import Data
+from py4DSTEM.data import Data
 
 from typing import Optional
 import numpy as np
diff --git a/py4DSTEM/classes/realslice.py b/py4DSTEM/data/realslice.py
similarity index 97%
rename from py4DSTEM/classes/realslice.py
rename to py4DSTEM/data/realslice.py
index 1a75f1e8e..0a2f893c9 100644
--- a/py4DSTEM/classes/realslice.py
+++ b/py4DSTEM/data/realslice.py
@@ -1,7 +1,7 @@
 # Defines the RealSlice class, which stores 2(+1)D real-space shaped data
 
 from emdfile import Array
-from py4DSTEM.classes import Data
+from py4DSTEM.data import Data
 
 from typing import Optional,Union
 import numpy as np
diff --git a/py4DSTEM/io/filereaders/empad.py b/py4DSTEM/io/filereaders/empad.py
index 04feaee11..4aef6ee77 100644
--- a/py4DSTEM/io/filereaders/empad.py
+++ b/py4DSTEM/io/filereaders/empad.py
@@ -8,7 +8,7 @@
 import numpy as np
 from pathlib import Path
 from emdfile import tqdmnd
-from py4DSTEM.classes import DataCube
+from py4DSTEM.data import DataCube
 from py4DSTEM.preprocess.utils import bin2D
 
 
diff --git a/py4DSTEM/io/filereaders/read_K2.py b/py4DSTEM/io/filereaders/read_K2.py
index 2e483e294..cf5dd8be6 100644
--- a/py4DSTEM/io/filereaders/read_K2.py
+++ b/py4DSTEM/io/filereaders/read_K2.py
@@ -9,7 +9,7 @@
 except ImportError:
     pass
 from emdfile import tqdmnd
-from py4DSTEM.classes import DataCube
+from py4DSTEM.data import DataCube
 
 
 def read_gatan_K2_bin(fp, mem="MEMMAP", binfactor=1, metadata=False, **kwargs):
diff --git a/py4DSTEM/io/filereaders/read_dm.py b/py4DSTEM/io/filereaders/read_dm.py
index 60b8975c9..6762ab9f8 100644
--- a/py4DSTEM/io/filereaders/read_dm.py
+++ b/py4DSTEM/io/filereaders/read_dm.py
@@ -5,7 +5,7 @@
 from ncempy.io import dm
 from emdfile import tqdmnd, Array
 
-from py4DSTEM.classes import DataCube
+from py4DSTEM.data import DataCube
 from py4DSTEM.preprocess.utils import bin2D
 
 
diff --git a/py4DSTEM/io/filereaders/read_mib.py b/py4DSTEM/io/filereaders/read_mib.py
index cfb0b10b8..b8e42ee4f 100644
--- a/py4DSTEM/io/filereaders/read_mib.py
+++ b/py4DSTEM/io/filereaders/read_mib.py
@@ -3,7 +3,7 @@
 # Based on the PyXEM load_mib module https://github.com/pyxem/pyxem/blob/563a3bb5f3233f46cd3e57f3cd6f9ddf7af55ad0/pyxem/utils/io_utils.py
 
 import numpy as np
-from py4DSTEM.classes import DataCube
+from py4DSTEM.data import DataCube
 import os
 
 def load_mib(
diff --git a/py4DSTEM/io/legacy/legacy12/read_v0_12.py b/py4DSTEM/io/legacy/legacy12/read_v0_12.py
index a327a567b..9622f0a0e 100644
--- a/py4DSTEM/io/legacy/legacy12/read_v0_12.py
+++ b/py4DSTEM/io/legacy/legacy12/read_v0_12.py
@@ -9,7 +9,7 @@
     PointList,
     PointListArray
 )
-from py4DSTEM.classes import (
+from py4DSTEM.data import (
     DataCube,
     DiffractionSlice,
     RealSlice,
diff --git a/py4DSTEM/io/legacy/legacy12/read_v0_5.py b/py4DSTEM/io/legacy/legacy12/read_v0_5.py
index 109c0a4c3..fa53fb7cb 100644
--- a/py4DSTEM/io/legacy/legacy12/read_v0_5.py
+++ b/py4DSTEM/io/legacy/legacy12/read_v0_5.py
@@ -9,7 +9,7 @@
     PointList,
     PointListArray
 )
-from py4DSTEM.classes import (
+from py4DSTEM.data import (
     DataCube,
     DiffractionSlice,
     RealSlice,
diff --git a/py4DSTEM/io/legacy/legacy12/read_v0_6.py b/py4DSTEM/io/legacy/legacy12/read_v0_6.py
index ded73a8c4..bec2e6d69 100644
--- a/py4DSTEM/io/legacy/legacy12/read_v0_6.py
+++ b/py4DSTEM/io/legacy/legacy12/read_v0_6.py
@@ -9,7 +9,7 @@
     PointList,
     PointListArray
 )
-from py4DSTEM.classes import (
+from py4DSTEM.data import (
     DataCube,
     DiffractionSlice,
     RealSlice,
diff --git a/py4DSTEM/io/legacy/legacy12/read_v0_7.py b/py4DSTEM/io/legacy/legacy12/read_v0_7.py
index 7635c56f6..7e3b782df 100644
--- a/py4DSTEM/io/legacy/legacy12/read_v0_7.py
+++ b/py4DSTEM/io/legacy/legacy12/read_v0_7.py
@@ -9,7 +9,7 @@
     PointList,
     PointListArray
 )
-from py4DSTEM.classes import (
+from py4DSTEM.data import (
     DataCube,
     DiffractionSlice,
     RealSlice,
diff --git a/py4DSTEM/io/legacy/legacy12/read_v0_9.py b/py4DSTEM/io/legacy/legacy12/read_v0_9.py
index b3fe4583b..71bf7adaf 100644
--- a/py4DSTEM/io/legacy/legacy12/read_v0_9.py
+++ b/py4DSTEM/io/legacy/legacy12/read_v0_9.py
@@ -9,7 +9,7 @@
     PointList,
     PointListArray
 )
-from py4DSTEM.classes import (
+from py4DSTEM.data import (
     DataCube,
     DiffractionSlice,
     RealSlice,
diff --git a/py4DSTEM/io/legacy/legacy13/v13_to_14.py b/py4DSTEM/io/legacy/legacy13/v13_to_14.py
index 1b0deafaa..453c4cf1c 100644
--- a/py4DSTEM/io/legacy/legacy13/v13_to_14.py
+++ b/py4DSTEM/io/legacy/legacy13/v13_to_14.py
@@ -36,15 +36,17 @@
     PointListArray
 )
 
-from py4DSTEM.classes import (
+from py4DSTEM.data import (
     Calibration,
     DataCube,
     DiffractionSlice,
-    VirtualDiffraction,
     RealSlice,
+    QPoints,
+)
+from py4DSTEM.classes import (
     VirtualImage,
+    VirtualDiffraction,
     Probe,
-    QPoints,
 )
 from py4DSTEM.process.diskdetection.braggvectors import BraggVectors
 
diff --git a/py4DSTEM/process/calibration/origin.py b/py4DSTEM/process/calibration/origin.py
index bc8c0be0c..5a4b09803 100644
--- a/py4DSTEM/process/calibration/origin.py
+++ b/py4DSTEM/process/calibration/origin.py
@@ -6,7 +6,7 @@
 from scipy.optimize import leastsq
 
 from emdfile import tqdmnd, PointListArray
-from py4DSTEM.classes import DataCube
+from py4DSTEM.data import DataCube
 from py4DSTEM.process.calibration.probe import get_probe_size
 from py4DSTEM.process.fit import plane,parabola,bezier_two,fit_2D
 from py4DSTEM.process.utils import get_CoM, add_to_2D_array_from_floats, get_maxima_2D
diff --git a/py4DSTEM/process/classification/classutils.py b/py4DSTEM/process/classification/classutils.py
index 1a7bccfda..b2381c26f 100644
--- a/py4DSTEM/process/classification/classutils.py
+++ b/py4DSTEM/process/classification/classutils.py
@@ -3,7 +3,7 @@
 import numpy as np
 
 from emdfile import tqdmnd, PointListArray
-from py4DSTEM.classes import DataCube
+from py4DSTEM.data import DataCube
 from py4DSTEM.process.utils import get_shifted_ar
 
 def get_class_DP(datacube, class_image, thresh=0.01, xshifts=None, yshifts=None,
diff --git a/py4DSTEM/process/diffraction/crystal_ACOM.py b/py4DSTEM/process/diffraction/crystal_ACOM.py
index b303ee916..4299a3624 100644
--- a/py4DSTEM/process/diffraction/crystal_ACOM.py
+++ b/py4DSTEM/process/diffraction/crystal_ACOM.py
@@ -4,7 +4,7 @@
 from typing import Union, Optional
 
 from emdfile import tqdmnd, PointList, PointListArray
-from py4DSTEM.classes import RealSlice
+from py4DSTEM.data import RealSlice
 from py4DSTEM.process.diffraction.utils import Orientation, OrientationMap, axisEqual3D
 from py4DSTEM.process.utils import electron_wavelength_angstrom
 
diff --git a/py4DSTEM/process/diskdetection/braggvectors.py b/py4DSTEM/process/diskdetection/braggvectors.py
index 3a22bd27b..3130e2c76 100644
--- a/py4DSTEM/process/diskdetection/braggvectors.py
+++ b/py4DSTEM/process/diskdetection/braggvectors.py
@@ -1,6 +1,6 @@
 # Defines the BraggVectors class
 
-from py4DSTEM.classes import Data
+from py4DSTEM.data import Data
 from emdfile import Custom,PointListArray,PointList,Metadata
 from py4DSTEM.process.diskdetection.braggvector_methods import BraggVectorMethods
 from os.path import basename
diff --git a/py4DSTEM/process/diskdetection/diskdetection.py b/py4DSTEM/process/diskdetection/diskdetection.py
index 1674fdc93..1c7916a51 100644
--- a/py4DSTEM/process/diskdetection/diskdetection.py
+++ b/py4DSTEM/process/diskdetection/diskdetection.py
@@ -6,7 +6,7 @@
 
 from emdfile import tqdmnd
 from py4DSTEM.process.diskdetection.braggvectors import BraggVectors
-from py4DSTEM.classes import DataCube, QPoints
+from py4DSTEM.data import DataCube, QPoints
 from py4DSTEM.preprocess.utils import get_maxima_2D
 from py4DSTEM.process.utils.cross_correlate import get_cross_correlation_FT
 from py4DSTEM.process.diskdetection.diskdetection_aiml import find_Bragg_disks_aiml
diff --git a/py4DSTEM/process/diskdetection/diskdetection_aiml.py b/py4DSTEM/process/diskdetection/diskdetection_aiml.py
index e076e0732..8f82dce9a 100644
--- a/py4DSTEM/process/diskdetection/diskdetection_aiml.py
+++ b/py4DSTEM/process/diskdetection/diskdetection_aiml.py
@@ -15,7 +15,7 @@
 
 from emdfile import tqdmnd, PointList, PointListArray
 from py4DSTEM.process.diskdetection.braggvectors import BraggVectors
-from py4DSTEM.classes import QPoints
+from py4DSTEM.data import QPoints
 from py4DSTEM.process.utils import get_maxima_2D
 # from py4DSTEM.process.diskdetection import universal_threshold
 
diff --git a/py4DSTEM/process/diskdetection/diskdetection_aiml_cuda.py b/py4DSTEM/process/diskdetection/diskdetection_aiml_cuda.py
index 1b6c38565..fbc9339a0 100644
--- a/py4DSTEM/process/diskdetection/diskdetection_aiml_cuda.py
+++ b/py4DSTEM/process/diskdetection/diskdetection_aiml_cuda.py
@@ -8,7 +8,8 @@
 
 from emdfile import tqdmnd
 from py4DSTEM.process.diskdetection.braggvectors import BraggVectors
-from py4DSTEM.classes import PointList, PointListArray, QPoints
+from emdfile import PointList, PointListArray
+from py4DSTEM.data import QPoints
 from py4DSTEM.process.diskdetection.kernels import kernels
 from py4DSTEM.process.diskdetection.diskdetection_aiml import _get_latest_model
 # from py4DSTEM.process.diskdetection.diskdetection import universal_threshold
diff --git a/py4DSTEM/process/diskdetection/diskdetection_parallel.py b/py4DSTEM/process/diskdetection/diskdetection_parallel.py
index f6d2624e1..5a6d6dc11 100644
--- a/py4DSTEM/process/diskdetection/diskdetection_parallel.py
+++ b/py4DSTEM/process/diskdetection/diskdetection_parallel.py
@@ -9,7 +9,7 @@
 
 # local
 import py4DSTEM
-from py4DSTEM.classes import PointListArray
+from emdfile import PointListArray
 
 
 def _find_Bragg_disks_single_DP_FK(DP, probe_kernel_FT,
diff --git a/py4DSTEM/process/diskdetection/diskdetection_parallel_new.py b/py4DSTEM/process/diskdetection/diskdetection_parallel_new.py
index c9e224eee..af011cb8e 100644
--- a/py4DSTEM/process/diskdetection/diskdetection_parallel_new.py
+++ b/py4DSTEM/process/diskdetection/diskdetection_parallel_new.py
@@ -17,7 +17,7 @@
 import distributed
 
 import py4DSTEM
-from py4DSTEM.classes import PointListArray, PointList
+from emdfile import PointListArray, PointList
 from py4DSTEM.process.diskdetection.diskdetection import _find_Bragg_disks_single_DP_FK
 
 
diff --git a/py4DSTEM/process/latticevectors/fit.py b/py4DSTEM/process/latticevectors/fit.py
index dae5d485f..822ffdea5 100644
--- a/py4DSTEM/process/latticevectors/fit.py
+++ b/py4DSTEM/process/latticevectors/fit.py
@@ -4,7 +4,7 @@
 from numpy.linalg import lstsq
 
 from emdfile import tqdmnd, PointList, PointListArray
-from py4DSTEM.classes import RealSlice
+from py4DSTEM.data import RealSlice
 
 def fit_lattice_vectors(braggpeaks, x0=0, y0=0, minNumPeaks=5):
     """
diff --git a/py4DSTEM/process/latticevectors/strain.py b/py4DSTEM/process/latticevectors/strain.py
index 0521f703c..50b9bddc9 100644
--- a/py4DSTEM/process/latticevectors/strain.py
+++ b/py4DSTEM/process/latticevectors/strain.py
@@ -3,7 +3,7 @@
 import numpy as np
 from numpy.linalg import lstsq
 
-from py4DSTEM.classes import RealSlice
+from py4DSTEM.data import RealSlice
 
 def get_reference_g1g2(g1g2_map, mask):
     """
diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index c2acbee34..42e207d97 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -18,7 +18,7 @@
     cp = None
 
 from emdfile import Array, Custom, Metadata, _read_metadata, tqdmnd
-from py4DSTEM.classes import Calibration, DataCube
+from py4DSTEM.data import Calibration, DataCube
 from py4DSTEM.process.calibration import fit_origin
 from py4DSTEM.process.phase.iterative_ptychographic_constraints import (
     PtychographicConstraints,
diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index b2d8ef891..16381c4d8 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -17,7 +17,7 @@
     cp = None
 
 from emdfile import Array, Custom, Metadata, _read_metadata, tqdmnd
-from py4DSTEM.classes import Calibration, DataCube
+from py4DSTEM.data import Calibration, DataCube
 from py4DSTEM.process.phase.iterative_base_class import PhaseReconstruction
 
 warnings.simplefilter(action="always", category=UserWarning)
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index 8a83fa5ba..ce298967d 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -18,7 +18,7 @@
     cp = None
 
 from emdfile import Custom, tqdmnd
-from py4DSTEM.classes import DataCube
+from py4DSTEM.data import DataCube
 from py4DSTEM.process.phase.iterative_base_class import PtychographicReconstruction
 from py4DSTEM.process.phase.utils import (
     ComplexProbe,
diff --git a/py4DSTEM/process/polar/polar_datacube.py b/py4DSTEM/process/polar/polar_datacube.py
index c8afa7609..9aa93d678 100644
--- a/py4DSTEM/process/polar/polar_datacube.py
+++ b/py4DSTEM/process/polar/polar_datacube.py
@@ -1,5 +1,5 @@
 import numpy as np
-from py4DSTEM.classes import DataCube
+from py4DSTEM.data import DataCube
 from scipy.ndimage import binary_opening,binary_closing, gaussian_filter1d
 
 
diff --git a/py4DSTEM/process/probe/probe.py b/py4DSTEM/process/probe/probe.py
index c9bb98634..04a2926de 100644
--- a/py4DSTEM/process/probe/probe.py
+++ b/py4DSTEM/process/probe/probe.py
@@ -5,7 +5,8 @@
     binary_opening, binary_dilation, distance_transform_edt)
 
 from emdfile import tqdmnd
-from py4DSTEM.classes import DataCube, Probe
+from py4DSTEM.data import DataCube
+from py4DSTEM.classes import Probe
 from py4DSTEM.process.utils import get_shifted_ar, get_shift
 
 
diff --git a/py4DSTEM/process/virtualimage.py b/py4DSTEM/process/virtualimage.py
index 1c5e5e1da..d6fe79566 100644
--- a/py4DSTEM/process/virtualimage.py
+++ b/py4DSTEM/process/virtualimage.py
@@ -2,7 +2,7 @@
 import numpy as np
 import dask.array as da
 from emdfile import tqdmnd
-from py4DSTEM.classes import Calibration
+from py4DSTEM.data import Calibration
 
 def get_virtual_image(
     datacube,
diff --git a/py4DSTEM/visualize/show.py b/py4DSTEM/visualize/show.py
index 45a5b7395..448a44590 100644
--- a/py4DSTEM/visualize/show.py
+++ b/py4DSTEM/visualize/show.py
@@ -9,7 +9,7 @@
 from math import log
 from copy import copy
 
-from py4DSTEM.classes import (
+from py4DSTEM.data import (
     Calibration,
     DiffractionSlice,
     RealSlice
diff --git a/py4DSTEM/visualize/virtualimage.py b/py4DSTEM/visualize/virtualimage.py
index 87931bfba..830fde5c5 100644
--- a/py4DSTEM/visualize/virtualimage.py
+++ b/py4DSTEM/visualize/virtualimage.py
@@ -1,6 +1,6 @@
 import numpy as np
 
-from py4DSTEM.classes import Calibration, DataCube, DiffractionSlice
+from py4DSTEM.data import Calibration, DataCube, DiffractionSlice
 from py4DSTEM.visualize.show import show
 
 
diff --git a/py4DSTEM/visualize/vis_special.py b/py4DSTEM/visualize/vis_special.py
index af8c074d0..d6ce64cf5 100644
--- a/py4DSTEM/visualize/vis_special.py
+++ b/py4DSTEM/visualize/vis_special.py
@@ -6,7 +6,7 @@
 from scipy.spatial import Voronoi
 
 from emdfile import PointList
-from py4DSTEM.classes import DataCube,Calibration
+from py4DSTEM.data import DataCube,Calibration
 from py4DSTEM.process.utils import get_voronoi_vertices,convert_ellipse_params
 from py4DSTEM.process.calibration import double_sided_gaussian
 from py4DSTEM.process.latticevectors import get_selected_lattice_vectors

From a99aba0dfe71620258c7817003cd3d1b0c3b968f Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Thu, 22 Jun 2023 17:19:39 -0400
Subject: [PATCH 066/362] bumps emdfile to 0.0.10

---
 py4DSTEM/data/datacube.py | 4 ----
 setup.py                  | 2 +-
 2 files changed, 1 insertion(+), 5 deletions(-)

diff --git a/py4DSTEM/data/datacube.py b/py4DSTEM/data/datacube.py
index 514424c1d..c573b7e30 100644
--- a/py4DSTEM/data/datacube.py
+++ b/py4DSTEM/data/datacube.py
@@ -38,10 +38,6 @@ def __init__(
         Returns:
             A new DataCube instance.
         """
-
-        # initialize DataCubeMethods
-        super(DataCubeMethods).__init__()
-
         # initialize as an Array
         Array.__init__(
             self,
diff --git a/setup.py b/setup.py
index 2f1e15a63..f518599cc 100644
--- a/setup.py
+++ b/setup.py
@@ -35,7 +35,7 @@
         'gdown >= 4.4.0',
         'dask >= 2.3.0',
         'distributed >= 2.3.0',
-        'emdfile >= 0.0.9',
+        'emdfile >= 0.0.10',
         ],
     extras_require={
         'ipyparallel': ['ipyparallel >= 6.2.4', 'dill >= 0.3.3'],

From a7f393f0baf6785d2abae4d046ce7f7c3fbf277e Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Thu, 22 Jun 2023 17:20:35 -0400
Subject: [PATCH 067/362] rms datacube_methods

---
 py4DSTEM/data/datacube_methods.py | 4 ----
 1 file changed, 4 deletions(-)
 delete mode 100644 py4DSTEM/data/datacube_methods.py

diff --git a/py4DSTEM/data/datacube_methods.py b/py4DSTEM/data/datacube_methods.py
deleted file mode 100644
index fd40910d9..000000000
--- a/py4DSTEM/data/datacube_methods.py
+++ /dev/null
@@ -1,4 +0,0 @@
-
-
-
-

From df5cfe95eed6cf7b0f5a6ae35949217b4e3b3767 Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Sat, 24 Jun 2023 13:18:58 -0400
Subject: [PATCH 068/362] propagate sampling overrides

---
 .../iterative_mixedstate_ptychography.py      | 22 +++++++++++++-
 .../iterative_multislice_ptychography.py      | 22 +++++++++++++-
 .../iterative_overlap_magnetic_tomography.py  | 23 ++++++++++++++-
 .../phase/iterative_overlap_tomography.py     | 23 ++++++++++++++-
 .../iterative_simultaneous_ptychography.py    | 29 ++++++++++++++++++-
 .../iterative_singleslice_ptychography.py     | 14 +++++----
 6 files changed, 122 insertions(+), 11 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
index afa565871..4dea8172f 100644
--- a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
@@ -52,7 +52,9 @@ class MixedstatePtychographicReconstruction(PtychographicReconstruction):
     num_probes: int, optional
         Number of mixed-state probes
     semiangle_cutoff: float, optional
-        Semiangle cutoff for the initial probe guess
+        Semiangle cutoff for the initial probe guess in mrad
+    semiangle_cutoff_pixels: float, optional
+        Semiangle cutoff for the initial probe guess in pixels
     rolloff: float, optional
         Semiangle rolloff for the initial probe guess
     vacuum_probe_intensity: np.ndarray, optional
@@ -91,6 +93,7 @@ def __init__(
         datacube: DataCube = None,
         num_probes: int = None,
         semiangle_cutoff: float = None,
+        semiangle_cutoff_pixels: float = None,
         rolloff: float = 2.0,
         vacuum_probe_intensity: np.ndarray = None,
         polar_parameters: Mapping[str, float] = None,
@@ -171,6 +174,7 @@ def __init__(
         self._scan_positions = initial_scan_positions
         self._energy = energy
         self._semiangle_cutoff = semiangle_cutoff
+        self._semiangle_cutoff_pixels = semiangle_cutoff_pixels
         self._rolloff = rolloff
         self._object_type = object_type
         self._object_padding_px = object_padding_px
@@ -196,6 +200,9 @@ def preprocess(
         force_com_rotation: float = None,
         force_com_transpose: float = None,
         force_com_shifts: float = None,
+        force_scan_sampling: float = None,
+        force_angular_sampling: float = None,
+        force_reciprocal_sampling: float = None,
         object_fov_mask: np.ndarray = None,
         **kwargs,
     ):
@@ -245,6 +252,12 @@ def preprocess(
             Amplitudes come from diffraction patterns shifted with
             the CoM in the upper left corner for each probe unless
             shift is overwritten.
+        force_scan_sampling: float, optional
+            Override DataCube real space scan pixel size calibrations, in Angstrom
+        force_angular_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in mrad
+        force_reciprocal_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in A^-1
         object_fov_mask: np.ndarray (boolean)
             Boolean mask of FOV. Used to calculate additional shrinkage of object
             If None, probe_overlap intensity is thresholded
@@ -289,6 +302,9 @@ def preprocess(
         self._intensities = self._extract_intensities_and_calibrations_from_datacube(
             self._datacube,
             require_calibrations=True,
+            force_scan_sampling=force_scan_sampling,
+            force_angular_sampling=force_angular_sampling,
+            force_reciprocal_sampling=force_reciprocal_sampling,
         )
 
         (
@@ -344,6 +360,10 @@ def preprocess(
             self._scan_positions
         )
 
+        # handle semiangle specified in pixels
+        if self._semiangle_cutoff_pixels:
+            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
+
         # Object Initialization
         if self._object is None:
             pad_x = self._object_padding_px[0][1]
diff --git a/py4DSTEM/process/phase/iterative_multislice_ptychography.py b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
index a67bd93e9..a9dcf2d41 100644
--- a/py4DSTEM/process/phase/iterative_multislice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
@@ -56,7 +56,9 @@ class MultislicePtychographicReconstruction(PtychographicReconstruction):
     datacube: DataCube, optional
         Input 4D diffraction pattern intensities
     semiangle_cutoff: float, optional
-        Semiangle cutoff for the initial probe guess
+        Semiangle cutoff for the initial probe guess in mrad
+    semiangle_cutoff_pixels: float, optional
+        Semiangle cutoff for the initial probe guess in pixels
     rolloff: float, optional
         Semiangle rolloff for the initial probe guess
     vacuum_probe_intensity: np.ndarray, optional
@@ -99,6 +101,7 @@ def __init__(
         slice_thicknesses: Union[float, Sequence[float]],
         datacube: DataCube = None,
         semiangle_cutoff: float = None,
+        semiangle_cutoff_pixels: float = None,
         rolloff: float = 2.0,
         vacuum_probe_intensity: np.ndarray = None,
         polar_parameters: Mapping[str, float] = None,
@@ -175,6 +178,7 @@ def __init__(
         self._scan_positions = initial_scan_positions
         self._energy = energy
         self._semiangle_cutoff = semiangle_cutoff
+        self._semiangle_cutoff_pixels = semiangle_cutoff_pixels
         self._rolloff = rolloff
         self._object_type = object_type
         self._object_padding_px = object_padding_px
@@ -271,6 +275,9 @@ def preprocess(
         force_com_rotation: float = None,
         force_com_transpose: float = None,
         force_com_shifts: float = None,
+        force_scan_sampling: float = None,
+        force_angular_sampling: float = None,
+        force_reciprocal_sampling: float = None,
         object_fov_mask: np.ndarray = None,
         **kwargs,
     ):
@@ -320,6 +327,12 @@ def preprocess(
             Amplitudes come from diffraction patterns shifted with
             the CoM in the upper left corner for each probe unless
             shift is overwritten.
+        force_scan_sampling: float, optional
+            Override DataCube real space scan pixel size calibrations, in Angstrom
+        force_angular_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in mrad
+        force_reciprocal_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in A^-1
         object_fov_mask: np.ndarray (boolean)
             Boolean mask of FOV. Used to calculate additional shrinkage of object
             If None, probe_overlap intensity is thresholded
@@ -364,6 +377,9 @@ def preprocess(
         self._intensities = self._extract_intensities_and_calibrations_from_datacube(
             self._datacube,
             require_calibrations=True,
+            force_scan_sampling=force_scan_sampling,
+            force_angular_sampling=force_angular_sampling,
+            force_reciprocal_sampling=force_reciprocal_sampling,
         )
 
         (
@@ -419,6 +435,10 @@ def preprocess(
             self._scan_positions
         )
 
+        # handle semiangle specified in pixels
+        if self._semiangle_cutoff_pixels:
+            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
+
         # Object Initialization
         if self._object is None:
             pad_x = self._object_padding_px[0][1]
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 92905cac2..30e2b520f 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -63,7 +63,9 @@ class OverlapMagneticTomographicReconstruction(PtychographicReconstruction):
           - \beta tilt around x-axis
           - -\alpha tilt around z-axis
     semiangle_cutoff: float, optional
-        Semiangle cutoff for the initial probe guess
+        Semiangle cutoff for the initial probe guess in mrad
+    semiangle_cutoff_pixels: float, optional
+        Semiangle cutoff for the initial probe guess in pixels
     rolloff: float, optional
         Semiangle rolloff for the initial probe guess
     vacuum_probe_intensity: np.ndarray, optional
@@ -106,6 +108,7 @@ def __init__(
         tilt_angles_deg: Sequence[Tuple[float, float]],
         datacube: Sequence[DataCube] = None,
         semiangle_cutoff: float = None,
+        semiangle_cutoff_pixels: float = None,
         rolloff: float = 2.0,
         vacuum_probe_intensity: np.ndarray = None,
         polar_parameters: Mapping[str, float] = None,
@@ -171,6 +174,7 @@ def __init__(
         self._scan_positions = initial_scan_positions
         self._energy = energy
         self._semiangle_cutoff = semiangle_cutoff
+        self._semiangle_cutoff_pixels = semiangle_cutoff_pixels
         self._rolloff = rolloff
         self._object_type = object_type
         self._object_padding_px = object_padding_px
@@ -422,6 +426,9 @@ def preprocess(
         diffraction_patterns_transpose: bool = None,
         force_com_shifts: Sequence[float] = None,
         progress_bar: bool = True,
+        force_scan_sampling: float = None,
+        force_angular_sampling: float = None,
+        force_reciprocal_sampling: float = None,
         object_fov_mask: np.ndarray = None,
         **kwargs,
     ):
@@ -458,6 +465,12 @@ def preprocess(
             Amplitudes come from diffraction patterns shifted with
             the CoM in the upper left corner for each probe unless
             shift is overwritten. One tuple per tilt.
+        force_scan_sampling: float, optional
+            Override DataCube real space scan pixel size calibrations, in Angstrom
+        force_angular_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in mrad
+        force_reciprocal_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in A^-1
         object_fov_mask: np.ndarray (boolean)
             Boolean mask of FOV. Used to calculate additional shrinkage of object
             If None, probe_overlap intensity is thresholded
@@ -551,6 +564,9 @@ def preprocess(
             intensities = self._extract_intensities_and_calibrations_from_datacube(
                 self._datacube[tilt_index],
                 require_calibrations=True,
+                force_scan_sampling=force_scan_sampling,
+                force_angular_sampling=force_angular_sampling,
+                force_reciprocal_sampling=force_reciprocal_sampling,
             )
 
             (
@@ -600,6 +616,11 @@ def preprocess(
                 self._scan_positions[tilt_index]
             )
 
+        # handle semiangle specified in pixels
+        if self._semiangle_cutoff_pixels:
+            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
+
+
         # Object Initialization
         if self._object is None:
             pad_x = self._object_padding_px[0][1]
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index 6166640f4..a55a08697 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -58,7 +58,9 @@ class OverlapTomographicReconstruction(PtychographicReconstruction):
     tilt_angles_deg: Sequence[float]
         List of tilt angles in degrees,
     semiangle_cutoff: float, optional
-        Semiangle cutoff for the initial probe guess
+        Semiangle cutoff for the initial probe guess in mrad
+    semiangle_cutoff_pixels: float, optional
+        Semiangle cutoff for the initial probe guess in pixels
     rolloff: float, optional
         Semiangle rolloff for the initial probe guess
     vacuum_probe_intensity: np.ndarray, optional
@@ -101,6 +103,7 @@ def __init__(
         tilt_angles_deg: Sequence[float],
         datacube: Sequence[DataCube] = None,
         semiangle_cutoff: float = None,
+        semiangle_cutoff_pixels: float = None,
         rolloff: float = 2.0,
         vacuum_probe_intensity: np.ndarray = None,
         polar_parameters: Mapping[str, float] = None,
@@ -172,6 +175,7 @@ def __init__(
         self._scan_positions = initial_scan_positions
         self._energy = energy
         self._semiangle_cutoff = semiangle_cutoff
+        self._semiangle_cutoff_pixels = semiangle_cutoff_pixels
         self._rolloff = rolloff
         self._object_type = object_type
         self._object_padding_px = object_padding_px
@@ -331,6 +335,9 @@ def preprocess(
         diffraction_patterns_rotate_degrees: float = None,
         diffraction_patterns_transpose: bool = None,
         force_com_shifts: Sequence[float] = None,
+        force_scan_sampling: float = None,
+        force_angular_sampling: float = None,
+        force_reciprocal_sampling: float = None,
         progress_bar: bool = True,
         object_fov_mask: np.ndarray = None,
         **kwargs,
@@ -368,6 +375,12 @@ def preprocess(
             Amplitudes come from diffraction patterns shifted with
             the CoM in the upper left corner for each probe unless
             shift is overwritten. One tuple per tilt.
+        force_scan_sampling: float, optional
+            Override DataCube real space scan pixel size calibrations, in Angstrom
+        force_angular_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in mrad
+        force_reciprocal_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in A^-1
         object_fov_mask: np.ndarray (boolean)
             Boolean mask of FOV. Used to calculate additional shrinkage of object
             If None, probe_overlap intensity is thresholded
@@ -460,6 +473,9 @@ def preprocess(
             intensities = self._extract_intensities_and_calibrations_from_datacube(
                 self._datacube[tilt_index],
                 require_calibrations=True,
+                force_scan_sampling=force_scan_sampling,
+                force_angular_sampling=force_angular_sampling,
+                force_reciprocal_sampling=force_reciprocal_sampling,
             )
 
             (
@@ -509,6 +525,11 @@ def preprocess(
                 self._scan_positions[tilt_index]
             )
 
+        # handle semiangle specified in pixels
+        if self._semiangle_cutoff_pixels:
+            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
+
+
         # Object Initialization
         if self._object is None:
             pad_x = self._object_padding_px[0][1]
diff --git a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
index da358e089..ae302f660 100644
--- a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
@@ -53,7 +53,9 @@ class SimultaneousPtychographicReconstruction(PtychographicReconstruction):
     simultaneous_measurements_mode: str, optional
         One of '-+', '-0+', '0+', where -/0/+ refer to the sign of the magnetic potential
     semiangle_cutoff: float, optional
-        Semiangle cutoff for the initial probe guess
+        Semiangle cutoff for the initial probe guess in mrad
+    semiangle_cutoff_pixels: float, optional
+        Semiangle cutoff for the initial probe guess in pixels
     rolloff: float, optional
         Semiangle rolloff for the initial probe guess
     vacuum_probe_intensity: np.ndarray, optional
@@ -95,6 +97,7 @@ def __init__(
         datacube: Sequence[DataCube] = None,
         simultaneous_measurements_mode: str = "-+",
         semiangle_cutoff: float = None,
+        semiangle_cutoff_pixels: float = None,
         rolloff: float = 2.0,
         vacuum_probe_intensity: np.ndarray = None,
         polar_parameters: Mapping[str, float] = None,
@@ -160,6 +163,7 @@ def __init__(
         self._scan_positions = initial_scan_positions
         self._energy = energy
         self._semiangle_cutoff = semiangle_cutoff
+        self._semiangle_cutoff_pixels = semiangle_cutoff_pixels
         self._rolloff = rolloff
         self._object_type = object_type
         self._object_padding_px = object_padding_px
@@ -184,6 +188,9 @@ def preprocess(
         force_com_rotation: float = None,
         force_com_transpose: float = None,
         force_com_shifts: float = None,
+        force_scan_sampling: float = None,
+        force_angular_sampling: float = None,
+        force_reciprocal_sampling: float = None,
         object_fov_mask: np.ndarray = None,
         **kwargs,
     ):
@@ -230,6 +237,12 @@ def preprocess(
             Amplitudes come from diffraction patterns shifted with
             the CoM in the upper left corner for each probe unless
             shift is overwritten.
+        force_scan_sampling: float, optional
+            Override DataCube real space scan pixel size calibrations, in Angstrom
+        force_angular_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in mrad
+        force_reciprocal_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in A^-1
         object_fov_mask: np.ndarray (boolean)
             Boolean mask of FOV. Used to calculate additional shrinkage of object
             If None, probe_overlap intensity is thresholded
@@ -344,6 +357,9 @@ def preprocess(
         intensities_0 = self._extract_intensities_and_calibrations_from_datacube(
             measurement_0,
             require_calibrations=True,
+            force_scan_sampling=force_scan_sampling,
+            force_angular_sampling=force_angular_sampling,
+            force_reciprocal_sampling=force_reciprocal_sampling,
         )
 
         (
@@ -424,6 +440,9 @@ def preprocess(
         intensities_1 = self._extract_intensities_and_calibrations_from_datacube(
             measurement_1,
             require_calibrations=True,
+            force_scan_sampling=force_scan_sampling,
+            force_angular_sampling=force_angular_sampling,
+            force_reciprocal_sampling=force_reciprocal_sampling,
         )
 
         (
@@ -505,6 +524,9 @@ def preprocess(
             intensities_2 = self._extract_intensities_and_calibrations_from_datacube(
                 measurement_2,
                 require_calibrations=True,
+                force_scan_sampling=force_scan_sampling,
+                force_angular_sampling=force_angular_sampling,
+                force_reciprocal_sampling=force_reciprocal_sampling,
             )
 
             (
@@ -591,6 +613,11 @@ def preprocess(
             self._scan_positions
         )
 
+        # handle semiangle specified in pixels
+        if self._semiangle_cutoff_pixels:
+            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
+
+
         # Object Initialization
         if self._object is None:
             pad_x = self._object_padding_px[0][1]
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index 0836b0ce2..c4c097f1b 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -50,7 +50,9 @@ class SingleslicePtychographicReconstruction(PtychographicReconstruction):
     datacube: DataCube
         Input 4D diffraction pattern intensities
     semiangle_cutoff: float, optional
-        Semiangle cutoff for the initial probe guess
+        Semiangle cutoff for the initial probe guess in mrad
+    semiangle_cutoff_pixels: float, optional
+        Semiangle cutoff for the initial probe guess in pixels
     rolloff: float, optional
         Semiangle rolloff for the initial probe guess
     vacuum_probe_intensity: np.ndarray, optional
@@ -289,11 +291,6 @@ def preprocess(
             force_reciprocal_sampling=force_reciprocal_sampling,
         )
 
-        # handle semiangle specified in pixels
-        if self._semiangle_cutoff_pixels:
-            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
-
-
         (
             self._com_measured_x,
             self._com_measured_y,
@@ -346,6 +343,11 @@ def preprocess(
         self._positions_px = self._calculate_scan_positions_in_pixels(
             self._scan_positions
         )
+
+        # handle semiangle specified in pixels
+        if self._semiangle_cutoff_pixels:
+            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
+
         # Object Initialization
         if self._object is None:
             pad_x = self._object_padding_px[0][1]

From 901da2395efb6b911ce1e3f3afedbde260aea654 Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Sat, 24 Jun 2023 13:21:25 -0400
Subject: [PATCH 069/362] format with black

---
 .../process/phase/iterative_base_class.py     | 20 ++++++++++++-------
 .../iterative_mixedstate_ptychography.py      |  4 +++-
 .../iterative_multislice_ptychography.py      |  4 +++-
 .../iterative_overlap_magnetic_tomography.py  |  5 +++--
 .../phase/iterative_overlap_tomography.py     |  5 +++--
 .../iterative_simultaneous_ptychography.py    |  5 +++--
 .../iterative_singleslice_ptychography.py     |  4 +++-
 7 files changed, 31 insertions(+), 16 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index dcd1d0d97..322de95bd 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -198,7 +198,7 @@ def _preprocess_datacube_and_vacuum_probe(
                         output_size=diffraction_intensities_shape,
                         force_nonnegative=True,
                     )
-        
+
         if probe_roi_shape is not None:
             Qx, Qy = datacube.shape[-2:]
             Sx, Sy = probe_roi_shape
@@ -324,9 +324,9 @@ def _extract_intensities_and_calibrations_from_datacube(
             # there is no xor keyword in Python!
             angular = force_angular_sampling is not None
             reciprocal = force_reciprocal_sampling is not None
-            assert (angular and not reciprocal) or (not angular and reciprocal), (
-                "Only one of angular or reciprocal calibration can be forced!"
-            )
+            assert (angular and not reciprocal) or (
+                not angular and reciprocal
+            ), "Only one of angular or reciprocal calibration can be forced!"
 
             # angular calibration specified
             if angular:
@@ -335,7 +335,9 @@ def _extract_intensities_and_calibrations_from_datacube(
 
                 if self._energy is not None:
                     self._reciprocal_sampling = (
-                        force_angular_sampling / electron_wavelength_angstrom(self._energy) / 1e3,
+                        force_angular_sampling
+                        / electron_wavelength_angstrom(self._energy)
+                        / 1e3,
                     ) * 2
                     self._reciprocal_units = ("A^-1",) * 2
 
@@ -346,7 +348,9 @@ def _extract_intensities_and_calibrations_from_datacube(
 
                 if self._energy is not None:
                     self._angular_sampling = (
-                        force_reciprocal_sampling * electron_wavelength_angstrom(self._energy) * 1e3,
+                        force_reciprocal_sampling
+                        * electron_wavelength_angstrom(self._energy)
+                        * 1e3,
                     ) * 2
                     self._angular_units = ("mrad",) * 2
 
@@ -377,7 +381,9 @@ def _extract_intensities_and_calibrations_from_datacube(
 
                 if self._energy is not None:
                     self._angular_sampling = (
-                        reciprocal_size * electron_wavelength_angstrom(self._energy) * 1e3,
+                        reciprocal_size
+                        * electron_wavelength_angstrom(self._energy)
+                        * 1e3,
                     ) * 2
                     self._angular_units = ("mrad",) * 2
 
diff --git a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
index 4dea8172f..8d4574aa4 100644
--- a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
@@ -362,7 +362,9 @@ def preprocess(
 
         # handle semiangle specified in pixels
         if self._semiangle_cutoff_pixels:
-            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
+            self._semiangle_cutoff = (
+                self._semiangle_cutoff_pixels * self._angular_sampling[0]
+            )
 
         # Object Initialization
         if self._object is None:
diff --git a/py4DSTEM/process/phase/iterative_multislice_ptychography.py b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
index a9dcf2d41..36b44b77e 100644
--- a/py4DSTEM/process/phase/iterative_multislice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
@@ -437,7 +437,9 @@ def preprocess(
 
         # handle semiangle specified in pixels
         if self._semiangle_cutoff_pixels:
-            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
+            self._semiangle_cutoff = (
+                self._semiangle_cutoff_pixels * self._angular_sampling[0]
+            )
 
         # Object Initialization
         if self._object is None:
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 30e2b520f..7497183da 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -618,8 +618,9 @@ def preprocess(
 
         # handle semiangle specified in pixels
         if self._semiangle_cutoff_pixels:
-            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
-
+            self._semiangle_cutoff = (
+                self._semiangle_cutoff_pixels * self._angular_sampling[0]
+            )
 
         # Object Initialization
         if self._object is None:
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index a55a08697..82d1caac3 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -527,8 +527,9 @@ def preprocess(
 
         # handle semiangle specified in pixels
         if self._semiangle_cutoff_pixels:
-            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
-
+            self._semiangle_cutoff = (
+                self._semiangle_cutoff_pixels * self._angular_sampling[0]
+            )
 
         # Object Initialization
         if self._object is None:
diff --git a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
index ae302f660..9e4b39cf5 100644
--- a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
@@ -615,8 +615,9 @@ def preprocess(
 
         # handle semiangle specified in pixels
         if self._semiangle_cutoff_pixels:
-            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
-
+            self._semiangle_cutoff = (
+                self._semiangle_cutoff_pixels * self._angular_sampling[0]
+            )
 
         # Object Initialization
         if self._object is None:
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index c4c097f1b..6004b2a98 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -346,7 +346,9 @@ def preprocess(
 
         # handle semiangle specified in pixels
         if self._semiangle_cutoff_pixels:
-            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
+            self._semiangle_cutoff = (
+                self._semiangle_cutoff_pixels * self._angular_sampling[0]
+            )
 
         # Object Initialization
         if self._object is None:

From 76797a82672b62ad1c56b4c3ea04db5f62a9c8f9 Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Sat, 24 Jun 2023 13:45:10 -0400
Subject: [PATCH 070/362] first attempt at caching preprocessed object if not
 optimized

---
 py4DSTEM/process/phase/parameter_optimize.py | 30 ++++++++++++++++----
 1 file changed, 24 insertions(+), 6 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 987ffedef..ee8473be1 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -294,17 +294,35 @@ def _get_optimization_function(
         dictionary are used.
         """
 
-        # Construct partial methods to encapsulate the static parameters
-        obj = partial(cls, **init_static_args)
-        affine = partial(AffineTransform, **affine_static_args)
-        prep = partial(cls.preprocess, **preprocess_static_args)
-        recon = partial(cls.reconstruct, **reconstruct_static_args)
-
+        # Get lists of optimization parameters for each step
         init_params = list(init_optimization_params.keys())
         afft_params = list(affine_optimization_params.keys())
         prep_params = list(preprocess_optimization_params.keys())
         reco_params = list(reconstruct_optimization_params.keys())
 
+        # Construct partial methods to encapsulate the static parameters.
+        # If only ``reconstruct`` has optimization variables, perform
+        # preprocessing now, store the ptycho object, and use dummy
+        # functions instead of the partials
+        if (len(init_params),len(afft_params),len(prep_params)) == (0,0,0):
+            affine_preprocessed = AffineTransform(**affine_static_args)
+            init_args = init_static_args.copy()
+            init_args["initial_scan_positions"] = self._get_scan_positions(affine_preprocessed, init_static_args["datacube"])
+
+            ptycho_preprocessed = cls.__init__(**init_args).preprocess(**preprocess_static_args)
+
+            def obj(**kwargs):
+                return ptycho_preprocessed
+            def prep(ptycho,**kwargs):
+                return ptycho
+
+        else:
+            obj = partial(cls, **init_static_args)
+            affine = partial(AffineTransform, **affine_static_args)
+            prep = partial(cls.preprocess, **preprocess_static_args)
+
+        recon = partial(cls.reconstruct, **reconstruct_static_args)
+
         # Target function for Gaussian process optimization that takes a single
         # dict of named parameters and returns the ptycho error metric
         @use_named_args(parameter_list)

From abe8eab1056a1245634509b02b58c2c14f075c4c Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Sat, 24 Jun 2023 13:45:32 -0400
Subject: [PATCH 071/362] format with black

---
 py4DSTEM/process/phase/parameter_optimize.py | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index ee8473be1..292df27b6 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -304,16 +304,21 @@ def _get_optimization_function(
         # If only ``reconstruct`` has optimization variables, perform
         # preprocessing now, store the ptycho object, and use dummy
         # functions instead of the partials
-        if (len(init_params),len(afft_params),len(prep_params)) == (0,0,0):
+        if (len(init_params), len(afft_params), len(prep_params)) == (0, 0, 0):
             affine_preprocessed = AffineTransform(**affine_static_args)
             init_args = init_static_args.copy()
-            init_args["initial_scan_positions"] = self._get_scan_positions(affine_preprocessed, init_static_args["datacube"])
+            init_args["initial_scan_positions"] = self._get_scan_positions(
+                affine_preprocessed, init_static_args["datacube"]
+            )
 
-            ptycho_preprocessed = cls.__init__(**init_args).preprocess(**preprocess_static_args)
+            ptycho_preprocessed = cls.__init__(**init_args).preprocess(
+                **preprocess_static_args
+            )
 
             def obj(**kwargs):
                 return ptycho_preprocessed
-            def prep(ptycho,**kwargs):
+
+            def prep(ptycho, **kwargs):
                 return ptycho
 
         else:

From cf849140e9d078ef9a45da1bbc99fbb2b73b53d5 Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Sat, 24 Jun 2023 15:04:18 -0400
Subject: [PATCH 072/362] preprocess caching bug fixed

---
 py4DSTEM/process/phase/parameter_optimize.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 292df27b6..2e52a677a 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -311,7 +311,7 @@ def _get_optimization_function(
                 affine_preprocessed, init_static_args["datacube"]
             )
 
-            ptycho_preprocessed = cls.__init__(**init_args).preprocess(
+            ptycho_preprocessed = cls(**init_args).preprocess(
                 **preprocess_static_args
             )
 
@@ -323,9 +323,9 @@ def prep(ptycho, **kwargs):
 
         else:
             obj = partial(cls, **init_static_args)
-            affine = partial(AffineTransform, **affine_static_args)
             prep = partial(cls.preprocess, **preprocess_static_args)
 
+        affine = partial(AffineTransform, **affine_static_args)
         recon = partial(cls.reconstruct, **reconstruct_static_args)
 
         # Target function for Gaussian process optimization that takes a single
@@ -364,6 +364,7 @@ def _set_optimizer_defaults(self):
 
         self._reconstruction_static_args["progress_bar"] = False
         self._reconstruction_static_args["store_iterations"] = False
+        self._reconstruction_static_args["reset"] = True
 
 
 class OptimizationParameter:

From d7a1537bd56aa63dace33b39de6c10df670bb633 Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Sun, 25 Jun 2023 13:05:14 -0400
Subject: [PATCH 073/362] use log error for optimizer

---
 py4DSTEM/process/phase/parameter_optimize.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 2e52a677a..3676616a4 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -348,7 +348,7 @@ def f(**kwargs):
             prep(ptycho, **prep_args)
             recon(ptycho, **reco_args)
 
-            return ptycho.error
+            return np.log(ptycho.error)
 
         return f
 

From f04fc10d4bf31f5014bc7bde5dae40f80f11ebed Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Mon, 26 Jun 2023 19:55:04 -0700
Subject: [PATCH 074/362] fix for ws2 notebook

---
 py4DSTEM/process/diffraction/crystal_ACOM.py | 9 +++++----
 py4DSTEM/process/utils/elliptical_coords.py  | 2 +-
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/py4DSTEM/process/diffraction/crystal_ACOM.py b/py4DSTEM/process/diffraction/crystal_ACOM.py
index b303ee916..5c69a8ae2 100644
--- a/py4DSTEM/process/diffraction/crystal_ACOM.py
+++ b/py4DSTEM/process/diffraction/crystal_ACOM.py
@@ -776,7 +776,7 @@ def match_orientations(
     ):
 
         orientation = self.match_single_pattern(
-            bragg_peaks_array.get_pointlist(rx, ry),
+            bragg_peaks_array.cal[rx, ry],
             num_matches_return=num_matches_return,
             min_number_peaks=min_number_peaks,
             inversion_symmetry=inversion_symmetry,
@@ -1616,9 +1616,10 @@ def calculate_strain(
     # Initialize empty strain maps
     strain_map = RealSlice(
         data=np.zeros((
+            5,
             bragg_peaks_array.shape[0],
-            bragg_peaks_array.shape[1],
-            5)),
+            bragg_peaks_array.shape[1]
+            )),
         slicelabels=('e_xx','e_yy','e_xy','theta','mask'),
         name='strain_map')
     if mask_from_corr:
@@ -1646,7 +1647,7 @@ def calculate_strain(
         disable=not progress_bar,
         ):
         # Get bragg peaks from experiment and reference
-        p = bragg_peaks_array.get_pointlist(rx,ry)
+        p = bragg_peaks_array.cal[rx,ry]
 
         if p.data.shape[0] >= min_num_peaks:
             p_ref = self.generate_diffraction_pattern(
diff --git a/py4DSTEM/process/utils/elliptical_coords.py b/py4DSTEM/process/utils/elliptical_coords.py
index 8bc80db79..97291bc20 100644
--- a/py4DSTEM/process/utils/elliptical_coords.py
+++ b/py4DSTEM/process/utils/elliptical_coords.py
@@ -151,7 +151,7 @@ def cartesian_to_polarelliptical_transform(
             * **pp**: *(2D array)* meshgrid of the phi coordinates
     """
     if mask is None:
-        mask = np.ones_like(cartesianData, dtype=bool)
+        mask = np.ones_like(cartesianData.data, dtype=bool)
     assert (
         cartesianData.shape == mask.shape
     ), "Mask and cartesian data array shapes must match."

From f9598d180d7d09d53d525eae8537276e4f076f38 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 27 Jun 2023 18:00:51 -0400
Subject: [PATCH 075/362] bugfixes

---
 py4DSTEM/data/calibration.py                  | 613 ++++++++++++++----
 py4DSTEM/data/data.py                         |  89 ++-
 py4DSTEM/data/datacube.py                     | 221 ++++---
 py4DSTEM/data/propagating_calibration.py      |  69 +-
 py4DSTEM/io/__init__.py                       |   3 +-
 py4DSTEM/io/google_drive_downloader.py        | 145 ++++-
 py4DSTEM/io/read.py                           |  27 +
 py4DSTEM/io/sample_file_ids.py                |  93 ---
 py4DSTEM/visualize/show.py                    |   2 +-
 test/gettestdata.py                           |   4 +-
 test/test_braggvectors.py                     |   2 +-
 test/test_calibration.py                      |   2 +-
 test/test_native_io/test_calibration_io.py    |  64 +-
 test/test_native_io/test_realslice_read.py    |   2 +-
 test/test_native_io/test_single_object_io.py  | 362 +++++------
 test/test_native_io/test_v0_13.py             |   2 +-
 test/test_native_io/test_v0_14.py             |   4 +-
 test/test_native_io/test_v0_9.py              |   2 +-
 test/test_nonnative_io/test_dm.py             |   2 +-
 test/test_workflow/test_basics.py             |   2 +-
 .../test_disk_detection_basic.py              |   2 +-
 .../test_disk_detection_with_calibration.py   |   2 +-
 22 files changed, 1120 insertions(+), 594 deletions(-)

diff --git a/py4DSTEM/data/calibration.py b/py4DSTEM/data/calibration.py
index e96d61e8b..a9937612d 100644
--- a/py4DSTEM/data/calibration.py
+++ b/py4DSTEM/data/calibration.py
@@ -3,45 +3,185 @@
 import numpy as np
 from numbers import Number
 from typing import Optional
+from warnings import warn
 
-from emdfile import Metadata
-from py4DSTEM.data.propagating_calibration import propagating_calibration
+from emdfile import Metadata,Root
+from py4DSTEM.data.propagating_calibration import call_calibrate
 
 class Calibration(Metadata):
     """
     Stores calibration measurements.
 
-    Usage:
+    Usage
+    -----
+    For some calibration instance `c`
+
+        >>> c['x'] = y
+
+    will set the value of some calibration item called 'x' to y, and
+
+        >>> _y = c['x']
+
+    will return the value currently stored as 'x' and assign it to _y.
+    Additionally, for calibration items in the list `l` given below,
+    the syntax
 
-        >>> c = Calibration()
         >>> c.set_p(p)
         >>> p = c.get_p()
 
-    If the parameter has not been set, the getter methods return None. For
-    parameters with multiple values, they're returned as a tuple. If any of
-    the multiple values can't be found, a single None is returned instead.
-    Some parameters may have distinct values for each scan position; these
-    are stored as 2D arrays, and
+    is equivalent to
+
+        >>> c.p = p
+        >>> p = c.p
+
+    is equivalent to
+
+        >>> c['p'] = p
+        >>> p = c['p']
+
+    where in the first line of each couplet the parameter `p` is set and in
+    the second it's retrieved, for parameters p in the list
+
+                                                  calibrate
+                                                  ---------
+    l = [
+        Q_pixel_size,                                 *
+        R_pixel_size,                                 *
+        Q_pixel_units,                                *
+        R_pixel_units,                                *
+        qx0,
+        qy0,
+        qx0_mean,
+        qy0_mean,
+        qx0shift,
+        qy0shift,
+        origin,                                       *
+        origin_meas,
+        origin_meas_mask,
+        origin_shift,
+        a,                                            *
+        b,                                            *
+        theta,                                        *
+        p_ellipse,                                    *
+        ellipse,                                      *
+        QR_rotation_degrees,
+        QR_flip,
+        QR_rotflip,                                   *
+        probe_semiangle,
+        probe_param,
+        probe_center,
+        probe_convergence_semiangle_pixels,
+        probe_convergence_semiangle_mrad,
+    ]
+
+    There are two advantages to using the getter/setter syntax for parameters
+    in `l` (e.g. either c.set_p or c.p) instead of the normal dictionary-like
+    getter/setter syntax (i.e. c['p']).  These are (1) enabling retrieving
+    parameters by beam scan position, and (2) enabling propagation of any
+    calibration changes to downstream data objects which are affected by the
+    altered calibrations.  See below.
+
+    Get a parameter by beam scan position
+    -------------------------------------
+    Some parameters support retrieval by beam scan position.  In these cases,
+    calling
 
-        >>> c.get_p()
+        >>> c.get_p(rx,ry)
 
-    will return the entire 2D array, while
+    will return the value of parameter p at beam position (rx,ry). This works
+    only for the above syntax. Using either of
 
-        >>> c.get_p(rx,ry)
+        >>> c.p
+        >>> c['p']
+
+    will return an R-space shaped array.
+
+    Trigger downstream calibrations
+    -------------------------------
+    Some objects store their own internal calibration state, which depends on
+    the calibrations stored here.  For example, a DataCube stores dimension
+    vectors which calibrate its 4 dimensions, and which depend on the pixel
+    sizes and the origin position.
+
+    Modifying certain parameters therefore can trigger other objects which
+    depend on these parameters to re-calibrate themselves by calling their
+    .calibrate() method, if the object has one. Methods marked with a * in the
+    list `l` above have this property. Only objects registered with the
+    Calibration instance will have their .calibrate method triggered by changing
+    these parameters.  An object `data` can be registered by calling
+
+        >>> c.register_target( data )
+
+    and deregistered with
+
+        >>> c.deregister_target( data )
+
+    If an object without a .calibrate method is registerd when a * method is
+    called, nothing happens.
+
+    The .calibrate methods are triggered by setting some parameter `p` using
+    either
+
+        >>> c.set_p( val )
+
+    or
+
+        >>> c.p = val
+
+    syntax.  Setting the parameter with
+
+        >>> c['p'] = val
+
+    will not trigger re-calibrations.
+
+    Calibration + Data
+    ------------------
+    Data in py4DSTEM is stored in filetree like representations, and
+    Calibration instances are the top-level objects in these trees,
+    in that they live here:
+
+    Root
+      |--metadata
+      |     |-- *****---> calibration <---*****
+      |
+      |--some_object(e.g.datacube)
+      |     |--another_object(e.g.max_dp)
+      |             |--etc.
+      |--etc.
+      :
 
-    will return the value of `p` at position `rx,ry`.
+    Every py4DSTEM Data object has a tree with a calibration, and calling
 
-    The Calibration object is capable of automatically calling the ``calibrate`` method
-    of any other py4DSTEM objects when certain calibrations are updated. The methods
-    that trigger propagation of calibration information are tagged with the
-    @propagating_calibration decorator. Use the ``register_target`` method
-    to set up an object to recieve calls to ``calibrate``
+        >>> data.calibration
 
+    will return the that Calibration instance. See also the docstring
+    for the `Data` class.
+
+    Attaching an object to a different Calibration
+    ----------------------------------------------
+    To modify the calibration associated with an object's `data`, use
+
+        >>> c.attach( data )
+
+    where `c` is the new calibration instance `data` is to be associated
+    with. This (1) moves `data` into the top level of `c`'s data tree,
+    which means the new calibration will now be accessible normally at
+
+        >>> data.calibration
+
+    and (2) if and only if `data` was registered with its old calibration,
+    de-registers it there and registers it with the new calibration. If
+    `data` was not registered with the old calibration and it should be
+    registered with the new one, `c.register_target( data )` should be
+    called.
+
+    To attach `data` to a different location in the calibration instance's
+    tree, use `data.attach( node )`. See the Data.attach docstring.
     """
     def __init__(
         self,
         name: Optional[str] = 'calibration',
-        datacube = None
+        root: Optional[Root] = None,
         ):
         """
         Args:
@@ -49,15 +189,18 @@ def __init__(
         """
         Metadata.__init__(
             self,
-            name=name)
+            name=name
+        )
+
+        # Set the root
+        if root is None:
+            root = Root( name="py4DSTEM_root" )
+        self.set_root(root)
 
         # List to hold objects that will re-`calibrate` when
         # certain properties are changed
         self._targets = []
 
-        # set datacube
-        self._datacube = datacube
-
         # set initial pixel values
         self.set_Q_pixel_size(1)
         self.set_R_pixel_size(1)
@@ -65,97 +208,141 @@ def __init__(
         self.set_R_pixel_units('pixels')
 
 
-
-    # datacube
-
+    # EMD root property
     @property
-    def datacube(self):
-        return self._datacube
+    def root(self):
+        return _root
+    @root.setter
+    def root(self):
+        raise Exception("Calibration.root does not support assignment; to change the root, use self.set_root")
+    def set_root(self,root):
+        assert(isinstance(root,Root)), f"root must be a Root, not type {type(root)}"
+        self._root = root
+
+
+    # Attach data to the calibration instance
+    def attach(self,data):
+        """
+        Attach `data` to this calibration instance, placing it in the top
+        level of the Calibration instance's tree. If `data` was in a
+        different data tree, remove it. If `data` was registered with
+        a different calibration instance, de-register it there and
+        register it here. If `data` was not previously registerd and it
+        should be, after attaching it run `self.register_target(data)`.
+        """
+        from py4DSTEM.data import Data
+        assert(isinstance(data,Data)), f"data must be a Data instance"
+        data.attach(self.root)
 
 
+    # Register for auto-calibration
+    def register_target(self,new_target):
+        """
+        Register an object to recieve calls to it `calibrate`
+        method when certain calibrations get updated
+        """
+        if new_target not in self._targets:
+            self._targets.append(new_target)
 
+    def unregister_target(self,target):
+        """
+        Unlink an object from recieving calls to `calibrate` when
+        certain calibration values are changed
+        """
+        if target in self._targets:
+            self._targets.remove(target)
+
+    @property
+    def targets(self):
+        return tuple(self._targets)
 
-    ### getter/setter methods
 
 
+    ######### Begin Calibration Metadata Params #########
 
     # pixel size/units
 
-    @propagating_calibration
+    @call_calibrate
     def set_Q_pixel_size(self,x):
-        if self._has_datacube():
-            self.datacube.set_dim(2,x)
-            self.datacube.set_dim(3,x)
         self._params['Q_pixel_size'] = x
     def get_Q_pixel_size(self):
         return self._get_value('Q_pixel_size')
+    # aliases
+    @property
+    def Q_pixel_size(self):
+        return self.get_Q_pixel_size()
+    @Q_pixel_size.setter
+    def Q_pixel_size(self,x):
+        self.set_Q_pixel_size(x)
+    @property
+    def qpixsize(self):
+        return self.get_Q_pixel_size()
+    @qpixsize.setter
+    def qpixsize(self,x):
+        self.set_Q_pixel_size(x)
 
-    @propagating_calibration
+    @call_calibrate
     def set_R_pixel_size(self,x):
-        if self._has_datacube():
-            self.datacube.set_dim(0,x)
-            self.datacube.set_dim(1,x)
         self._params['R_pixel_size'] = x
     def get_R_pixel_size(self):
         return self._get_value('R_pixel_size')
+    # aliases
+    @property
+    def R_pixel_size(self):
+        return self.get_R_pixel_size()
+    @R_pixel_size.setter
+    def R_pixel_size(self,x):
+        self.set_R_pixel_size(x)
+    @property
+    def qpixsize(self):
+        return self.get_R_pixel_size()
+    @qpixsize.setter
+    def qpixsize(self,x):
+        self.set_R_pixel_size(x)
 
-    @propagating_calibration
+    @call_calibrate
     def set_Q_pixel_units(self,x):
         assert(x in ('pixels','A^-1','mrad')), f"Q pixel units must be 'A^-1', 'mrad' or 'pixels'."
-        if self._has_datacube():
-            self.datacube.set_dim_units(2,x)
-            self.datacube.set_dim_units(3,x)
         self._params['Q_pixel_units'] = x
     def get_Q_pixel_units(self):
         return self._get_value('Q_pixel_units')
+    # aliases
+    @property
+    def Q_pixel_units(self):
+        return self.get_Q_pixel_units()
+    @Q_pixel_units.setter
+    def Q_pixel_units(self,x):
+        self.set_Q_pixel_units(x)
+    @property
+    def qpixunits(self):
+        return self.get_Q_pixel_units()
+    @qpixunits.setter
+    def qpixunits(self,x):
+        self.set_Q_pixel_units(x)
 
-    @propagating_calibration
+    @call_calibrate
     def set_R_pixel_units(self,x):
-        if self._has_datacube():
-            self.datacube.set_dim_units(0,x)
-            self.datacube.set_dim_units(1,x)
         self._params['R_pixel_units'] = x
     def get_R_pixel_units(self):
         return self._get_value('R_pixel_units')
-
-
-
-    # datacube shape
-
-    def get_R_Nx(self):
-        self._validate_datacube()
-        return self.datacube.R_Nx
-    def get_R_Ny(self):
-        self._validate_datacube()
-        return self.datacube.R_Ny
-    def get_Q_Nx(self):
-        self._validate_datacube()
-        return self.datacube.Q_Nx
-    def get_Q_Ny(self):
-        self._validate_datacube()
-        return self.datacube.Q_Ny
-    def get_datacube_shape(self):
-        self._validate_datacube()
-        """ (R_Nx,R_Ny,Q_Nx,Q_Ny)
-        """
-        return self.datacube.data.dshape
-    def get_Qshape(self,x):
-        self._validate_datacube()
-        return self.data.Qshape
-    def get_Rshape(self,x):
-        self._validate_datacube()
-        return self.data.Rshape
-
-    # is there a datacube?
-    def _validate_datacube(self):
-        assert(self.datacube is not None), "Can't find shape attr because Calibration doesn't point to a DataCube"
-    def _has_datacube(self):
-        return(self.datacube is not None)
-
-
+    # aliases
+    @property
+    def R_pixel_units(self):
+        return self.get_R_pixel_units()
+    @R_pixel_units.setter
+    def R_pixel_units(self,x):
+        self.set_R_pixel_units(x)
+    @property
+    def rpixunits(self):
+        return self.get_R_pixel_units()
+    @rpixunits.setter
+    def rpixunits(self,x):
+        self.set_R_pixel_units(x)
 
 
     # origin
+
+    # qx0,qy0
     def set_qx0(self,x):
         self._params['qx0'] = x
         x = np.asarray(x)
@@ -203,7 +390,60 @@ def set_origin_meas_mask(self,x):
     def get_origin_meas_mask(self,rx=None,ry=None):
         return self._get_value('origin_meas_mask',rx,ry)
 
-    @propagating_calibration
+    # aliases
+    @property
+    def qx0(self):
+        return self.get_qx0()
+    @qx0.setter
+    def qx0(self,x):
+        self.set_qx0(x)
+    @property
+    def qx0_mean(self):
+        return self.get_qx0_mean()
+    @qx0_mean.setter
+    def qx0_mean(self,x):
+        self.set_qx0_mean(x)
+    @property
+    def qx0shift(self):
+        return self.get_qx0shift()
+    @property
+    def qy0(self):
+        return self.get_qy0()
+    @qy0.setter
+    def qy0(self,x):
+        self.set_qy0(x)
+    @property
+    def qy0_mean(self):
+        return self.get_qy0_mean()
+    @qy0_mean.setter
+    def qy0_mean(self,x):
+        self.set_qy0_mean(x)
+    @property
+    def qy0_shift(self):
+        return self.get_qy0_shift()
+    @property
+    def qx0_meas(self):
+        return self.get_qx0_meas()
+    @qx0_meas.setter
+    def qx0_meas(self,x):
+        self.set_qx0_meas(x)
+    @property
+    def qy0_meas(self):
+        return self.get_qy0_meas()
+    @qy0_meas.setter
+    def qy0_meas(self,x):
+        self.set_qy0_meas(x)
+    @property
+    def origin_meas_mask(self):
+        return self.get_origin_meas_mask()
+    @origin_meas_mask.setter
+    def origin_meas_mask(self,x):
+        self.set_origin_meas_mask(x)
+
+
+    # origin = (qx0,qy0)
+
+    @call_calibrate
     def set_origin(self,x):
         """
         Args:
@@ -252,44 +492,43 @@ def get_origin_meas(self,rx=None,ry=None):
             ans = None
         return ans
 
-    def set_probe_semiangle(self,x):
-        self._params['probe_semiangle'] = x
-    def get_probe_semiangle(self):
-        return self._get_value('probe_semiangle')
-    def set_probe_param(self, x):
-        """
-        Args:
-            x (3-tuple): (probe size, x0, y0)
-        """
-        probe_semiangle, qx0, qy0 = x
-        self.set_probe_semiangle(probe_semiangle)
-        self.set_qx0_mean(qx0)
-        self.set_qy0_mean(qy0)
-    def get_probe_param(self):
-        probe_semiangle = self._get_value('probe_semiangle')
-        qx0 = self._get_value('qx0')
-        qy0 = self._get_value('qy0')
-        ans = (probe_semiangle,qx0,qy0)
-        if any([x is None for x in ans]):
-            ans = None
-        return ans
+    # aliases
+    @property
+    def origin(self):
+        return self.get_origin()
+    @origin.setter
+    def origin(self,x):
+        self.set_origin(x)
+    @property
+    def origin_meas(self):
+        return self.get_origin_meas()
+    @origin_meas.setter
+    def origin_meas(self,x):
+        self.set_origin_meas(x)
+    @property
+    def origin_shift(self):
+        return self.get_origin_shift()
 
 
     # ellipse
+
+    @call_calibrate
     def set_a(self,x):
         self._params['a'] = x
     def get_a(self,rx=None,ry=None):
         return self._get_value('a',rx,ry)
+    @call_calibrate
     def set_b(self,x):
         self._params['b'] = x
     def get_b(self,rx=None,ry=None):
         return self._get_value('b',rx,ry)
+    @call_calibrate
     def set_theta(self,x):
         self._params['theta'] = x
     def get_theta(self,rx=None,ry=None):
         return self._get_value('theta',rx,ry)
 
-    @propagating_calibration
+    @call_calibrate
     def set_ellipse(self,x):
         """
         Args:
@@ -300,7 +539,7 @@ def set_ellipse(self,x):
         self._params['b'] = b
         self._params['theta'] = theta
 
-    @propagating_calibration
+    @call_calibrate
     def set_p_ellipse(self,x):
         """
         Args:
@@ -323,7 +562,42 @@ def get_p_ellipse(self,rx=None,ry=None):
         a,b,theta = self.get_ellipse(rx,ry)
         return (qx0,qy0,a,b,theta)
 
+    # aliases
+    @property
+    def a(self):
+        return self.get_a()
+    @a.setter
+    def a(self,x):
+        self.set_a(x)
+    @property
+    def b(self):
+        return self.get_b()
+    @b.setter
+    def b(self,x):
+        self.set_b(x)
+    @property
+    def theta(self):
+        return self.get_theta()
+    @theta.setter
+    def theta(self,x):
+        self.set_theta(x)
+    @property
+    def p_ellipse(self):
+        return self.get_p_ellipse()
+    @p_ellipse.setter
+    def p_ellipse(self,x):
+        self.set_p_ellipse(x)
+    @property
+    def ellipse(self):
+        return self.get_ellipse()
+    @ellipse.setter
+    def ellipse(self,x):
+        self.set_ellipse(x)
+
+
+
     # Q/R-space rotation and flip
+
     def set_QR_rotation_degrees(self,x):
         self._params['QR_rotation_degrees'] = x
     def get_QR_rotation_degrees(self):
@@ -334,7 +608,7 @@ def set_QR_flip(self,x):
     def get_QR_flip(self):
         return self._get_value('QR_flip')
 
-    @propagating_calibration
+    @call_calibrate
     def set_QR_rotflip(self, rot_flip):
         """
         Args:
@@ -352,21 +626,113 @@ def get_QR_rotflip(self):
             return None
         return (rot,flip)
 
+    # aliases
+    @property
+    def QR_rotation_degrees(self):
+        return self.get_QR_rotation_degrees()
+    @QR_rotation_degrees.setter
+    def QR_rotation_degrees(self,x):
+        self.set_QR_rotation_degrees(x)
+    @property
+    def QR_flip(self):
+        return self.get_QR_flip()
+    @QR_flip.setter
+    def QR_flip(self,x):
+        self.set_QR_flip(x)
+    @property
+    def QR_rotflip(self):
+        return self.get_QR_rotflip()
+    @QR_rotflip.setter
+    def QR_rotflip(self,x):
+        self.set_QR_rotflip(x)
+
+
+
+
 
     # probe
+
+    def set_probe_semiangle(self,x):
+        self._params['probe_semiangle'] = x
+    def get_probe_semiangle(self):
+        return self._get_value('probe_semiangle')
+    def set_probe_param(self, x):
+        """
+        Args:
+            x (3-tuple): (probe size, x0, y0)
+        """
+        probe_semiangle, qx0, qy0 = x
+        self.set_probe_semiangle(probe_semiangle)
+        self.set_qx0_mean(qx0)
+        self.set_qy0_mean(qy0)
+    def get_probe_param(self):
+        probe_semiangle = self._get_value('probe_semiangle')
+        qx0 = self._get_value('qx0')
+        qy0 = self._get_value('qy0')
+        ans = (probe_semiangle,qx0,qy0)
+        if any([x is None for x in ans]):
+            ans = None
+        return ans
+
     def set_convergence_semiangle_pixels(self,x):
         self._params['convergence_semiangle_pixels'] = x
     def get_convergence_semiangle_pixels(self):
         return self._get_value('convergence_semiangle_pixels')
-    def set_convergence_semiangle_pixels(self,x):
+    def set_convergence_semiangle_mrad(self,x):
         self._params['convergence_semiangle_mrad'] = x
-    def get_convergence_semiangle_pixels(self):
+    def get_convergence_semiangle_mrad(self):
         return self._get_value('convergence_semiangle_mrad')
     def set_probe_center(self,x):
         self._params['probe_center'] = x
     def get_probe_center(self):
         return self._get_value('probe_center')
 
+    #aliases
+    @property
+    def probe_semiangle(self):
+        return self.get_probe_semiangle()
+    @probe_semiangle.setter
+    def probe_semiangle(self,x):
+        self.set_probe_semiangle(x)
+    @property
+    def probe_param(self):
+        return self.get_probe_param()
+    @probe_param.setter
+    def probe_param(self,x):
+        self.set_probe_param(x)
+    @property
+    def probe_center(self):
+        return self.get_probe_center()
+    @probe_center.setter
+    def probe_center(self,x):
+        self.set_probe_center(x)
+    @property
+    def probe_convergence_semiangle_pixels(self):
+        return self.get_probe_convergence_semiangle_pixels()
+    @probe_convergence_semiangle_pixels.setter
+    def probe_convergence_semiangle_pixels(self,x):
+        self.set_probe_convergence_semiangle_pixels(x)
+    @property
+    def probe_convergence_semiangle_mrad(self):
+        return self.get_probe_convergence_semiangle_mrad()
+    @probe_convergence_semiangle_mrad.setter
+    def probe_convergence_semiangle_mrad(self,x):
+        self.set_probe_convergence_semiangle_mrad(x)
+
+
+
+
+
+    ######## End Calibration Metadata Params ########
+
+
+
+    # calibrate targets
+    @call_calibrate
+    def calibrate(self):
+        pass
+
+
 
     # For parameters which can have 2D or (2+n)D array values,
     # this function enables returning the value(s) at a 2D position,
@@ -399,31 +765,24 @@ def copy(self,name=None):
         return cal
 
 
-    # Methods for assigning objects which will be
-    # auto-calibrated when the Calibration instance is updated
-
-    def register_target(self,new_target):
-        """
-        Register an object to recieve calls to it `calibrate`
-        method when certain calibrations get updated
-        """
-        self._targets.append(new_target)
-
-    def unregister_target(self,target):
-        """
-        Unlink an object from recieving calls to `calibrate` when
-        certain calibration values are changed
-        """
-        if target in self._targets:
-            self._targets.remove(target)
-
 
     # HDF5 i/o
 
     # write is inherited from Metadata
+    def to_h5(self,group):
+        """
+        Saves the metadata dictionary _params to group, then adds the
+        calibration's target's list
+        """
+        # Add targets list to metadata
+        targets = [x._treepath for x in self.targets]
+        self['_target_paths'] = targets
+        # Save the metadata
+        Metadata.to_h5(self,group)
 
     # read
-    def from_h5(group):
+    @classmethod
+    def from_h5(cls,group):
         """
         Takes a valid group for an HDF5 file object which is open in
         read mode. Determines if it's a valid Metadata representation, and
diff --git a/py4DSTEM/data/data.py b/py4DSTEM/data/data.py
index 0f6d10d52..c2c4aef50 100644
--- a/py4DSTEM/data/data.py
+++ b/py4DSTEM/data/data.py
@@ -1,5 +1,5 @@
 # Base class for all py4DSTEM data
-# which adds a pointer to 'calibration' metadata
+# which adds an EMD root and a pointer to 'calibration' metadata
 
 import warnings
 
@@ -8,26 +8,80 @@
 
 
 class Data:
+    """
+    Data in py4DSTEM is stored in filetree like representations, e.g.
+
+    Root
+      |--metadata
+      |     |--calibration
+      |
+      |--some_object(e.g.datacube)
+      |     |--another_object(e.g.max_dp)
+      |             |--etc.
+      |
+      |--one_more_object(e.g.crystal)
+      |     |--etc.
+      :
+
+    In a Python interpreter, do
+
+        >>> data.tree(True)
+
+    to display the data tree of Data instance `data`, and
+
+        >>> data.tree()
+
+    to display the tree of from the current node on, i.e. the branch
+    downstream of `data`.
+
+    Every object can access the calibrations which live in the root metadata
+    of its tree with
+
+        >>> data.calibration
+
+    which returns the calibrations, or, if none are found, raises a warning
+    and returns None.
+
+    Some objects should be modified when the calibrations change - these
+    objects must have .calibrate() method, which is called any time relevant
+    calibration parameters change if the object has been registered with
+    the calibrations.
+
+    To transfer `data` from it's current tree to another existing tree, use
+
+        >>> data.attach(some_other_data)
+
+    which will move the data to the new tree. If the data was registered with
+    it's old calibrations, this will also de-register it there and register
+    it with the new calibrations such that .calibrate() is called when it
+    should be.
+
+    See also the Calibration docstring.
+    """
 
     def __init__(
         self,
-        setup_tree = True,
         calibration = None
         ):
-        assert(isinstance(self,Node)), "Data instances must alse inherit from Node"
+        assert(isinstance(self,Node)), "Data instances must inherit from Node"
         pass
 
-        if setup_tree:
-            # set up EMD tree
+        # set up calibration + EMD tree
+        if calibration is None:
             root = Root( name = self.name+"_root" )
             root.tree( self )
-
-            # set up calibration
-            calibration = Calibration() if calibration is None else calibration
-            self._setup_calibration( calibration )
+            self.calibration = Calibration()
+        else:
+            assert(isinstance(calibration,Calibration)), f"`calibration` must be a Calibration, not type {type(calibration)}"
+            self.calibration = calibration
+            if calibration.root is None:
+                calibration._root = Root( name = self.name+"_root" )
+                calibration.root.tree( self )
+            else:
+                calibration.root.tree( self )
 
 
-    # calibration
+    # calibration property
 
     @property
     def calibration(self):
@@ -49,6 +103,21 @@ def calibration(self, x):
         self.root.metadata['calibration'] = x
 
 
+    # transfer trees
+
+    def attach(self,node):
+        """
+        Moves self to `node`'s tree, attaching to node's calibration and detaching
+        from the current calibration.
+        """
+        assert(isinstance(node,Node)), f"node must be a Node, not type {type(node)}"
+        assert(hasattr(node,'calibration')), "node must have a calibration"
+        if self in self.calibration._targets:
+            register = True
+            self.calibration.unregister_target(self)
+        node.graft(self)
+        if register:
+            self.calibration.register_target(self)
 
 
 
diff --git a/py4DSTEM/data/datacube.py b/py4DSTEM/data/datacube.py
index c573b7e30..775ca75a8 100644
--- a/py4DSTEM/data/datacube.py
+++ b/py4DSTEM/data/datacube.py
@@ -10,7 +10,6 @@
 
 
 
-
 class DataCube(Array,Data):
     """
     Storage and processing methods for 4D-STEM datasets.
@@ -21,7 +20,6 @@ def __init__(
         data: np.ndarray,
         name: Optional[str] = 'datacube',
         slicelabels: Optional[Union[bool,list]] = None,
-        setup_tree: Optional[bool] = True,
         calibration: Optional[Union[Calibration,None]] = None,
         ):
         """
@@ -31,7 +29,6 @@ def __init__(
             calibration (None or Calibration or 'pass'): default (None)
                 creates and attaches a new Calibration instance to root
                 metadata, or, passing a Calibration instance uses this instead.
-                'skip' is for internal use for the reader
             slicelabels (None or list): names for slices if this is a
                 stack of datacubes
 
@@ -56,114 +53,103 @@ def __init__(
         # initialize as Data
         Data.__init__(
             self,
-            setup_tree,
             calibration
         )
 
+        # register with calibration
+        self.calibration.register_target(self)
+
         # cartesian coords
-        # TODO - tmp hack, needs to be refactored -
-        # this will break when preprocess methods are called
-        self.qyy,self.qxx = np.meshgrid(
-            np.arange(0,self.Q_Ny),
-            np.arange(0,self.Q_Nx)
-        )
+        self.calibrate()
 
         # polar coords
         self.polar = None
 
 
 
-    def _setup_calibration(self, cal):
-        """
-        Ensures that a calibration instance exists. Passing None
-        makes a new Calibration instance, puts it in root.calibration, and
-        makes a two way link. Passing a Calibration instance attaches that
-        instance. `'skip'` does nothing (internal use, on read from file).
-        """
-        if cal is None:
-            self.calibration = Calibration( datacube = self )
-        elif cal == 'skip':
-            pass
-        else:
-            assert(isinstance(cal, Calibration)), "`calibration` must be a Calibration instance, not type f{type(cal)}"
-            self.calibration = cal
-            cal._datacube = self
 
-
-    def copy(self):
+    def calibrate(self):
         """
-        Copys datacube
+        Calibrate the coordinate axes of the datacube. Using the calibrations
+        at self.calibration, sets the 4 dim vectors (Qx,Qy,Rx,Ry) according
+        to the pixel size, units and origin positions, then updates the
+        meshgrids representing Q and R space.
         """
-        from py4DSTEM import DataCube
-        new_datacube = DataCube(
-            data = self.data.copy(),
-            name = self.name,
-            calibration = self.calibration.copy(),
-            slicelabels = self.slicelabels,
-        )
+        assert(self.calibration is not None), "No calibration found!"
 
-        Qpixsize  = new_datacube.calibration.get_Q_pixel_size()
-        Qpixunits = new_datacube.calibration.get_Q_pixel_units()
-        Rpixsize  = new_datacube.calibration.get_R_pixel_size()
-        Rpixunits = new_datacube.calibration.get_R_pixel_units()
+        # Get calibration values
+        rpixsize = self.calibration.get_R_pixel_size()
+        rpixunits = self.calibration.get_R_pixel_units()
+        qpixsize = self.calibration.get_Q_pixel_size()
+        qpixunits = self.calibration.get_Q_pixel_units()
+        origin = self.calibration.get_origin_mean()
+        if origin is None or origin==(None,None):
+            origin = (0,0)
 
-        new_datacube.set_dim(
+        # Calc dim vectors
+        dim_rx = np.arange(self.R_Nx)*rpixsize
+        dim_ry = np.arange(self.R_Ny)*rpixsize
+        dim_qx = -origin[0] + np.arange(self.Q_Nx)*qpixsize
+        dim_qy = -origin[1] + np.arange(self.Q_Ny)*qpixsize
+
+        # Set dim vectors
+        self.set_dim(
             0,
-            [0,Rpixsize],
-            units = Rpixunits,
-            name = 'Rx'
+            dim_rx,
+            units = rpixunits
         )
-        new_datacube.set_dim(
+        self.set_dim(
             1,
-            [0,Rpixsize],
-            units = Rpixunits,
-            name = 'Ry'
+            dim_ry,
+            units = rpixunits
         )
-
-        new_datacube.set_dim(
+        self.set_dim(
             2,
-            [0,Qpixsize],
-            units = Qpixunits,
-            name = 'Qx'
+            dim_qx,
+            units = qpixunits
         )
-        new_datacube.set_dim(
+        self.set_dim(
             3,
-            [0,Qpixsize],
-            units = Qpixunits,
-            name = 'Qy'
+            dim_qy,
+            units = qpixunits
         )
 
-        return new_datacube
+        # Set meshgrids
+        self._qxx,self._qyy = np.meshgrid( dim_qx,dim_qy )
+        self._rxx,self._ryy = np.meshgrid( dim_rx,dim_ry )
 
 
-    # properties
 
-
-    ## pixel size / units
-
-    # Q 
+    # coordinate meshgrids
     @property
-    def Q_pixel_size(self):
-        return self.calibration.get_Q_pixel_size()
+    def rxx(self):
+        return self._rxx
     @property
-    def Q_pixel_units(self):
-        return self.calibration.get_Q_pixel_units()
-
-    # R
+    def ryy(self):
+        return self._ryy
     @property
-    def R_pixel_size(self):
-        return self.calibration.get_R_pixel_size()
+    def qxx(self):
+        return self._qxx
     @property
-    def R_pixel_units(self):
-        return self.calibration.get_R_pixel_units()
+    def qyy(self):
+        return self._qyy
+
+    # coordinate meshgrids with shifted origin
+    def qxxs(self,rx,ry):
+        qx0_shift = self.calibration.get_qx0shift(rx,ry)
+        if qx0_shift is None:
+            raise Exception("Can't compute shifted meshgrid - origin shift is not defined")
+        return qxx - qx0_shift
+    def qyys(self,rx,ry):
+        qy0_shift = self.calibration.get_qy0shift(rx,ry)
+        if qy0_shift is None:
+            raise Exception("Can't compute shifted meshgrid - origin shift is not defined")
+        return qyy - qy0_shift
 
-    # aliases
-    qpixsize = Q_pixel_size
-    qpixunit = Q_pixel_units
-    rpixsize = R_pixel_size
-    rpixunit = R_pixel_units
 
 
+    # shape properties
+
     ## shape
 
     # FOV
@@ -202,6 +188,85 @@ def R_N(self):
 
 
 
+    ## pixel size / units
+
+    # Q 
+    @property
+    def Q_pixel_size(self):
+        return self.calibration.get_Q_pixel_size()
+    @property
+    def Q_pixel_units(self):
+        return self.calibration.get_Q_pixel_units()
+
+    # R
+    @property
+    def R_pixel_size(self):
+        return self.calibration.get_R_pixel_size()
+    @property
+    def R_pixel_units(self):
+        return self.calibration.get_R_pixel_units()
+
+    # aliases
+    qpixsize = Q_pixel_size
+    qpixunit = Q_pixel_units
+    rpixsize = R_pixel_size
+    rpixunit = R_pixel_units
+
+
+
+
+
+
+    def copy(self):
+        """
+        Copys datacube
+        """
+        from py4DSTEM import DataCube
+        new_datacube = DataCube(
+            data = self.data.copy(),
+            name = self.name,
+            calibration = self.calibration.copy(),
+            slicelabels = self.slicelabels,
+        )
+
+        Qpixsize  = new_datacube.calibration.get_Q_pixel_size()
+        Qpixunits = new_datacube.calibration.get_Q_pixel_units()
+        Rpixsize  = new_datacube.calibration.get_R_pixel_size()
+        Rpixunits = new_datacube.calibration.get_R_pixel_units()
+
+        new_datacube.set_dim(
+            0,
+            [0,Rpixsize],
+            units = Rpixunits,
+            name = 'Rx'
+        )
+        new_datacube.set_dim(
+            1,
+            [0,Rpixsize],
+            units = Rpixunits,
+            name = 'Ry'
+        )
+
+        new_datacube.set_dim(
+            2,
+            [0,Qpixsize],
+            units = Qpixunits,
+            name = 'Qx'
+        )
+        new_datacube.set_dim(
+            3,
+            [0,Qpixsize],
+            units = Qpixunits,
+            name = 'Qy'
+        )
+
+        return new_datacube
+
+
+
+
+
+
 
 
     # I/O
@@ -223,7 +288,7 @@ def _get_constructor_args(cls,group):
             'data': ar_args['data'],
             'name': ar_args['name'],
             'slicelabels': ar_args['slicelabels'],
-            'calibration': 'skip'
+            'calibration': None
         }
 
         return args
diff --git a/py4DSTEM/data/propagating_calibration.py b/py4DSTEM/data/propagating_calibration.py
index 8b1196ee6..fa34f1468 100644
--- a/py4DSTEM/data/propagating_calibration.py
+++ b/py4DSTEM/data/propagating_calibration.py
@@ -1,13 +1,17 @@
+# Define decorators call_* which, when used to decorate class methods,
+# calls all objects in a list _targets? to call some method *.
+
 import warnings
 
-class propagating_calibration(object):
+
+# This is the abstract pattern:
+
+class call_method(object):
     """
-    A decorator which, when attached to a method of Calibration,
-    causes `calibrate` to be called on any objects in the
-    Calibration object's `_targets` list, following execution of
+    A decorator which, when attached to a method of SomeClass,
+    causes `method` to be called on any objects in the
+    instance's `_targets` list, following execution of
     the decorated function.
-    This allows objects associated with the Calibration to
-    automatically respond to changes in the calibration state.
     """
     def __init__(self, func):
         self.func = func
@@ -15,21 +19,22 @@ def __init__(self, func):
     def __call__(self, *args, **kwargs):
         """
         Update the parameters the caller wanted by calling the wrapped
-        method, then loop through the list of targetsand call their
+        method, then loop through the list of targets and call their
         `calibrate` methods.
         """
         self.func(*args,**kwargs)
-
-        calibration = args[0]
-        assert hasattr(calibration, "_targets"), "Calibration object appears to be in an invalid state. _targets attribute is missing."
-        for target in calibration._targets:
-            if hasattr(target,'calibrate') and callable(target.calibrate):
+        some_object = args[0]
+        assert hasattr(some_object, "_targets"), "SomeObject object appears to be in an invalid state. _targets attribute is missing."
+        for target in some_object._targets:
+            if hasattr(target,'method') and callable(target,method):
                 try:
-                    target.calibrate()
+                    target.method()
                 except Exception as err:
-                    print(f"Attempted to calibrate object {target} but this raised an error: {err}")
+                    print(f"Attempted to call .method(), but this raised an error: {err}")
             else:
-                warnings.warn(f"{target} is registered as a target for calibration propagation but does not appear to have a calibrate() method")
+                # warn or pass or error out here, as needs be
+                #pass
+                warnings.warn(f"{target} is registered as a target but does not appear to have a .method() callable")
 
     def __get__(self, instance, owner):
         """
@@ -44,3 +49,37 @@ def __get__(self, instance, owner):
         from functools import partial
         return partial(self.__call__, instance)
 
+
+# This is a functional decorator, @call_calibrate:
+
+# calls: calibrate()
+# targets: _targets
+
+class call_calibrate(object):
+    """
+    Decorated methods cause all targets in _targets to call .calibrate().
+    """
+    def __init__(self, func):
+        self.func = func
+
+    def __call__(self, *args, **kwargs):
+        """
+        """
+        self.func(*args,**kwargs)
+        calibration = args[0]
+        assert hasattr(calibration, "_targets"), "Calibration object appears to be in an invalid state. _targets attribute is missing."
+        for target in calibration._targets:
+            if hasattr(target,'calibrate') and callable(target.calibrate):
+                try:
+                    target.calibrate()
+                except Exception as err:
+                    print(f"Attempted to calibrate object {target} but this raised an error: {err}")
+            else:
+                pass
+
+    def __get__(self, instance, owner):
+        """
+        """
+        from functools import partial
+        return partial(self.__call__, instance)
+
diff --git a/py4DSTEM/io/__init__.py b/py4DSTEM/io/__init__.py
index 71a0f2dd5..80b591f8a 100644
--- a/py4DSTEM/io/__init__.py
+++ b/py4DSTEM/io/__init__.py
@@ -6,8 +6,7 @@
 
 
 # google downloader
-from py4DSTEM.io.google_drive_downloader import gdrive_download
-from py4DSTEM.io.sample_file_ids import get_sample_file_ids
+from py4DSTEM.io.google_drive_downloader import gdrive_download, get_sample_file_ids
 
 
 
diff --git a/py4DSTEM/io/google_drive_downloader.py b/py4DSTEM/io/google_drive_downloader.py
index a4ff72abe..c8b410d47 100644
--- a/py4DSTEM/io/google_drive_downloader.py
+++ b/py4DSTEM/io/google_drive_downloader.py
@@ -1,7 +1,127 @@
 import gdown
 import os
 
-from py4DSTEM.io.sample_file_ids import file_ids, collection_ids
+
+### File IDs
+
+# single files
+file_ids = {
+    'sample_diffraction_pattern' : (
+        'a_diffraction_pattern.h5',
+        '1ymYMnuDC0KV6dqduxe2O1qafgSd0jjnU',
+    ),
+    'Au_sim' : (
+        'Au_sim.h5',
+        '1PmbCYosA1eYydWmmZebvf6uon9k_5g_S',
+    ),
+    'carbon_nanotube' : (
+        'carbon_nanotube.h5',
+        '1bHv3u61Cr-y_GkdWHrJGh1lw2VKmt3UM',
+    ),
+    'Si_SiGe_exp' : (
+        'Si_SiGe_exp.h5',
+        '1fXNYSGpe6w6E9RBA-Ai_owZwoj3w8PNC',
+    ),
+    'Si_SiGe_probe' : (
+        'Si_SiGe_probe.h5',
+        '141Tv0YF7c5a-MCrh3CkY_w4FgWtBih80',
+    ),
+    'Si_SiGe_EELS_strain' : (
+        'Si_SiGe_EELS_strain.h5',
+        '1klkecq8IuEOYB-bXchO7RqOcgCl4bmDJ',
+    ),
+    'AuAgPd_wire' : (
+        'AuAgPd_wire.h5',
+        '1OQYW0H6VELsmnLTcwicP88vo2V5E3Oyt',
+    ),
+    'AuAgPd_wire_probe' : (
+        'AuAgPd_wire_probe.h5',
+        '17OduUKpxVBDumSK_VHtnc2XKkaFVN8kq',
+    ),
+    'polycrystal_2D_WS2' : (
+        'polycrystal_2D_WS2.h5',
+        '1AWB3-UTPiTR9dgrEkNFD7EJYsKnbEy0y',
+    ),
+    'WS2cif' : (
+        'WS2.cif',
+        '13zBl6aFExtsz_sew-L0-_ALYJfcgHKjo',
+    ),
+    'polymers' : (
+        'polymers.h5',
+        '1lK-TAMXN1MpWG0Q3_4vss_uEZgW2_Xh7',
+    ),
+    'vac_probe' : (
+        'vac_probe.h5',
+        '1QTcSKzZjHZd1fDimSI_q9_WsAU25NIXe',
+    ),
+    'small_dm3_3Dstack' : (
+        'small_dm3_3Dstack.dm3',
+        '1B-xX3F65JcWzAg0v7f1aVwnawPIfb5_o'
+    ),
+    'FCU-Net' : (
+        'filename.name',
+        '1-KX0saEYfhZ9IJAOwabH38PCVtfXidJi',
+    ),
+    'small_datacube' : (
+        'small_datacube.dm4',
+        # TODO - change this file to something smaller - ideally e.g. shape (4,8,256,256) ~= 4.2MB'
+        '1QTcSKzZjHZd1fDimSI_q9_WsAU25NIXe'
+    ),
+    'legacy_v0.9' : (
+        'legacy_v0.9_simAuNanoplatelet_bin.h5',
+        '1AIRwpcj87vK3ubLaKGj1UiYXZByD2lpu'
+    ),
+    'legacy_v0.13' : (
+        'legacy_v0.13.h5',
+        '1VEqUy0Gthama7YAVkxwbjQwdciHpx8rA'
+    ),
+    'legacy_v0.14' : (
+        'legacy_v0.14.h5',
+        '1eOTEJrpHnNv9_DPrWgZ4-NTN21UbH4aR',
+    ),
+    'test_realslice_io' : (
+        'test_realslice_io.h5',
+        '1siH80-eRJwG5R6AnU4vkoqGWByrrEz1y'
+    ),
+}
+
+# collections of files
+collection_ids = {
+    'tutorials' : (
+        'Au_sim',
+        'carbon_nanotube',
+        'Si_SiGe_exp',
+        'Si_SiGe_probe',
+        'Si_SiGe_EELS_strain',
+        'AuAgPd_wire',
+        'AuAgPd_wire_probe',
+        'polycrystal_2D_WS2',
+        'WS2cif',
+        'polymers',
+        'vac_probe',
+    ),
+    'test_io' : (
+        'small_dm3_3Dstack',
+        'vac_probe',
+        'legacy_v0.9',
+        'legacy_v0.13',
+        'legacy_v0.14',
+        'test_realslice_io',
+    ),
+    'test_braggvectors' : (
+        'Au_sim',
+    )
+}
+
+def get_sample_file_ids():
+    return {
+        'files' : file_ids.keys(),
+        'collections' : collection_ids.keys()
+    }
+
+
+
+### Downloader
 
 def gdrive_download(
     id_,
@@ -19,22 +139,22 @@ def gdrive_download(
         File ID for the desired file.  May be either a key from the list
         of files and collections of files accessible at get_sample_file_ids(),
         or a complete url, or the portions of a google drive link specifying
-        the file ID, i.e. for the address
+        it's google file ID, i.e. for the address
         https://drive.google.com/file/d/1bHv3u61Cr-y_GkdWHrJGh1lw2VKmt3UM/,
         the id string '1bHv3u61Cr-y_GkdWHrJGh1lw2VKmt3UM'.
     destination : None or str
-        The location to download to. If None, downloads to the current
-        working directory. If a string is passed which points to a valid
-        location on the filesystem, downloads there. For collections of
-        files, makes a new directory named after the collection id and
-        places all files there.
+        The location files are downloaded to. If a collection of files has been
+        specified, creates a new directory at the specified destination and
+        downloads the collection there.  If None, downloads to the current
+        working directory. Otherwise must be a string or Path pointint to
+        a valid location on the filesystem.
     overwrite : bool
         Turns overwrite protection on/off.
     filename : None or str
-        Used only if `id_` is a url or gdrive id. Specifies the name of the
-        output file.  If left as None, saves to 'gdrivedownload.file'. If `id_`
-        is a key from the sample file id list, this parameter is ignored and
-        the filenames in that list are used.
+        Used only if `id_` is a url or gdrive id. In these cases, specifies
+        the name of the output file.  If left as None, saves to
+        'gdrivedownload.file'. If `id_` is a key from the sample file id list,
+        this parameter is ignored.
     verbose : bool
         Toggles verbose output
     """
@@ -89,3 +209,6 @@ def gdrive_download(
                     fuzzy = True
                 )
 
+
+
+
diff --git a/py4DSTEM/io/read.py b/py4DSTEM/io/read.py
index e5d227b86..a28d06e16 100644
--- a/py4DSTEM/io/read.py
+++ b/py4DSTEM/io/read.py
@@ -3,6 +3,7 @@
 from pathlib import Path
 from os.path import exists
 from typing import Optional,Union
+import warnings
 
 import py4DSTEM
 import emdfile as emd
@@ -81,11 +82,37 @@ def read(
         version = emd._get_EMD_version(filepath)
         if verbose: print(f"EMD version {version[0]}.{version[1]}.{version[2]} detected. Reading...")
         assert emd._version_is_geq(version,(1,0,0)), f"EMD version {version} detected. Expected version >= 1.0.0"
+        # read
         data = emd.read(
             filepath,
             emdpath = datapath,
             tree = tree
         )
+        # calibration links
+        if isinstance(data,py4DSTEM.Data):
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore')
+                cal = data.calibration
+        elif isinstance(data,py4DSTEM.Root):
+            try:
+                cal = data.metadata['calibration']
+            except KeyError:
+                cal = None
+        else:
+            cal = None
+        if cal is not None:
+            try:
+                target_paths = cal['_target_paths']
+                del(cal._params['_target_paths'])
+                for p in target_paths:
+                    d = data.root.tree(p)
+                    cal.register_target( d )
+                    if hasattr(d,'setcal'):
+                        dsetcal()
+            except KeyError:
+                pass
+            cal.calibrate()
+        # return
         if verbose: print("Done.")
         return data
 
diff --git a/py4DSTEM/io/sample_file_ids.py b/py4DSTEM/io/sample_file_ids.py
index b53d63621..8b1378917 100644
--- a/py4DSTEM/io/sample_file_ids.py
+++ b/py4DSTEM/io/sample_file_ids.py
@@ -1,94 +1 @@
-# single files
-file_ids = {
-    'sample_diffraction_pattern' : (
-        'a_diffraction_pattern.h5',
-        '1ymYMnuDC0KV6dqduxe2O1qafgSd0jjnU',
-    ),
-    'Au_sim' : (
-        'au_sim.h5',
-        '1PmbCYosA1eYydWmmZebvf6uon9k_5g_S',
-    ),
-    'carbon_nanotube' : (
-        'carbon_nanotube.h5',
-        '1bHv3u61Cr-y_GkdWHrJGh1lw2VKmt3UM',
-    ),
-    'Si_SiGe_exp' : (
-        'Si_SiGe_exp.h5',
-        '1fXNYSGpe6w6E9RBA-Ai_owZwoj3w8PNC',
-    ),
-    'Si_SiGe_probe' : (
-        'Si_SiGe_probe.h5',
-        '141Tv0YF7c5a-MCrh3CkY_w4FgWtBih80',
-    ),
-    'Si_SiGe_EELS_strain' : (
-        'Si_SiGe_EELS_strain.h5',
-        '1klkecq8IuEOYB-bXchO7RqOcgCl4bmDJ',
-    ),
-    'AuAgPd_wire' : (
-        'AuAgPd_wire.h5',
-        '1OQYW0H6VELsmnLTcwicP88vo2V5E3Oyt',
-    ),
-    'AuAgPd_wire_probe' : (
-        'AuAgPd_wire_probe.h5',
-        '17OduUKpxVBDumSK_VHtnc2XKkaFVN8kq',
-    ),
-    'polycrystal_2D_WS2' : (
-        'polycrystal_2D_WS2.h5',
-        '1AWB3-UTPiTR9dgrEkNFD7EJYsKnbEy0y',
-    ),
-    'WS2cif' : (
-        'WS2.cif',
-        '13zBl6aFExtsz_sew-L0-_ALYJfcgHKjo',
-    ),
-    'polymers' : (
-        'polymers.h5',
-        '1lK-TAMXN1MpWG0Q3_4vss_uEZgW2_Xh7',
-    ),
-    'vac_probe' : (
-        'vac_probe.h5',
-        '1QTcSKzZjHZd1fDimSI_q9_WsAU25NIXe',
-    ),
-    'small_dm3_3Dstack' : (
-        'small_dm3_3Dstack.dm3',
-        '1B-xX3F65JcWzAg0v7f1aVwnawPIfb5_o'
-    ),
-    'FCU-Net' : (
-        'filename.name',
-        '1-KX0saEYfhZ9IJAOwabH38PCVtfXidJi',
-    ),
-    'small_datacube' : (
-        'small_datacube.dm4',
-        # TODO - change this file to something smaller - ideally e.g. shape (4,8,256,256) ~= 4.2MB'
-        '1QTcSKzZjHZd1fDimSI_q9_WsAU25NIXe'
-    ),
-}
-
-# collections of files
-collection_ids = {
-    'tutorials' : (
-        'Au_sim',
-        'carbon_nanotube',
-        'Si_SiGe_exp',
-        'Si_SiGe_probe',
-        'Si_SiGe_EELS_strain',
-        'AuAgPd_wire',
-        'AuAgPd_wire_probe',
-        'polycrystal_2D_WS2',
-        'WS2cif',
-        'polymers',
-        'vac_probe',
-    ),
-    'io_test_data' : (
-        'small_dm3_3Dstack',
-        'vac_probe',
-    ),
-}
-
-
-def get_sample_file_ids():
-    return {
-        'files' : file_ids.keys(),
-        'collections' : collection_ids.keys()
-    }
-
 
diff --git a/py4DSTEM/visualize/show.py b/py4DSTEM/visualize/show.py
index 448a44590..20ed0be2b 100644
--- a/py4DSTEM/visualize/show.py
+++ b/py4DSTEM/visualize/show.py
@@ -553,7 +553,7 @@ def show(
 
 
         # Create colormap with mask_color for bad values
-        cm = copy(plt.cm.get_cmap(cmap))
+        cm = copy(plt.colormaps.get_cmap(cmap))
         if mask_color=='empty':
             cm.set_bad(alpha=0)
         else:
diff --git a/test/gettestdata.py b/test/gettestdata.py
index a370cdcc1..0b5608a7c 100644
--- a/test/gettestdata.py
+++ b/test/gettestdata.py
@@ -54,7 +54,7 @@
 if args.data == 'tutorials':
     data = 'tutorials'
 elif args.data == 'io':
-    data = 'io_test_data'
+    data = 'test_io'
 elif args.data == 'basic':
     data = 'small_datacube'
 else:
@@ -69,7 +69,7 @@
 )
 
 # Always download the basic datacube
-if args.data is not 'basic':
+if args.data != 'basic':
     download(
         'small_datacube',
         destination = testpath,
diff --git a/test/test_braggvectors.py b/test/test_braggvectors.py
index 901317c05..e8a8d5ccc 100644
--- a/test/test_braggvectors.py
+++ b/test/test_braggvectors.py
@@ -3,7 +3,7 @@
 from os.path import join
 
 # set filepath
-path = join(py4DSTEM._TESTPATH,"simulatedAuNanoplatelet_binned_v0_9.h5")
+path = join(py4DSTEM._TESTPATH,"test_io/legacy_v0.9_simAuNanoplatelet_bin.h5")
 
 
 
diff --git a/test/test_calibration.py b/test/test_calibration.py
index eb600fa3a..80cb03493 100644
--- a/test/test_calibration.py
+++ b/test/test_calibration.py
@@ -6,7 +6,7 @@
 
 # set filepaths
 path_datacube = join(py4DSTEM._TESTPATH, "small_datacube.dm4")
-path_3Darray = join(py4DSTEM._TESTPATH, "io_test_data/small_dm3_3Dstack.dm3")
+path_3Darray = join(py4DSTEM._TESTPATH, "test_io/small_dm3_3Dstack.dm3")
 
 path_out_dir = join(py4DSTEM._TESTPATH, "test_outputs")
 path_out = join(path_out_dir, "test_calibration.h5")
diff --git a/test/test_native_io/test_calibration_io.py b/test/test_native_io/test_calibration_io.py
index 7aaa42d30..a753c7c81 100644
--- a/test/test_native_io/test_calibration_io.py
+++ b/test/test_native_io/test_calibration_io.py
@@ -3,38 +3,38 @@
 from os.path import join
 
 # set filepath
-path = join(py4DSTEM._TESTPATH, "filename")
-
-
-
-class TestCalibrationIO:
-
-
-
-    def test_datacube_cal_io(self):
-        # TODO
-        # make a datacube
-        # modify its calibration
-        # save
-        # load the datacube
-        # check its calibration
-        assert 0
-        pass
-
-
-    def test_datacube_child_node(self):
-        # TODO
-        # make a datacube
-        # make a child node
-        # confirm calibrations are the same
-        # modify the calibration
-        # save
-        # load the datacube
-        # check its calibration
-        # load just the child node
-        # check its calibration
-        assert 0
-        pass
+#path = join(py4DSTEM._TESTPATH, "filename")
+
+
+
+# class TestCalibrationIO:
+# 
+# 
+# 
+#     def test_datacube_cal_io(self):
+#         # TODO
+#         # make a datacube
+#         # modify its calibration
+#         # save
+#         # load the datacube
+#         # check its calibration
+#         assert 0
+#         pass
+# 
+# 
+#     def test_datacube_child_node(self):
+#         # TODO
+#         # make a datacube
+#         # make a child node
+#         # confirm calibrations are the same
+#         # modify the calibration
+#         # save
+#         # load the datacube
+#         # check its calibration
+#         # load just the child node
+#         # check its calibration
+#         assert 0
+#         pass
 
 
 
diff --git a/test/test_native_io/test_realslice_read.py b/test/test_native_io/test_realslice_read.py
index a1a8f09e7..8fb577ad8 100644
--- a/test/test_native_io/test_realslice_read.py
+++ b/test/test_native_io/test_realslice_read.py
@@ -6,7 +6,7 @@
 
 
 # Set filepaths
-filepath = join(py4DSTEM._TESTPATH, "YanAiming_bilayer_v01.h5")
+filepath = join(py4DSTEM._TESTPATH, "test_io/test_realslice_io.h5")
 
 def test_read_realslice():
     realslice = py4DSTEM.read(filepath, datapath='4DSTEM/Fit Data')
diff --git a/test/test_native_io/test_single_object_io.py b/test/test_native_io/test_single_object_io.py
index 22ee2d0df..ae77b01cd 100644
--- a/test/test_native_io/test_single_object_io.py
+++ b/test/test_native_io/test_single_object_io.py
@@ -7,172 +7,67 @@
 from py4DSTEM import save,read
 import emdfile as emd
 
-from py4DSTEM.classes import (
+from py4DSTEM.data import (
     DataCube,
-    BraggVectors,
+    Calibration,
     DiffractionSlice,
-    VirtualDiffraction,
-    Probe,
     RealSlice,
-    VirtualImage,
     QPoints,
-    Calibration
 )
+from py4DSTEM.process.diskdetection import BraggVectors
+from py4DSTEM.classes import Probe, VirtualDiffraction, VirtualImage
 
 # Set paths
 dirpath = py4DSTEM._TESTPATH
-path_dm3 = join(dirpath,"small_dm3.dm3")
+path_dm3 = join(dirpath,"test_io/small_dm3_3Dstack.dm3")
 path_h5 = join(dirpath,"test.h5")
 
 
+class TestDataCubeIO():
 
-
-class TestSingleDataNodeIO:
-
-    ## Setup and teardown
-
-    @classmethod
-    def setup_class(cls):
-        cls._clear_files(cls)
-        cls._make_data(cls)
-
-    @classmethod
-    def teardown_class(cls):
-        pass
-
-    def setup_method(self, method):
-        pass
-
-    def teardown_method(self, method):
-        self._clear_files()
-
-    def _make_data(self):
-        """ Make
-            - a datacube
-            - a braggvectors instance with only v_uncal
-            - a braggvectors instance with both PLAs
-            - a diffractionslice
-            - a realslice
-            - a probe, with no kernel
-            - a probe, with a kernel
-            - a qpoints instance
-            - a virtualdiffraction instance
-            - a virtualimage instance
+    def test_datacube_instantiation(self):
+        """
+        Instantiate a datacube and apply basic calibrations
         """
-        # datacube
-        self.datacube = DataCube(
+        datacube = DataCube(
             data = np.arange(np.prod((4,5,6,7))).reshape((4,5,6,7))
         )
         # calibration
-        self.datacube.calibration.set_Q_pixel_size(0.062)
-        self.datacube.calibration.set_Q_pixel_units("A^-1")
-        self.datacube.calibration.set_R_pixel_size(2.8)
-        self.datacube.calibration.set_R_pixel_units("nm")
-        # braggvectors
-        self.braggvectors = BraggVectors(
-            Rshape = (5,6),
-            Qshape = (7,8)
-        )
-        for x in range(self.braggvectors.Rshape[0]):
-            for y in range(self.braggvectors.Rshape[1]):
-                L = int(4 * (np.sin(x*y)+1))
-                self.braggvectors.vectors_uncal[x,y].add(
-                    np.ones(L,dtype=self.braggvectors.vectors_uncal.dtype)
-                )
-        # braggvectors 2
-        self.braggvectors2 = BraggVectors(
-            Rshape = (5,6),
-            Qshape = (7,8)
-        )
-        for x in range(self.braggvectors2.Rshape[0]):
-            for y in range(self.braggvectors2.Rshape[1]):
-                L = int(4 * (np.sin(x*y)+1))
-                self.braggvectors2.vectors_uncal[x,y].add(
-                    np.ones(L,dtype=self.braggvectors2.vectors_uncal.dtype)
-                )
-        self.braggvectors2._v_cal = self.braggvectors2._v_uncal.copy(name='_v_uncal')
-        # diffractionslice
-        self.diffractionslice = DiffractionSlice(
-            data = np.arange(np.prod((4,8,2))).reshape((4,8,2)),
-            slicelabels = ['a','b']
-        )
-        # realslice
-        self.realslice = RealSlice(
-            data = np.arange(np.prod((8,4,2))).reshape((8,4,2)),
-            slicelabels = ['x','y']
-        )
-        # virtualdiffraction instance
-        self.virtualdiffraction = VirtualDiffraction(
-            data = np.arange(np.prod((8,4,2))).reshape((8,4,2)),
-        )
-        # virtualimage instance
-        self.virtualimage = VirtualImage(
-            data = np.arange(np.prod((8,4,2))).reshape((8,4,2)),
-        )
-        # probe, with no kernel
-        self.probe1 = Probe(
-            data = np.arange(8*12).reshape((8,12))
-        )
-        # probe, with a kernel
-        self.probe2 = Probe(
-            data = np.arange(8*12*2).reshape((8,12,2))
-        )
-        # qpoints instance
-        self.qpoints = QPoints(
-            data = np.ones(10,
-                dtype = [('qx',float),('qy',float),('intensity',float)]
-            )
-        )
-
-
-
-
-
-
+        datacube.calibration.set_Q_pixel_size(0.062)
+        datacube.calibration.set_Q_pixel_units("A^-1")
+        datacube.calibration.set_R_pixel_size(2.8)
+        datacube.calibration.set_R_pixel_units("nm")
 
+        return datacube
 
-
-    def _clear_files(self):
+    def test_datacube_io(self):
         """
-        Delete h5 files which this test suite wrote
+        Instantiate, save, then read a datacube, and
+        compare its contents before/after
         """
-        paths = [
-            path_h5
-        ]
-        for p in paths:
-            if exists(p):
-                remove(p)
-
-
-
+        datacube = self.test_datacube_instantiation()
 
-
-    ## Tests
-
-    def test_datacube(self):
-        """ Save then read a datacube, and compare its contents before/after
-        """
-        assert(isinstance(self.datacube,DataCube))
+        assert(isinstance(datacube,DataCube))
         # test dim vectors
-        assert(self.datacube.dim_names[0] == 'Rx')
-        assert(self.datacube.dim_names[1] == 'Ry')
-        assert(self.datacube.dim_names[2] == 'Qx')
-        assert(self.datacube.dim_names[3] == 'Qy')
-        assert(self.datacube.dim_units[0] == 'nm')
-        assert(self.datacube.dim_units[1] == 'nm')
-        assert(self.datacube.dim_units[2] == 'A^-1')
-        assert(self.datacube.dim_units[3] == 'A^-1')
-        assert(self.datacube.dims[0][1] == 2.8)
-        assert(self.datacube.dims[2][1] == 0.062)
+        assert(datacube.dim_names[0] == 'Rx')
+        assert(datacube.dim_names[1] == 'Ry')
+        assert(datacube.dim_names[2] == 'Qx')
+        assert(datacube.dim_names[3] == 'Qy')
+        assert(datacube.dim_units[0] == 'nm')
+        assert(datacube.dim_units[1] == 'nm')
+        assert(datacube.dim_units[2] == 'A^-1')
+        assert(datacube.dim_units[3] == 'A^-1')
+        assert(datacube.dims[0][1] == 2.8)
+        assert(datacube.dims[2][1] == 0.062)
         # check the calibrations
-        assert(self.datacube.calibration.get_Q_pixel_size() == 0.062)
-        assert(self.datacube.calibration.get_Q_pixel_units() == "A^-1")
+        assert(datacube.calibration.get_Q_pixel_size() == 0.062)
+        assert(datacube.calibration.get_Q_pixel_units() == "A^-1")
         # save and read
-        save(path_h5,self.datacube)
+        save(path_h5,datacube,mode='o')
         new_datacube = read(path_h5)
         # check it's the same
         assert(isinstance(new_datacube,DataCube))
-        assert(array_equal(self.datacube.data,new_datacube.data))
+        assert(array_equal(datacube.data,new_datacube.data))
         assert(new_datacube.calibration.get_Q_pixel_size() == 0.062)
         assert(new_datacube.calibration.get_Q_pixel_units() == "A^-1")
         assert(new_datacube.dims[0][1] == 2.8)
@@ -180,137 +75,180 @@ def test_datacube(self):
 
 
 
+class TestBraggVectorsIO():
 
-    def test_braggvectors(self):
-        """ Save then read a BraggVectors instance, and compare contents before/after
+    def test_braggvectors_instantiation(self):
         """
-        assert(isinstance(self.braggvectors,BraggVectors))
-        # save then read
-        save(path_h5,self.braggvectors)
-        new_braggvectors = read(path_h5)
-        # check it's the same
-        assert(isinstance(new_braggvectors,BraggVectors))
-        assert(new_braggvectors is not self.braggvectors)
-        for x in range(new_braggvectors.shape[0]):
-            for y in range(new_braggvectors.shape[1]):
-                assert(array_equal(
-                    new_braggvectors.v_uncal[x,y].data,
-                    self.braggvectors.v_uncal[x,y].data))
-        # check that _v_cal isn't there
-        assert(not(hasattr(new_braggvectors,'_v_cal')))
+        Instantiate a braggvectors instance
+        """
+        braggvectors = BraggVectors(
+            Rshape = (5,6),
+            Qshape = (7,8)
+        )
+        for x in range(braggvectors.Rshape[0]):
+            for y in range(braggvectors.Rshape[1]):
+                L = int(4 * (np.sin(x*y)+1))
+                braggvectors._v_uncal[x,y].add(
+                    np.ones(L,dtype=braggvectors._v_uncal.dtype)
+                )
+        return braggvectors
 
 
-    def test_braggvectors2(self):
+    def test_braggvectors_io(self):
         """ Save then read a BraggVectors instance, and compare contents before/after
         """
-        assert(isinstance(self.braggvectors2,BraggVectors))
+        braggvectors = self.test_braggvectors_instantiation()
+
+        assert(isinstance(braggvectors,BraggVectors))
         # save then read
-        save(path_h5,self.braggvectors2)
+        save(path_h5,braggvectors,mode='o')
         new_braggvectors = read(path_h5)
         # check it's the same
         assert(isinstance(new_braggvectors,BraggVectors))
-        assert(new_braggvectors is not self.braggvectors2)
+        assert(new_braggvectors is not braggvectors)
         for x in range(new_braggvectors.shape[0]):
             for y in range(new_braggvectors.shape[1]):
                 assert(array_equal(
-                    new_braggvectors.v_uncal[x,y].data,
-                    self.braggvectors2.v_uncal[x,y].data))
-        # check cal vectors are there
-        assert(hasattr(new_braggvectors,'_v_cal'))
-        # check it's the same
-        for x in range(new_braggvectors.shape[0]):
-            for y in range(new_braggvectors.shape[1]):
-                assert(array_equal(
-                    new_braggvectors.v[x,y].data,
-                    self.braggvectors2.v[x,y].data))
+                    new_braggvectors._v_uncal[x,y].data,
+                    braggvectors._v_uncal[x,y].data))
+
+
+class TestSlices:
 
 
-    def test_diffractionslice(self):
+    # test instantiation
+
+    def test_diffractionslice_instantiation(self):
+        diffractionslice = DiffractionSlice(
+            data = np.arange(np.prod((4,8,2))).reshape((4,8,2)),
+            slicelabels = ['a','b']
+        )
+        return diffractionslice
+
+    def test_realslice_instantiation(self):
+        realslice = RealSlice(
+            data = np.arange(np.prod((8,4,2))).reshape((8,4,2)),
+            slicelabels = ['x','y']
+        )
+        return realslice
+
+    def test_virtualdiffraction_instantiation(self):
+        virtualdiffraction = VirtualDiffraction(
+            data = np.arange(np.prod((8,4,2))).reshape((8,4,2)),
+        )
+        return virtualdiffraction
+
+    def test_virtualimage_instantiation(self):
+        virtualimage = VirtualImage(
+            data = np.arange(np.prod((8,4,2))).reshape((8,4,2)),
+        )
+        return virtualimage
+
+    def test_probe_instantiation(self):
+        probe = Probe(
+            data = np.arange(8*12).reshape((8,12))
+        )
+        # add a kernel
+        probe.kernel = np.ones_like(probe.probe)
+        # return
+        return probe
+
+
+    # test io
+
+    def test_diffractionslice_io(self):
         """ test diffractionslice io
         """
-        assert(isinstance(self.diffractionslice,DiffractionSlice))
+        diffractionslice = self.test_diffractionslice_instantiation()
+        assert(isinstance(diffractionslice,DiffractionSlice))
         # save and read
-        save(path_h5,self.diffractionslice)
-        diffractionslice = read(path_h5)
+        save(path_h5,diffractionslice,mode='o')
+        new_diffractionslice = read(path_h5)
         # check it's the same
-        assert(isinstance(diffractionslice,DiffractionSlice))
-        assert(array_equal(self.diffractionslice.data,diffractionslice.data))
-        assert(diffractionslice.slicelabels == self.diffractionslice.slicelabels)
+        assert(isinstance(new_diffractionslice,DiffractionSlice))
+        assert(array_equal(diffractionslice.data,new_diffractionslice.data))
+        assert(diffractionslice.slicelabels == new_diffractionslice.slicelabels)
 
 
-    def test_realslice(self):
+    def test_realslice_io(self):
         """ test realslice io
         """
-        assert(isinstance(self.realslice,RealSlice))
+        realslice = self.test_realslice_instantiation()
+        assert(isinstance(realslice,RealSlice))
         # save and read
-        save(path_h5,self.realslice)
+        save(path_h5,realslice,mode='o')
         rs = read(path_h5)
         # check it's the same
         assert(isinstance(rs,RealSlice))
-        assert(array_equal(self.realslice.data,rs.data))
-        assert(rs.slicelabels == self.realslice.slicelabels)
+        assert(array_equal(realslice.data,rs.data))
+        assert(rs.slicelabels == realslice.slicelabels)
 
-    def test_virtualdiffraction(self):
+    def test_virtualdiffraction_io(self):
         """ test virtualdiffraction io
         """
-        assert(isinstance(self.virtualdiffraction,VirtualDiffraction))
+        virtualdiffraction = self.test_virtualdiffraction_instantiation()
+        assert(isinstance(virtualdiffraction,VirtualDiffraction))
         # save and read
-        save(path_h5,self.virtualdiffraction)
-        virtualdiffraction = read(path_h5)
+        save(path_h5,virtualdiffraction,mode='o')
+        vd = read(path_h5)
         # check it's the same
-        assert(isinstance(virtualdiffraction,VirtualDiffraction))
-        assert(array_equal(self.virtualdiffraction.data,virtualdiffraction.data))
+        assert(isinstance(vd,VirtualDiffraction))
+        assert(array_equal(vd.data,virtualdiffraction.data))
         pass
 
-    def test_virtualimage(self):
+    def test_virtualimage_io(self):
         """ test virtualimage io
         """
-        assert(isinstance(self.virtualimage,VirtualImage))
+        virtualimage = self.test_virtualimage_instantiation()
+        assert(isinstance(virtualimage,VirtualImage))
         # save and read
-        save(path_h5,self.virtualimage)
+        save(path_h5,virtualimage,mode='o')
         virtIm = read(path_h5)
         # check it's the same
         assert(isinstance(virtIm,VirtualImage))
-        assert(array_equal(self.virtualimage.data,virtIm.data))
+        assert(array_equal(virtualimage.data,virtIm.data))
         pass
 
-    def test_probe1(self):
-        """ test probe io
-        """
-        assert(isinstance(self.probe1,Probe))
-        # check for an empty kernel array
-        assert(array_equal(self.probe1.kernel,np.zeros_like(self.probe1.probe)))
-        # save and read
-        save(path_h5,self.probe1)
-        probe = read(path_h5)
-        # check it's the same
-        assert(isinstance(probe,Probe))
-        assert(array_equal(self.probe1.data,probe.data))
-        pass
 
-    def test_probe2(self):
+    def test_probe1_io(self):
         """ test probe io
         """
-        assert(isinstance(self.probe2,Probe))
+        probe0 = self.test_probe_instantiation()
+        assert(isinstance(probe0,Probe))
         # save and read
-        save(path_h5,self.probe2)
+        save(path_h5,probe0,mode='o')
         probe = read(path_h5)
         # check it's the same
         assert(isinstance(probe,Probe))
-        assert(array_equal(self.probe2.data,probe.data))
+        assert(array_equal(probe0.data,probe.data))
         pass
 
 
-    def test_qpoints(self):
+
+
+
+class TestPoints:
+
+    def test_qpoints_instantiation(self):
+        qpoints = QPoints(
+            data = np.ones(10,
+                dtype = [('qx',float),('qy',float),('intensity',float)]
+            )
+        )
+        return qpoints
+
+
+    def test_qpoints_io(self):
         """ test qpoints io
         """
-        assert(isinstance(self.qpoints,QPoints))
+        qpoints0 = self.test_qpoints_instantiation()
+        assert(isinstance(qpoints0,QPoints))
         # save and read
-        save(path_h5,self.qpoints)
+        save(path_h5,qpoints0,mode='o')
         qpoints = read(path_h5)
         # check it's the same
         assert(isinstance(qpoints,QPoints))
-        assert(array_equal(self.qpoints.data,qpoints.data))
+        assert(array_equal(qpoints0.data,qpoints.data))
         pass
 
 
diff --git a/test/test_native_io/test_v0_13.py b/test/test_native_io/test_v0_13.py
index b3fa0328d..92ab41ca2 100644
--- a/test/test_native_io/test_v0_13.py
+++ b/test/test_native_io/test_v0_13.py
@@ -3,7 +3,7 @@
 
 
 # Set filepaths
-filepath = join(_TESTPATH, "v13_sample.h5")
+filepath = join(_TESTPATH, "test_io/legacy_v0.13.h5")
 
 
 
diff --git a/test/test_native_io/test_v0_14.py b/test/test_native_io/test_v0_14.py
index c6ba27ea8..33230a816 100644
--- a/test/test_native_io/test_v0_14.py
+++ b/test/test_native_io/test_v0_14.py
@@ -3,7 +3,7 @@
 
 
 
-path = join(py4DSTEM._TESTPATH,'test_v14_sample.h5')
+path = join(py4DSTEM._TESTPATH,'test_io/legacy_v0.14.h5')
 
 
 
@@ -14,7 +14,7 @@ def _make_v14_test_file():
     assert(py4DSTEM.__version__.split('.')[1]=='14'), 'no!'
 
     # Set filepaths
-    filepath_data = join(py4DSTEM._TESTPATH,"simulatedAuNanoplatelet_binned_v0_9.h5")
+    filepath_data = join(py4DSTEM._TESTPATH,"test_io/legacy_v0.9_simAuNanoplatelet_bin.h5")
 
     # Read sim Au datacube
     datacube = py4DSTEM.io.read(
diff --git a/test/test_native_io/test_v0_9.py b/test/test_native_io/test_v0_9.py
index b3424efa4..8024f646c 100644
--- a/test/test_native_io/test_v0_9.py
+++ b/test/test_native_io/test_v0_9.py
@@ -1,7 +1,7 @@
 from py4DSTEM import read, DataCube, _TESTPATH
 from os.path import join
 
-path = join(_TESTPATH, 'simulatedAuNanoplatelet_binned_v0_9.h5')
+path = join(_TESTPATH,"test_io/legacy_v0.9_simAuNanoplatelet_bin.h5")
 
 def test_read_v0_9_noID():
 
diff --git a/test/test_nonnative_io/test_dm.py b/test/test_nonnative_io/test_dm.py
index 9fd311579..a3d5aa7b0 100644
--- a/test/test_nonnative_io/test_dm.py
+++ b/test/test_nonnative_io/test_dm.py
@@ -5,7 +5,7 @@
 
 # Set filepaths
 filepath_dm4_datacube = join(py4DSTEM._TESTPATH, "small_datacube.dm4")
-filepath_dm3_3Dstack = join(py4DSTEM._TESTPATH, "io_test_data/small_dm3_3Dstack.dm3")
+filepath_dm3_3Dstack = join(py4DSTEM._TESTPATH, "test_io/small_dm3_3Dstack.dm3")
 
 
 def test_dmfile_datacube():
diff --git a/test/test_workflow/test_basics.py b/test/test_workflow/test_basics.py
index 083b15fcb..cb30f5d6c 100644
--- a/test/test_workflow/test_basics.py
+++ b/test/test_workflow/test_basics.py
@@ -2,7 +2,7 @@
 from os.path import join
 
 # set filepath
-path = join(py4DSTEM._TESTPATH,"simulatedAuNanoplatelet_binned_v0_9.h5")
+path = join(py4DSTEM._TESTPATH,"test_io/legacy_v0.9_simAuNanoplatelet_bin.h5")
 
 
 
diff --git a/test/test_workflow/test_disk_detection_basic.py b/test/test_workflow/test_disk_detection_basic.py
index 18296d0a7..058fb67ee 100644
--- a/test/test_workflow/test_disk_detection_basic.py
+++ b/test/test_workflow/test_disk_detection_basic.py
@@ -3,7 +3,7 @@
 from numpy import zeros
 
 # set filepath
-path = join(py4DSTEM._TESTPATH,"simulatedAuNanoplatelet_binned_v0_9.h5")
+path = join(py4DSTEM._TESTPATH,"test_io/legacy_v0.9_simAuNanoplatelet_bin.h5")
 
 
 
diff --git a/test/test_workflow/test_disk_detection_with_calibration.py b/test/test_workflow/test_disk_detection_with_calibration.py
index 83e52050f..c1bb4a581 100644
--- a/test/test_workflow/test_disk_detection_with_calibration.py
+++ b/test/test_workflow/test_disk_detection_with_calibration.py
@@ -3,7 +3,7 @@
 from numpy import zeros
 
 # set filepath
-path = join(py4DSTEM._TESTPATH,"simulatedAuNanoplatelet_binned_v0_9.h5")
+path = join(py4DSTEM._TESTPATH,"test_io/legacy_v0.9_simAuNanoplatelet_bin.h5")
 
 
 

From 36e2061e08e338c968da65163e2525accc916260 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 27 Jun 2023 18:48:25 -0400
Subject: [PATCH 076/362] bugfixes

---
 py4DSTEM/data/calibration.py             | 2 +-
 py4DSTEM/data/datacube.py                | 4 ++--
 py4DSTEM/data/propagating_calibration.py | 2 +-
 py4DSTEM/io/read.py                      | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/py4DSTEM/data/calibration.py b/py4DSTEM/data/calibration.py
index a9937612d..1fd6fd492 100644
--- a/py4DSTEM/data/calibration.py
+++ b/py4DSTEM/data/calibration.py
@@ -211,7 +211,7 @@ def __init__(
     # EMD root property
     @property
     def root(self):
-        return _root
+        return self._root
     @root.setter
     def root(self):
         raise Exception("Calibration.root does not support assignment; to change the root, use self.set_root")
diff --git a/py4DSTEM/data/datacube.py b/py4DSTEM/data/datacube.py
index 775ca75a8..461787b6a 100644
--- a/py4DSTEM/data/datacube.py
+++ b/py4DSTEM/data/datacube.py
@@ -139,12 +139,12 @@ def qxxs(self,rx,ry):
         qx0_shift = self.calibration.get_qx0shift(rx,ry)
         if qx0_shift is None:
             raise Exception("Can't compute shifted meshgrid - origin shift is not defined")
-        return qxx - qx0_shift
+        return self.qxx - qx0_shift
     def qyys(self,rx,ry):
         qy0_shift = self.calibration.get_qy0shift(rx,ry)
         if qy0_shift is None:
             raise Exception("Can't compute shifted meshgrid - origin shift is not defined")
-        return qyy - qy0_shift
+        return self.qyy - qy0_shift
 
 
 
diff --git a/py4DSTEM/data/propagating_calibration.py b/py4DSTEM/data/propagating_calibration.py
index fa34f1468..a80382338 100644
--- a/py4DSTEM/data/propagating_calibration.py
+++ b/py4DSTEM/data/propagating_calibration.py
@@ -26,7 +26,7 @@ def __call__(self, *args, **kwargs):
         some_object = args[0]
         assert hasattr(some_object, "_targets"), "SomeObject object appears to be in an invalid state. _targets attribute is missing."
         for target in some_object._targets:
-            if hasattr(target,'method') and callable(target,method):
+            if hasattr(target,'method') and callable(target.method):
                 try:
                     target.method()
                 except Exception as err:
diff --git a/py4DSTEM/io/read.py b/py4DSTEM/io/read.py
index a28d06e16..589486040 100644
--- a/py4DSTEM/io/read.py
+++ b/py4DSTEM/io/read.py
@@ -108,7 +108,7 @@ def read(
                     d = data.root.tree(p)
                     cal.register_target( d )
                     if hasattr(d,'setcal'):
-                        dsetcal()
+                        d.setcal()
             except KeyError:
                 pass
             cal.calibrate()

From ad3f334898b45cdcff27e9fee78b8565d483d8c0 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Wed, 28 Jun 2023 13:13:34 -0400
Subject: [PATCH 077/362] update cupy min version to 10.0.0

---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index f518599cc..bc38d2419 100644
--- a/setup.py
+++ b/setup.py
@@ -39,7 +39,7 @@
         ],
     extras_require={
         'ipyparallel': ['ipyparallel >= 6.2.4', 'dill >= 0.3.3'],
-        'cuda': ['cupy'],
+        'cuda': ['cupy >= 10.0.0'],
         'acom': ['pymatgen >= 2022', 'mp-api == 0.24.1'],
         'aiml': ['tensorflow == 2.4.1','tensorflow-addons <= 0.14.0','crystal4D'],
         'aiml-cuda': ['tensorflow == 2.4.1','tensorflow-addons <= 0.14.0','crystal4D','cupy'],

From 621401e26c0017875676bedc2e064118a640ab9e Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Wed, 28 Jun 2023 17:37:03 -0400
Subject: [PATCH 078/362] rms Probe from classes, ->diskdection, all tests
 passing

---
 py4DSTEM/__init__.py                          |   2 +-
 py4DSTEM/classes/__init__.py                  |   1 -
 py4DSTEM/classes/methods/__init__.py          |   2 -
 py4DSTEM/classes/methods/probe_methods.py     |  76 ---
 py4DSTEM/classes/probe.py                     |  84 ---
 py4DSTEM/data/calibration.py                  |  12 +-
 py4DSTEM/data/data.py                         |  21 +-
 py4DSTEM/data/datacube.py                     | 138 ++--
 py4DSTEM/data/diffractionslice.py             |  10 +-
 py4DSTEM/data/realslice.py                    |   8 +-
 py4DSTEM/io/legacy/legacy13/v13_to_14.py      |   3 +-
 py4DSTEM/process/__init__.py                  |   2 -
 py4DSTEM/process/diskdetection/__init__.py    |   1 +
 .../process/diskdetection/braggvectors.py     |   2 +
 py4DSTEM/process/diskdetection/probe.py       | 608 ++++++++++++++++++
 .../probe_gen_methods.py}                     | 119 ----
 py4DSTEM/process/probe/__init__.py            |   3 -
 py4DSTEM/process/probe/kernel.py              | 279 --------
 test/test_braggvectors.py                     |   2 +-
 test/test_native_io/test_single_object_io.py  |   4 +-
 test/test_probe.py                            |  65 ++
 .../test_disk_detection_basic.py              |   2 +-
 .../test_disk_detection_with_calibration.py   |   2 +-
 23 files changed, 812 insertions(+), 634 deletions(-)
 delete mode 100644 py4DSTEM/classes/methods/__init__.py
 delete mode 100644 py4DSTEM/classes/methods/probe_methods.py
 delete mode 100644 py4DSTEM/classes/probe.py
 create mode 100644 py4DSTEM/process/diskdetection/probe.py
 rename py4DSTEM/process/{probe/probe.py => diskdetection/probe_gen_methods.py} (69%)
 delete mode 100644 py4DSTEM/process/probe/__init__.py
 delete mode 100644 py4DSTEM/process/probe/kernel.py
 create mode 100644 test/test_probe.py

diff --git a/py4DSTEM/__init__.py b/py4DSTEM/__init__.py
index f01604896..de56213d0 100644
--- a/py4DSTEM/__init__.py
+++ b/py4DSTEM/__init__.py
@@ -25,9 +25,9 @@
 from py4DSTEM.classes import (
     VirtualDiffraction,
     VirtualImage,
-    Probe,
 )
 from py4DSTEM.process.diskdetection import (
+    Probe,
     BraggVectors,
     BraggVectorMap,
 )
diff --git a/py4DSTEM/classes/__init__.py b/py4DSTEM/classes/__init__.py
index d97b413d9..750c8a9bb 100644
--- a/py4DSTEM/classes/__init__.py
+++ b/py4DSTEM/classes/__init__.py
@@ -1,6 +1,5 @@
 _emd_hook = True
 
-from py4DSTEM.classes.probe import Probe
 from py4DSTEM.classes.virtualdiffraction import VirtualDiffraction
 from py4DSTEM.classes.virtualimage import VirtualImage
 
diff --git a/py4DSTEM/classes/methods/__init__.py b/py4DSTEM/classes/methods/__init__.py
deleted file mode 100644
index a2455dba3..000000000
--- a/py4DSTEM/classes/methods/__init__.py
+++ /dev/null
@@ -1,2 +0,0 @@
-from py4DSTEM.classes.methods.probe_methods import ProbeMethods
-
diff --git a/py4DSTEM/classes/methods/probe_methods.py b/py4DSTEM/classes/methods/probe_methods.py
deleted file mode 100644
index 9fd040ff6..000000000
--- a/py4DSTEM/classes/methods/probe_methods.py
+++ /dev/null
@@ -1,76 +0,0 @@
-# Functions to become Probe methods
-
-import numpy as np
-
-
-
-class ProbeMethods:
-    """
-    A container for Probe object instance methods.
-    """
-
-    def __init__(self):
-        pass
-
-
-
-    # Kernel generation
-
-    def get_kernel(
-        self,
-        mode = 'flat',
-        returncalc = True,
-        **kwargs
-        ):
-        """
-        Creates a kernel from the probe for cross-correlative template matching.
-
-        Precise behavior and valid keyword arguments depend on the `mode`
-        selected.  In each case, the center of the probe is shifted to the
-        origin and the kernel normalized such that it sums to 1. In 'flat'
-        mode, this is the only processing performed. In the remaining modes,
-        some additional processing is performed which adds a ring of
-        negative intensity around the central probe, which results in
-        edge-filetering-like behavior during cross correlation. Valid modes,
-        and the required additional kwargs, if any, for each, are:
-
-            - 'flat': creates a flat probe kernel. For bullseye or other
-                structured probes, this mode is recommended. No required
-                arguments, optional arg `origin` (2 tuple)
-            - 'gaussian': subtracts a gaussian with a width of standard
-                deviation `sigma`, which is a required argument. Optional
-                arg `origin`.
-            - 'sigmoid': subtracts an annulus with inner and outer radii
-                of (ri,ro) and a sine-squared sigmoid radial profile from
-                the probe template. Required arg: `radii` (2 tuple). Optional
-                args `origin` (2-tuple)
-            - 'sigmoid_log': subtracts an annulus with inner and outer radii
-                of (ri,ro) and a logistic sigmoid radial profile from
-                the probe template. Required arg: `radii` (2 tuple). Optional
-                args `origin` (2-tuple)
-
-        Returns:
-            (2D array)
-        """
-
-        # perform computation
-        from py4DSTEM.process.probe import get_kernel
-        kern = get_kernel(
-            self.probe,
-            mode = mode,
-            **kwargs
-        )
-
-        # add to the Probe
-        self.kernel = kern
-
-        # return
-        if returncalc:
-            return kern
-
-
-
-
-
-
-
diff --git a/py4DSTEM/classes/probe.py b/py4DSTEM/classes/probe.py
deleted file mode 100644
index 53eaa3298..000000000
--- a/py4DSTEM/classes/probe.py
+++ /dev/null
@@ -1,84 +0,0 @@
-
-from py4DSTEM.data import DiffractionSlice, Data
-from py4DSTEM.classes.methods import ProbeMethods
-
-from typing import Optional
-import numpy as np
-
-class Probe(DiffractionSlice,ProbeMethods,Data):
-    """
-    Stores a vacuum probe.
-    """
-
-    def __init__(
-        self,
-        data: np.ndarray,
-        name: Optional[str] = 'probe'
-        ):
-        """
-        Accepts:
-            data (2D or 3D np.ndarray): the vacuum probe, or
-                the vacuum probe + kernel
-            name (str): a name
-
-        Returns:
-            (Probe)
-        """
-        # if only the probe is passed, make space for the kernel
-        if data.ndim == 2:
-            data = np.stack([
-                data,
-                np.zeros_like(data)
-            ])
-
-        # initialize as a ProbeMethods instance
-        super(ProbeMethods).__init__()
-
-        # initialize as a DiffractionSlice
-        DiffractionSlice.__init__(
-            self,
-            name = name,
-            data = data,
-            slicelabels = [
-                'probe',
-                'kernel'
-            ]
-        )
-
-
-    ## properties
-
-    @property
-    def probe(self):
-        return self.get_slice('probe').data
-    @probe.setter
-    def probe(self,x):
-        assert(x.shape == (self.data.shape[1:]))
-        self.data[0,:,:] = x
-    @property
-    def kernel(self):
-        return self.get_slice('kernel').data
-    @kernel.setter
-    def kernel(self,x):
-        assert(x.shape == (self.data.shape[1:]))
-        self.data[1,:,:] = x
-
-
-
-
-    # read
-    @classmethod
-    def _get_constructor_args(cls,group):
-        """
-        Returns a dictionary of args/values to pass to the class constructor
-        """
-        ar_constr_args = DiffractionSlice._get_constructor_args(group)
-        args = {
-            'data' : ar_constr_args['data'],
-            'name' : ar_constr_args['name'],
-        }
-        return args
-
-
-
-
diff --git a/py4DSTEM/data/calibration.py b/py4DSTEM/data/calibration.py
index 1fd6fd492..e2fe0c393 100644
--- a/py4DSTEM/data/calibration.py
+++ b/py4DSTEM/data/calibration.py
@@ -159,13 +159,13 @@ class Calibration(Metadata):
 
     Attaching an object to a different Calibration
     ----------------------------------------------
-    To modify the calibration associated with an object's `data`, use
+    To modify the calibration associated with some object `data`, use
 
         >>> c.attach( data )
 
-    where `c` is the new calibration instance `data` is to be associated
-    with. This (1) moves `data` into the top level of `c`'s data tree,
-    which means the new calibration will now be accessible normally at
+    where `c` is the new calibration instance. This (1) moves `data` into the
+    top level of `c`'s data tree, which means the new calibration will now be
+    accessible normally at
 
         >>> data.calibration
 
@@ -176,7 +176,7 @@ class Calibration(Metadata):
     called.
 
     To attach `data` to a different location in the calibration instance's
-    tree, use `data.attach( node )`. See the Data.attach docstring.
+    tree, use `node.attach( data )`. See the Data.attach docstring.
     """
     def __init__(
         self,
@@ -232,7 +232,7 @@ def attach(self,data):
         """
         from py4DSTEM.data import Data
         assert(isinstance(data,Data)), f"data must be a Data instance"
-        data.attach(self.root)
+        self.root.attach(data)
 
 
     # Register for auto-calibration
diff --git a/py4DSTEM/data/data.py b/py4DSTEM/data/data.py
index c2c4aef50..ba82f4fec 100644
--- a/py4DSTEM/data/data.py
+++ b/py4DSTEM/data/data.py
@@ -107,17 +107,22 @@ def calibration(self, x):
 
     def attach(self,node):
         """
-        Moves self to `node`'s tree, attaching to node's calibration and detaching
-        from the current calibration.
+        Attach `node` to the current object's tree, attaching calibration and detaching
+        calibrations as needed.
         """
         assert(isinstance(node,Node)), f"node must be a Node, not type {type(node)}"
-        assert(hasattr(node,'calibration')), "node must have a calibration"
-        if self in self.calibration._targets:
-            register = True
-            self.calibration.unregister_target(self)
-        node.graft(self)
+        register = False
+        if hasattr(node,'calibration'):
+            if node.calibration is not None:
+                if node in node.calibration._targets:
+                    register = True
+                    node.calibration.unregister_target(node)
+        if node.root is None:
+            self.tree(node)
+        else:
+            self.graft(node)
         if register:
-            self.calibration.register_target(self)
+            self.calibration.register_target(node)
 
 
 
diff --git a/py4DSTEM/data/datacube.py b/py4DSTEM/data/datacube.py
index 461787b6a..dc19a9443 100644
--- a/py4DSTEM/data/datacube.py
+++ b/py4DSTEM/data/datacube.py
@@ -3,9 +3,11 @@
 import numpy as np
 from scipy.ndimage import distance_transform_edt, binary_fill_holes, gaussian_filter1d
 from scipy.interpolate import interp1d
+from scipy.ndimage import (
+    binary_opening, binary_dilation, distance_transform_edt)
 from typing import Optional,Union
 
-from emdfile import Array, Metadata, Node, Root
+from emdfile import Array, Metadata, Node, Root, tqdmnd
 from py4DSTEM.data import Data, Calibration
 
 
@@ -329,7 +331,7 @@ def add(
                 data = data,
                 name = name
             )
-        self.tree( data )
+        self.attach( data )
 
     def set_scan_shape(
         self,
@@ -640,7 +642,7 @@ def get_virtual_diffraction(
         )
 
         # add to the tree
-        self.tree( dp )
+        self.attach( dp )
 
         # return
         if returncalc:
@@ -738,7 +740,7 @@ def get_dp_max(
         )
 
         # add to the tree
-        self.tree( dp )
+        self.attach( dp )
 
         # return
         if returncalc:
@@ -837,7 +839,7 @@ def get_dp_mean(
         )
 
         # add to the tree
-        self.tree( dp )
+        self.attach( dp )
 
         # return
         if returncalc:
@@ -933,7 +935,7 @@ def get_dp_median(
         )
 
         # add to the tree
-        self.tree( dp )
+        self.attach( dp )
 
         # return
         if returncalc:
@@ -1059,7 +1061,7 @@ def get_virtual_image(
         )
 
         # add to the tree
-        self.tree( im )
+        self.attach( im )
 
         # return
         if returncalc:
@@ -1141,50 +1143,98 @@ def position_detector(
     def get_vacuum_probe(
         self,
         ROI = None,
-        name = 'probe',
-        returncalc = True,
+        align = True,
+        mask = None,
+        threshold = 0.2,
+        expansion = 12,
+        opening = 3,
+        verbose = False,
+        returncalc = True
         ):
         """
-        Computes a vacuum probe from the DataCube by aligning and averaging
-        either all or some subset of the diffraction patterns.
+        Computes a vacuum probe.
 
-        Args:
-            ROI (None or boolean array or tuple): if None, uses the whole
-                datacube. Otherwise, uses a subset of diffraction patterns.
-                If `ROI` is a boolean array, it should be Rspace shaped, and
-                diffraction patterns where True are used. Else should be
-                a 4-tuple representing (Rxmin,Rxmax,Rymin,Rymax) of a
-                rectangular region to use.
+        Which diffraction patterns are included in the calculation is specified
+        by the `ROI` parameter.  Diffraction patterns are aligned before averaging
+        if `align` is True (default). A global mask is applied to each diffraction
+        pattern before aligning/averaging if `mask` is specified. After averaging,
+        a final masking step is applied according to the parameters `threshold`,
+        `expansion`, and `opening`.
 
-        Returns:
-            (Probe) a Probe instance
+        Parameters
+        ----------
+        ROI : optional, boolean array or len 4 list/tuple
+            If unspecified, uses the whole datacube. If a boolean array is
+            passed must be real-space shaped, and True pixels are used. If a
+            4-tuple is passed, uses the region inside the limits
+            (rx_min,rx_max,ry_min,ry_max)
+        align : optional, bool
+            if True, aligns the probes before averaging
+        mask : optional, array
+            mask applied to each diffraction pattern before alignment and
+            averaging
+        threshold : float
+            in the final masking step, values less than max(probe)*threshold
+            are considered outside the probe
+        expansion : int
+            number of pixels by which the final mask is expanded after
+            thresholding
+        opening : int
+            size of binary opening applied to the final mask to eliminate stray
+            bright pixels
+        verbose : bool
+            toggles verbose output
+        returncalc : bool
+            if True, returns the answer
 
+        Returns
+        -------
+        probe : Probe, optional
+            the vacuum probe
         """
+        from py4DSTEM.process.utils import get_shifted_ar, get_shift
+        from py4DSTEM.process.diskdetection import Probe
 
-        # perform computation
-        from py4DSTEM.classes.probe import Probe
-        from py4DSTEM.process.probe import get_vacuum_probe
+        # parse region to use
         if ROI is None:
-            x = get_vacuum_probe(
-                self
-            )
+            ROI = np.ones(self.Rshape,dtype=bool)
+        elif isinstance(ROI,tuple):
+            assert(len(ROI)==4), "if ROI is a tuple must be length 4"
+            _ROI = np.ones(self.Rshape,dtype=bool)
+            ROI = _ROI[ROI[0]:ROI[1],ROI[2]:ROI[3]]
         else:
-            x = get_vacuum_probe(
-                self,
-                ROI = ROI
-            )
-
-        # wrap with a py4dstem class
-        x = Probe(
-            data = x
-        )
-
-        # add to the tree
-        self.tree( x )
-
-        # return
+            assert(isinstance(ROI,np.ndarray))
+            assert(ROI.shape == self.Rshape)
+        xy = np.vstack(np.nonzero(ROI))
+        length = xy.shape[1]
+
+        # setup global mask
+        if mask is None:
+            mask = 1
+        else:
+            assert(mask.shape == self.Qshape)
+
+        # compute average probe
+        probe = self.data[xy[0,0],xy[1,0],:,:]
+        for n in tqdmnd(range(1,length)):
+            curr_DP = self.data[xy[0,n],xy[1,n],:,:] * mask
+            if align:
+                xshift,yshift = get_shift(probe, curr_DP)
+                curr_DP = get_shifted_ar(curr_DP, xshift, yshift)
+            probe = probe*(n-1)/n + curr_DP/n
+
+        # mask
+        mask = probe > np.max(probe)*threshold
+        mask = binary_opening(mask, iterations=opening)
+        mask = binary_dilation(mask, iterations=1)
+        mask = np.cos((np.pi/2)*np.minimum(distance_transform_edt(np.logical_not(mask)) / expansion, 1))**2
+        probe *= mask
+
+        # make a probe, add to tree, and return
+        probe = Probe(probe)
+        self.attach(probe)
         if returncalc:
-            return x
+            return probe
 
 
 
@@ -1248,7 +1298,7 @@ def get_probe_size(
             DP = self.tree( 'dp_mean' ).data
         elif type(dp) == str:
             assert dp in self._branch.keys(), "mode not found"
-            DP = self.tree( dp )
+            DP = self.attach( dp )
         elif type(dp) == np.ndarray:
             assert len(dp.shape) == 2, "must be a 2D array"
             DP = dp
@@ -1540,7 +1590,7 @@ def find_Bragg_disks(
 
             # add to tree
             if data is None:
-                self.tree( peaks )
+                self.attach( peaks )
 
         # return
         if returncalc:
@@ -1626,7 +1676,7 @@ def get_beamstop_mask(
         )
 
         # Add to tree
-        self.tree( mask_beamstop )
+        self.attach( mask_beamstop )
 
         # return
         if returncalc:
diff --git a/py4DSTEM/data/diffractionslice.py b/py4DSTEM/data/diffractionslice.py
index ece658adc..40104cf80 100644
--- a/py4DSTEM/data/diffractionslice.py
+++ b/py4DSTEM/data/diffractionslice.py
@@ -18,7 +18,8 @@ def __init__(
         data: np.ndarray,
         name: Optional[str] = 'diffractionslice',
         units: Optional[str] = 'intensity',
-        slicelabels: Optional[Union[bool,list]] = None
+        slicelabels: Optional[Union[bool,list]] = None,
+        calibration = None
         ):
         """
         Accepts:
@@ -39,6 +40,13 @@ def __init__(
             units = units,
             slicelabels = slicelabels
         )
+        # initialize as Data
+        Data.__init__(
+            self,
+            calibration
+        )
+
+
 
 
     # read
diff --git a/py4DSTEM/data/realslice.py b/py4DSTEM/data/realslice.py
index 0a2f893c9..205cbc1ab 100644
--- a/py4DSTEM/data/realslice.py
+++ b/py4DSTEM/data/realslice.py
@@ -17,7 +17,8 @@ def __init__(
         data: np.ndarray,
         name: Optional[str] = 'realslice',
         units: Optional[str] = 'intensity',
-        slicelabels: Optional[Union[bool,list]] = None
+        slicelabels: Optional[Union[bool,list]] = None,
+        calibration = None
         ):
         """
         Accepts:
@@ -37,6 +38,11 @@ def __init__(
             units = 'intensity',
             slicelabels = slicelabels
         )
+        # initialize as Data
+        Data.__init__(
+            self,
+            calibration
+        )
 
 
     # read
diff --git a/py4DSTEM/io/legacy/legacy13/v13_to_14.py b/py4DSTEM/io/legacy/legacy13/v13_to_14.py
index 453c4cf1c..9bafe15d2 100644
--- a/py4DSTEM/io/legacy/legacy13/v13_to_14.py
+++ b/py4DSTEM/io/legacy/legacy13/v13_to_14.py
@@ -46,9 +46,8 @@
 from py4DSTEM.classes import (
     VirtualImage,
     VirtualDiffraction,
-    Probe,
 )
-from py4DSTEM.process.diskdetection.braggvectors import BraggVectors
+from py4DSTEM.process.diskdetection import BraggVectors, Probe
 
 
 
diff --git a/py4DSTEM/process/__init__.py b/py4DSTEM/process/__init__.py
index 841314fbb..da88ec4ba 100644
--- a/py4DSTEM/process/__init__.py
+++ b/py4DSTEM/process/__init__.py
@@ -3,10 +3,8 @@
 from py4DSTEM.process import diskdetection
 from py4DSTEM.process import virtualdiffraction
 from py4DSTEM.process import virtualimage
-from py4DSTEM.process import probe
 from py4DSTEM.process import latticevectors
 from py4DSTEM.process import phase
-from py4DSTEM.process import probe
 from py4DSTEM.process import calibration
 from py4DSTEM.process import utils
 from py4DSTEM.process import classification
diff --git a/py4DSTEM/process/diskdetection/__init__.py b/py4DSTEM/process/diskdetection/__init__.py
index 76b0ea25c..9d42a2ad5 100644
--- a/py4DSTEM/process/diskdetection/__init__.py
+++ b/py4DSTEM/process/diskdetection/__init__.py
@@ -1,3 +1,4 @@
+from py4DSTEM.process.diskdetection.probe import Probe
 from py4DSTEM.process.diskdetection.braggvectors import BraggVectors
 from py4DSTEM.process.diskdetection.braggvector_methods import BraggVectorMap
 from py4DSTEM.process.diskdetection.diskdetection import *
diff --git a/py4DSTEM/process/diskdetection/braggvectors.py b/py4DSTEM/process/diskdetection/braggvectors.py
index 3130e2c76..15b326475 100644
--- a/py4DSTEM/process/diskdetection/braggvectors.py
+++ b/py4DSTEM/process/diskdetection/braggvectors.py
@@ -53,8 +53,10 @@ def __init__(
         Qshape,
         name = 'braggvectors',
         verbose = True,
+        calibration = None
         ):
         Custom.__init__(self,name=name)
+        Data.__init__(self,calibration=calibration)
 
         self.Rshape = Rshape
         self.shape = self.Rshape
diff --git a/py4DSTEM/process/diskdetection/probe.py b/py4DSTEM/process/diskdetection/probe.py
new file mode 100644
index 000000000..4952044fa
--- /dev/null
+++ b/py4DSTEM/process/diskdetection/probe.py
@@ -0,0 +1,608 @@
+# Defines the Probe class
+
+import numpy as np
+from typing import Optional
+
+from py4DSTEM.data import DiffractionSlice, Data
+from py4DSTEM.process.calibration import get_probe_size
+from py4DSTEM.process.utils import get_CoM, get_shifted_ar
+from scipy.ndimage import (
+    binary_opening, binary_dilation, distance_transform_edt)
+
+
+
+class Probe(DiffractionSlice,Data):
+    """
+    Stores a vacuum probe.
+
+    Both a vacuum probe and a kernel for cross-correlative template matching
+    derived from that probe are stored and can be accessed at
+
+        >>> p.probe
+        >>> p.kernel
+
+    respectively, for some Probe instance `p`. If a kernel has not been computed
+    the latter expression returns None.
+
+
+    """
+
+    def __init__(
+        self,
+        data: np.ndarray,
+        name: Optional[str] = 'probe'
+        ):
+        """
+        Accepts:
+            data (2D or 3D np.ndarray): the vacuum probe, or
+                the vacuum probe + kernel
+            name (str): a name
+
+        Returns:
+            (Probe)
+        """
+        # if only the probe is passed, make space for the kernel
+        if data.ndim == 2:
+            data = np.stack([
+                data,
+                np.zeros_like(data)
+            ])
+
+        # initialize as a DiffractionSlice
+        DiffractionSlice.__init__(
+            self,
+            name = name,
+            data = data,
+            slicelabels = [
+                'probe',
+                'kernel'
+            ]
+        )
+
+
+    ## properties
+
+    @property
+    def probe(self):
+        return self.get_slice('probe').data
+    @probe.setter
+    def probe(self,x):
+        assert(x.shape == (self.data.shape[1:]))
+        self.data[0,:,:] = x
+    @property
+    def kernel(self):
+        return self.get_slice('kernel').data
+    @kernel.setter
+    def kernel(self,x):
+        assert(x.shape == (self.data.shape[1:]))
+        self.data[1,:,:] = x
+
+
+    # read
+    @classmethod
+    def _get_constructor_args(cls,group):
+        """
+        Returns a dictionary of args/values to pass to the class constructor
+        """
+        ar_constr_args = DiffractionSlice._get_constructor_args(group)
+        args = {
+            'data' : ar_constr_args['data'],
+            'name' : ar_constr_args['name'],
+        }
+        return args
+
+
+
+    # generation methods
+
+    @classmethod
+    def from_vacuum_data(
+        cls,
+        data,
+        mask = None,
+        threshold = 0.2,
+        expansion = 12,
+        opening = 3
+        ):
+        """
+        Generates and returns a vacuum probe Probe instance from either a
+        2D vacuum image or a 3D stack of vacuum diffraction patterns.
+
+        The probe is multiplied by `mask`, if it's passed.  An additional
+        masking step zeros values outside of a mask determined by `threshold`,
+        `expansion`, and `opening`, generated by first computing the binary image
+        probe < max(probe)*threshold, then applying a binary expansion and
+        then opening to this image. No alignment is performed - i.e. it is assumed
+        that the beam was stationary during acquisition of the stack. To align
+        the images, use the DataCube .get_vacuum_probe method.
+
+        Parameters
+        ----------
+        data : 2D or 3D array
+            the vacuum diffraction data. For 3D stacks, use shape (N,Q_Nx,Q_Ny)
+        mask : boolean array, optional
+            mask applied to the probe
+        threshold : float
+            threshold determining mask which zeros values outside of probe
+        expansion : int
+            number of pixels by which the zeroing mask is expanded to capture
+            the full probe
+        opening : int
+            size of binary opening used to eliminate stray bright pixels
+
+        Returns
+        -------
+        probe : Probe
+            the vacuum probe
+        """
+        assert(isinstance(data,np.ndarray))
+        if data.ndim == 3:
+            probe = np.average(data,axis=0)
+        elif data.ndim == 2:
+            probe = data
+        else:
+            raise Exception(f"data must be 2- or 3-D, not {data.ndim}-D")
+
+        if mask is not None:
+            probe *= mask
+
+        mask = probe > np.max(probe)*threshold
+        mask = binary_opening(mask, iterations=opening)
+        mask = binary_dilation(mask, iterations=1)
+        mask = np.cos((np.pi/2)*np.minimum(
+            distance_transform_edt(np.logical_not(mask)) / expansion, 1))**2
+
+        probe = cls(probe*mask)
+        return probe
+
+
+    @classmethod
+    def generate_synthetic_probe(
+        cls,
+        radius,
+        width,
+        Qshape
+        ):
+        """
+        Makes a synthetic probe, with the functional form of a disk blurred by a
+        sigmoid (a logistic function).
+
+        Parameters
+        ----------
+        radius : float
+            the probe radius
+        width : float
+            the blurring of the probe edge. width represents the
+            full width of the blur, with x=-w/2 to x=+w/2 about the edge
+            spanning values of ~0.12 to 0.88
+        Qshape : 2 tuple
+            the diffraction plane dimensions
+
+        Returns
+        -------
+        probe : Probe
+            the probe
+        """
+        # Make coords
+        Q_Nx,Q_Ny = Qshape
+        qy,qx = np.meshgrid(np.arange(Q_Ny),np.arange(Q_Nx))
+        qy,qx = qy - Q_Ny/2., qx-Q_Nx/2.
+        qr = np.sqrt(qx**2+qy**2)
+
+        # Shift zero to disk edge
+        qr = qr - radius
+
+        # Calculate logistic function
+        probe = 1/(1+np.exp(4*qr/width))
+
+        return cls(probe)
+
+
+
+    # calibration methods
+
+    def measure_disk(
+        self,
+        thresh_lower=0.01,
+        thresh_upper=0.99,
+        N=100,
+        returncalc=True,
+        data=None,
+        ):
+        """
+        Finds the center and radius of an average probe image.
+
+        A naive algorithm. Creates a series of N binary masks by thresholding
+        the probe image a linspace of N thresholds from thresh_lower to
+        thresh_upper, relative to the image max/min. For each mask, we find the
+        square root of the number of True valued pixels divided by pi to
+        estimate a radius. Because the central disk is intense relative to the
+        remainder of the image, the computed radii are expected to vary very
+        little over a wider range threshold values. A range of r values
+        considered trustworthy is estimated by taking the derivative
+        r(thresh)/dthresh identifying where it is small, and the mean of this
+        range is returned as the radius. A center is estimated using a binary
+        thresholded image in combination with the center of mass operator.
+
+        Parameters
+        ----------
+        thresh_lower : float, 0 to 1
+            the lower limit of threshold values
+        thresh_upper : float, 0 to 1)
+            the upper limit of threshold values
+        N : int
+            the number of thresholds / masks to use
+        returncalc : True
+            toggles returning the answer
+        data : 2d array, optional
+            if passed, uses this 2D array in place of the probe image when
+            performing the computation. This also supresses storing the
+            results in the Probe's calibration metadata
+
+        Returns
+        -------
+        r, x0, y0 : (3-tuple)
+            the radius and origin
+        """
+        # set the image
+        im = self.probe if data is None else data
+
+        # define the thresholds
+        thresh_vals = np.linspace(thresh_lower, thresh_upper, N)
+        r_vals = np.zeros(N)
+
+        # get binary images and compute a radius for each
+        immax = np.max(im)
+        for i,val in enumerate(thresh_vals):
+            mask = im > immax * val
+            r_vals[i] = np.sqrt(np.sum(mask) / np.pi)
+
+        # Get derivative and determine trustworthy r-values
+        dr_dtheta = np.gradient(r_vals)
+        mask = (dr_dtheta <= 0) * (dr_dtheta >= 2 * np.median(dr_dtheta))
+        r = np.mean(r_vals[mask])
+
+        # Get origin
+        thresh = np.mean(thresh_vals[mask])
+        mask = im > immax * thresh
+        x0, y0 = get_CoM(im * mask)
+
+        # Store metadata and return
+        ans = r,x0,y0
+        if data is None:
+            try:
+                self.calibration.set_probe_param(ans)
+            except AttributeError:
+                warn(f"Couldn't store the probe parameters in metadata as no calibration was found for this Probe instance, {self}")
+                pass
+        if returncalc:
+            return ans
+
+
+
+
+
+
+
+
+    # Kernel generation methods
+
+    def get_kernel(
+        self,
+        mode = 'flat',
+        origin = None,
+        data = None,
+        returncalc = True,
+        **kwargs
+        ):
+        """
+        Creates a cross-correlation kernel from the vacuum probe.
+
+        Specific behavior and valid keyword arguments depend on the `mode`
+        specified.  In each case, the center of the probe is shifted to the
+        origin and the kernel normalized such that it sums to 1. This is the
+        only processing performed if mode is 'flat'. Otherwise, a centrosymmetric
+        region of negative intensity is added around the probe intended to promote
+        edge-filtering-like behavior during cross correlation, with the
+        functional form of the subtracted region defined by `mode` and the
+        relevant **kwargs. For normalization, flat probes integrate to 1, and the
+        remaining probes integrate to 1 before subtraction and 0 after.  Required
+        keyword arguments are:
+
+          - 'flat': No required arguments. This mode is recommended for bullseye
+            or other structured probes
+          - 'gaussian': Required arg `sigma` (number), the width (standard
+            deviation) of a centered gaussian to be subtracted.
+          - 'sigmoid': Required arg `radii` (2-tuple), the inner and outer radii
+            (ri,ro) of an annular region with a sine-squared sigmoidal radial
+            profile to be subtracted.
+          - 'sigmoid_log': Required arg `radii` (2-tuple), the inner and outer radii
+            (ri,ro) of an annular region with a logistic sigmoidal radial
+            profile to be subtracted.
+
+        Parameters
+        ----------
+        mode : str
+            must be in 'flat','gaussian','sigmoid','sigmoid_log'
+        origin : 2-tuple, optional
+            specify the origin. If not passed, looks for a value for the probe
+            origin in metadata. If not found there, calls .measure_probe.
+        data : 2d array, optional
+            if specified, uses this array instead of the probe image to compute
+            the kernel
+        **kwargs
+            see descriptions above
+
+        Returns
+        -------
+        kernel : 2D array
+        """
+
+        modes = [
+            'flat',
+            'gaussian',
+            'sigmoid',
+            'sigmoid_log'
+        ]
+
+        # parse args
+        assert mode in modes, f"mode must be in {modes}. Received {mode}"
+
+        # get function
+        function_dict = {
+            'flat' : self.get_probe_kernel_flat,
+            'gaussian' : self.get_probe_kernel_edge_gaussian,
+            'sigmoid' : self._get_probe_kernel_edge_sigmoid_sine_squared,
+            'sigmoid_log' : self._get_probe_kernel_edge_sigmoid_sine_squared
+        }
+        fn = function_dict[mode]
+
+        # check for the origin
+        if origin is None:
+            try:
+                x = self.calibration.get_probe_params()
+            except AttributeError:
+                x = None
+            finally:
+                if x is None:
+                    origin = None
+                else:
+                    r,x,y = x
+                    origin = (x,y)
+
+        # get the data
+        probe = data if data is not None else self.probe
+
+        print()
+        print('meow')
+        print(kwargs)
+        print()
+
+        # compute
+        kern = fn(
+            probe,
+            origin = origin,
+            **kwargs
+        )
+
+        # add to the Probe
+        self.kernel = kern
+
+        # return
+        if returncalc:
+            return kern
+
+
+
+    @staticmethod
+    def get_probe_kernel_flat(
+        probe,
+        origin=None,
+        bilinear=False
+        ):
+        """
+        Creates a cross-correlation kernel from the vacuum probe by normalizing
+        and shifting the center.
+
+        Parameters
+        ----------
+        probe : 2d array
+            the vacuum probe
+        origin : 2-tuple (optional)
+            the origin of diffraction space. If not specified, finds the origin
+            using get_probe_radius.
+        bilinear : bool (optional)
+            By default probe is shifted via a Fourier transform. Setting this to
+            True overrides it and uses bilinear shifting. Not recommended!
+
+        Returns
+        -------
+        kernel : ndarray
+            the cross-correlation kernel corresponding to the probe, in real
+            space
+        """
+        Q_Nx, Q_Ny = probe.shape
+
+        # Get CoM
+        if origin is None:
+            _,xCoM,yCoM = get_probe_size(probe)
+        else:
+            xCoM,yCoM = origin
+
+        # Normalize
+        probe = self.probe/np.sum(probe)
+
+        # Shift center to corners of array
+        probe_kernel = get_shifted_ar(probe, -xCoM, -yCoM, bilinear=bilinear)
+
+        # Return
+        return probe_kernel
+
+
+    @staticmethod
+    def get_probe_kernel_edge_gaussian(
+        probe,
+        sigma,
+        origin=None,
+        bilinear=True,
+        ):
+        """
+        Creates a cross-correlation kernel from the probe, subtracting a
+        gaussian from the normalized probe such that the kernel integrates to
+        zero, then shifting the center of the probe to the array corners.
+
+        Parameters
+        ----------
+        probe : ndarray
+            the diffraction pattern corresponding to the probe over vacuum
+        sigma : float
+            the width of the gaussian to subtract, relative to the standard
+            deviation of the probe
+        origin : 2-tuple (optional)
+            the origin of diffraction space. If not specified, finds the origin
+            using get_probe_radius.
+        bilinear : bool
+            By default probe is shifted via a Fourier transform. Setting this to
+            True overrides it and uses bilinear shifting. Not recommended!
+
+        Returns
+        -------
+        kernel : ndarray
+            the cross-correlation kernel
+        """
+        Q_Nx, Q_Ny = probe.shape
+
+        # Get CoM
+        if origin is None:
+            _,xCoM,yCoM = get_probe_size(probe)
+        else:
+            xCoM,yCoM = origin
+
+        # Shift probe to origin
+        probe_kernel = get_shifted_ar(probe, -xCoM, -yCoM, bilinear=bilinear)
+
+        # Generate normalization kernel
+        # Coordinates
+        qy,qx = np.meshgrid(
+            np.mod(np.arange(Q_Ny) + Q_Ny//2, Q_Ny) - Q_Ny//2,
+            np.mod(np.arange(Q_Nx) + Q_Nx//2, Q_Nx) - Q_Nx//2)
+        qr2 = (qx**2 + qy**2)
+        # Calculate Gaussian normalization kernel
+        qstd2 = np.sum(qr2*probe_kernel) / np.sum(probe_kernel)
+        kernel_norm = np.exp(-qr2 / (2*qstd2*sigma**2))
+
+        # Output normalized kernel
+        probe_kernel = probe_kernel/np.sum(probe_kernel) - kernel_norm/np.sum(kernel_norm)
+
+        return probe_kernel
+
+
+    @staticmethod
+    def get_probe_kernel_edge_sigmoid(
+        probe,
+        radii,
+        origin=None,
+        type='sine_squared',
+        bilinear=True,
+        ):
+        """
+        Creates a convolution kernel from an average probe, subtracting an annular
+        trench about the probe such that the kernel integrates to zero, then
+        shifting the center of the probe to the array corners.
+
+        Parameters
+        ----------
+        probe : ndarray
+            the diffraction pattern corresponding to the probe over vacuum
+        radii : 2-tuple
+            the sigmoid inner and outer radii
+        origin : 2-tuple (optional)
+            the origin of diffraction space. If not specified, finds the origin
+            using get_probe_radius.
+        type : string
+            must be 'logistic' or 'sine_squared'
+        bilinear : bool
+            By default probe is shifted via a Fourier transform. Setting this to
+            True overrides it and uses bilinear shifting. Not recommended!
+
+        Returns
+        -------
+        kernel : 2d array
+            the cross-correlation kernel
+        """
+        valid_types = ('logistic','sine_squared')
+        assert(type in valid_types), "type must be in {}".format(valid_types)
+        Q_Nx, Q_Ny = probe.shape
+        ri,ro = radii
+
+        # Get CoM
+        if origin is None:
+            _,xCoM,yCoM = get_probe_size(probe)
+        else:
+            xCoM,yCoM = origin
+
+        # Shift probe to origin
+        probe_kernel = get_shifted_ar(probe, -xCoM, -yCoM, bilinear=bilinear)
+
+        # Generate normalization kernel
+        # Coordinates
+        qy,qx = np.meshgrid(
+            np.mod(np.arange(Q_Ny) + Q_Ny//2, Q_Ny) - Q_Ny//2,
+            np.mod(np.arange(Q_Nx) + Q_Nx//2, Q_Nx) - Q_Nx//2)
+        qr = np.sqrt(qx**2 + qy**2)
+        # Calculate sigmoid
+        if type == 'logistic':
+            r0 = 0.5*(ro+ri)
+            sigma = 0.25*(ro-ri)
+            sigmoid = 1/(1+np.exp((qr-r0)/sigma))
+        elif type == 'sine_squared':
+            sigmoid = (qr - ri) / (ro - ri)
+            sigmoid = np.minimum(np.maximum(sigmoid, 0.0), 1.0)
+            sigmoid = np.cos((np.pi/2)*sigmoid)**2
+        else:
+            raise Exception("type must be in {}".format(valid_types))
+
+        # Output normalized kernel
+        probe_kernel = probe_kernel/np.sum(probe_kernel) - sigmoid/np.sum(sigmoid)
+
+        return probe_kernel
+
+
+    def _get_probe_kernel_edge_sigmoid_sine_squared(
+        self,
+        probe,
+        radii,
+        origin=None,
+        **kwargs,
+        ):
+        return self.get_probe_kernel_edge_sigmoid(
+            probe,
+            radii,
+            origin = origin,
+            type='sine_squared',
+            **kwargs,
+        )
+
+    def _get_probe_kernel_edge_sigmoid_logistic(
+        self,
+        probe,
+        radii,
+        origin=None,
+        **kwargs,
+        ):
+        return self.get_probe_kernel_edge_sigmoid(
+            probe,
+            radii,
+            origin = origin,
+            type='logistic',
+            **kwargs
+        )
+
+
+
+
+
+
+
+
+
diff --git a/py4DSTEM/process/probe/probe.py b/py4DSTEM/process/diskdetection/probe_gen_methods.py
similarity index 69%
rename from py4DSTEM/process/probe/probe.py
rename to py4DSTEM/process/diskdetection/probe_gen_methods.py
index 04a2926de..2e5925f24 100644
--- a/py4DSTEM/process/probe/probe.py
+++ b/py4DSTEM/process/diskdetection/probe_gen_methods.py
@@ -258,125 +258,6 @@ def get_probe_from_4Dscan_ROI_mask(
 
 
 
-def get_probe_from_vacuum_3Dstack(
-    data,
-    mask_threshold=0.2,
-    mask_expansion=12,
-    mask_opening=3
-    ):
-    """
-    Averages all diffraction patterns in a 3D stack of diffraction patterns,
-    assumed to be taken over vacuum, to create and average vacuum probe. No
-    alignment is performed - i.e. it is assumed that the beam was stationary
-    during acquisition of the stack.
-
-    Values outisde the average probe are zeroed, using a binary mask determined
-    by the optional parameters mask_threshold, mask_expansion, and mask_opening.
-    An initial binary mask is created using a threshold of less than
-    mask_threshold times the maximal probe value. A morphological opening of
-    mask_opening pixels is performed to eliminate stray pixels (e.g. from
-    x-rays), followed by a dilation of mask_expansion pixels to ensure the
-    entire probe is captured.
-
-    Args:
-        data (array): a 3D stack of vacuum diffraction patterns, shape
-            (Q_Nx,Q_Ny,N)
-        mask_threshold (float): threshold determining mask which zeros values
-            outside of probe
-        mask_expansion (int): number of pixels by which the zeroing mask is
-            expanded to capture the full probe
-        mask_opening (int): size of binary opening used to eliminate stray
-            bright pixels
-
-    Returns:
-        (array of shape (Q_Nx,Q_Ny)): the average probe
-    """
-    probe = np.average(data,axis=2)
-
-    mask = probe > np.max(probe)*mask_threshold
-    mask = binary_opening(mask, iterations=mask_opening)
-    mask = binary_dilation(mask, iterations=1)
-    mask = np.cos((np.pi/2)*np.minimum(distance_transform_edt(np.logical_not(mask)) / mask_expansion, 1))**2
-
-    return probe*mask
-
-
-
-
-def get_probe_from_vacuum_2Dimage(
-    data,
-    mask_threshold=0.2,
-    mask_expansion=12,
-    mask_opening=3
-    ):
-    """
-    A single image of the probe over vacuum is processed by zeroing values
-    outside the central disk, using a binary mask determined by the optional
-    parameters mask_threshold, mask_expansion, and mask_opening.  An initial
-    binary mask is created using a threshold of less than mask_threshold time
-    the maximal probe value. A morphological opening of mask_opening pixels is
-    performed to eliminate stray pixels (e.g. from x-rays), followed by a
-    dilation of mask_expansion pixels to ensure the entire probe is captured.
-
-    Args:
-        data (array): a 2D array of the vacuum diffraction pattern, shape
-            (Q_Nx,Q_Ny)
-        mask_threshold (float): threshold determining mask which zeros values
-            outside of probe
-        mask_expansion (int): number of pixels by which the zeroing mask is
-            expanded to capture the full probe
-        mask_opening (int): size of binary opening used to eliminate stray
-            bright pixels
-
-    Returns:
-        (array of shape (Q_Nx,Q_Ny)) the average probe
-    """
-    mask = data > np.max(data)*mask_threshold
-    mask = binary_opening(mask, iterations=mask_opening)
-    mask = binary_dilation(mask, iterations=1)
-    mask = np.cos((np.pi/2)*np.minimum(distance_transform_edt(np.logical_not(mask)) / mask_expansion, 1))**2
-
-    return data*mask
-
-
-
-
-def get_probe_synthetic(
-    radius,
-    width,
-    Qshape
-    ):
-    """
-    Makes a synthetic probe, with the functional form of a disk blurred by a
-    sigmoid (a logistic function).
-
-    Args:
-        radius (float): the probe radius
-        width (float): the blurring of the probe edge. width represents the
-            full width of the blur, with x=-w/2 to x=+w/2 about the edge
-            spanning values of ~0.12 to 0.88
-        Qshape (2 tuple): the diffraction plane dimensions
-
-    Returns:
-        (ndarray of shape (Q_Nx,Q_Ny)): the probe
-    """
-    # Make coords
-    Q_Nx,Q_Ny = Qshape
-    qy,qx = np.meshgrid(np.arange(Q_Ny),np.arange(Q_Nx))
-    qy,qx = qy - Q_Ny/2., qx-Q_Nx/2.
-    qr = np.sqrt(qx**2+qy**2)
-
-    # Shift zero to disk edge
-    qr = qr - radius
-
-    # Calculate logistic function
-    probe = 1/(1+np.exp(4*qr/width))
-
-    return probe
-
-
-
-
 
 
 
diff --git a/py4DSTEM/process/probe/__init__.py b/py4DSTEM/process/probe/__init__.py
deleted file mode 100644
index a77a14ae6..000000000
--- a/py4DSTEM/process/probe/__init__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-from py4DSTEM.process.probe.probe import *
-from py4DSTEM.process.probe.kernel import *
-
diff --git a/py4DSTEM/process/probe/kernel.py b/py4DSTEM/process/probe/kernel.py
deleted file mode 100644
index f415ae96d..000000000
--- a/py4DSTEM/process/probe/kernel.py
+++ /dev/null
@@ -1,279 +0,0 @@
-# Functions for preparing the probe for cross-correlative template matching.
-
-
-import numpy as np
-
-from py4DSTEM.process.utils import get_shifted_ar
-from py4DSTEM.process.calibration import get_probe_size
-
-
-def get_kernel(
-    probe,
-    mode = 'flat',
-    **kwargs
-    ):
-    """
-    Creates a kernel from the probe for cross-correlative template matching.
-
-    Precise behavior and valid keyword arguments depend on the `mode`
-    selected.  In each case, the center of the probe is shifted to the
-    origin and the kernel normalized such that it sums to 1. In 'flat'
-    mode, this is the only processing performed. In the remaining modes,
-    some additional processing is performed which adds a ring of
-    negative intensity around the central probe, which results in
-    edge-filetering-like behavior during cross correlation. Valid modes
-    are:
-
-        - 'flat': creates a flat probe kernel. For bullseye or other
-            structured probes, this mode is recommended.
-        - 'gaussian': subtracts a gaussian with a width of standard
-            deviation 'sigma'
-        - 'sigmoid': subtracts an annulus with inner and outer radii
-            of (ri,ro) and a sine-squared sigmoid radial profile from
-            the probe template.
-        - 'sigmoid_log': subtracts an annulus with inner and outer radii
-            of (ri,ro) and a logistic sigmoid radial profile from
-            the probe template.
-
-    Each mode accepts 'center' (2-tuple) as a kwarg to manually specify
-    the center of the probe, which is otherwise autodetected. Modes which
-    accept additional kwargs and those arguments are:
-
-        - 'gaussian':
-            sigma (number)
-        - 'sigmoid':
-            radii (2-tuple)
-        - 'sigmoid_log':
-            radii (2-tuple)
-
-    Accepts:
-        probe (2D array):
-        mode (str): must be in 'flat','gaussian','sigmoid','sigmoid_log'
-        **kwargs: depend on `mode`, see above
-
-    Returns:
-        (2D array)
-    """
-
-    modes = [
-        'flat',
-        'gaussian',
-        'sigmoid',
-        'sigmoid_log'
-    ]
-
-    # parse args
-    assert mode in modes, f"mode must be in {modes}. Received {mode}"
-
-    # get function
-    fn_dict = _make_function_dict()
-    fn = fn_dict[mode]
-
-    # compute and return
-    kernel = fn(probe, **kwargs)
-    return kernel
-
-
-
-def _make_function_dict():
-    d = {
-        'flat' : get_probe_kernel,
-        'gaussian' : get_probe_kernel_edge_gaussian,
-        'sigmoid' : _get_probe_kernel_edge_sigmoid_sine_squared,
-        'sigmoid_log' : _get_probe_kernel_edge_sigmoid_sine_squared
-    }
-    return d
-
-
-
-
-
-def get_probe_kernel(
-    probe,
-    origin=None,
-    bilinear=True
-    ):
-    """
-    Creates a convolution kernel from an average probe, by normalizing, then
-    shifting the center of the probe to the corners of the array.
-
-    Args:
-        probe (ndarray): the diffraction pattern corresponding to the probe over
-            vacuum
-        origin (2-tuple or None): if None (default), finds the origin using
-            get_probe_radius. Otherwise, should be a 2-tuple (x0,y0) specifying
-            the origin position
-        bilinear (bool): By default probe is shifted via a Fourier transform. 
-                 Setting this to True overrides it and uses bilinear shifting.
-                 Not recommended!
-
-    Returns:
-        (ndarray): the convolution kernel corresponding to the probe, in real
-            space
-    """
-    Q_Nx, Q_Ny = probe.shape
-
-    # Get CoM
-    if origin is None:
-        _,xCoM,yCoM = get_probe_size(probe)
-    else:
-        xCoM,yCoM = origin
-
-    # Normalize
-    probe = probe/np.sum(probe)
-
-    # Shift center to corners of array
-    probe_kernel = get_shifted_ar(probe, -xCoM, -yCoM, bilinear=bilinear)
-
-    return probe_kernel
-
-
-def get_probe_kernel_edge_gaussian(
-        probe,
-        sigma,
-        origin=None,
-        bilinear=True,
-        ):
-    """
-    Creates a convolution kernel from an average probe, subtracting a gaussian
-    from the normalized probe such that the kernel integrates to zero, then
-    shifting the center of the probe to the array corners.
-
-    Args:
-        probe (ndarray): the diffraction pattern corresponding to the probe
-            over vacuum
-        sigma (float): the width of the gaussian to subtract, relative to
-            the standard deviation of the probe
-        origin (2-tuple or None): if None (default), finds the origin using
-            get_probe_radius. Otherwise, should be a 2-tuple (x0,y0) specifying
-            the origin position
-        bilinear (bool): By default probe is shifted via a Fourier transform.
-                         Setting this to True overrides it and uses bilinear shifting.
-                         Not recommended!
-
-    Returns:
-        (ndarray) the convolution kernel corresponding to the probe
-    """
-    Q_Nx, Q_Ny = probe.shape
-
-    # Get CoM
-    if origin is None:
-        _,xCoM,yCoM = get_probe_size(probe)
-    else:
-        xCoM,yCoM = origin
-
-    # Shift probe to origin
-    probe_kernel = get_shifted_ar(probe, -xCoM, -yCoM, bilinear=bilinear)
-
-    # Generate normalization kernel
-    # Coordinates
-    qy,qx = np.meshgrid(
-        np.mod(np.arange(Q_Ny) + Q_Ny//2, Q_Ny) - Q_Ny//2,
-        np.mod(np.arange(Q_Nx) + Q_Nx//2, Q_Nx) - Q_Nx//2)
-    qr2 = (qx**2 + qy**2)
-    # Calculate Gaussian normalization kernel
-    qstd2 = np.sum(qr2*probe_kernel) / np.sum(probe_kernel)
-    kernel_norm = np.exp(-qr2 / (2*qstd2*sigma**2))
-
-    # Output normalized kernel
-    probe_kernel = probe_kernel/np.sum(probe_kernel) - kernel_norm/np.sum(kernel_norm)
-
-    return probe_kernel
-
-
-def get_probe_kernel_edge_sigmoid(
-    probe,
-    radii,
-    origin=None,
-    type='sine_squared',
-    bilinear=True,
-    ):
-    """
-    Creates a convolution kernel from an average probe, subtracting an annular
-    trench about the probe such that the kernel integrates to zero, then
-    shifting the center of the probe to the array corners.
-
-    Args:
-        probe (ndarray): the diffraction pattern corresponding to the probe over
-            vacuum
-        radii (2-tuple): the sigmoid inner and outer radii, from the probe center
-        origin (2-tuple or None): if None (default), finds the origin using
-            get_probe_radius. Otherwise, should be a 2-tuple (x0,y0) specifying
-            the origin position
-        type (string): must be 'logistic' or 'sine_squared'
-        bilinear (bool): By default probe is shifted via a Fourier transform. 
-                 Setting this to True overrides it and uses bilinear shifting.
-                 Not recommended!
-
-    Returns:
-        (ndarray): the convolution kernel corresponding to the probe
-    """
-    valid_types = ('logistic','sine_squared')
-    assert(type in valid_types), "type must be in {}".format(valid_types)
-    Q_Nx, Q_Ny = probe.shape
-    ri,ro = radii
-
-    # Get CoM
-    if origin is None:
-        _,xCoM,yCoM = get_probe_size(probe)
-    else:
-        xCoM,yCoM = origin
-
-    # Shift probe to origin
-    probe_kernel = get_shifted_ar(probe, -xCoM, -yCoM, bilinear=bilinear)
-
-    # Generate normalization kernel
-    # Coordinates
-    qy,qx = np.meshgrid(
-        np.mod(np.arange(Q_Ny) + Q_Ny//2, Q_Ny) - Q_Ny//2,
-        np.mod(np.arange(Q_Nx) + Q_Nx//2, Q_Nx) - Q_Nx//2)
-    qr = np.sqrt(qx**2 + qy**2)
-    # Calculate sigmoid
-    if type == 'logistic':
-        r0 = 0.5*(ro+ri)
-        sigma = 0.25*(ro-ri)
-        sigmoid = 1/(1+np.exp((qr-r0)/sigma))
-    elif type == 'sine_squared':
-        sigmoid = (qr - ri) / (ro - ri)
-        sigmoid = np.minimum(np.maximum(sigmoid, 0.0), 1.0)
-        sigmoid = np.cos((np.pi/2)*sigmoid)**2
-    else:
-        raise Exception("type must be in {}".format(valid_types))
-
-    # Output normalized kernel
-    probe_kernel = probe_kernel/np.sum(probe_kernel) - sigmoid/np.sum(sigmoid)
-
-    return probe_kernel
-
-
-
-def _get_probe_kernel_edge_sigmoid_sine_squared(
-    probe,
-    radii,
-    origin=None,
-    **kwargs,
-    ):
-    return get_probe_kernel_edge_sigmoid(
-        probe,
-        radii,
-        origin = origin,
-        type='sine_squared',
-        **kwargs,
-    )
-
-def _get_probe_kernel_edge_sigmoid_logistic(
-    probe,
-    radii,
-    origin=None,
-    **kwargs,
-    ):
-    return get_probe_kernel_edge_sigmoid(
-        probe,
-        radii,
-        origin = origin,
-        type='logistic',
-        **kwargs
-    )
-
-
-
diff --git a/test/test_braggvectors.py b/test/test_braggvectors.py
index e8a8d5ccc..107cf7a64 100644
--- a/test/test_braggvectors.py
+++ b/test/test_braggvectors.py
@@ -24,7 +24,7 @@ def setup_class(cls):
         mask = np.zeros(datacube.Rshape,dtype=bool)
         mask[28:33,14:19] = 1
         probe = datacube.get_vacuum_probe( ROI=mask )
-        alpha_pr,qx0_pr,qy0_pr = py4DSTEM.process.probe.get_probe_size( probe.probe )
+        alpha_pr,qx0_pr,qy0_pr = py4DSTEM.process.calibration.get_probe_size( probe.probe )
         probe.get_kernel(
             mode='sigmoid',
             origin=(qx0_pr,qy0_pr),
diff --git a/test/test_native_io/test_single_object_io.py b/test/test_native_io/test_single_object_io.py
index ae77b01cd..6687274c5 100644
--- a/test/test_native_io/test_single_object_io.py
+++ b/test/test_native_io/test_single_object_io.py
@@ -14,8 +14,8 @@
     RealSlice,
     QPoints,
 )
-from py4DSTEM.process.diskdetection import BraggVectors
-from py4DSTEM.classes import Probe, VirtualDiffraction, VirtualImage
+from py4DSTEM.process.diskdetection import BraggVectors,Probe
+from py4DSTEM.classes import VirtualDiffraction, VirtualImage
 
 # Set paths
 dirpath = py4DSTEM._TESTPATH
diff --git a/test/test_probe.py b/test/test_probe.py
new file mode 100644
index 000000000..ad10c3100
--- /dev/null
+++ b/test/test_probe.py
@@ -0,0 +1,65 @@
+import py4DSTEM
+from py4DSTEM import Probe
+import numpy as np
+from os.path import join
+
+# set filepath
+path = py4DSTEM._TESTPATH + "/small_datacube.dm4"
+
+
+
+class TestProbe:
+
+    # setup/teardown
+    def setup_class(cls):
+
+        # Read datacube
+        datacube = py4DSTEM.import_file(path)
+        cls.datacube = datacube
+
+    # tests
+
+    def test_probe_gen_from_dp(self):
+        p = Probe.from_vacuum_data(
+            self.datacube[0,0]
+        )
+        assert(isinstance(p,Probe))
+        pass
+
+    def test_probe_gen_from_stack(self):
+        # get a 3D stack
+        x,y = np.zeros(10).astype(int),np.arange(10).astype(int)
+        data = self.datacube.data[x,y,:,:]
+        # get the probe
+        p = Probe.from_vacuum_data(
+            data
+        )
+        assert(isinstance(p,Probe))
+        pass
+
+    def test_probe_gen_from_datacube_ROI_1(self):
+        ROI = np.zeros(self.datacube.Rshape,dtype=bool)
+        ROI[3:7,5:10] = True
+        p = self.datacube.get_vacuum_probe( ROI )
+        assert(isinstance(p,Probe))
+
+        self.datacube.tree()
+        self.datacube.tree(True)
+        _p = self.datacube.tree('probe')
+        print(_p)
+
+        assert(p is self.datacube.tree('probe'))
+        pass
+
+    def test_probe_gen_from_datacube_ROI_2(self):
+        ROI = (3,7,5,10)
+        p = self.datacube.get_vacuum_probe( ROI )
+        assert(isinstance(p,Probe))
+        assert(p is self.datacube.tree('probe'))
+        pass
+
+
+
+
+
+
diff --git a/test/test_workflow/test_disk_detection_basic.py b/test/test_workflow/test_disk_detection_basic.py
index 058fb67ee..60a5e2aa1 100644
--- a/test/test_workflow/test_disk_detection_basic.py
+++ b/test/test_workflow/test_disk_detection_basic.py
@@ -23,7 +23,7 @@ def setup_class(cls):
         mask = zeros(datacube.Rshape,dtype=bool)
         mask[28:33,14:19] = 1
         probe = datacube.get_vacuum_probe( ROI=mask )
-        alpha_pr,qx0_pr,qy0_pr = py4DSTEM.process.probe.get_probe_size( probe.probe )
+        alpha_pr,qx0_pr,qy0_pr = py4DSTEM.process.calibration.get_probe_size( probe.probe )
         probe.get_kernel(
             mode='sigmoid',
             origin=(qx0_pr,qy0_pr),
diff --git a/test/test_workflow/test_disk_detection_with_calibration.py b/test/test_workflow/test_disk_detection_with_calibration.py
index c1bb4a581..b93e2d00b 100644
--- a/test/test_workflow/test_disk_detection_with_calibration.py
+++ b/test/test_workflow/test_disk_detection_with_calibration.py
@@ -23,7 +23,7 @@ def setup_class(cls):
         mask = zeros(datacube.Rshape,dtype=bool)
         mask[28:33,14:19] = 1
         probe = datacube.get_vacuum_probe( ROI=mask )
-        alpha_pr,qx0_pr,qy0_pr = py4DSTEM.process.probe.get_probe_size( probe.probe )
+        alpha_pr,qx0_pr,qy0_pr = py4DSTEM.process.calibration.get_probe_size( probe.probe )
         probe.get_kernel(
             mode='sigmoid',
             origin=(qx0_pr,qy0_pr),

From cc57170407ca0118042d16aa4477f0f6fda14825 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Wed, 28 Jun 2023 17:16:55 -0700
Subject: [PATCH 079/362] Adding 2D calibrations

---
 py4DSTEM/io/filereaders/read_abTEM.py | 14 ++++++++++++--
 py4DSTEM/io/filereaders/read_arina.py |  2 +-
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/py4DSTEM/io/filereaders/read_abTEM.py b/py4DSTEM/io/filereaders/read_abTEM.py
index af0c71c63..cf6892d76 100644
--- a/py4DSTEM/io/filereaders/read_abTEM.py
+++ b/py4DSTEM/io/filereaders/read_abTEM.py
@@ -60,9 +60,19 @@ def read_abTEM(
     elif len(data.shape) == 2:
         if units[0] == b"mrad":
             diffraction = VirtualDiffraction(data=data)
-            # TODO, calibrations for 2D
+            if sampling[0] != sampling[1]:
+                print(
+                    "Warning: py4DSTEM currently only handles uniform qx,qy sampling. Setting sampling with x calibration"
+                )
+            diffraction.calibration.set_Q_pixel_units(units[0].decode("utf-8"))
+            diffraction.calibration.set_Q_pixel_size(sampling[0])
             return diffraction
         elif units[0] == b"\xc3\x85":
             image = VirtualImage(data=data)
-            # TODO calibrations for 2D
+            if sampling[0] != sampling[1]:
+                print(
+                    "Warning: py4DSTEM currently only handles uniform x,y sampling. Setting sampling with x calibration"
+                )
+            image.calibration.set_Q_pixel_units("A")
+            image.calibration.set_Q_pixel_size(sampling[0])
             return image
diff --git a/py4DSTEM/io/filereaders/read_arina.py b/py4DSTEM/io/filereaders/read_arina.py
index 0f334f52b..1434301fe 100644
--- a/py4DSTEM/io/filereaders/read_arina.py
+++ b/py4DSTEM/io/filereaders/read_arina.py
@@ -7,7 +7,7 @@
 
 def read_arina(
     filename,
-    scan_width,
+    scan_width=1,
     mem="RAM",
     binfactor: int = 1,
     dtype_bin: float = None,

From 439afedf1a9120110346ba42c84eaefc0a647e0d Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Wed, 28 Jun 2023 22:10:03 -0400
Subject: [PATCH 080/362] correctly links + sets cals/data on read

---
 py4DSTEM/data/calibration.py                  |  9 +-
 py4DSTEM/io/read.py                           | 18 ++--
 py4DSTEM/io/sample_file_ids.py                |  1 -
 py4DSTEM/io/save.py                           | 36 +++++++-
 py4DSTEM/process/calibration/origin.py        | 86 +++++++++----------
 py4DSTEM/process/calibration/probe.py         |  7 ++
 .../diskdetection/braggvector_methods.py      | 21 +++--
 .../process/diskdetection/braggvectors.py     |  6 ++
 py4DSTEM/process/diskdetection/probe.py       | 11 ++-
 9 files changed, 128 insertions(+), 67 deletions(-)
 delete mode 100644 py4DSTEM/io/sample_file_ids.py

diff --git a/py4DSTEM/data/calibration.py b/py4DSTEM/data/calibration.py
index e2fe0c393..6077864f3 100644
--- a/py4DSTEM/data/calibration.py
+++ b/py4DSTEM/data/calibration.py
@@ -202,10 +202,10 @@ def __init__(
         self._targets = []
 
         # set initial pixel values
-        self.set_Q_pixel_size(1)
-        self.set_R_pixel_size(1)
-        self.set_Q_pixel_units('pixels')
-        self.set_R_pixel_units('pixels')
+        self['Q_pixel_size'] = 1
+        self['R_pixel_size'] = 1
+        self['Q_pixel_units'] = 'pixels'
+        self['R_pixel_units'] = 'pixels'
 
 
     # EMD root property
@@ -779,6 +779,7 @@ def to_h5(self,group):
         self['_target_paths'] = targets
         # Save the metadata
         Metadata.to_h5(self,group)
+        del(self._params['_target_paths'])
 
     # read
     @classmethod
diff --git a/py4DSTEM/io/read.py b/py4DSTEM/io/read.py
index 589486040..79291fe86 100644
--- a/py4DSTEM/io/read.py
+++ b/py4DSTEM/io/read.py
@@ -82,13 +82,15 @@ def read(
         version = emd._get_EMD_version(filepath)
         if verbose: print(f"EMD version {version[0]}.{version[1]}.{version[2]} detected. Reading...")
         assert emd._version_is_geq(version,(1,0,0)), f"EMD version {version} detected. Expected version >= 1.0.0"
+
         # read
         data = emd.read(
             filepath,
             emdpath = datapath,
             tree = tree
         )
-        # calibration links
+
+        # add calibration links
         if isinstance(data,py4DSTEM.Data):
             with warnings.catch_warnings():
                 warnings.simplefilter('ignore')
@@ -102,16 +104,22 @@ def read(
             cal = None
         if cal is not None:
             try:
+                root_treepath = cal['_root_treepath']
                 target_paths = cal['_target_paths']
                 del(cal._params['_target_paths'])
                 for p in target_paths:
-                    d = data.root.tree(p)
-                    cal.register_target( d )
-                    if hasattr(d,'setcal'):
-                        d.setcal()
+                    try:
+                        p = p.replace(root_treepath,'')
+                        d = data.root.tree(p)
+                        cal.register_target( d )
+                        if hasattr(d,'setcal'):
+                            d.setcal()
+                    except AssertionError:
+                        pass
             except KeyError:
                 pass
             cal.calibrate()
+
         # return
         if verbose: print("Done.")
         return data
diff --git a/py4DSTEM/io/sample_file_ids.py b/py4DSTEM/io/sample_file_ids.py
deleted file mode 100644
index 8b1378917..000000000
--- a/py4DSTEM/io/sample_file_ids.py
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/py4DSTEM/io/save.py b/py4DSTEM/io/save.py
index 3d2ae95d8..ce79b6cd0 100644
--- a/py4DSTEM/io/save.py
+++ b/py4DSTEM/io/save.py
@@ -1,4 +1,38 @@
-from emdfile import save
+from emdfile import save as _save
+
+
+def save(
+    filepath,
+    data,
+    mode='w',
+    emdpath=None,
+    tree=True
+    ):
+    """
+    Saves data to an EMD 1.0 formatted HDF5 file at filepath.
+
+    For the full docstring, see py4DSTEM.emdfile.save.
+    """
+    # This function wraps emdfile's save and adds a small piece
+    # of metadata to the calibration to allow linking to calibrated
+    # data items on read
+
+    cal = None
+    if hasattr(data,'calibration') and data.calibration is not None:
+        cal = data.calibration
+        rp = '/'.join(data._treepath.split('/')[:-1])
+        cal['_root_treepath'] = rp
+
+    _save(
+        filepath,
+        data = data,
+        mode = mode,
+        emdpath = emdpath,
+        tree = tree
+    )
+
+    if cal is not None:
+       del(cal._params['_root_treepath'])
 
 
 
diff --git a/py4DSTEM/process/calibration/origin.py b/py4DSTEM/process/calibration/origin.py
index 5a4b09803..b3a141231 100644
--- a/py4DSTEM/process/calibration/origin.py
+++ b/py4DSTEM/process/calibration/origin.py
@@ -12,49 +12,49 @@
 from py4DSTEM.process.utils import get_CoM, add_to_2D_array_from_floats, get_maxima_2D
 
 
-
-# origin setting decorators
-
-def set_measured_origin(fun):
-    """
-    This is intended as a decorator function to wrap other functions which measure
-    the position of the origin.  If some function `get_the_origin` returns the
-    position of the origin as a tuple of two (R_Nx,R_Ny)-shaped arrays, then
-    decorating the function definition like
-
-        >>> @measure_origin
-        >>> def get_the_origin(...):
-
-    will make the function also save those arrays as the measured origin in the
-    calibration associated with the data used for the measurement. Any existing
-    measured origin value will be overwritten.
-
-    For the wrapper to work, the decorated function's first argument must have
-    a .calibration property, and its first two return values must be qx0,qy0.
-    """
-    @functools.wraps(fun)
-    def wrapper(*args,**kwargs):
-        ans = fun(*args,**kwargs)
-        data = args[0]
-        cali = data.calibration
-        cali.set_origin_meas((ans[0],ans[1]))
-        return ans
-    return wrapper
-
-
-def set_fit_origin(fun):
-    """
-    See docstring for `set_measured_origin`
-    """
-    @functools.wraps(fun)
-    def wrapper(*args,**kwargs):
-        ans = fun(*args,**kwargs)
-        data = args[0]
-        cali = data.calibration
-        cali.set_origin((ans[0],ans[1]))
-        return ans
-    return wrapper
-
+# 
+# # origin setting decorators
+# 
+# def set_measured_origin(fun):
+#     """
+#     This is intended as a decorator function to wrap other functions which measure
+#     the position of the origin.  If some function `get_the_origin` returns the
+#     position of the origin as a tuple of two (R_Nx,R_Ny)-shaped arrays, then
+#     decorating the function definition like
+# 
+#         >>> @measure_origin
+#         >>> def get_the_origin(...):
+# 
+#     will make the function also save those arrays as the measured origin in the
+#     calibration associated with the data used for the measurement. Any existing
+#     measured origin value will be overwritten.
+# 
+#     For the wrapper to work, the decorated function's first argument must have
+#     a .calibration property, and its first two return values must be qx0,qy0.
+#     """
+#     @functools.wraps(fun)
+#     def wrapper(*args,**kwargs):
+#         ans = fun(*args,**kwargs)
+#         data = args[0]
+#         cali = data.calibration
+#         cali.set_origin_meas((ans[0],ans[1]))
+#         return ans
+#     return wrapper
+# 
+# 
+# def set_fit_origin(fun):
+#     """
+#     See docstring for `set_measured_origin`
+#     """
+#     @functools.wraps(fun)
+#     def wrapper(*args,**kwargs):
+#         ans = fun(*args,**kwargs)
+#         data = args[0]
+#         cali = data.calibration
+#         cali.set_origin((ans[0],ans[1]))
+#         return ans
+#     return wrapper
+# 
 
 
 
diff --git a/py4DSTEM/process/calibration/probe.py b/py4DSTEM/process/calibration/probe.py
index d77f88500..8d9a87ae2 100644
--- a/py4DSTEM/process/calibration/probe.py
+++ b/py4DSTEM/process/calibration/probe.py
@@ -34,11 +34,18 @@ def get_probe_size(DP, thresh_lower=0.01, thresh_upper=0.99, N=100):
             * **x0**: *(float)* the x position of the central disk center
             * **y0**: *(float)* the y position of the central disk center
     """
+    from py4DSTEM.process.diskdetection import Probe
+
+    # parse input
+    if isinstance(DP,Probe):
+        DP = DP.probe
+
     thresh_vals = np.linspace(thresh_lower, thresh_upper, N)
     r_vals = np.zeros(N)
 
     # Get r for each mask
     DPmax = np.max(DP)
+    print(DPmax)
     for i in range(len(thresh_vals)):
         thresh = thresh_vals[i]
         mask = DP > DPmax * thresh
diff --git a/py4DSTEM/process/diskdetection/braggvector_methods.py b/py4DSTEM/process/diskdetection/braggvector_methods.py
index bb03852ed..d55332214 100644
--- a/py4DSTEM/process/diskdetection/braggvector_methods.py
+++ b/py4DSTEM/process/diskdetection/braggvector_methods.py
@@ -4,7 +4,6 @@
 from scipy.ndimage import gaussian_filter
 from emdfile import Array,Metadata
 from emdfile import _read_metadata
-from py4DSTEM.process.calibration.origin import set_measured_origin, set_fit_origin
 from py4DSTEM.process.utils import get_CoM
 
 
@@ -179,7 +178,6 @@ def histogram(
 
     # calibration measurements
 
-    @set_measured_origin
     def measure_origin(
         self,
         center_guess = None,
@@ -269,11 +267,14 @@ def measure_origin(
                     qx0[Rx, Ry] = x0
                     qy0[Rx, Ry] = y0
 
+        # set calibration metadata
+        self.calibration.set_origin_meas((qx0,qy0))
+        self.calibration.set_origin_meas_mask(mask)
+
         # return
         return qx0, qy0, mask
 
 
-    @set_measured_origin
     def measure_origin_beamstop(
         self,
         center_guess,
@@ -353,14 +354,18 @@ def measure_origin_beamstop(
             y0_curr = np.mean(centers[found_center,1])
             center_curr = x0_curr,y0_curr
 
-        # return
+        # collect answers
         mask = found_center
         qx0,qy0 = centers[:,:,0],centers[:,:,1]
 
+        # set calibration metadata
+        self.calibration.set_origin_meas((qx0,qy0))
+        self.calibration.set_origin_meas_mask(mask)
+
+        # return
         return qx0,qy0,mask
 
 
-    @set_fit_origin
     def fit_origin(
         self,
         mask=None,
@@ -456,6 +461,8 @@ def fit_origin(
                 **kwargs,
             )
 
+        # update calibration metadata
+        self.calibration.set_origin((qx0_fit,qy0_fit))
         self.setcal()
 
         if returncalc:
@@ -472,11 +479,11 @@ def fit_p_ellipse(
         ):
         """
         Args:
-            bvm (BraggVectorMap): a 2D array used for ellipse fitting 
+            bvm (BraggVectorMap): a 2D array used for ellipse fitting
             center (2-tuple of floats): the center (x0,y0) of the annular fitting region
             fitradii (2-tuple of floats): inner and outer radii (ri,ro) of the fit region
             mask (ar-shaped ndarray of bools): ignore data wherever mask==True
-        
+
         Returns:
             p_ellipse if returncal is True
         """
diff --git a/py4DSTEM/process/diskdetection/braggvectors.py b/py4DSTEM/process/diskdetection/braggvectors.py
index 15b326475..e6566a33e 100644
--- a/py4DSTEM/process/diskdetection/braggvectors.py
+++ b/py4DSTEM/process/diskdetection/braggvectors.py
@@ -80,9 +80,15 @@ def __init__(
             "pixel" : False,
             "rotate" : False,
         }
+
+        # register with calibrations
+        self.calibration.register_target(self)
+
+        # setup vector getters
         self._set_raw_vector_getter()
         self._set_cal_vector_getter()
 
+
     @property
     def calstate(self):
         return self._calstate
diff --git a/py4DSTEM/process/diskdetection/probe.py b/py4DSTEM/process/diskdetection/probe.py
index 4952044fa..3525e42be 100644
--- a/py4DSTEM/process/diskdetection/probe.py
+++ b/py4DSTEM/process/diskdetection/probe.py
@@ -326,7 +326,7 @@ def get_kernel(
             must be in 'flat','gaussian','sigmoid','sigmoid_log'
         origin : 2-tuple, optional
             specify the origin. If not passed, looks for a value for the probe
-            origin in metadata. If not found there, calls .measure_probe.
+            origin in metadata. If not found there, calls .measure_disk.
         data : 2d array, optional
             if specified, uses this array instead of the probe image to compute
             the kernel
@@ -373,11 +373,6 @@ def get_kernel(
         # get the data
         probe = data if data is not None else self.probe
 
-        print()
-        print('meow')
-        print(kwargs)
-        print()
-
         # compute
         kern = fn(
             probe,
@@ -530,6 +525,10 @@ def get_probe_kernel_edge_sigmoid(
         kernel : 2d array
             the cross-correlation kernel
         """
+        # parse inputs
+        if isinstance(probe,Probe):
+            probe = probe.probe
+
         valid_types = ('logistic','sine_squared')
         assert(type in valid_types), "type must be in {}".format(valid_types)
         Q_Nx, Q_Ny = probe.shape

From 0392cb0146af52eb58d32b3657c53f592ad5772c Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Wed, 28 Jun 2023 22:39:20 -0400
Subject: [PATCH 081/362] fix extraneous save warning

---
 py4DSTEM/io/save.py | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/py4DSTEM/io/save.py b/py4DSTEM/io/save.py
index ce79b6cd0..ce0076724 100644
--- a/py4DSTEM/io/save.py
+++ b/py4DSTEM/io/save.py
@@ -1,5 +1,5 @@
 from emdfile import save as _save
-
+import warnings
 
 def save(
     filepath,
@@ -18,10 +18,12 @@ def save(
     # data items on read
 
     cal = None
-    if hasattr(data,'calibration') and data.calibration is not None:
-        cal = data.calibration
-        rp = '/'.join(data._treepath.split('/')[:-1])
-        cal['_root_treepath'] = rp
+    with warnings.catch_warnings():
+        warnings.simplefilter('ignore')
+        if hasattr(data,'calibration') and data.calibration is not None:
+            cal = data.calibration
+            rp = '/'.join(data._treepath.split('/')[:-1])
+            cal['_root_treepath'] = rp
 
     _save(
         filepath,

From 4e057a9aa7a728d75447a8b826d12f35c7aedbc7 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Thu, 29 Jun 2023 00:11:56 -0400
Subject: [PATCH 082/362] legacy13 stackarray bugfix

---
 py4DSTEM/io/legacy/legacy13/v13_to_14.py | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/py4DSTEM/io/legacy/legacy13/v13_to_14.py b/py4DSTEM/io/legacy/legacy13/v13_to_14.py
index 9bafe15d2..c9509d9f3 100644
--- a/py4DSTEM/io/legacy/legacy13/v13_to_14.py
+++ b/py4DSTEM/io/legacy/legacy13/v13_to_14.py
@@ -1,5 +1,6 @@
 # Convert v13 to v14 classes
 
+import numpy as np
 from emdfile import tqdmnd
 
 
@@ -138,9 +139,13 @@ def _v13_to_14_cls(obj):
         )
 
     elif isinstance(obj, DiffractionSlice13):
+        if obj.is_stack:
+            data = np.rollaxis(obj.data, axis=2)
+        else:
+            data = obj.data
         x = DiffractionSlice(
             name = obj.name,
-            data = obj.data,
+            data = data,
             units = obj.units,
             slicelabels = obj.slicelabels
         )
@@ -152,9 +157,13 @@ def _v13_to_14_cls(obj):
         )
 
     elif isinstance(obj, RealSlice13):
+        if obj.is_stack:
+            data = np.rollaxis(obj.data, axis=2)
+        else:
+            data = obj.data
         x = RealSlice(
             name = obj.name,
-            data = obj.data,
+            data = data,
             units = obj.units,
             slicelabels = obj.slicelabels
         )
@@ -196,9 +205,13 @@ def _v13_to_14_cls(obj):
     elif isinstance(obj, Array13):
 
         # prepare arguments
+        if obj.is_stack:
+            data = np.rollaxis(obj.data, axis=2)
+        else:
+            data = obj.data
         args = {
             'name' : obj.name,
-            'data' : obj.data
+            'data' : data
         }
         if hasattr(obj,'units'): args['units'] = obj.units
         if hasattr(obj,'dim_names'): args['dim_names'] = obj.dim_names

From 067d42172ba1cea78c7aea60c0bb7c240c36e78d Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Thu, 29 Jun 2023 00:18:52 -0400
Subject: [PATCH 083/362] legacy io bugfix

---
 py4DSTEM/io/legacy/legacy13/v13_to_14.py | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/py4DSTEM/io/legacy/legacy13/v13_to_14.py b/py4DSTEM/io/legacy/legacy13/v13_to_14.py
index 1b0deafaa..a569b8915 100644
--- a/py4DSTEM/io/legacy/legacy13/v13_to_14.py
+++ b/py4DSTEM/io/legacy/legacy13/v13_to_14.py
@@ -1,5 +1,6 @@
 # Convert v13 to v14 classes
 
+import numpy as np
 from emdfile import tqdmnd
 
 
@@ -137,9 +138,13 @@ def _v13_to_14_cls(obj):
         )
 
     elif isinstance(obj, DiffractionSlice13):
+        if obj.is_stack:
+            data = np.rollaxis(obj.data, axis=2)
+        else:
+            data = obj.data
         x = DiffractionSlice(
             name = obj.name,
-            data = obj.data,
+            data = data,
             units = obj.units,
             slicelabels = obj.slicelabels
         )
@@ -151,9 +156,13 @@ def _v13_to_14_cls(obj):
         )
 
     elif isinstance(obj, RealSlice13):
+        if obj.is_stack:
+            data = np.rollaxis(obj.data, axis=2)
+        else:
+            data = obj.data
         x = RealSlice(
             name = obj.name,
-            data = obj.data,
+            data = data,
             units = obj.units,
             slicelabels = obj.slicelabels
         )
@@ -195,9 +204,13 @@ def _v13_to_14_cls(obj):
     elif isinstance(obj, Array13):
 
         # prepare arguments
+        if obj.is_stack:
+            data = np.rollaxis(obj.data, axis=2)
+        else:
+            data = obj.data
         args = {
             'name' : obj.name,
-            'data' : obj.data
+            'data' : data
         }
         if hasattr(obj,'units'): args['units'] = obj.units
         if hasattr(obj,'dim_names'): args['dim_names'] = obj.dim_names

From 88047814216a615aa0fbec8777fe7022df50dba0 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Thu, 29 Jun 2023 06:58:30 -0700
Subject: [PATCH 084/362] remove print statement

---
 py4DSTEM/io/legacy/read_legacy_13.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/py4DSTEM/io/legacy/read_legacy_13.py b/py4DSTEM/io/legacy/read_legacy_13.py
index ebf86d5c3..a8b2151ed 100644
--- a/py4DSTEM/io/legacy/read_legacy_13.py
+++ b/py4DSTEM/io/legacy/read_legacy_13.py
@@ -257,7 +257,6 @@ def _get_v13_class(grp):
         'QPoints' : QPoints,
         'BraggVectors' : BraggVectors
     }
-    print(grp)
     if 'py4dstem_class' in grp.attrs:
         classname = grp.attrs['py4dstem_class']
     elif 'emd_group_type' in grp.attrs:

From f4fad7aa0f3444ba15df0b206082a71aac4e2801 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Thu, 29 Jun 2023 12:46:49 -0400
Subject: [PATCH 085/362] patch emdfile RootedNode bug

---
 py4DSTEM/version.py | 2 +-
 setup.py            | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/version.py b/py4DSTEM/version.py
index 7be84a82a..4009e43c9 100644
--- a/py4DSTEM/version.py
+++ b/py4DSTEM/version.py
@@ -1,2 +1,2 @@
-__version__='0.14.1'
+__version__='0.14.2'
 
diff --git a/setup.py b/setup.py
index 2f1e15a63..cdb55e891 100644
--- a/setup.py
+++ b/setup.py
@@ -35,7 +35,7 @@
         'gdown >= 4.4.0',
         'dask >= 2.3.0',
         'distributed >= 2.3.0',
-        'emdfile >= 0.0.9',
+        'emdfile == 0.0.8',
         ],
     extras_require={
         'ipyparallel': ['ipyparallel >= 6.2.4', 'dill >= 0.3.3'],

From fb9a4191b8a5988f5619f668b8b47c3a1ec741c2 Mon Sep 17 00:00:00 2001
From: bsavitzky <bsavitzky@users.noreply.github.com>
Date: Thu, 29 Jun 2023 12:47:58 -0400
Subject: [PATCH 086/362] patch emdfile bug

---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index 2f1e15a63..cdb55e891 100644
--- a/setup.py
+++ b/setup.py
@@ -35,7 +35,7 @@
         'gdown >= 4.4.0',
         'dask >= 2.3.0',
         'distributed >= 2.3.0',
-        'emdfile >= 0.0.9',
+        'emdfile == 0.0.8',
         ],
     extras_require={
         'ipyparallel': ['ipyparallel >= 6.2.4', 'dill >= 0.3.3'],

From 3b9c36b18cad9eabd85bc137abac208a17e52452 Mon Sep 17 00:00:00 2001
From: bsavitzky <bsavitzky@users.noreply.github.com>
Date: Thu, 29 Jun 2023 12:48:22 -0400
Subject: [PATCH 087/362] patch emdfile bug

---
 py4DSTEM/version.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/version.py b/py4DSTEM/version.py
index 7be84a82a..4009e43c9 100644
--- a/py4DSTEM/version.py
+++ b/py4DSTEM/version.py
@@ -1,2 +1,2 @@
-__version__='0.14.1'
+__version__='0.14.2'
 

From 31d7ce67ff25d24aa58ef99ba01597f08b1d1998 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Thu, 29 Jun 2023 13:29:20 -0700
Subject: [PATCH 088/362] probe imports

---
 py4DSTEM/process/diskdetection/__init__.py          | 3 ++-
 py4DSTEM/process/diskdetection/probe_gen_methods.py | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/process/diskdetection/__init__.py b/py4DSTEM/process/diskdetection/__init__.py
index 9d42a2ad5..6ea191fbd 100644
--- a/py4DSTEM/process/diskdetection/__init__.py
+++ b/py4DSTEM/process/diskdetection/__init__.py
@@ -2,7 +2,8 @@
 from py4DSTEM.process.diskdetection.braggvectors import BraggVectors
 from py4DSTEM.process.diskdetection.braggvector_methods import BraggVectorMap
 from py4DSTEM.process.diskdetection.diskdetection import *
-
+from py4DSTEM.process.diskdetection.probe import * 
+from py4DSTEM.process.diskdetection.probe_gen_methods import * 
 #from .diskdetection_aiml import *
 #from .diskdetection_parallel_new import *
 
diff --git a/py4DSTEM/process/diskdetection/probe_gen_methods.py b/py4DSTEM/process/diskdetection/probe_gen_methods.py
index 2e5925f24..8e7b1d717 100644
--- a/py4DSTEM/process/diskdetection/probe_gen_methods.py
+++ b/py4DSTEM/process/diskdetection/probe_gen_methods.py
@@ -6,7 +6,7 @@
 
 from emdfile import tqdmnd
 from py4DSTEM.data import DataCube
-from py4DSTEM.classes import Probe
+from py4DSTEM.process.diskdetection import Probe
 from py4DSTEM.process.utils import get_shifted_ar, get_shift
 
 

From edab61d7f7ea60bd8b5597c8ff61e046f6b3afb1 Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Thu, 29 Jun 2023 17:26:11 -0400
Subject: [PATCH 089/362] fix bad merge?

---
 py4DSTEM/preprocess/preprocess.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/py4DSTEM/preprocess/preprocess.py b/py4DSTEM/preprocess/preprocess.py
index 78394ce68..d809d68f5 100644
--- a/py4DSTEM/preprocess/preprocess.py
+++ b/py4DSTEM/preprocess/preprocess.py
@@ -645,8 +645,7 @@ def resample_data_diffraction(
         datacube.data = fourier_resample(
             datacube.data, scale=resampling_factor, output_size=output_size
         )
-        datacube.calibration.set_Q_pixel_size(datacube.calibration.get_Q_pixel_size() / resampling_factor)
-
+        
         if not resampling_factor:
             resampling_factor = old_size[2] / output_size[0]
         if datacube.calibration.get_Q_pixel_size() is not None:

From 4c6fde6812f6b827edc0b6c450f8ba2997d38375 Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Thu, 29 Jun 2023 17:35:17 -0400
Subject: [PATCH 090/362] add skopt to dependencies

---
 setup.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/setup.py b/setup.py
index 2f1e15a63..a2bfbde83 100644
--- a/setup.py
+++ b/setup.py
@@ -30,6 +30,7 @@
         'matplotlib >= 3.2.2',
         'scikit-image >= 0.17.2',
         'scikit-learn >= 0.23.2',
+        'scikit-optimize >= 0.9.0',
         'tqdm >= 4.46.1',
         'dill >= 0.3.3',
         'gdown >= 4.4.0',

From 28ffb64d28034afe62d312c585d07d15590fff78 Mon Sep 17 00:00:00 2001
From: Ben Savitzky <ben.savitzky@gmail.com>
Date: Thu, 29 Jun 2023 20:45:48 -0700
Subject: [PATCH 091/362] adds coords axes. Adds two_fold_symm -> @property

---
 py4DSTEM/process/polar/polar_datacube.py | 50 +++++++++++++++++-------
 1 file changed, 35 insertions(+), 15 deletions(-)

diff --git a/py4DSTEM/process/polar/polar_datacube.py b/py4DSTEM/process/polar/polar_datacube.py
index c8afa7609..50fba3de8 100644
--- a/py4DSTEM/process/polar/polar_datacube.py
+++ b/py4DSTEM/process/polar/polar_datacube.py
@@ -21,7 +21,7 @@ def __init__(
         mask = None,
         mask_thresh = 0.25,
         ellipse = True,
-        two_fold_rotation = False,
+        two_fold_symmetry = False,
         ):
         """
         Parameters
@@ -29,14 +29,15 @@ def __init__(
         datacube : DataCube
             The datacube in cartesian coordinates
         qmin : number
-            Minumum radius of the polar transformation
+            Minumum radius of the polar transformation, in pixels
         qmax : number or None
-            Maximum radius of the polar transformation
+            Maximum radius of the polar transformation, in pixels
         qstep : number
-            Width of radial bins
+            Width of radial bins, in pixels
         n_annular : integer
             Number of bins in the annular direction. Bins will each
-            have a width of 360/num_annular_bins, in degrees
+            have a width of 360/n_annular, or 180/n_annular if
+            two_fold_rotation is set to True, in degrees
         qscale : number or None
             Radial scaling power to apply to polar transform
         mask : boolean array
@@ -49,9 +50,10 @@ def __init__(
             performs an elliptic transform iff elliptic calibrations are
             available.
         two_fold_rotation : bool
-            Setting to True computes the transform mod(theta,pi), i.e. assumes all patterns
-            posess two-fold rotation (Friedel symmetry).  The output angular range in this case
-            becomes [0, pi) as opposed to the default of [0,2*pi).
+            Setting to True computes the transform mod(theta,pi), i.e. assumes
+            all patterns possess two-fold rotation (Friedel symmetry).  The
+            output angular range in this case becomes [0, pi) as opposed to the
+            default of [0,2*pi).
         """
 
         # attach datacube
@@ -68,17 +70,12 @@ def __init__(
 
         # setup sampling
 
-        # annular range, depending on if polar transform spans pi or 2*pi
-        if two_fold_rotation:
-            self._annular_range = np.pi
-        else:
-            self._annular_range = 2.0 * np.pi
-
         # polar
         self._qscale = qscale
         if qmax is None:
             qmax = np.min(self._datacube.Qshape) / np.sqrt(2)
-        self.set_annular_bins(n_annular)
+        self._n_annular = n_annular
+        self.two_fold_symmetry = two_fold_symmetry #implicitly calls set_annular_bins
         self.set_radial_bins(qmin,qmax,qstep)
 
         # cartesian
@@ -176,6 +173,18 @@ def annular_bins(self):
     @property
     def annular_step(self):
         return self._annular_step
+    @property
+    def two_fold_symmetry(self):
+        return self._two_fold_symmetry
+    @two_fold_symmetry.setter
+    def two_fold_symmetry(self,x):
+        assert(isinstance(x,bool)), f"two_fold_symmetry must be boolean, not type {type(x)}"
+        self._two_fold_symmetry = x
+        if x:
+            self._annular_range = np.pi
+        else:
+            self._annular_range = 2 * np.pi
+        self.set_annular_bins(self._n_annular)
 
     @property
     def n_annular(self):
@@ -197,6 +206,17 @@ def set_polar_shape(self):
             self._sigma_KDE = self._annular_bin_step * 0.5
 
 
+    # coordinate grid properties
+    @property
+    def tt(self):
+        return self._annular_bins
+    @property
+    def tt_deg(self):
+        return self._annular_bins * 180/np.pi
+    @property
+    def qq(self):
+        return self.radial_bins * self.calibration.get_Q_pixel_size()
+
 
 
     # scaling property

From 8b2089505118cb61982a334b30909624a259032d Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Sat, 1 Jul 2023 15:44:55 -0400
Subject: [PATCH 092/362] add custom error metrics for ptycho optimizer

---
 py4DSTEM/process/phase/parameter_optimize.py | 104 +++++++++++++++++--
 1 file changed, 96 insertions(+), 8 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 9c1e3b297..f1f896fce 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -12,7 +12,7 @@
 import numpy as np
 
 from functools import partial
-from typing import Union
+from typing import Union, Callable
 
 from py4DSTEM.process.phase.iterative_base_class import PhaseReconstruction
 from py4DSTEM.process.phase.utils import AffineTransform
@@ -107,8 +107,9 @@ def __init__(
 
     def optimize(
         self,
-        n_calls: int,
-        n_initial_points: int,
+        n_calls: int = 50,
+        n_initial_points: int = 20,
+        error_metric: Union[Callable, str] = "log",
         **skopt_kwargs: dict,
     ):
         """
@@ -121,10 +122,29 @@ def optimize(
         n_initial_points: int
             Number of uniformly spaced trial points to test before
             beginning Bayesian optimization (must be less than n_calls)
+        error_metric: Callable or str
+            Function used to compute the reconstruction error.
+            When passed as a string, may be one of:
+                'log': log(NMSE) of final object
+                'linear': NMSE of final object
+                'log-converged': log(NMSE) of final object if
+                    NMSE is decreasing, 0 if NMSE increasing
+                'linear-converged': NMSE of final object if
+                    NMSE is decreasing, 1 if NMSE increasing
+                'TV': sum( abs( grad( object ) ) ) / sum( abs( object ) )
+                'std': negative standard deviation of cropped object
+                'std-phase': negative standard deviation of
+                    phase of the cropped object
+            When passed as a Callable, a function that takes the
+                PhaseReconstruction object as its only argument
+                and returns the error metric as a single float
         skopt_kwargs: dict
             Additional arguments to be passed to skopt.gp_minimize
 
         """
+
+        error_metric = self._get_error_metric(error_metric)
+
         self._optimization_function = self._get_optimization_function(
             self._reconstruction_type,
             self._parameter_list,
@@ -137,6 +157,7 @@ def optimize(
             self._affine_optimize_args,
             self._preprocess_optimize_args,
             self._reconstruction_optimize_args,
+            error_metric,
         )
 
         # Make a progress bar
@@ -270,6 +291,74 @@ def _get_scan_positions(self, affine_transform, dataset):
         scan_positions = scan_positions @ affine_transform.asarray()
         return scan_positions
 
+    def _get_error_metric(self, error_metric: Union[Callable, str]) -> Callable:
+        """
+        Get error metric as a function, converting builtin method names
+        to functions
+        """
+
+        if callable(error_metric):
+            return error_metric
+
+        assert error_metric in (
+            "log",
+            "linear",
+            "log-converged",
+            "linear-converged",
+            "TV",
+            "std",
+            "std-phase",
+        ), f"Error metric {error_metric} not recognized."
+
+        if error_metric == "log":
+
+            def f(ptycho):
+                return np.log(ptycho.error)
+
+        elif error_metric == "linear":
+
+            def f(ptycho):
+                return ptycho.error
+
+        elif error_metric == "log-converged":
+
+            def f(ptycho):
+                converged = ptycho.error_iterations[-1] <= np.min(
+                    ptycho.error_iterations
+                )
+                return np.log(ptycho.error) if converged else 0.0
+
+        elif error_metric == "log-linear":
+
+            def f(ptycho):
+                converged = ptycho.error_iterations[-1] <= np.min(
+                    ptycho.error_iterations
+                )
+                return ptycho.error if converged else 1.0
+
+        elif error_metric == "TV":
+
+            def f(ptycho):
+                gx, gy = np.gradient(ptycho.object_cropped, axis=(-2, -1))
+                obj_mag = np.sum(np.abs(ptycho.object_cropped))
+                tv = np.sum(np.abs(gx)) + np.sum(np.abs(gy))
+                return tv / obj_mag
+
+        elif error_metric == "std":
+
+            def f(ptycho):
+                return -np.std(ptycho.object_cropped)
+
+        elif error_metric == "std-phase":
+
+            def f(ptycho):
+                return -np.std(np.angle(ptycho.object_cropped))
+
+        else:
+            raise ValueError(f"Error metric {error_metric} not recognized.")
+
+        return f
+
     def _get_optimization_function(
         self,
         cls: type[PhaseReconstruction],
@@ -283,6 +372,7 @@ def _get_optimization_function(
         affine_optimization_params: dict,
         preprocess_optimization_params: dict,
         reconstruct_optimization_params: dict,
+        error_metric: Callable,
     ):
         """
         Wrap the ptychography pipeline into a single function that encapsulates all of the
@@ -313,9 +403,7 @@ def _get_optimization_function(
                 affine_preprocessed, init_static_args["datacube"]
             )
 
-            ptycho_preprocessed = cls(**init_args).preprocess(
-                **preprocess_static_args
-            )
+            ptycho_preprocessed = cls(**init_args).preprocess(**preprocess_static_args)
 
             def obj(**kwargs):
                 return ptycho_preprocessed
@@ -329,7 +417,7 @@ def prep(ptycho, **kwargs):
 
         affine = partial(AffineTransform, **affine_static_args)
         recon = partial(cls.reconstruct, **reconstruct_static_args)
-        
+
         # Target function for Gaussian process optimization that takes a single
         # dict of named parameters and returns the ptycho error metric
         @use_named_args(parameter_list)
@@ -350,7 +438,7 @@ def f(**kwargs):
             prep(ptycho, **prep_args)
             recon(ptycho, **reco_args)
 
-            return np.log(ptycho.error)
+            return error_metric(ptycho)
 
         return f
 

From c30fce506709a0c2ad147cb6dcfafb84046b66bf Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <37132012+sezelt@users.noreply.github.com>
Date: Sun, 2 Jul 2023 15:27:41 -0400
Subject: [PATCH 093/362] docstring clarification

Co-authored-by: Georgios Varnavides <gvarnavides@berkeley.edu>
---
 py4DSTEM/process/phase/parameter_optimize.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 9c1e3b297..771787563 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -21,9 +21,8 @@
 class PtychographyOptimizer:
     """
     Optimize ptychographic hyperparameters with Bayesian Optimization of a
-    Gaussian process. Any of the arguments to the ptychographic
-    init-preprocess-reconstruct pipeline can be optimized over (including
-    boolean or other flag options)
+    Gaussian process. Any of the scalar-valued real or integer,  boolean, or categorical 
+    arguments to the ptychographic init-preprocess-reconstruct pipeline can be optimized over.
     """
 
     def __init__(

From e86abab575fd265da93d96cd4e80923b0a353599 Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <37132012+sezelt@users.noreply.github.com>
Date: Sun, 2 Jul 2023 15:33:22 -0400
Subject: [PATCH 094/362] remove unused argument

Co-authored-by: Georgios Varnavides <gvarnavides@berkeley.edu>
---
 py4DSTEM/process/phase/parameter_optimize.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 771787563..04d776137 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -273,7 +273,6 @@ def _get_optimization_function(
         self,
         cls: type[PhaseReconstruction],
         parameter_list: list,
-        n_iterations: int,
         init_static_args: dict,
         affine_static_args: dict,
         preprocess_static_args: dict,

From cd80145ff3e5ab1205ca7b71e25675c3281f6093 Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <37132012+sezelt@users.noreply.github.com>
Date: Sun, 2 Jul 2023 15:34:43 -0400
Subject: [PATCH 095/362] remove another unused argument

Co-authored-by: Georgios Varnavides <gvarnavides@berkeley.edu>
---
 py4DSTEM/process/phase/parameter_optimize.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 04d776137..f2a3fdf89 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -127,7 +127,6 @@ def optimize(
         self._optimization_function = self._get_optimization_function(
             self._reconstruction_type,
             self._parameter_list,
-            n_calls,
             self._init_static_args,
             self._affine_static_args,
             self._preprocess_static_args,

From 61ace431ba88cc28d6040cc79f419480b9aa05f8 Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <37132012+sezelt@users.noreply.github.com>
Date: Sun, 2 Jul 2023 15:37:14 -0400
Subject: [PATCH 096/362] update plot function

Co-authored-by: Georgios Varnavides <gvarnavides@berkeley.edu>
---
 py4DSTEM/process/phase/parameter_optimize.py | 81 +++++++++++++++-----
 1 file changed, 61 insertions(+), 20 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index f2a3fdf89..4b2ee331b 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -166,37 +166,78 @@ def callback(*args, **kwargs):
 
     def visualize(
         self,
-        gp_model=True,
-        convergence=False,
-        objective=True,
-        evaluations=False,
+        plot_gp_model=True,
+        plot_convergence=False,
+        plot_objective=True,
+        plot_evaluations=False,
+        **kwargs,
     ):
         """
         Visualize optimization results
 
         Parameters
         ----------
-        gp_model: bool
+        plot_gp_model: bool
             Display fitted Gaussian process model (only available for 1-dimensional problem)
-        convergence: bool
+        plot_convergence: bool
             Display convergence history
-        objective: bool
+        plot_objective: bool
             Display GP objective function and partial dependence plots
-        evaluations: bool
+        plot_evaluations: bool
             Display histograms of sampled points
+        kwargs:
+            Passed directly to the skopt plot_gassian_process/plot_objective
         """
-        if (len(self._parameter_list) == 1) and gp_model:
-            plot_gaussian_process(self._skopt_result)
-            plt.show()
-        if convergence:
-            plot_convergence(self._skopt_result)
-            plt.show()
-        if objective:
-            plot_objective(self._skopt_result)
-            plt.show()
-        if evaluations:
-            plot_evaluations(self._skopt_result)
-            plt.show()
+        ndims = len(self._parameter_list)
+        if ndims == 1:
+            if plot_convergence:
+                figsize = kwargs.pop("figsize", (9, 9))
+                spec = GridSpec(nrows=2,ncols=1,height_ratios=[2,1], hspace=0.15)
+            else:
+                figsize = kwargs.pop("figsize", (9, 6))
+                spec = GridSpec(nrows=1,ncols=1)
+
+            fig = plt.figure(figsize = figsize)
+            ax = fig.add_subplot(spec[0])
+            skopt_plot_gaussian_process(self._skopt_result,ax=ax, **kwargs)
+
+            if plot_convergence:
+                ax = fig.add_subplot(spec[1])
+                skopt_plot_convergence(self._skopt_result,ax=ax)
+
+        else:
+            if plot_convergence:
+                figsize = kwargs.pop("figsize", (4*ndims, 4*(ndims+0.5)))
+                spec = GridSpec(nrows=ndims+1,ncols=ndims,height_ratios=[2]*ndims+[1], hspace=0.15)
+            else:
+                figsize = kwargs.pop("figsize", (4*ndims, 4*ndims))
+                spec = GridSpec(nrows=ndims,ncols=ndims, hspace=0.15)
+
+            if plot_evaluations:
+                axs = skopt_plot_evaluations(self._skopt_result)
+            elif plot_objective:
+                cmap = kwargs.pop("cmap", 'magma')
+                axs = skopt_plot_objective(self._skopt_result, cmap=cmap,**kwargs)
+            elif plot_convergence:
+                skopt_plot_convergence(self._skopt_result)
+                return self
+
+            fig = axs[0,0].figure
+            fig.set_size_inches(figsize)
+            for i in range(ndims):
+                for j in range(ndims):
+                    ax = axs[i,j]
+                    ax.remove()
+                    ax.figure = fig
+                    fig.add_axes(ax)
+                    ax.set_subplotspec(spec[i,j])
+
+            if plot_convergence:
+                ax = fig.add_subplot(spec[ndims,:])
+                skopt_plot_convergence(self._skopt_result,ax=ax)
+
+        spec.tight_layout(fig)
+
         return self
 
     def get_optimized_arguments(self):

From 355848460585ea7905054a8f2f75b687f7217244 Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <37132012+sezelt@users.noreply.github.com>
Date: Sun, 2 Jul 2023 15:37:35 -0400
Subject: [PATCH 097/362] update plot imports

Co-authored-by: Georgios Varnavides <gvarnavides@berkeley.edu>
---
 py4DSTEM/process/phase/parameter_optimize.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 4b2ee331b..b35867a2a 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -2,10 +2,10 @@
 from skopt import gp_minimize
 from skopt.space import Real, Integer, Categorical
 from skopt.plots import (
-    plot_convergence,
-    plot_gaussian_process,
-    plot_evaluations,
-    plot_objective,
+    plot_convergence as skopt_plot_convergence,
+    plot_gaussian_process as skopt_plot_gaussian_process,
+    plot_evaluations as skopt_plot_evaluations,
+    plot_objective as skopt_plot_objective,
 )
 from skopt.utils import use_named_args
 import matplotlib.pyplot as plt

From 9e22bcc8faf69013b37029ec44cc1d8bf03df620 Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <37132012+sezelt@users.noreply.github.com>
Date: Sun, 2 Jul 2023 15:38:59 -0400
Subject: [PATCH 098/362] aesthetic preferences regarding asserts

Co-authored-by: Georgios Varnavides <gvarnavides@berkeley.edu>
---
 py4DSTEM/process/phase/parameter_optimize.py | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index b35867a2a..c9ee9a31c 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -439,12 +439,9 @@ def __init__(
         """
         # Check input
         space = space.lower()
-        assert space in (
-            "real",
-            "integer",
-            "bool",
-            "categorical",
-        ), f"Unknown Parameter type: {space}"
+        if space not in ("real", "integer", "bool", "categorical"):
+            raise ValueError(f"Unknown Parameter type: {space}")
+
 
         scaling = scaling.lower()
         assert scaling in ("uniform", "log-uniform"), f"Unknown scaling: {scaling}"

From 8b094b4e261219b0ca68a5a9494ab11549e905a3 Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <37132012+sezelt@users.noreply.github.com>
Date: Sun, 2 Jul 2023 15:39:21 -0400
Subject: [PATCH 099/362] being less assertive

Co-authored-by: Georgios Varnavides <gvarnavides@berkeley.edu>
---
 py4DSTEM/process/phase/parameter_optimize.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index c9ee9a31c..c71242b67 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -444,7 +444,8 @@ def __init__(
 
 
         scaling = scaling.lower()
-        assert scaling in ("uniform", "log-uniform"), f"Unknown scaling: {scaling}"
+        if scaling not in ("uniform", "log-uniform"):
+            raise ValueError(f"Unknown scaling: {scaling}")
 
         # Get the right scikit-optimize class
         space_map = {

From 320bc7526600a27393f1daca64989140b6fa6051 Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <37132012+sezelt@users.noreply.github.com>
Date: Sun, 2 Jul 2023 15:39:51 -0400
Subject: [PATCH 100/362] you wouldn't raise an AssertionError

Co-authored-by: Georgios Varnavides <gvarnavides@berkeley.edu>
---
 py4DSTEM/process/phase/parameter_optimize.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index c71242b67..c0ce99646 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -460,6 +460,8 @@ def __init__(
         if space == "bool":
             categories = [True, False]
 
+        if not categories:
+            raise ValueError("Empty list of categories!")
         # store necessary information
         self._initial_value = initial_value
         self._categories = categories

From 200b3e56210f4a618b2e8c8f81ef435ad8e6feb8 Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <37132012+sezelt@users.noreply.github.com>
Date: Sun, 2 Jul 2023 15:40:23 -0400
Subject: [PATCH 101/362] remove another assert

Co-authored-by: Georgios Varnavides <gvarnavides@berkeley.edu>
---
 py4DSTEM/process/phase/parameter_optimize.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index c0ce99646..ead52b9bc 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -473,7 +473,6 @@ def __init__(
     def _get(self, name):
         self._name = name
         if self._param_type is Categorical:
-            assert self._categories is not None, "Empty list of categories!"
             self._skopt_param = self._param_type(
                 name=self._name, categories=self._categories
             )

From d2750c9ee67e998f880911b4914ca34ae825a2d4 Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Sun, 2 Jul 2023 19:38:36 -0700
Subject: [PATCH 102/362] Update circular polar transform

Set theta = 0 to the x axis
---
 py4DSTEM/process/polar/polar_datacube.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/process/polar/polar_datacube.py b/py4DSTEM/process/polar/polar_datacube.py
index 50fba3de8..73c519779 100644
--- a/py4DSTEM/process/polar/polar_datacube.py
+++ b/py4DSTEM/process/polar/polar_datacube.py
@@ -492,7 +492,7 @@ def _transform_array(
             # get polar coords
             rr = np.sqrt(x**2 + y**2)
             tt = np.mod(
-                np.arctan2(y, x) - np.pi/2,
+                np.arctan2(y, x),
                 self._polarcube._annular_range)
 
         # elliptical

From 19d8e011bfee63fdcba690bc9b995c3e09008f26 Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Sun, 2 Jul 2023 20:01:24 -0700
Subject: [PATCH 103/362] Updating polar transform

theta = 0 set t0 x axis
---
 py4DSTEM/process/polar/polar_datacube.py | 36 +++++++++++++++---------
 1 file changed, 22 insertions(+), 14 deletions(-)

diff --git a/py4DSTEM/process/polar/polar_datacube.py b/py4DSTEM/process/polar/polar_datacube.py
index 73c519779..558947258 100644
--- a/py4DSTEM/process/polar/polar_datacube.py
+++ b/py4DSTEM/process/polar/polar_datacube.py
@@ -500,21 +500,29 @@ def _transform_array(
             # unpack ellipse
             a,b,theta = ellipse
 
-            # transformation matrix (elliptic cartesian -> circular cartesian)
-            A = (a/b)*np.cos(theta)
-            B = -np.sin(theta)
-            C = (a/b)*np.sin(theta)
-            D = np.cos(theta)
-            det = 1 / (A*D - B*C)
-
-            # get circular cartesian coords
-            xc =  x*D - y*B
-            yc = -x*C + y*A
-
-            # get polar coords
-            rr = det * np.hypot(xc,yc)
+            # # transformation matrix (elliptic cartesian -> circular cartesian)
+            # A = (a/b)*np.cos(theta)
+            # B = -np.sin(theta)
+            # C = (a/b)*np.sin(theta)
+            # D = np.cos(theta)
+            # det = 1 / (A*D - B*C)
+
+            # # get circular cartesian coords
+            # xc =  x*D - y*B
+            # yc = -x*C + y*A
+
+            # # get polar coords
+            # rr = det * np.hypot(xc,yc)
+            # tt = np.mod(
+            #     np.arctan2(yc,xc),
+            #     self._polarcube._annular_range)
+
+            # Get polar coords
+            xc = x*np.cos(theta) + y*np.sin(theta)
+            yc = (y*np.cos(theta) - x*np.sin(theta))*(a/b)
+            rr = (b/a) * np.hypot(xc,yc)
             tt = np.mod(
-                np.arctan2(yc,xc) - np.pi/2,
+                np.arctan2(yc,xc) + theta,
                 self._polarcube._annular_range)
 
         # transform to bin sampling

From f70302008ac0e5d3c2923fd620ce855f60985b5a Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Sun, 2 Jul 2023 20:06:21 -0700
Subject: [PATCH 104/362] cleaning up the comments

---
 py4DSTEM/process/polar/polar_datacube.py | 17 -----------------
 1 file changed, 17 deletions(-)

diff --git a/py4DSTEM/process/polar/polar_datacube.py b/py4DSTEM/process/polar/polar_datacube.py
index 558947258..2912928d5 100644
--- a/py4DSTEM/process/polar/polar_datacube.py
+++ b/py4DSTEM/process/polar/polar_datacube.py
@@ -500,23 +500,6 @@ def _transform_array(
             # unpack ellipse
             a,b,theta = ellipse
 
-            # # transformation matrix (elliptic cartesian -> circular cartesian)
-            # A = (a/b)*np.cos(theta)
-            # B = -np.sin(theta)
-            # C = (a/b)*np.sin(theta)
-            # D = np.cos(theta)
-            # det = 1 / (A*D - B*C)
-
-            # # get circular cartesian coords
-            # xc =  x*D - y*B
-            # yc = -x*C + y*A
-
-            # # get polar coords
-            # rr = det * np.hypot(xc,yc)
-            # tt = np.mod(
-            #     np.arctan2(yc,xc),
-            #     self._polarcube._annular_range)
-
             # Get polar coords
             xc = x*np.cos(theta) + y*np.sin(theta)
             yc = (y*np.cos(theta) - x*np.sin(theta))*(a/b)

From c05fe1a0393134ed914d710cbff96abf57040fdf Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Mon, 3 Jul 2023 08:50:26 -0400
Subject: [PATCH 105/362] fix for george's suggestion

---
 py4DSTEM/process/phase/parameter_optimize.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 0c420c5be..cbd83ec16 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -548,8 +548,9 @@ def __init__(
         if space == "bool":
             categories = [True, False]
 
-        if not categories:
+        if categories == [] and space in ("categorical", "bool"):
             raise ValueError("Empty list of categories!")
+
         # store necessary information
         self._initial_value = initial_value
         self._categories = categories

From 5b977fdf22171bfd04b288858a29c152b40894da Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Mon, 3 Jul 2023 07:58:41 -0700
Subject: [PATCH 106/362] Init for peak detection

---
 py4DSTEM/process/polar/polar_fits.py  | 2 ++
 py4DSTEM/process/polar/polar_peaks.py | 4 ++++
 2 files changed, 6 insertions(+)
 create mode 100644 py4DSTEM/process/polar/polar_peaks.py

diff --git a/py4DSTEM/process/polar/polar_fits.py b/py4DSTEM/process/polar/polar_fits.py
index ad418939f..1e45c3230 100644
--- a/py4DSTEM/process/polar/polar_fits.py
+++ b/py4DSTEM/process/polar/polar_fits.py
@@ -348,3 +348,5 @@ def amorphous_model(basis, *coefs):
 
     return int_model
 
+
+
diff --git a/py4DSTEM/process/polar/polar_peaks.py b/py4DSTEM/process/polar/polar_peaks.py
new file mode 100644
index 000000000..c03e5d7db
--- /dev/null
+++ b/py4DSTEM/process/polar/polar_peaks.py
@@ -0,0 +1,4 @@
+
+import numpy as np
+import matplotlib.pyplot as plt
+

From 2e3547e3057783ec5037d8d847d9224d568fca1b Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Mon, 3 Jul 2023 10:31:39 -0700
Subject: [PATCH 107/362] avoid transpose

---
 py4DSTEM/io/filereaders/read_arina.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/io/filereaders/read_arina.py b/py4DSTEM/io/filereaders/read_arina.py
index 1434301fe..d42eb2803 100644
--- a/py4DSTEM/io/filereaders/read_arina.py
+++ b/py4DSTEM/io/filereaders/read_arina.py
@@ -71,8 +71,11 @@ def read_arina(
     scan_height = int(nimages / scan_width)
 
     datacube = DataCube(
-        array_3D.reshape(
-            scan_width, scan_height, array_3D.data.shape[1], array_3D.data.shape[2]
+        np.flip(
+            array_3D.reshape(
+                scan_width, scan_height, array_3D.data.shape[1], array_3D.data.shape[2]
+            ),
+            0,
         )
     )
 

From 76c04e085e5a0b57068640f1f294d556796d7a21 Mon Sep 17 00:00:00 2001
From: Ben Savitzky <ben.savitzky@gmail.com>
Date: Mon, 3 Jul 2023 11:42:33 -0700
Subject: [PATCH 108/362] updates

---
 py4DSTEM/process/calibration/origin.py   |  11 +-
 py4DSTEM/process/fit/fit.py              | 161 +++++++++++++++++------
 py4DSTEM/process/polar/polar_datacube.py |   3 +
 3 files changed, 129 insertions(+), 46 deletions(-)

diff --git a/py4DSTEM/process/calibration/origin.py b/py4DSTEM/process/calibration/origin.py
index bc8c0be0c..d9007b899 100644
--- a/py4DSTEM/process/calibration/origin.py
+++ b/py4DSTEM/process/calibration/origin.py
@@ -73,11 +73,12 @@ def fit_origin(
 ):
     """
     Fits the position of the origin of diffraction space to a plane or parabola,
-    given some 2D arrays (qx0_meas,qy0_meas) of measured center positions, optionally
-    masked by the Boolean array `mask`. The 2D data arrays may be passed directly as
-    a 2-tuple to the arg `data`, or, if `data` is either a DataCube or Calibration
-    instance, they will be retreived automatically. If a DataCube or Calibration are
-    passed, fitted origin and residuals are stored there directly.
+    given some 2D arrays (qx0_meas,qy0_meas) of measured center positions,
+    optionally masked by the Boolean array `mask`. The 2D data arrays may be
+    passed directly as a 2-tuple to the arg `data`, or, if `data` is either a
+    DataCube or Calibration instance, they will be retreived automatically. If a
+    DataCube or Calibration are passed, fitted origin and residuals are stored
+    there directly.
 
     Args:
         data (2-tuple of 2d arrays): the measured origin position (qx0,qy0)
diff --git a/py4DSTEM/process/fit/fit.py b/py4DSTEM/process/fit/fit.py
index e3bb4d86e..5b9a5a43e 100644
--- a/py4DSTEM/process/fit/fit.py
+++ b/py4DSTEM/process/fit/fit.py
@@ -29,44 +29,48 @@ def fit_1D_gaussian(xdata,ydata,xmin,xmax):
     A,mu,sigma = scale*popt[0],popt[1],popt[2]
     return A,mu,sigma
 
-def fit_2D(function, data, data_mask=None, popt=None,
-    robust=False, robust_steps=3, robust_thresh=2):
+def fit_2D(
+    function,
+    data,
+    data_mask=None,
+    popt=None,
+    robust=False,
+    robust_steps=3,
+    robust_thresh=2,
+    ):
     """
-    Performs a 2D fit, where the fit function takes its first input in the form of a
-    length 2 vector (ndarray) of (x,y) positions, followed by the remaining parameters,
-    and the data to fit takes the form of an (n,m) shaped array. Robust fitting can be
-    enabled to iteratively reject outlier data points, which have a root-mean-square
-    error beyond the user-specified threshold.
-
-    Args:
-        function: First input should be a length 2 array xy, where (xy[0],xy[1]) are the
-            (x,y) coordinates
-        data: Data to fit, in an (n,m) shaped ndarray
-        data_mask:  Optional parameter. If specified, must be a boolean array of the same
-            shape as data, specifying which elements of data to use in the fit
-        return_ar: Optional parameter. If False, only the fit parameters and covariance
-            matrix are returned. If True, return an array  of the same shape as data with
-            the fit values. Defaults to True
-        popt: Optional parameter for input. If specified, should be a tuple of initial
-            guesses for the fit parameters.
-        robust: Optional parameter. If set to True, fit will be repeated with outliers
-            removed.
-        robust_steps: Optional parameter. Number of robust iterations performed after
-            initial fit.
-        robust_thresh: Optional parameter. Threshold for including points, in units of
-            root-mean-square (standard deviations) error of the predicted values after
-            fitting.
+    Performs a 2D fit.
+
+    Parameters
+    ----------
+    function : callable
+        Some `function( xy, **p)` where `xy` is a length 2 vector (1D np array)
+        specifying the pixel position (x,y), and `p` is the function parameters
+    data : ndarray
+        Some 2D array of any shape (n,m)
+    data_mask : None or boolean array of shape (n,m), optional
+        If specified, fits only the pixels in `data` where this array is True
+    popt : dict
+        Initial guess at the parameters `p` of `function`. Note that positions
+        in pixels (i.e. the xy positions) are linearly scaled to the space [0,1]
+    robust : bool
+        Toggles robust fitting, which iteratively rejects outlier data points
+        which have a root-mean-square error beyond `robust_thresh`
+    robust_steps : int
+        The number of robust fitting iterations to perform
+    robust_thresh : int
+        The robust fitting cutoff
 
-    Returns:
-        (3-tuple) A 3-tuple containing:
 
-            * **popt**: optimal fit parameters to function
-            * **pcov**: the covariance matrix
-            * **fit_ar**: optional. If return_ar==True, fit_ar is returned, and is an
-              array of the same shape as data, containing the fit values
+    Returns:
+    (popt,pcov,fit_at) : 3-tuple
+        The optimal fit parameters, the fitting covariance matrix, and the
+        the fit array with the returned `popt` params
     """
+    # get shape
     shape = data.shape
     shape1D = [1,np.prod(shape)]
+
     # x and y coordinates normalized from 0 to 1
     x,y = np.linspace(0, 1, shape[0]),np.linspace(0, 1, shape[1])
     ry,rx = np.meshgrid(y,x)
@@ -78,8 +82,10 @@ def fit_2D(function, data, data_mask=None, popt=None,
     if robust==False:
         robust_steps=0
 
-    # least squares fitting - 1st iteration 
+    # least squares fitting
     for k in range(robust_steps+1):
+
+        # in 1st iteration, set up params and mask
         if k == 0:
             if popt is None:
                 popt = np.zeros((1,len(signature(function).parameters)-1))
@@ -87,21 +93,26 @@ def fit_2D(function, data, data_mask=None, popt=None,
                 mask = data_mask
             else:
                 mask = np.ones(shape,dtype=bool)
+
+        # otherwise, get fitting error and add high error pixels to mask
         else:
-            fit_mean_square_error = (function(xy,*popt).reshape(shape) - data)**2
-            mask = fit_mean_square_error <= np.mean(fit_mean_square_error) * robust_thresh**2
-            # include user-specified mask if provided
-            if data_mask is not None:
-                mask[data_mask==False] = False
+            fit_mean_square_error = (
+                function(xy,*popt).reshape(shape) - data)**2
+            _mask = fit_mean_square_error > np.mean(
+                fit_mean_square_error) * robust_thresh**2
+            mask[_mask] == False
 
         # perform fitting
-        popt, pcov = curve_fit(function,
-            np.vstack((rx_1D[mask.reshape(shape1D)],ry_1D[mask.reshape(shape1D)])),
+        popt, pcov = curve_fit(
+            function,
+            np.vstack((
+                rx_1D[mask.reshape(shape1D)],
+                ry_1D[mask.reshape(shape1D)])),
             data[mask],
             p0=popt)
 
     fit_ar = function(xy,*popt).reshape(shape)
-    return popt, pcov, fit_ar
+    return popt, pcov, fit_ar,mask
 
 
 # Functions for fitting
@@ -127,5 +138,73 @@ def bezier_two(xy, c00, c01, c02, c10, c11, c12, c20, c21, c22):
         c12*2*(1-xy[0])*xy[0] * (xy[1]**2) + \
         c22  *(xy[0]**2)      * (xy[1]**2)
 
+def polar_gaussian_2D(
+    tq,
+    I0,
+    mu_t,
+    mu_q,
+    sigma_t,
+    sigma_q,
+    C,
+    ):
+    # unpack position
+    t,q = tq
+    # set theta value to its closest periodic reflection to mu_t
+    #t = np.square(t-mu_t)
+    #t2 = np.min(np.vstack([t,1-t]))
+    t2 = np.square(t-mu_t)
+    return \
+        I0 * np.exp(
+            - ( t2/(2*sigma_t**2) + \
+                (q-mu_q)**2/(2*sigma_q**2) ) ) + C
+
+def fit_2D_polar_gaussian(
+    data,
+    mask = None,
+    p0 = None,
+    robust = False,
+    robust_steps = 3,
+    robust_thresh = 2,
+):
+    """
+    Fits a 2D gaussian to the pixels in `data` which are set to True in `mask`.
+
+    The gaussian is anisotropic and oriented along (t,q), centered at
+    (mu_t,mu_q), has standard deviations (sigma_t,sigma_q), maximum of I0,
+    and a constant offset of C, and is periodic in t.
+
+        f(x,y) = I0 * exp( - (x-mu_x)^2/(2sig_x^2) + (y-mu_y)^2/(2sig_y^2) )
+
+    Parameters
+    ----------
+    data : 2d array
+        the data to fit
+    p0 : 6-tuple
+        initial guess at fit parameters, (I0,mu_x,mu_y,sigma_x_sigma_y,C)
+    mask : 2d boolean array
+        ignore pixels where mask is False
+    robust : bool
+        toggle robust fitting
+    robust_steps : int
+        number of robust fit iterations
+    robust_thresh : number
+        the robust fitting threshold
+
+    Returns
+    -------
+    (popt,pcov,fit_ar) : 3-tuple
+        the optimal fit parameters, the covariance matrix, and the fit array
+    """
+    return fit_2D(
+        polar_gaussian_2D,
+        data = data,
+        data_mask = mask,
+        popt = p0,
+        robust = robust,
+        robust_steps = robust_steps,
+        robust_thresh = robust_thresh
+    )
+
+
 
 
diff --git a/py4DSTEM/process/polar/polar_datacube.py b/py4DSTEM/process/polar/polar_datacube.py
index 50fba3de8..4f9b67c61 100644
--- a/py4DSTEM/process/polar/polar_datacube.py
+++ b/py4DSTEM/process/polar/polar_datacube.py
@@ -204,6 +204,9 @@ def set_polar_shape(self):
             # set KDE params
             self._annular_bin_step = 1 / (self._annular_step * (self.radial_bins + self.qstep * 0.5))
             self._sigma_KDE = self._annular_bin_step * 0.5
+            # set array indices
+            self._annular_indices = np.arange(self.polar_shape[0]).astype(int)
+            self._radial_indices = np.arange(self.polar_shape[1]).astype(int)
 
 
     # coordinate grid properties

From e315b7eb558a8a4997b1b0044aec83c75ca8c944 Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Mon, 3 Jul 2023 17:04:29 -0400
Subject: [PATCH 109/362] add entropy metric, not sure if correct

---
 py4DSTEM/process/phase/parameter_optimize.py | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index cbd83ec16..d218871e5 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -9,6 +9,7 @@
 )
 from skopt.utils import use_named_args
 import matplotlib.pyplot as plt
+from matplotlib.gridspec import GridSpec
 import numpy as np
 
 from functools import partial
@@ -347,6 +348,7 @@ def _get_error_metric(self, error_metric: Union[Callable, str]) -> Callable:
             "TV",
             "std",
             "std-phase",
+            "entropy-phase",
         ), f"Error metric {error_metric} not recognized."
 
         if error_metric == "log":
@@ -393,6 +395,15 @@ def f(ptycho):
             def f(ptycho):
                 return -np.std(np.angle(ptycho.object_cropped))
 
+        elif error_metric == "entropy-phase":
+            def f(ptycho):
+                obj = np.angle(ptycho.object_cropped)
+                gx,gy = np.gradient(obj)
+                ghist,_,_ = np.histogram2d(gx.ravel(),gy.ravel(),bins=obj.shape,density=True)
+                nz = ghist > 0
+                S = np.sum(ghist[nz] * np.log2(ghist[nz]))
+                return S
+
         else:
             raise ValueError(f"Error metric {error_metric} not recognized.")
 

From 864d46b51d86507db412f22ce1fff097eb312fdc Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Mon, 3 Jul 2023 17:05:10 -0400
Subject: [PATCH 110/362] docstring

---
 py4DSTEM/process/phase/parameter_optimize.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index d218871e5..3a4c18a50 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -135,6 +135,8 @@ def optimize(
                 'std': negative standard deviation of cropped object
                 'std-phase': negative standard deviation of
                     phase of the cropped object
+                'entropy-phase': entropy of the phase of the 
+                    cropped object
             When passed as a Callable, a function that takes the
                 PhaseReconstruction object as its only argument
                 and returns the error metric as a single float

From 2f40df30381cf91384a85f2de1eb37811f6be0ca Mon Sep 17 00:00:00 2001
From: Colin <cophus@gmail.com>
Date: Mon, 3 Jul 2023 16:39:13 -0700
Subject: [PATCH 111/362] Updating polar function defaults

---
 py4DSTEM/classes/methods/datacube_methods.py |  2 +-
 py4DSTEM/process/polar/polar_fits.py         | 18 ++++++++++++++----
 2 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/py4DSTEM/classes/methods/datacube_methods.py b/py4DSTEM/classes/methods/datacube_methods.py
index bf347e5ae..9b4340c9d 100644
--- a/py4DSTEM/classes/methods/datacube_methods.py
+++ b/py4DSTEM/classes/methods/datacube_methods.py
@@ -1325,7 +1325,7 @@ def get_beamstop_mask(
         )
 
         # Add to tree
-        self.tree( mask_beamstop )
+        self.tree(x)
 
         # return
         if returncalc:
diff --git a/py4DSTEM/process/polar/polar_fits.py b/py4DSTEM/process/polar/polar_fits.py
index 1e45c3230..4661fc5bd 100644
--- a/py4DSTEM/process/polar/polar_fits.py
+++ b/py4DSTEM/process/polar/polar_fits.py
@@ -10,10 +10,11 @@ def fit_amorphous_ring(
     center,
     radial_range,
     coefs = None,
+    mask_dp = None,
     show_fit_mask = False,
     verbose = False,
     plot_result = True,
-    plot_log_scale = True,
+    plot_log_scale = False,
     plot_int_scale = (-3,3),
     figsize = (8,8),
     return_all_coefs = True,
@@ -30,6 +31,10 @@ def fit_amorphous_ring(
         (x,y) center coordinates for fitting mask
     radial_range: np.array
         (radius_inner, radius_outer) radial range to perform fitting over
+    coefs: np.array (optional)
+        Array containing initial fitting coefficients for the amorphous fit.
+    mask_dp: np.array
+        Dark field mask for fitting, in addition to the radial range specified above.
     show_fit_mask: bool
         Set to true to preview the fitting mask and initial guess for the ellipse params
     verbose: bool
@@ -66,6 +71,9 @@ def fit_amorphous_ring(
         ra2 >= radial_range[0]**2,
         ra2 <= radial_range[1]**2,
         )
+    if mask_dp is not None:
+        # Logical AND the radial mask with the user-provided mask
+        mask = np.logical_and(mask, mask_dp)
     vals = im[mask]
     basis = np.vstack((xa[mask],ya[mask]))
 
@@ -118,9 +126,11 @@ def fit_amorphous_ring(
             int_range = (
                 int_med + plot_int_scale[0]*int_std, 
                 int_med + plot_int_scale[1]*int_std)
-            im_plot = np.tile(np.clip(
-                (np.log(im[:,:,None]) - int_range[0]) / (int_range[1] - int_range[0]),
-                0,1),(1,1,3))
+            im_plot = np.tile(
+                np.clip(
+                    (np.log(im[:,:,None]) - int_range[0]) / (int_range[1] - int_range[0]),
+                    0,1),
+                (1,1,3))
 
         else:
             int_med = np.median(vals)

From 872a09437d4ccc249362e52e36786535cf861d60 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Mon, 3 Jul 2023 19:59:13 -0400
Subject: [PATCH 112/362] adds BraggVectors.get_vectors method

---
 .../process/diskdetection/braggvectors.py     | 61 ++++++++++++++++++-
 test/test_braggvectors.py                     | 27 +++++---
 2 files changed, 77 insertions(+), 11 deletions(-)

diff --git a/py4DSTEM/process/diskdetection/braggvectors.py b/py4DSTEM/process/diskdetection/braggvectors.py
index e6566a33e..1b84dc8b6 100644
--- a/py4DSTEM/process/diskdetection/braggvectors.py
+++ b/py4DSTEM/process/diskdetection/braggvectors.py
@@ -45,6 +45,19 @@ class BraggVectors(Custom,BraggVectorMethods,Data):
         >>> vects.qx,vects.qy,vects.I
         >>> vects['qx'],vects['qy'],vects['intensity']
 
+    Alternatively, you can access the centered vectors in pixel units with
+
+        >>> vects.get_vectors(
+        >>>     scan_x,
+        >>>     scan_y,
+        >>>     center = bool,
+        >>>     ellipse = bool,
+        >>>     pixel = bool,
+        >>>     rotate = bool
+        >>> )
+
+    which will return the vectors at scan position (scan_x,scan_y) with the
+    requested calibrations applied.
     """
 
     def __init__(
@@ -212,6 +225,46 @@ def setcal(
         pass
 
 
+    # vector getter method
+
+    def get_vectors(
+        self,
+        scan_x,
+        scan_y,
+        center,
+        ellipse,
+        pixel,
+        rotate
+    ):
+        """
+        Returns the bragg vectors at the specified scan position with
+        the specified calibration state.
+
+        Parameters
+        ----------
+        scan_x : int
+        scan_y : int
+        center : bool
+        ellipse : bool
+        pixel : bool
+        rotate : bool
+
+        Returns
+        -------
+        vectors : BVects
+        """
+        ans = self._v_uncal[scan_x,scan_y].data
+        ans = self.cal._transform(
+            data = ans,
+            cal = self.calibration,
+            scanxy = (scan_x,scan_y),
+            center = center,
+            ellipse = ellipse,
+            pixel = pixel,
+            rotate = rotate,
+        )
+        return BVects(ans)
+
 
     # copy
 
@@ -397,13 +450,16 @@ def _transform(
 
         if center:
             origin = cal.get_origin(x,y)
+            assert(origin is not None), "Requested calibration was not found!"
             ans['qx'] -= origin[0]
             ans['qy'] -= origin[1]
 
 
         # ellipse
         if ellipse:
-            a,b,theta = cal.get_ellipse(x,y)
+            ell = cal.get_ellipse(x,y)
+            assert(ell is not None), "Requested calibration was not found!"
+            a,b,theta = ell
             # Get the transformation matrix
             e = b/a
             sint, cost = np.sin(theta-np.pi/2.), np.cos(theta-np.pi/2.)
@@ -423,6 +479,7 @@ def _transform(
         # pixel size
         if pixel:
             qpix = cal.get_Q_pixel_size()
+            assert(qpix is not None), "Requested calibration was not found!"
             ans['qx'] *= qpix
             ans['qy'] *= qpix
 
@@ -431,6 +488,8 @@ def _transform(
         if rotate:
             flip = cal.get_QR_flip()
             theta = cal.get_QR_rotation_degrees()
+            assert(flip is not None), "Requested calibration was not found!"
+            assert(theta is not None), "Requested calibration was not found!"
             # rotation matrix
             R = np.array([
                 [np.cos(theta), -np.sin(theta)],
diff --git a/test/test_braggvectors.py b/test/test_braggvectors.py
index 107cf7a64..f250f7a0f 100644
--- a/test/test_braggvectors.py
+++ b/test/test_braggvectors.py
@@ -45,6 +45,14 @@ def setup_class(cls):
         #     'CUDA': True,
         }
 
+        # find disks
+        cls.braggpeaks = datacube.find_Bragg_disks(
+            template = probe.kernel,
+            **cls.detect_params,
+        )
+
+        # set an arbitrary center for testing
+        cls.braggpeaks.calibration.set_origin((datacube.Qshape[0]/2,datacube.Qshape[1]/2))
 
 
 
@@ -68,20 +76,19 @@ def test_disk_detection_selected_positions(self):
             **self.detect_params,
         )
 
-    def test_disk_detection(self):
-
-        braggpeaks = self.datacube.find_Bragg_disks(
-            template = self.probe.kernel,
-            **self.detect_params,
-        )
-
+    def test_BraggVectors(self):
 
-        print(braggpeaks)
+        print(self.braggpeaks)
         print()
-        print(braggpeaks.raw[0,0])
+        print(self.braggpeaks.raw[0,0])
         print()
-        print(braggpeaks.cal[0,0])
+        print(self.braggpeaks.cal[0,0])
         print()
+        print(self.braggpeaks.get_vectors(
+            scan_x=5,scan_y=5,
+            center=True,ellipse=False,pixel=False,rotate=False
+        ))
+
 
 
 

From fa576bd6bf4b93b31465187bfd8e27ba3dd5f251 Mon Sep 17 00:00:00 2001
From: Colin <cophus@gmail.com>
Date: Tue, 4 Jul 2023 14:39:01 -0700
Subject: [PATCH 113/362] Adding peak detection

---
 py4DSTEM/preprocess/preprocess.py        |   6 +
 py4DSTEM/process/polar/__init__.py       |   1 +
 py4DSTEM/process/polar/polar_datacube.py |   5 +
 py4DSTEM/process/polar/polar_fits.py     |   3 -
 py4DSTEM/process/polar/polar_peaks.py    | 285 +++++++++++++++++++++++
 5 files changed, 297 insertions(+), 3 deletions(-)

diff --git a/py4DSTEM/preprocess/preprocess.py b/py4DSTEM/preprocess/preprocess.py
index 343c20895..8d95ccd81 100644
--- a/py4DSTEM/preprocess/preprocess.py
+++ b/py4DSTEM/preprocess/preprocess.py
@@ -281,6 +281,12 @@ def bin_data_diffraction(
     # set calibration pixel size
     datacube.calibration.set_Q_pixel_size(Qpixsize)
 
+    # remake Cartesian coordinate system
+    datacube.qyy,datacube.qxx = np.meshgrid(
+        np.arange(0,datacube.Q_Ny),
+        np.arange(0,datacube.Q_Nx)
+    )
+
     # return
     return datacube
 
diff --git a/py4DSTEM/process/polar/__init__.py b/py4DSTEM/process/polar/__init__.py
index 741e0c610..fcabc7f41 100644
--- a/py4DSTEM/process/polar/__init__.py
+++ b/py4DSTEM/process/polar/__init__.py
@@ -1,3 +1,4 @@
 from py4DSTEM.process.polar.polar_datacube import PolarDatacube
 from py4DSTEM.process.polar.polar_fits import fit_amorphous_ring, plot_amorphous_ring
+from py4DSTEM.process.polar.polar_peaks import find_peaks_single_pattern, find_peaks
 
diff --git a/py4DSTEM/process/polar/polar_datacube.py b/py4DSTEM/process/polar/polar_datacube.py
index 1356c4a8d..72171d9a2 100644
--- a/py4DSTEM/process/polar/polar_datacube.py
+++ b/py4DSTEM/process/polar/polar_datacube.py
@@ -99,6 +99,10 @@ def __init__(
         plot_FEM_global,
         calculate_FEM_local,
     )
+    from py4DSTEM.process.polar.polar_peaks import (
+        find_peaks_single_pattern,
+        find_peaks,
+    )
 
 
     # sampling methods + properties
@@ -465,6 +469,7 @@ def _transform(
             )
             return ans
         elif returnval == 'nan':
+            ans[mask_bool] = np.nan
             return ans
         elif returnval == 'all':
             return ans, ans_norm, norm_array, mask_bool
diff --git a/py4DSTEM/process/polar/polar_fits.py b/py4DSTEM/process/polar/polar_fits.py
index 4661fc5bd..82085d6fb 100644
--- a/py4DSTEM/process/polar/polar_fits.py
+++ b/py4DSTEM/process/polar/polar_fits.py
@@ -357,6 +357,3 @@ def amorphous_model(basis, *coefs):
     int_model[sub] += int12*np.exp(dr2[sub]/(-2*sigma2**2))
 
     return int_model
-
-
-
diff --git a/py4DSTEM/process/polar/polar_peaks.py b/py4DSTEM/process/polar/polar_peaks.py
index c03e5d7db..48969fce8 100644
--- a/py4DSTEM/process/polar/polar_peaks.py
+++ b/py4DSTEM/process/polar/polar_peaks.py
@@ -2,3 +2,288 @@
 import numpy as np
 import matplotlib.pyplot as plt
 
+from scipy.ndimage import gaussian_filter
+from skimage.feature import peak_local_max
+from scipy.signal import peak_prominences
+
+from py4DSTEM import PointList
+
+def find_peaks_single_pattern(
+    self,
+    x,
+    y,
+    mask = None,
+    sigma_annular_deg = 10.0,
+    sigma_radial_px = 3.0,
+    radial_background_subtract = True,
+    radial_background_thresh = 0.25,
+    num_peaks_max = 100,
+    threshold_abs = 1.0,
+    threshold_prom_annular = None,
+    threshold_prom_radial = None,
+    remove_masked_peaks = False,
+    scale_sigma = 0.25,
+    plot_result = True,
+    plot_power_scale = 1.0,
+    plot_scale_size = 100.0,
+    ):
+    """
+    Peak detection function for polar transformations.
+
+    Parameters
+    --------
+    x: int
+        x index of diffraction pattern
+    y: int
+        y index of diffraction pattern
+    sigma_annular_deg: float
+        smoothing along the annular direction in degrees, periodic
+    sigma_radial_px: float
+        smoothing along the radial direction in pixels, not periodic
+    radial_background_subtract: bool
+        If true, subtract radial background estimate
+    radial_background_thresh: float
+        Relative order of sorted values to use as background estimate.
+        Setting to 0.5 is equivalent to median, 0.0 is min value.
+    
+    Returns
+    --------
+
+    """
+
+
+
+    # Convert sigma values into units of bins
+    sigma_annular = np.deg2rad(sigma_annular_deg) / self.annular_step
+    sigma_radial = sigma_radial_px / self.qstep
+    
+    # Get transformed image and normalization array
+    im_polar, im_polar_norm, norm_array, mask_bool = self.transform(
+            self._datacube.data[x,y],
+            mask = mask,
+            returnval = 'all_zeros', 
+        )
+    # Change sign convention of mask
+    mask_bool = np.logical_not(mask_bool)
+
+
+    # Background subtraction
+    if radial_background_subtract:
+        sig_bg = np.zeros(im_polar.shape[1])
+        for a0 in range(im_polar.shape[1]):
+            if np.any(mask_bool[:,a0]):
+                vals = np.sort(im_polar[mask_bool[:,a0],a0])
+                ind = np.round(radial_background_thresh * (vals.shape[0]-1)).astype('int')
+                sig_bg[a0] = vals[ind]
+        im_polar = np.maximum(im_polar - sig_bg[None,:], 0)
+
+    # apply smoothing and normalization
+    im_polar_sm = gaussian_filter(
+        im_polar * norm_array,
+        sigma = (sigma_annular, sigma_radial),
+        mode = ('wrap', 'nearest'),
+        )
+    im_mask = gaussian_filter(
+        norm_array,
+        sigma = (sigma_annular, sigma_radial),
+        mode = ('wrap', 'nearest'),
+        )
+    sub = im_mask > 0.001 * np.max(im_mask)
+    im_polar_sm[sub] /= im_mask[sub]
+
+    # Find local maxima
+    peaks = peak_local_max(
+        im_polar_sm,
+        num_peaks = num_peaks_max,
+        threshold_abs = threshold_abs,
+        )
+
+    # check if peaks should be removed from the polar transformation mask
+    if remove_masked_peaks:
+        peaks = np.delete(
+                peaks,
+                mask_bool[peaks[:,0],peaks[:,1]] == False,
+                axis = 0,
+            )
+
+    # peak intensity
+    peaks_int = im_polar_sm[peaks[:,0],peaks[:,1]]
+
+    # Estimate prominance of peaks, and their size in units of pixels
+    peaks_prom = np.zeros((peaks.shape[0],4))
+    annular_ind_center = np.atleast_1d(np.array(im_polar_sm.shape[0]//2).astype('int'))
+    for a0 in range(peaks.shape[0]):
+
+        # annular
+        trace_annular = np.roll(
+            np.squeeze(im_polar_sm[:,peaks[a0,1]]),
+            annular_ind_center - peaks[a0,0])
+        p_annular = peak_prominences(
+            trace_annular, 
+            annular_ind_center,
+            )
+        sigma_annular = scale_sigma * np.maximum(
+            annular_ind_center - p_annular[1],
+            p_annular[2] - annular_ind_center)
+
+        # radial
+        trace_radial  = im_polar_sm[peaks[a0,0],:]
+        p_radial = peak_prominences(
+            trace_radial, 
+            np.atleast_1d(peaks[a0,1]),
+            )
+        sigma_radial = scale_sigma * np.maximum(
+            peaks[a0,1] - p_radial[1],
+            p_radial[2] - peaks[a0,1])
+
+        # output
+        peaks_prom[a0,0] = p_annular[0]
+        peaks_prom[a0,1] = sigma_annular[0]
+        peaks_prom[a0,2] = p_radial[0]
+        peaks_prom[a0,3] = sigma_radial[0]
+
+    # if needed, remove peaks using prominance criteria
+    if threshold_prom_annular is not None:
+        remove = peaks_prom[:,0] < threshold_prom_annular
+        peaks = np.delete(
+            peaks,
+            remove,
+            axis = 0,
+            )
+        peaks_int = np.delete(
+            peaks_int,
+            remove,
+            )
+        peaks_prom = np.delete(
+            peaks_prom,
+            remove,
+            axis = 0,
+            )
+    if threshold_prom_radial is not None:
+        remove = peaks_prom[:,2] < threshold_prom_radial
+        peaks = np.delete(
+            peaks,
+            remove,
+            axis = 0,
+            )
+        peaks_int = np.delete(
+            peaks_int,
+            remove,
+            )
+        peaks_prom = np.delete(
+            peaks_prom,
+            remove,
+            axis = 0,
+            )
+
+    # Output data as a pointlist
+    # peaks_polar = np.zeros(
+    #     peaks.shape[0], 
+    #     dtype={
+    #         'names':('qt', 'qr', 'intensity',
+    #             'sigma_annular', 'prom_annular',
+    #             'sigma_radial',  'prom_radial',
+    #             ),
+    #         'formats':('f8', 'f8', 'f8', 'f8', 'f8', 'f8', 'f8')}
+    #     )
+    peaks_polar = PointList(
+            np.column_stack((peaks, peaks_int, peaks_prom)).ravel().view([
+            ('qt', np.float),
+            ('qr', np.float),
+            ('intensity', np.float),
+            ('prom_annular', np.float),
+            ('sigma_annular', np.float),
+            ('prom_radial', np.float),
+            ('sigma_radial', np.float),
+        ]),
+        name = 'peaks_polar')
+    
+
+    if plot_result:
+        # init
+        im_plot = im_polar.copy()
+        im_plot = np.maximum(im_plot, 0) ** plot_power_scale
+
+        t = np.linspace(0,2*np.pi,180+1)
+        ct = np.cos(t)
+        st = np.sin(t)
+
+
+        fig,ax = plt.subplots(figsize=(12,6))
+
+        ax.imshow(
+            im_plot,
+            cmap = 'gray',
+            )
+
+        # peaks
+        ax.scatter(
+            peaks_polar['qr'],
+            peaks_polar['qt'],
+            s = peaks_polar['intensity'] * plot_scale_size,
+            marker='o',
+            color = (1,0,0),
+            )
+        for a0 in range(peaks_polar.data.shape[0]):
+            ax.plot(
+                peaks_polar['qr'][a0] + st * peaks_polar['sigma_radial'][a0],
+                peaks_polar['qt'][a0] + ct * peaks_polar['sigma_annular'][a0],
+                linewidth = 1,
+                color = 'r',
+                )
+            if peaks_polar['qt'][a0] - peaks_polar['sigma_annular'][a0] < 0:
+                ax.plot(
+                    peaks_polar['qr'][a0] + st * peaks_polar['sigma_radial'][a0],
+                    peaks_polar['qt'][a0] + ct * peaks_polar['sigma_annular'][a0] + im_plot.shape[0],
+                    linewidth = 1,
+                    color = 'r',
+                    )
+            if peaks_polar['qt'][a0] + peaks_polar['sigma_annular'][a0] > im_plot.shape[0]:
+                ax.plot(
+                    peaks_polar['qr'][a0] + st * peaks_polar['sigma_radial'][a0],
+                    peaks_polar['qt'][a0] + ct * peaks_polar['sigma_annular'][a0] - im_plot.shape[0],
+                    linewidth = 1,
+                    color = 'r',
+                    )
+
+        # plot appearance
+        ax.set_xlim((0,im_plot.shape[1]-1))
+        ax.set_ylim((im_plot.shape[0]-1,0))
+
+    # ax.imshow(np.hstack((
+    #     im_polar,
+    #     im_polar_sm * 2,
+    #     # np.tile(sig_bg[None,:],(im_polar.shape[0],1))
+    #     )),
+    #     cmap = 'gray',
+    # )
+    # ax.imshow(
+    #     im_polar_sm,
+    # )
+
+
+    return peaks_polar
+
+
+
+def find_peaks(
+    self,
+    mask = None,
+    sigma_annular_deg = 10.0,
+    sigma_radial_px = 2.0,
+    ):
+    """
+    Peak detection function for polar transformations.
+
+    Parameters
+    --------
+    sigma_annular_deg: float
+        smoothing along the annular direction in degrees, periodic
+    sigma_radial_px: float
+        smoothing along the radial direction in pixels, not periodic
+    
+    Returns
+    --------
+
+    """
+    pass
\ No newline at end of file

From cc35a7c63bb94e92123f68e8a85975c9c4940876 Mon Sep 17 00:00:00 2001
From: Colin <cophus@gmail.com>
Date: Tue, 4 Jul 2023 15:50:41 -0700
Subject: [PATCH 114/362] Adding new function stems

---
 py4DSTEM/process/polar/__init__.py       |   3 +-
 py4DSTEM/process/polar/polar_datacube.py |   4 +
 py4DSTEM/process/polar/polar_peaks.py    | 166 +++++++++++++++++++----
 3 files changed, 145 insertions(+), 28 deletions(-)

diff --git a/py4DSTEM/process/polar/__init__.py b/py4DSTEM/process/polar/__init__.py
index fcabc7f41..ddf0a9e50 100644
--- a/py4DSTEM/process/polar/__init__.py
+++ b/py4DSTEM/process/polar/__init__.py
@@ -1,4 +1,3 @@
 from py4DSTEM.process.polar.polar_datacube import PolarDatacube
 from py4DSTEM.process.polar.polar_fits import fit_amorphous_ring, plot_amorphous_ring
-from py4DSTEM.process.polar.polar_peaks import find_peaks_single_pattern, find_peaks
-
+from py4DSTEM.process.polar.polar_peaks import find_peaks_single_pattern, find_peaks, refine_peaks, plot_radial_peaks, plot_radial_background, make_orientation_histogram
diff --git a/py4DSTEM/process/polar/polar_datacube.py b/py4DSTEM/process/polar/polar_datacube.py
index 72171d9a2..9da003418 100644
--- a/py4DSTEM/process/polar/polar_datacube.py
+++ b/py4DSTEM/process/polar/polar_datacube.py
@@ -102,6 +102,10 @@ def __init__(
     from py4DSTEM.process.polar.polar_peaks import (
         find_peaks_single_pattern,
         find_peaks,
+        refine_peaks,
+        plot_radial_peaks,
+        plot_radial_background,
+        make_orientation_histogram,
     )
 
 
diff --git a/py4DSTEM/process/polar/polar_peaks.py b/py4DSTEM/process/polar/polar_peaks.py
index 48969fce8..807013801 100644
--- a/py4DSTEM/process/polar/polar_peaks.py
+++ b/py4DSTEM/process/polar/polar_peaks.py
@@ -6,13 +6,16 @@
 from skimage.feature import peak_local_max
 from scipy.signal import peak_prominences
 
-from py4DSTEM import PointList
+# from emdfile import tqdmnd, PointList, PointListArray
+from py4DSTEM import tqdmnd, PointList, PointListArray
 
 def find_peaks_single_pattern(
     self,
     x,
     y,
     mask = None,
+    bragg_peaks = None,
+    bragg_mask_radius = None,
     sigma_annular_deg = 10.0,
     sigma_radial_px = 3.0,
     radial_background_subtract = True,
@@ -23,9 +26,11 @@ def find_peaks_single_pattern(
     threshold_prom_radial = None,
     remove_masked_peaks = False,
     scale_sigma = 0.25,
+    return_background = False,
     plot_result = True,
     plot_power_scale = 1.0,
     plot_scale_size = 100.0,
+    returnfig = False,
     ):
     """
     Peak detection function for polar transformations.
@@ -36,6 +41,10 @@ def find_peaks_single_pattern(
         x index of diffraction pattern
     y: int
         y index of diffraction pattern
+    mask: np.array
+        Boolean mask in Cartesian space, to filter detected peaks.
+    bragg_peaks: py4DSTEM.BraggVectors
+        Set of Bragg peaks used to generated a mask in Cartesian space, to filter detected peaks
     sigma_annular_deg: float
         smoothing along the annular direction in degrees, periodic
     sigma_radial_px: float
@@ -51,6 +60,18 @@ def find_peaks_single_pattern(
 
     """
 
+    # if needed, generate mask from Bragg peaks
+    if bragg_peaks is not None:
+        mask_bragg = self._datacube.get_braggmask(
+            bragg_peaks,
+            x,
+            y,
+            radius = bragg_mask_radius,
+        )
+        if mask is None:
+            mask = mask_bragg
+        else:
+            mask = np.logical_or(mask, mask_bragg)
 
 
     # Convert sigma values into units of bins
@@ -177,15 +198,6 @@ def find_peaks_single_pattern(
             )
 
     # Output data as a pointlist
-    # peaks_polar = np.zeros(
-    #     peaks.shape[0], 
-    #     dtype={
-    #         'names':('qt', 'qr', 'intensity',
-    #             'sigma_annular', 'prom_annular',
-    #             'sigma_radial',  'prom_radial',
-    #             ),
-    #         'formats':('f8', 'f8', 'f8', 'f8', 'f8', 'f8', 'f8')}
-    #     )
     peaks_polar = PointList(
             np.column_stack((peaks, peaks_int, peaks_prom)).ravel().view([
             ('qt', np.float),
@@ -250,30 +262,38 @@ def find_peaks_single_pattern(
         ax.set_xlim((0,im_plot.shape[1]-1))
         ax.set_ylim((im_plot.shape[0]-1,0))
 
-    # ax.imshow(np.hstack((
-    #     im_polar,
-    #     im_polar_sm * 2,
-    #     # np.tile(sig_bg[None,:],(im_polar.shape[0],1))
-    #     )),
-    #     cmap = 'gray',
-    # )
-    # ax.imshow(
-    #     im_polar_sm,
-    # )
-
-
-    return peaks_polar
-
+    if returnfig and plot_result:
+        if return_background:
+            return peaks_polar, sig_bg, fig, ax
+        else:
+            return peaks_polar, fig, ax            
+    else:
+        if return_background:
+            return peaks_polar, sig_bg
+        else:
+            return peaks_polar
 
 
 def find_peaks(
     self,
     mask = None,
+    bragg_peaks = None,
+    bragg_mask_radius = None,
     sigma_annular_deg = 10.0,
-    sigma_radial_px = 2.0,
+    sigma_radial_px = 3.0,
+    radial_background_subtract = True,
+    radial_background_thresh = 0.25,
+    num_peaks_max = 100,
+    threshold_abs = 1.0,
+    threshold_prom_annular = None,
+    threshold_prom_radial = None,
+    remove_masked_peaks = False,
+    scale_sigma = 0.25,
+    progress_bar = True,
     ):
     """
-    Peak detection function for polar transformations.
+    Peak detection function for polar transformations. Loop through all probe positions,
+    find peaks.  Store the peak positions and background signals.
 
     Parameters
     --------
@@ -285,5 +305,99 @@ def find_peaks(
     Returns
     --------
 
+    """
+
+    # init
+    self.bragg_peaks = bragg_peaks
+    self.peaks = PointListArray(
+        dtype = [
+        ('qt', '<f8'), 
+        ('qr', '<f8'), 
+        ('intensity', '<f8'), 
+        ('prom_annular', '<f8'), 
+        ('sigma_annular', '<f8'), 
+        ('prom_radial', '<f8'), 
+        ('sigma_radial', '<f8')],
+        shape = self._datacube.Rshape,
+        name = 'peaks_polardata',
+        )
+    self.background_radial = np.zeros((
+        self._datacube.Rshape[0],
+        self._datacube.Rshape[1],
+        self.radial_bins.shape[0],
+        ))
+
+    # Loop over probe positions
+    for rx, ry in tqdmnd(
+        *bragg_peaks.shape,
+        desc="Finding peaks",
+        unit=" images",
+        disable=not progress_bar,
+        ):
+
+        polar_peaks, sig_bg = self.find_peaks_single_pattern(
+            rx,
+            ry,
+            mask = mask,
+            bragg_peaks = bragg_peaks,
+            bragg_mask_radius = bragg_mask_radius,
+            sigma_annular_deg = sigma_annular_deg,
+            sigma_radial_px = sigma_radial_px,
+            radial_background_subtract = radial_background_subtract,
+            radial_background_thresh = radial_background_thresh,
+            num_peaks_max = num_peaks_max,
+            threshold_abs = threshold_abs,
+            threshold_prom_annular = threshold_prom_annular,
+            threshold_prom_radial = threshold_prom_radial,
+            remove_masked_peaks = remove_masked_peaks,
+            scale_sigma = scale_sigma,
+            return_background = True,
+            plot_result = False,
+            )
+
+        self.peaks[rx,ry] = polar_peaks
+        self.background_radial[rx,ry] = sig_bg
+
+
+
+def refine_peaks(
+    self,
+    radial_background_subtract = True,
+    ):
+    """
+    Use local 2D elliptic gaussian fitting to refine the peak locations. 
+    Optionally include background offset of the peaks.
+
+    """
+    pass
+
+
+def plot_radial_peaks(
+    self,
+    returnfig = True,
+    ):
+    """
+    Calculate and plot the total peak signal as a function of the radial coordinate.
+
+    """
+    pass
+
+
+def plot_radial_background(
+    self,
+    returnfig = True,
+    ):
+    """
+    Calculate and plot the mean background signal, background standard deviation.
+
+    """
+    pass
+
+
+def make_orientation_histogram(
+    self,
+    ):
+    """
+    Make an orientation histogram, in order to use flowline visualization of orientation maps.
     """
     pass
\ No newline at end of file

From 1367cfc80166eed0748cc4c12f8c57d97bf91de3 Mon Sep 17 00:00:00 2001
From: Colin <cophus@gmail.com>
Date: Tue, 4 Jul 2023 17:37:44 -0700
Subject: [PATCH 115/362] Adding orientation histogram outputs

Links this code to the flowline module
---
 py4DSTEM/process/diffraction/flowlines.py |   2 +-
 py4DSTEM/process/polar/polar_peaks.py     | 310 +++++++++++++++++++++-
 2 files changed, 298 insertions(+), 14 deletions(-)

diff --git a/py4DSTEM/process/diffraction/flowlines.py b/py4DSTEM/process/diffraction/flowlines.py
index c2fa224fa..27d4f9381 100644
--- a/py4DSTEM/process/diffraction/flowlines.py
+++ b/py4DSTEM/process/diffraction/flowlines.py
@@ -15,7 +15,7 @@
 
 
 def make_orientation_histogram(
-    bragg_peaks: PointList = None,
+    bragg_peaks: PointListArray = None,
     radial_ranges: np.ndarray = None,
     orientation_map = None,
     orientation_ind: int = 0,
diff --git a/py4DSTEM/process/polar/polar_peaks.py b/py4DSTEM/process/polar/polar_peaks.py
index 807013801..678f8829a 100644
--- a/py4DSTEM/process/polar/polar_peaks.py
+++ b/py4DSTEM/process/polar/polar_peaks.py
@@ -2,9 +2,9 @@
 import numpy as np
 import matplotlib.pyplot as plt
 
-from scipy.ndimage import gaussian_filter
-from skimage.feature import peak_local_max
+from scipy.ndimage import gaussian_filter, gaussian_filter1d
 from scipy.signal import peak_prominences
+from skimage.feature import peak_local_max
 
 # from emdfile import tqdmnd, PointList, PointListArray
 from py4DSTEM import tqdmnd, PointList, PointListArray
@@ -87,7 +87,6 @@ def find_peaks_single_pattern(
     # Change sign convention of mask
     mask_bool = np.logical_not(mask_bool)
 
-
     # Background subtraction
     if radial_background_subtract:
         sig_bg = np.zeros(im_polar.shape[1])
@@ -96,6 +95,7 @@ def find_peaks_single_pattern(
                 vals = np.sort(im_polar[mask_bool[:,a0],a0])
                 ind = np.round(radial_background_thresh * (vals.shape[0]-1)).astype('int')
                 sig_bg[a0] = vals[ind]
+        sig_bg_mask = np.sum(mask_bool, axis=0) >= (im_polar.shape[0]//2)
         im_polar = np.maximum(im_polar - sig_bg[None,:], 0)
 
     # apply smoothing and normalization
@@ -264,12 +264,12 @@ def find_peaks_single_pattern(
 
     if returnfig and plot_result:
         if return_background:
-            return peaks_polar, sig_bg, fig, ax
+            return peaks_polar, sig_bg, sig_bg_mask, fig, ax
         else:
             return peaks_polar, fig, ax            
     else:
         if return_background:
-            return peaks_polar, sig_bg
+            return peaks_polar, sig_bg, sig_bg_mask
         else:
             return peaks_polar
 
@@ -326,16 +326,22 @@ def find_peaks(
         self._datacube.Rshape[1],
         self.radial_bins.shape[0],
         ))
+    self.background_radial_mask = np.zeros((
+        self._datacube.Rshape[0],
+        self._datacube.Rshape[1],
+        self.radial_bins.shape[0],
+        ), dtype='bool')
 
     # Loop over probe positions
     for rx, ry in tqdmnd(
-        *bragg_peaks.shape,
+        self._datacube.Rshape[0],
+        self._datacube.Rshape[1],
         desc="Finding peaks",
         unit=" images",
         disable=not progress_bar,
         ):
 
-        polar_peaks, sig_bg = self.find_peaks_single_pattern(
+        polar_peaks, sig_bg, sig_bg_mask = self.find_peaks_single_pattern(
             rx,
             ry,
             mask = mask,
@@ -357,7 +363,7 @@ def find_peaks(
 
         self.peaks[rx,ry] = polar_peaks
         self.background_radial[rx,ry] = sig_bg
-
+        self.background_radial_mask[rx,ry] = sig_bg_mask
 
 
 def refine_peaks(
@@ -374,30 +380,308 @@ def refine_peaks(
 
 def plot_radial_peaks(
     self,
-    returnfig = True,
+    qmin = None,
+    qmax = None,
+    qstep = None,
+    figsize = (8,4),
+    returnfig = False,
     ):
     """
     Calculate and plot the total peak signal as a function of the radial coordinate.
 
     """
-    pass
+    
+    # Get all peak data
+    vects = np.concatenate(
+        [self.peaks[i,j].data for i in range(self._datacube.Rshape[0]) for j in range(self._datacube.Rshape[1])])
+    qr = vects['qr'] * self.calibration.get_Q_pixel_size()
+    intensity = vects['intensity']
+
+    # bins
+    if qmin is None:
+        qmin = self.qq[0]
+    if qmax is None:
+        qmax = self.qq[-1]
+    if qstep is None:
+        qstep = self.qq[1] - self.qq[0]
+    q_bins = np.arange(qmin,qmax,qstep)
+    q_num = q_bins.shape[0]
+
+    # histogram
+    q_ind = (qr - qmin) / qstep
+    qf = np.floor(q_ind).astype("int")
+    dq = q_ind - qf
+
+    sub = np.logical_and(qf >= 0, qf < q_num)
+    int_peaks = np.bincount(
+        np.floor(q_ind[sub]).astype("int"),
+        weights=(1 - dq[sub]) * intensity[sub],
+        minlength=q_num,
+    )
+    sub = np.logical_and(q_ind >= -1, q_ind < q_num - 1)
+    int_peaks += np.bincount(
+        np.floor(q_ind[sub] + 1).astype("int"),
+        weights=dq[sub] * intensity[sub],
+        minlength=q_num,
+    )
+
+
+
+    # plotting
+    fig,ax = plt.subplots(figsize = figsize)
+    ax.plot(
+        q_bins,
+        int_peaks,
+        color = 'r',
+        linewidth = 2,
+        )
+    ax.set_xlim((q_bins[0],q_bins[-1]))
+    ax.set_xlabel(
+        'Scattering Angle (' + self.calibration.get_Q_pixel_units() +')',
+        fontsize = 14,
+        )
+    ax.set_ylabel(
+        'Total Peak Signal',
+        fontsize = 14,
+        )
+
+    if returnfig:
+        return fig,ax
+
+
 
 
 def plot_radial_background(
     self,
-    returnfig = True,
+    figsize = (8,4),
+    returnfig = False,
     ):
     """
     Calculate and plot the mean background signal, background standard deviation.
 
     """
-    pass
+    
+    # mean
+    self.background_radial_mean = np.sum(
+        self.background_radial * self.background_radial_mask,
+        axis=(0,1))
+    background_radial_mean_norm = np.sum(
+        self.background_radial_mask,
+        axis=(0,1))
+    self.background_mask = \
+        background_radial_mean_norm > (np.max(background_radial_mean_norm)*0.05)
+    self.background_radial_mean[self.background_mask] \
+        /= background_radial_mean_norm[self.background_mask]
+    self.background_radial_mean[np.logical_not(self.background_mask)] = 0
+
+    # variance and standard deviation
+    self.background_radial_var = np.sum(
+        (self.background_radial - self.background_radial_mean[None,None,:])**2 \
+        * self.background_radial_mask,
+        axis=(0,1))
+    self.background_radial_var[self.background_mask] \
+        /= self.background_radial_var[self.background_mask]
+    self.background_radial_var[np.logical_not(self.background_mask)] = 0
+    self.background_radial_std = np.sqrt(self.background_radial_var)
+
+
+    fig,ax = plt.subplots(figsize = figsize)
+    ax.fill_between(
+        self.qq[self.background_mask], 
+        self.background_radial_mean[self.background_mask] \
+        - self.background_radial_std[self.background_mask], 
+        self.background_radial_mean[self.background_mask] \
+        + self.background_radial_std[self.background_mask], 
+        color = 'r',
+        alpha=0.2,
+        )
+    ax.plot(
+        self.qq[self.background_mask],
+        self.background_radial_mean[self.background_mask],
+        color = 'r',
+        linewidth = 2,
+        )
+    ax.set_xlim((self.qq[0],self.qq[-1]))
+    ax.set_xlabel(
+        'Scattering Angle (' + self.calibration.get_Q_pixel_units() +')',
+        fontsize = 14,
+        )
+    ax.set_ylabel(
+        'Background Signal',
+        fontsize = 14,
+        )
+
+    if returnfig:
+        return fig,ax
 
 
 def make_orientation_histogram(
     self,
+    radial_ranges: np.ndarray = None,
+    orientation_offset_degrees: float = 0.0,
+    orientation_flip_sign: bool = False,
+    orientation_separate_bins: bool = False,
+    upsample_factor: float = 4.0,
+    theta_step_deg: float = None,
+    sigma_x: float = 1.0,
+    sigma_y: float = 1.0,
+    sigma_theta: float = 3.0,
+    normalize_intensity_image: bool = False,
+    normalize_intensity_stack: bool = True,
+    progress_bar: bool = True,
     ):
     """
     Make an orientation histogram, in order to use flowline visualization of orientation maps.
+    Use peaks attached to polardatacube.
+
+    NOTE - currently assumes two fold rotation symmetry
+    TODO - add support for non two fold symmetry polardatacube
+
+    Args:
+        radial_ranges (np array):           Size (N x 2) array for N radial bins, or (2,) for a single bin.
+        orientation_offset_degrees (float): Offset for orientation angles
+
+        orientation_separate_bins (bool):   whether to place multiple angles into multiple radial bins.
+        upsample_factor (float):            Upsample factor
+        theta_step_deg (float):             Step size along annular direction in degrees
+        sigma_x (float):                    Smoothing in x direction before upsample
+        sigma_y (float):                    Smoothing in x direction before upsample
+        sigma_theta (float):                Smoothing in annular direction (units of bins, periodic)
+        normalize_intensity_image (bool):   Normalize to max peak intensity = 1, per image
+        normalize_intensity_stack (bool):   Normalize to max peak intensity = 1, all images
+        progress_bar (bool):                Enable progress bar
+
+    Returns:
+        orient_hist (array):                4D array containing Bragg peak intensity histogram 
+                                            [radial_bin x_probe y_probe theta]
     """
-    pass
\ No newline at end of file
+
+    # coordinates
+    if theta_step_deg is None:
+        # Get angles from polardatacube
+        theta = self.tt
+    else:
+        theta = np.arange(0,180,theta_step_deg) * np.pi / 180.0
+    dtheta = theta[1] - theta[0]
+    dtheta_deg = dtheta * 180 / np.pi
+    num_theta_bins = np.size(theta)
+
+    # Input bins
+    radial_ranges = np.array(radial_ranges)
+    if radial_ranges.ndim == 1:
+        radial_ranges = radial_ranges[None,:]
+    radial_ranges_2 = radial_ranges**2
+    num_radii = radial_ranges.shape[0]
+    size_input = self._datacube.shape[0:2]
+
+    # Output size
+    size_output = np.round(np.array(size_input).astype('float') * upsample_factor).astype('int')
+
+    # output init
+    orient_hist = np.zeros([
+        num_radii,
+        size_output[0],
+        size_output[1],
+        num_theta_bins])
+
+    # Loop over all probe positions
+    for a0 in range(num_radii):
+        t = "Generating histogram " + str(a0)
+        # for rx, ry in tqdmnd(
+        #         *bragg_peaks.shape, desc=t,unit=" probe positions", disable=not progress_bar
+        #     ):
+        for rx, ry in tqdmnd(
+                *size_input, 
+                desc=t,
+                unit=" probe positions", 
+                disable=not progress_bar
+            ):
+            x = (rx + 0.5)*upsample_factor - 0.5
+            y = (ry + 0.5)*upsample_factor - 0.5
+            x = np.clip(x,0,size_output[0]-2)
+            y = np.clip(y,0,size_output[1]-2)
+
+            xF = np.floor(x).astype('int')
+            yF = np.floor(y).astype('int')
+            dx = x - xF
+            dy = y - yF
+
+            add_data = False
+
+            q = self.peaks[rx,ry]['qr'] * self.calibration.get_Q_pixel_size()
+            r2 = q**2
+            sub = np.logical_and(r2 >= radial_ranges_2[a0,0], r2 < radial_ranges_2[a0,1])                
+            if np.any(sub):
+                add_data = True
+                intensity = self.peaks[rx,ry]['intensity'][sub]
+
+                # Angles
+                theta = self.peaks[rx,ry]['qt'][sub] * self.annular_step
+                t = theta / dtheta
+
+            if add_data:
+                tF = np.floor(t).astype('int')
+                dt = t - tF
+
+                orient_hist[a0,xF  ,yF  ,:] = orient_hist[a0,xF  ,yF  ,:] + \
+                    np.bincount(np.mod(tF  ,num_theta_bins),
+                        weights=(1-dx)*(1-dy)*(1-dt)*intensity,minlength=num_theta_bins)
+                orient_hist[a0,xF  ,yF  ,:] = orient_hist[a0,xF  ,yF  ,:] + \
+                    np.bincount(np.mod(tF+1,num_theta_bins),
+                        weights=(1-dx)*(1-dy)*(  dt)*intensity,minlength=num_theta_bins)
+
+                orient_hist[a0,xF+1,yF  ,:] = orient_hist[a0,xF+1,yF  ,:] + \
+                    np.bincount(np.mod(tF  ,num_theta_bins),
+                        weights=(  dx)*(1-dy)*(1-dt)*intensity,minlength=num_theta_bins)
+                orient_hist[a0,xF+1,yF  ,:] = orient_hist[a0,xF+1,yF  ,:] + \
+                    np.bincount(np.mod(tF+1,num_theta_bins),
+                        weights=(  dx)*(1-dy)*(  dt)*intensity,minlength=num_theta_bins)
+ 
+                orient_hist[a0,xF  ,yF+1,:] = orient_hist[a0,xF  ,yF+1,:] + \
+                    np.bincount(np.mod(tF  ,num_theta_bins),
+                        weights=(1-dx)*(  dy)*(1-dt)*intensity,minlength=num_theta_bins)
+                orient_hist[a0,xF  ,yF+1,:] = orient_hist[a0,xF  ,yF+1,:] + \
+                    np.bincount(np.mod(tF+1,num_theta_bins),
+                        weights=(1-dx)*(  dy)*(  dt)*intensity,minlength=num_theta_bins)
+
+                orient_hist[a0,xF+1,yF+1,:] = orient_hist[a0,xF+1,yF+1,:] + \
+                    np.bincount(np.mod(tF  ,num_theta_bins),
+                        weights=(  dx)*(  dy)*(1-dt)*intensity,minlength=num_theta_bins)
+                orient_hist[a0,xF+1,yF+1,:] = orient_hist[a0,xF+1,yF+1,:] + \
+                    np.bincount(np.mod(tF+1,num_theta_bins),
+                        weights=(  dx)*(  dy)*(  dt)*intensity,minlength=num_theta_bins)           
+
+    # smoothing / interpolation
+    if (sigma_x is not None) or (sigma_y is not None) or (sigma_theta is not None):
+        if num_radii > 1:
+            print('Interpolating orientation matrices ...', end='')
+        else:
+            print('Interpolating orientation matrix ...', end='')            
+        if sigma_x is not None and sigma_x > 0:
+            orient_hist = gaussian_filter1d(
+                orient_hist,sigma_x*upsample_factor,
+                mode='nearest',
+                axis=1,
+                truncate=3.0)
+        if sigma_y is not None and sigma_y > 0:
+            orient_hist = gaussian_filter1d(
+                orient_hist,sigma_y*upsample_factor,
+                mode='nearest',
+                axis=2,
+                truncate=3.0)
+        if sigma_theta is not None and sigma_theta > 0:
+            orient_hist = gaussian_filter1d(
+                orient_hist,sigma_theta/dtheta_deg,
+                mode='wrap',
+                axis=3,
+                truncate=2.0)
+        print(' done.')
+
+    # normalization
+    if normalize_intensity_stack is True:
+            orient_hist = orient_hist / np.max(orient_hist)
+    elif normalize_intensity_image is True:
+        for a0 in range(num_radii):
+            orient_hist[a0,:,:,:] = orient_hist[a0,:,:,:] / np.max(orient_hist[a0,:,:,:])
+
+    return orient_hist
\ No newline at end of file

From b0d394f93926cdf11b662bd191652cce76e58557 Mon Sep 17 00:00:00 2001
From: Colin <cophus@gmail.com>
Date: Tue, 4 Jul 2023 17:39:48 -0700
Subject: [PATCH 116/362] Implementing angle modification variables

---
 py4DSTEM/process/polar/polar_peaks.py | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/py4DSTEM/process/polar/polar_peaks.py b/py4DSTEM/process/polar/polar_peaks.py
index 678f8829a..1ac5de946 100644
--- a/py4DSTEM/process/polar/polar_peaks.py
+++ b/py4DSTEM/process/polar/polar_peaks.py
@@ -375,7 +375,10 @@ def refine_peaks(
     Optionally include background offset of the peaks.
 
     """
-    pass
+    
+    # See if the intial detected peaks have been saved 
+
+
 
 
 def plot_radial_peaks(
@@ -518,8 +521,8 @@ def plot_radial_background(
 def make_orientation_histogram(
     self,
     radial_ranges: np.ndarray = None,
-    orientation_offset_degrees: float = 0.0,
     orientation_flip_sign: bool = False,
+    orientation_offset_degrees: float = 0.0,
     orientation_separate_bins: bool = False,
     upsample_factor: float = 4.0,
     theta_step_deg: float = None,
@@ -539,8 +542,8 @@ def make_orientation_histogram(
 
     Args:
         radial_ranges (np array):           Size (N x 2) array for N radial bins, or (2,) for a single bin.
+        orientation_flip_sign (bool):       Flip the direction of theta
         orientation_offset_degrees (float): Offset for orientation angles
-
         orientation_separate_bins (bool):   whether to place multiple angles into multiple radial bins.
         upsample_factor (float):            Upsample factor
         theta_step_deg (float):             Step size along annular direction in degrees
@@ -615,8 +618,12 @@ def make_orientation_histogram(
                 add_data = True
                 intensity = self.peaks[rx,ry]['intensity'][sub]
 
-                # Angles
+                # Angles of all peaks
                 theta = self.peaks[rx,ry]['qt'][sub] * self.annular_step
+                if orientation_flip_sign:
+                    theta *= -1
+                theta += orientation_offset_degrees
+
                 t = theta / dtheta
 
             if add_data:

From 6461a503d4ec7b65646384e59547c242e1358797 Mon Sep 17 00:00:00 2001
From: Colin <cophus@gmail.com>
Date: Tue, 4 Jul 2023 19:36:53 -0700
Subject: [PATCH 117/362] Testing fitting

---
 py4DSTEM/process/fit/fit.py              |  97 +++++++++--
 py4DSTEM/process/polar/polar_datacube.py |   1 +
 py4DSTEM/process/polar/polar_peaks.py    | 213 ++++++++++++++++++++++-
 3 files changed, 288 insertions(+), 23 deletions(-)

diff --git a/py4DSTEM/process/fit/fit.py b/py4DSTEM/process/fit/fit.py
index 5b9a5a43e..9abb713f7 100644
--- a/py4DSTEM/process/fit/fit.py
+++ b/py4DSTEM/process/fit/fit.py
@@ -41,6 +41,8 @@ def fit_2D(
     """
     Performs a 2D fit.
 
+    TODO: make returning the mask optional
+
     Parameters
     ----------
     function : callable
@@ -61,11 +63,10 @@ def fit_2D(
     robust_thresh : int
         The robust fitting cutoff
 
-
     Returns:
-    (popt,pcov,fit_at) : 3-tuple
-        The optimal fit parameters, the fitting covariance matrix, and the
-        the fit array with the returned `popt` params
+    (popt,pcov,fit_at, mask) : 4-tuple
+        The optimal fit parameters, the fitting covariance matrix, the
+        the fit array with the returned `popt` params, and the mask
     """
     # get shape
     shape = data.shape
@@ -112,7 +113,7 @@ def fit_2D(
             p0=popt)
 
     fit_ar = function(xy,*popt).reshape(shape)
-    return popt, pcov, fit_ar,mask
+    return popt, pcov, fit_ar, mask
 
 
 # Functions for fitting
@@ -158,6 +159,49 @@ def polar_gaussian_2D(
             - ( t2/(2*sigma_t**2) + \
                 (q-mu_q)**2/(2*sigma_q**2) ) ) + C
 
+
+def polar_twofold_gaussian_2D(
+    tq,
+    I0,
+    mu_t,
+    mu_q,
+    sigma_t,
+    sigma_q,
+    ):
+    
+    # unpack position
+    t,q = tq
+
+    # theta periodicity
+    dt = np.mod(t - mu_t + np.pi/2, np.pi) - np.pi/2
+
+    # output intensity
+    return I0 * np.exp(
+        (dt**2 / (-2.0*sigma_t**2)) + \
+        ((q - mu_q)**2 / (-2.0*sigma_q**2)) )
+
+def polar_twofold_gaussian_2D_background(
+    tq,
+    I0,
+    mu_t,
+    mu_q,
+    sigma_t,
+    sigma_q,
+    C,
+    ):
+    
+    # unpack position
+    t,q = tq
+
+    # theta periodicity
+    dt = np.mod(t - mu_t + np.pi/2, np.pi) - np.pi/2
+
+    # output intensity
+    return C + I0 * np.exp(
+        (dt**2 / (-2.0*sigma_t**2)) + \
+        ((q - mu_q)**2 / (-2.0*sigma_q**2)) )
+
+
 def fit_2D_polar_gaussian(
     data,
     mask = None,
@@ -165,15 +209,22 @@ def fit_2D_polar_gaussian(
     robust = False,
     robust_steps = 3,
     robust_thresh = 2,
-):
+    constant_background = False,
+    ):
     """
+
+    NOTE - this cannot work without using pixel coordinates - something is wrong in the workflow.
+
+
     Fits a 2D gaussian to the pixels in `data` which are set to True in `mask`.
 
     The gaussian is anisotropic and oriented along (t,q), centered at
     (mu_t,mu_q), has standard deviations (sigma_t,sigma_q), maximum of I0,
-    and a constant offset of C, and is periodic in t.
+    and an optional constant offset of C, and is periodic in t.
 
         f(x,y) = I0 * exp( - (x-mu_x)^2/(2sig_x^2) + (y-mu_y)^2/(2sig_y^2) )
+        or
+        f(x,y) = I0 * exp( - (x-mu_x)^2/(2sig_x^2) + (y-mu_y)^2/(2sig_y^2) ) + C
 
     Parameters
     ----------
@@ -189,21 +240,35 @@ def fit_2D_polar_gaussian(
         number of robust fit iterations
     robust_thresh : number
         the robust fitting threshold
+    constant_background : bool
+        whether or not to include constant background
 
     Returns
     -------
     (popt,pcov,fit_ar) : 3-tuple
         the optimal fit parameters, the covariance matrix, and the fit array
     """
-    return fit_2D(
-        polar_gaussian_2D,
-        data = data,
-        data_mask = mask,
-        popt = p0,
-        robust = robust,
-        robust_steps = robust_steps,
-        robust_thresh = robust_thresh
-    )
+
+    if constant_background:
+        return fit_2D(
+            polar_twofold_gaussian_2D_background,
+            data = data,
+            data_mask = mask,
+            popt = p0,
+            robust = robust,
+            robust_steps = robust_steps,
+            robust_thresh = robust_thresh
+        )
+    else:
+        return fit_2D(
+            polar_twofold_gaussian_2D,
+            data = data,
+            data_mask = mask,
+            popt = p0,
+            robust = robust,
+            robust_steps = robust_steps,
+            robust_thresh = robust_thresh
+        )
 
 
 
diff --git a/py4DSTEM/process/polar/polar_datacube.py b/py4DSTEM/process/polar/polar_datacube.py
index 9da003418..4610364a9 100644
--- a/py4DSTEM/process/polar/polar_datacube.py
+++ b/py4DSTEM/process/polar/polar_datacube.py
@@ -126,6 +126,7 @@ def set_radial_bins(
             self._qstep
         )
         self.qscale = self._qscale
+        self._radial_step = self._datacube.calibration.get_Q_pixel_size() * self._qstep
         self.set_polar_shape()
 
     @property
diff --git a/py4DSTEM/process/polar/polar_peaks.py b/py4DSTEM/process/polar/polar_peaks.py
index 1ac5de946..e2c32f11a 100644
--- a/py4DSTEM/process/polar/polar_peaks.py
+++ b/py4DSTEM/process/polar/polar_peaks.py
@@ -5,9 +5,11 @@
 from scipy.ndimage import gaussian_filter, gaussian_filter1d
 from scipy.signal import peak_prominences
 from skimage.feature import peak_local_max
+from scipy.optimize import curve_fit
 
 # from emdfile import tqdmnd, PointList, PointListArray
 from py4DSTEM import tqdmnd, PointList, PointListArray
+# from py4DSTEM.process.fit import fit_2D_polar_gaussian
 
 def find_peaks_single_pattern(
     self,
@@ -309,6 +311,7 @@ def find_peaks(
 
     # init
     self.bragg_peaks = bragg_peaks
+    self.bragg_mask_radius = bragg_mask_radius
     self.peaks = PointListArray(
         dtype = [
         ('qt', '<f8'), 
@@ -336,7 +339,7 @@ def find_peaks(
     for rx, ry in tqdmnd(
         self._datacube.Rshape[0],
         self._datacube.Rshape[1],
-        desc="Finding peaks",
+        desc="Finding peaks ",
         unit=" images",
         disable=not progress_bar,
         ):
@@ -368,18 +371,212 @@ def find_peaks(
 
 def refine_peaks(
     self,
+    mask = None,
     radial_background_subtract = True,
+    reset_fits_to_init_positions = False,
+    fit_range_sigma_annular = 2.0,
+    fit_range_sigma_radial = 2.0,
+    progress_bar = True,
     ):
     """
     Use local 2D elliptic gaussian fitting to refine the peak locations. 
     Optionally include background offset of the peaks.
 
+    Parameters
+    --------
+    mask: np.array
+        Mask image to apply to all images
+    radial_background_subtract: bool
+        Subtract radial background before fitting
+    reset_init_positions: bool
+        Use the initial peak parameters for fitting
+    fit_range_sigma_annular: float
+        Fit range in annular direction, in terms of the current sigma_annular
+    fit_range_sigma_radial: float
+        Fit range in radial direction, in terms of the current sigma_radial
+
+    Returns
+    --------
+
     """
     
-    # See if the intial detected peaks have been saved 
+    # See if the intial detected peaks have been saved yet, copy them if needed
+    if not hasattr(self, "peaks_init"):
+        self.peaks_init = self.peaks.copy()
+
+    # coordinate scaling
+    dt = self._annular_step
+    dq = self._radial_step
+
+    # Coordinate array for the fit
+    qq,tt = np.meshgrid(
+        self.qq,
+        self.tt,
+        )
+    tq = np.vstack([
+        tt.ravel(),
+        qq.ravel(),
+    ])
 
+    # Loop over probe positions
+    for rx, ry in tqdmnd(
+        # 1,#self._datacube.Rshape[0],
+        # 1,#self._datacube.Rshape[1],
+        range(11,12),
+        range(11,12),
+        desc="Refining peaks ",
+        unit=" images",
+        disable=not progress_bar,
+        ):
+        # mask
+        # if needed, generate mask from Bragg peaks
+        if self.bragg_peaks is not None:
+            mask_bragg = self._datacube.get_braggmask(
+                self.bragg_peaks,
+                rx,
+                ry,
+                radius = self.bragg_mask_radius,
+            )
+            if mask is None:
+                mask_fit = mask_bragg
+            else:
+                mask_fit = np.logical_or(mask, mask_bragg)
 
 
+        # Get polar image
+        im_polar, im_polar_norm, norm_array, mask_bool = self.transform(
+                self._datacube.data[rx,ry],
+                mask = mask_fit,
+                returnval = 'all_zeros', 
+            )
+        # Change sign convention of mask
+        mask_bool = np.logical_not(mask_bool)
+        # Background subtraction
+        if radial_background_subtract:
+            sig_bg = self.background_radial[rx,ry]
+            im_polar = np.maximum(im_polar - sig_bg[None,:], 0)
+
+        # initial peak positions
+        if reset_fits_to_init_positions:
+            p = self.peaks_init[rx,ry]
+        else:
+            p = self.peaks[rx,ry]
+
+        # loop over peaks
+        for a0 in range(1,2):#p.data.shape[0]):
+
+            if radial_background_subtract:
+                p0 = [
+                    p['intensity'][a0],
+                    p['qt'][a0] * dt,
+                    p['qr'][a0] * dq,
+                    p['sigma_annular'][a0] * dt,
+                    p['sigma_radial'][a0] * dq,
+                    ]
+
+                dt = np.mod(tt - p0[1] + np.pi/2, np.pi) - np.pi/2
+                mask_peak = np.logical_and(mask_bool,
+                    dt**2/(fit_range_sigma_annular*p0[3])**2 \
+                    + (qq-p0[2])**2/(fit_range_sigma_radial*p0[4])**2 <= 1)
+
+                from py4DSTEM.process.fit import polar_twofold_gaussian_2D
+                im_test1 = polar_twofold_gaussian_2D(
+                    tq,
+                    p0[0],
+                    p0[1],
+                    p0[2],
+                    p0[3],
+                    p0[4],
+                    ).reshape(im_polar.shape)
+
+                p0, pcov = curve_fit(
+                    polar_twofold_gaussian_2D, 
+                    tq[:,mask_peak.ravel()], 
+                    im_polar[mask_peak], 
+                    p0 = p0,
+                    # bounds = bounds,
+                    )
+                # p0 = popt[0]
+                # print(p0)
+
+                # p_fit = fit_2D_polar_gaussian(
+                #     tq[:,mask_peak.ravel()],
+                #     p0 = p0,
+                #     constant_background = False,
+                #     )
+                # p0 = p_fit[0]
+                # print(p0)
+
+
+                im_test2 = polar_twofold_gaussian_2D(
+                    tq,
+                    p0[0],
+                    p0[1],
+                    p0[2],
+                    p0[3],
+                    p0[4],
+                    ).reshape(im_polar.shape)
+
+                fig,ax = plt.subplots(figsize = (12,6))
+                ax.imshow(np.hstack((
+                    im_polar * mask_peak,
+                    im_test1 * mask_peak,
+                    im_test2 * mask_peak,
+                    )))
+
+                # p_fit = fit_2D_polar_gaussian(
+                #     tq,
+                #     p0 = p0,
+                #     constant_background = False,
+                #     )
+
+                # p_new = p_fit[0]
+                # int0 = p_new[0]
+                # qt = p_new[1] / dt
+                # qr = p_new[2] / dq
+                # sigma_annular = p_new[3] / dt 
+                # sigma_radial = p_new[4] / dq 
+
+                # print(p0)
+                # print()
+                # print(int0, qt, qr, sigma_annular, sigma_radial)
+                # print()
+
+                # print(p0)
+                # print()
+                # print(p_new)
+                # print()
+                # print(p_new[0])
+                # print(p['intensity'].data[a0])
+
+
+                # p['intensity'][a0] = p_new[0],
+                # p['qt'][a0] = p_new[1] / dq,
+                # p['qr'][a0] = p_new[2] / dt,
+                # p['sigma_annular'][a0] = p_new[3] / dt,
+                # p['sigma_radial'][a0] = p_new[4] / dq,
+
+            else:
+                pass
+
+
+        # print(p0[0])
+        # print(p[0])
+
+
+    # Testing
+    fig,ax = plt.subplots()
+    ax.imshow(
+        im_polar**0.5,
+        cmap = 'gray',
+        )
+    ax.scatter(
+        p['qr'],
+        p['qt'],
+        marker = '+',
+        color = 'r',
+        s = 100
+        )
 
 def plot_radial_peaks(
     self,
@@ -397,7 +594,7 @@ def plot_radial_peaks(
     # Get all peak data
     vects = np.concatenate(
         [self.peaks[i,j].data for i in range(self._datacube.Rshape[0]) for j in range(self._datacube.Rshape[1])])
-    qr = vects['qr'] * self.calibration.get_Q_pixel_size()
+    qr = vects['qr'] * self._radial_step 
     intensity = vects['intensity']
 
     # bins
@@ -490,7 +687,7 @@ def plot_radial_background(
 
     fig,ax = plt.subplots(figsize = figsize)
     ax.fill_between(
-        self.qq[self.background_mask], 
+        self.qq[self.background_mask] * self._radial_step, 
         self.background_radial_mean[self.background_mask] \
         - self.background_radial_std[self.background_mask], 
         self.background_radial_mean[self.background_mask] \
@@ -504,7 +701,9 @@ def plot_radial_background(
         color = 'r',
         linewidth = 2,
         )
-    ax.set_xlim((self.qq[0],self.qq[-1]))
+    ax.set_xlim((
+        self.qq[0] * self._radial_step,
+        self.qq[-1]  * self._radial_step))
     ax.set_xlabel(
         'Scattering Angle (' + self.calibration.get_Q_pixel_units() +')',
         fontsize = 14,
@@ -611,7 +810,7 @@ def make_orientation_histogram(
 
             add_data = False
 
-            q = self.peaks[rx,ry]['qr'] * self.calibration.get_Q_pixel_size()
+            q = self.peaks[rx,ry]['qr'] * self._radial_step
             r2 = q**2
             sub = np.logical_and(r2 >= radial_ranges_2[a0,0], r2 < radial_ranges_2[a0,1])                
             if np.any(sub):
@@ -619,7 +818,7 @@ def make_orientation_histogram(
                 intensity = self.peaks[rx,ry]['intensity'][sub]
 
                 # Angles of all peaks
-                theta = self.peaks[rx,ry]['qt'][sub] * self.annular_step
+                theta = self.peaks[rx,ry]['qt'][sub] * self._annular_step
                 if orientation_flip_sign:
                     theta *= -1
                 theta += orientation_offset_degrees

From 95729757fdf165c2cd28ecd96e7c944e520daeae Mon Sep 17 00:00:00 2001
From: Colin <cophus@gmail.com>
Date: Tue, 4 Jul 2023 19:45:02 -0700
Subject: [PATCH 118/362] fixing outputs

---
 py4DSTEM/process/polar/polar_peaks.py | 65 ++++++---------------------
 1 file changed, 14 insertions(+), 51 deletions(-)

diff --git a/py4DSTEM/process/polar/polar_peaks.py b/py4DSTEM/process/polar/polar_peaks.py
index e2c32f11a..3b4893587 100644
--- a/py4DSTEM/process/polar/polar_peaks.py
+++ b/py4DSTEM/process/polar/polar_peaks.py
@@ -405,8 +405,8 @@ def refine_peaks(
         self.peaks_init = self.peaks.copy()
 
     # coordinate scaling
-    dt = self._annular_step
-    dq = self._radial_step
+    t_step = self._annular_step
+    q_step = self._radial_step
 
     # Coordinate array for the fit
     qq,tt = np.meshgrid(
@@ -422,8 +422,8 @@ def refine_peaks(
     for rx, ry in tqdmnd(
         # 1,#self._datacube.Rshape[0],
         # 1,#self._datacube.Rshape[1],
-        range(11,12),
-        range(11,12),
+        range(21,22),
+        range(21,22),
         desc="Refining peaks ",
         unit=" images",
         disable=not progress_bar,
@@ -463,15 +463,15 @@ def refine_peaks(
             p = self.peaks[rx,ry]
 
         # loop over peaks
-        for a0 in range(1,2):#p.data.shape[0]):
+        for a0 in range(p.data.shape[0]):
 
             if radial_background_subtract:
                 p0 = [
                     p['intensity'][a0],
-                    p['qt'][a0] * dt,
-                    p['qr'][a0] * dq,
-                    p['sigma_annular'][a0] * dt,
-                    p['sigma_radial'][a0] * dq,
+                    p['qt'][a0] * t_step,
+                    p['qr'][a0] * q_step,
+                    p['sigma_annular'][a0] * t_step,
+                    p['sigma_radial'][a0] * q_step,
                     ]
 
                 dt = np.mod(tt - p0[1] + np.pi/2, np.pi) - np.pi/2
@@ -496,17 +496,6 @@ def refine_peaks(
                     p0 = p0,
                     # bounds = bounds,
                     )
-                # p0 = popt[0]
-                # print(p0)
-
-                # p_fit = fit_2D_polar_gaussian(
-                #     tq[:,mask_peak.ravel()],
-                #     p0 = p0,
-                #     constant_background = False,
-                #     )
-                # p0 = p_fit[0]
-                # print(p0)
-
 
                 im_test2 = polar_twofold_gaussian_2D(
                     tq,
@@ -524,37 +513,11 @@ def refine_peaks(
                     im_test2 * mask_peak,
                     )))
 
-                # p_fit = fit_2D_polar_gaussian(
-                #     tq,
-                #     p0 = p0,
-                #     constant_background = False,
-                #     )
-
-                # p_new = p_fit[0]
-                # int0 = p_new[0]
-                # qt = p_new[1] / dt
-                # qr = p_new[2] / dq
-                # sigma_annular = p_new[3] / dt 
-                # sigma_radial = p_new[4] / dq 
-
-                # print(p0)
-                # print()
-                # print(int0, qt, qr, sigma_annular, sigma_radial)
-                # print()
-
-                # print(p0)
-                # print()
-                # print(p_new)
-                # print()
-                # print(p_new[0])
-                # print(p['intensity'].data[a0])
-
-
-                # p['intensity'][a0] = p_new[0],
-                # p['qt'][a0] = p_new[1] / dq,
-                # p['qr'][a0] = p_new[2] / dt,
-                # p['sigma_annular'][a0] = p_new[3] / dt,
-                # p['sigma_radial'][a0] = p_new[4] / dq,
+                self.peaks[rx,ry]['intensity'][a0] = p0[0]
+                self.peaks[rx,ry]['qt'][a0] = p0[1] / t_step
+                self.peaks[rx,ry]['qr'][a0] = p0[2] / q_step
+                self.peaks[rx,ry]['sigma_annular'][a0] = p0[3] / t_step
+                self.peaks[rx,ry]['sigma_radial'][a0] = p0[4] / q_step
 
             else:
                 pass

From e3c2d1e440b3bf115aaaca8bbbed9be81f05cb7d Mon Sep 17 00:00:00 2001
From: Colin <cophus@gmail.com>
Date: Tue, 4 Jul 2023 20:07:41 -0700
Subject: [PATCH 119/362] Adding constant background option

---
 py4DSTEM/process/polar/polar_peaks.py | 130 +++++++++++++-------------
 1 file changed, 66 insertions(+), 64 deletions(-)

diff --git a/py4DSTEM/process/polar/polar_peaks.py b/py4DSTEM/process/polar/polar_peaks.py
index 3b4893587..6471576c7 100644
--- a/py4DSTEM/process/polar/polar_peaks.py
+++ b/py4DSTEM/process/polar/polar_peaks.py
@@ -9,7 +9,7 @@
 
 # from emdfile import tqdmnd, PointList, PointListArray
 from py4DSTEM import tqdmnd, PointList, PointListArray
-# from py4DSTEM.process.fit import fit_2D_polar_gaussian
+from py4DSTEM.process.fit import polar_twofold_gaussian_2D, polar_twofold_gaussian_2D_background
 
 def find_peaks_single_pattern(
     self,
@@ -376,6 +376,7 @@ def refine_peaks(
     reset_fits_to_init_positions = False,
     fit_range_sigma_annular = 2.0,
     fit_range_sigma_radial = 2.0,
+    min_num_pixels_fit = 10,
     progress_bar = True,
     ):
     """
@@ -394,6 +395,10 @@ def refine_peaks(
         Fit range in annular direction, in terms of the current sigma_annular
     fit_range_sigma_radial: float
         Fit range in radial direction, in terms of the current sigma_radial
+    min_num_pixels_fit: int
+        Minimum number of pixels to perform fitting
+    progress_bar: bool
+        Enable progress bar
 
     Returns
     --------
@@ -420,10 +425,8 @@ def refine_peaks(
 
     # Loop over probe positions
     for rx, ry in tqdmnd(
-        # 1,#self._datacube.Rshape[0],
-        # 1,#self._datacube.Rshape[1],
-        range(21,22),
-        range(21,22),
+        self._datacube.Rshape[0],
+        self._datacube.Rshape[1],
         desc="Refining peaks ",
         unit=" images",
         disable=not progress_bar,
@@ -466,6 +469,7 @@ def refine_peaks(
         for a0 in range(p.data.shape[0]):
 
             if radial_background_subtract:
+                # initial parameters
                 p0 = [
                     p['intensity'][a0],
                     p['qt'][a0] * t_step,
@@ -474,72 +478,71 @@ def refine_peaks(
                     p['sigma_radial'][a0] * q_step,
                     ]
 
+                # Mask around peak for fitting
                 dt = np.mod(tt - p0[1] + np.pi/2, np.pi) - np.pi/2
                 mask_peak = np.logical_and(mask_bool,
                     dt**2/(fit_range_sigma_annular*p0[3])**2 \
                     + (qq-p0[2])**2/(fit_range_sigma_radial*p0[4])**2 <= 1)
 
-                from py4DSTEM.process.fit import polar_twofold_gaussian_2D
-                im_test1 = polar_twofold_gaussian_2D(
-                    tq,
-                    p0[0],
-                    p0[1],
-                    p0[2],
-                    p0[3],
-                    p0[4],
-                    ).reshape(im_polar.shape)
-
-                p0, pcov = curve_fit(
-                    polar_twofold_gaussian_2D, 
-                    tq[:,mask_peak.ravel()], 
-                    im_polar[mask_peak], 
-                    p0 = p0,
-                    # bounds = bounds,
-                    )
-
-                im_test2 = polar_twofold_gaussian_2D(
-                    tq,
-                    p0[0],
-                    p0[1],
-                    p0[2],
-                    p0[3],
-                    p0[4],
-                    ).reshape(im_polar.shape)
-
-                fig,ax = plt.subplots(figsize = (12,6))
-                ax.imshow(np.hstack((
-                    im_polar * mask_peak,
-                    im_test1 * mask_peak,
-                    im_test2 * mask_peak,
-                    )))
-
-                self.peaks[rx,ry]['intensity'][a0] = p0[0]
-                self.peaks[rx,ry]['qt'][a0] = p0[1] / t_step
-                self.peaks[rx,ry]['qr'][a0] = p0[2] / q_step
-                self.peaks[rx,ry]['sigma_annular'][a0] = p0[3] / t_step
-                self.peaks[rx,ry]['sigma_radial'][a0] = p0[4] / q_step
+                if np.sum(mask_peak) > min_num_pixels_fit:
+                    try:
+                        # perform fitting
+                        p0, pcov = curve_fit(
+                            polar_twofold_gaussian_2D, 
+                            tq[:,mask_peak.ravel()], 
+                            im_polar[mask_peak], 
+                            p0 = p0,
+                            # bounds = bounds,
+                            )
+
+                        # Output parameters
+                        self.peaks[rx,ry]['intensity'][a0] = p0[0]
+                        self.peaks[rx,ry]['qt'][a0] = p0[1] / t_step
+                        self.peaks[rx,ry]['qr'][a0] = p0[2] / q_step
+                        self.peaks[rx,ry]['sigma_annular'][a0] = p0[3] / t_step
+                        self.peaks[rx,ry]['sigma_radial'][a0] = p0[4] / q_step
+                    
+                    except:
+                        pass
 
             else:
-                pass
+                # initial parameters
+                p0 = [
+                    p['intensity'][a0],
+                    p['qt'][a0] * t_step,
+                    p['qr'][a0] * q_step,
+                    p['sigma_annular'][a0] * t_step,
+                    p['sigma_radial'][a0] * q_step,
+                    0,
+                    ]
+
+                # Mask around peak for fitting
+                dt = np.mod(tt - p0[1] + np.pi/2, np.pi) - np.pi/2
+                mask_peak = np.logical_and(mask_bool,
+                    dt**2/(fit_range_sigma_annular*p0[3])**2 \
+                    + (qq-p0[2])**2/(fit_range_sigma_radial*p0[4])**2 <= 1)
 
+                if np.sum(mask_peak) > min_num_pixels_fit:
+                    try:
+                        # perform fitting
+                        p0, pcov = curve_fit(
+                            polar_twofold_gaussian_2D_background, 
+                            tq[:,mask_peak.ravel()], 
+                            im_polar[mask_peak], 
+                            p0 = p0,
+                            # bounds = bounds,
+                            )
 
-        # print(p0[0])
-        # print(p[0])
+                        # Output parameters
+                        self.peaks[rx,ry]['intensity'][a0] = p0[0]
+                        self.peaks[rx,ry]['qt'][a0] = p0[1] / t_step
+                        self.peaks[rx,ry]['qr'][a0] = p0[2] / q_step
+                        self.peaks[rx,ry]['sigma_annular'][a0] = p0[3] / t_step
+                        self.peaks[rx,ry]['sigma_radial'][a0] = p0[4] / q_step
 
+                    except:
+                        pass
 
-    # Testing
-    fig,ax = plt.subplots()
-    ax.imshow(
-        im_polar**0.5,
-        cmap = 'gray',
-        )
-    ax.scatter(
-        p['qr'],
-        p['qt'],
-        marker = '+',
-        color = 'r',
-        s = 100
-        )
 
 def plot_radial_peaks(
     self,
@@ -589,7 +592,6 @@ def plot_radial_peaks(
     )
 
 
-
     # plotting
     fig,ax = plt.subplots(figsize = figsize)
     ax.plot(
@@ -650,7 +652,7 @@ def plot_radial_background(
 
     fig,ax = plt.subplots(figsize = figsize)
     ax.fill_between(
-        self.qq[self.background_mask] * self._radial_step, 
+        self.qq[self.background_mask], 
         self.background_radial_mean[self.background_mask] \
         - self.background_radial_std[self.background_mask], 
         self.background_radial_mean[self.background_mask] \
@@ -665,8 +667,8 @@ def plot_radial_background(
         linewidth = 2,
         )
     ax.set_xlim((
-        self.qq[0] * self._radial_step,
-        self.qq[-1]  * self._radial_step))
+        self.qq[0],
+        self.qq[-1]))
     ax.set_xlabel(
         'Scattering Angle (' + self.calibration.get_Q_pixel_units() +')',
         fontsize = 14,

From 29dda66561c23f3db2e700664488faaba801bf27 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Wed, 5 Jul 2023 15:20:25 -0400
Subject: [PATCH 120/362] cuda disk detec fix

---
 py4DSTEM/process/diskdetection/diskdetection_cuda.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/py4DSTEM/process/diskdetection/diskdetection_cuda.py b/py4DSTEM/process/diskdetection/diskdetection_cuda.py
index 2cd96be51..df5793b47 100644
--- a/py4DSTEM/process/diskdetection/diskdetection_cuda.py
+++ b/py4DSTEM/process/diskdetection/diskdetection_cuda.py
@@ -198,9 +198,9 @@ def find_Bragg_disks_CUDA(
                     threads=threads,
                 )
 
-            # clean up
-            del batched_subcube, batched_crosscorr, subFFT, cc, ccc
-            cp.get_default_memory_pool().free_all_blocks()
+        # clean up
+        del batched_subcube, batched_crosscorr, subFFT, cc, ccc
+        cp.get_default_memory_pool().free_all_blocks()
 
 
     else:

From 003d66d2538e4a0e44c2db3b4307fbff077ba808 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Wed, 5 Jul 2023 15:23:27 -0400
Subject: [PATCH 121/362] cuda disk detec fix

---
 py4DSTEM/process/diskdetection/diskdetection_cuda.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/py4DSTEM/process/diskdetection/diskdetection_cuda.py b/py4DSTEM/process/diskdetection/diskdetection_cuda.py
index 2cd96be51..df5793b47 100644
--- a/py4DSTEM/process/diskdetection/diskdetection_cuda.py
+++ b/py4DSTEM/process/diskdetection/diskdetection_cuda.py
@@ -198,9 +198,9 @@ def find_Bragg_disks_CUDA(
                     threads=threads,
                 )
 
-            # clean up
-            del batched_subcube, batched_crosscorr, subFFT, cc, ccc
-            cp.get_default_memory_pool().free_all_blocks()
+        # clean up
+        del batched_subcube, batched_crosscorr, subFFT, cc, ccc
+        cp.get_default_memory_pool().free_all_blocks()
 
 
     else:

From 3ec60a3ee49b8ea8c76d850a27f749e95d7e4fa9 Mon Sep 17 00:00:00 2001
From: Colin <cophus@gmail.com>
Date: Wed, 5 Jul 2023 17:06:51 -0700
Subject: [PATCH 122/362] Adding peak splitting

---
 py4DSTEM/process/polar/polar_peaks.py | 58 ++++++++++++++++++++++++---
 1 file changed, 52 insertions(+), 6 deletions(-)

diff --git a/py4DSTEM/process/polar/polar_peaks.py b/py4DSTEM/process/polar/polar_peaks.py
index 6471576c7..dda307188 100644
--- a/py4DSTEM/process/polar/polar_peaks.py
+++ b/py4DSTEM/process/polar/polar_peaks.py
@@ -20,6 +20,7 @@ def find_peaks_single_pattern(
     bragg_mask_radius = None,
     sigma_annular_deg = 10.0,
     sigma_radial_px = 3.0,
+    sigma_annular_deg_max = None,
     radial_background_subtract = True,
     radial_background_thresh = 0.25,
     num_peaks_max = 100,
@@ -27,7 +28,8 @@ def find_peaks_single_pattern(
     threshold_prom_annular = None,
     threshold_prom_radial = None,
     remove_masked_peaks = False,
-    scale_sigma = 0.25,
+    scale_sigma_annular = 0.5,
+    scale_sigma_radial = 0.25,
     return_background = False,
     plot_result = True,
     plot_power_scale = 1.0,
@@ -51,6 +53,9 @@ def find_peaks_single_pattern(
         smoothing along the annular direction in degrees, periodic
     sigma_radial_px: float
         smoothing along the radial direction in pixels, not periodic
+    sigma_annular_deg_max: float
+        Specify this value for the max annular sigma.  Peaks larger than this will be split 
+        into multiple peaks, depending on the ratio.
     radial_background_subtract: bool
         If true, subtract radial background estimate
     radial_background_thresh: float
@@ -145,7 +150,7 @@ def find_peaks_single_pattern(
             trace_annular, 
             annular_ind_center,
             )
-        sigma_annular = scale_sigma * np.maximum(
+        sigma_annular = scale_sigma_annular * np.maximum(
             annular_ind_center - p_annular[1],
             p_annular[2] - annular_ind_center)
 
@@ -155,7 +160,7 @@ def find_peaks_single_pattern(
             trace_radial, 
             np.atleast_1d(peaks[a0,1]),
             )
-        sigma_radial = scale_sigma * np.maximum(
+        sigma_radial = scale_sigma_radial * np.maximum(
             peaks[a0,1] - p_radial[1],
             p_radial[2] - peaks[a0,1])
 
@@ -199,9 +204,46 @@ def find_peaks_single_pattern(
             axis = 0,
             )
 
+    # combine peaks into one array
+    peaks_all = np.column_stack((peaks, peaks_int, peaks_prom))
+
+    # Split peaks into multiple peaks if they have sigma values larger than user-specified threshold
+    if sigma_annular_deg_max is not None:
+        peaks_new = np.zeros((0,peaks_all.shape[1]))
+        for a0 in range(peaks_all.shape[0]):
+            if peaks_all[a0,4] >= (1.5*sigma_annular_deg_max):
+                num = np.round(peaks_all[a0,4] / sigma_annular_deg_max)
+                sigma_annular_new = peaks_all[a0,4] / num
+
+                v = np.arange(num)
+                v -= np.mean(v)
+                t_new = np.mod(peaks_all[a0,0] + 2*v*sigma_annular_new,
+                    self._n_annular)
+
+                for a1 in range(num.astype('int')):
+                    peaks_new = np.vstack((
+                        peaks_new,
+                        np.array((
+                            t_new[a1],
+                            peaks_all[a0,1],
+                            peaks_all[a0,2],
+                            peaks_all[a0,3],
+                            sigma_annular_new,
+                            peaks_all[a0,5],
+                            peaks_all[a0,6],
+                        )),
+                    ))
+            else:
+                peaks_new = np.vstack((
+                    peaks_new,
+                    peaks_all[a0,:]
+                ))
+        peaks_all = peaks_new
+
+
     # Output data as a pointlist
     peaks_polar = PointList(
-            np.column_stack((peaks, peaks_int, peaks_prom)).ravel().view([
+            peaks_all.ravel().view([
             ('qt', np.float),
             ('qr', np.float),
             ('intensity', np.float),
@@ -283,6 +325,7 @@ def find_peaks(
     bragg_mask_radius = None,
     sigma_annular_deg = 10.0,
     sigma_radial_px = 3.0,
+    sigma_annular_deg_max = None,
     radial_background_subtract = True,
     radial_background_thresh = 0.25,
     num_peaks_max = 100,
@@ -290,7 +333,8 @@ def find_peaks(
     threshold_prom_annular = None,
     threshold_prom_radial = None,
     remove_masked_peaks = False,
-    scale_sigma = 0.25,
+    scale_sigma_annular = 0.5,
+    scale_sigma_radial = 0.25,
     progress_bar = True,
     ):
     """
@@ -352,6 +396,7 @@ def find_peaks(
             bragg_mask_radius = bragg_mask_radius,
             sigma_annular_deg = sigma_annular_deg,
             sigma_radial_px = sigma_radial_px,
+            sigma_annular_deg_max = sigma_annular_deg_max,
             radial_background_subtract = radial_background_subtract,
             radial_background_thresh = radial_background_thresh,
             num_peaks_max = num_peaks_max,
@@ -359,7 +404,8 @@ def find_peaks(
             threshold_prom_annular = threshold_prom_annular,
             threshold_prom_radial = threshold_prom_radial,
             remove_masked_peaks = remove_masked_peaks,
-            scale_sigma = scale_sigma,
+            scale_sigma_annular = scale_sigma_annular,
+            scale_sigma_radial = scale_sigma_radial,
             return_background = True,
             plot_result = False,
             )

From 104a5cd4db1a20c720a1795122fe6c4f78d4e0d4 Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <37132012+sezelt@users.noreply.github.com>
Date: Thu, 6 Jul 2023 14:24:52 -0400
Subject: [PATCH 123/362] change how optimized dict is assembled

Co-authored-by: Georgios Varnavides <gvarnavides@berkeley.edu>
---
 py4DSTEM/process/phase/parameter_optimize.py | 43 +++++++-------------
 1 file changed, 15 insertions(+), 28 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index cbd83ec16..2df443d0a 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -272,12 +272,14 @@ def get_optimized_arguments(self):
             where the OptimizationParameter items have been replaced with the optimal
             values obtained from the optimizer
         """
-        init_opt = self._replace_optimized_parameters(
-            self._init_args, self._parameter_list
-        )
-        affine_opt = self._replace_optimized_parameters(
-            self._affine_args, self._parameter_list
-        )
+        optimized_dict = {p.name: v for p,v in zip(self._parameter_list,self._skopt_result.x)}
+        
+        filtered_dict = { k: v for k,v in optimized_dict.items() if k in self._init_args }
+        init_opt = self._init_args | filtered_dict
+        
+        filtered_dict = { k: v for k,v in optimized_dict.items() if k in self._affine_args }
+        affine_opt = self._affine_args | filtered_dict
+        
         affine_transform = partial(AffineTransform, **self._affine_static_args)(
             **affine_opt
         )
@@ -285,30 +287,15 @@ def get_optimized_arguments(self):
             affine_transform, init_opt["datacube"]
         )
         init_opt["initial_scan_positions"] = scan_positions
-
-        prep_opt = self._replace_optimized_parameters(
-            self._preprocess_args, self._parameter_list
-        )
-        reco_opt = self._replace_optimized_parameters(
-            self._reconstruction_args, self._parameter_list
-        )
-
+        
+        filtered_dict = { k: v for k,v in optimized_dict.items() if k in self._preprocess_args }
+        prep_opt = self._preprocess_args | filtered_dict
+        
+        filtered_dict = { k: v for k,v in optimized_dict.items() if k in self._reconstruction_args }
+        reco_opt = self._reconstruction_args | filtered_dict
+        
         return init_opt, prep_opt, reco_opt
 
-    def _replace_optimized_parameters(self, arg_dict, parameters):
-        opt_args = {}
-        for k, v in arg_dict.items():
-            # Check for optimization parameters
-            if isinstance(v, OptimizationParameter):
-                # Find the right parameter in the list
-                # There is probably a better way to do this inverse mapping!
-                for i, p in enumerate(parameters):
-                    if p.name == k:
-                        opt_args[k] = self._skopt_result.x[i]
-            else:
-                opt_args[k] = v
-        return opt_args
-
     def _split_static_and_optimization_vars(self, argdict):
         static_args = {}
         optimization_args = {}

From 3e9fa6c6c475a1b403dce42f97d704d19c357543 Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Thu, 6 Jul 2023 15:33:13 -0700
Subject: [PATCH 124/362] Updating beamstop mask

---
 py4DSTEM/classes/methods/datacube_methods.py | 51 ++++++++++++++++----
 1 file changed, 41 insertions(+), 10 deletions(-)

diff --git a/py4DSTEM/classes/methods/datacube_methods.py b/py4DSTEM/classes/methods/datacube_methods.py
index 9b4340c9d..1ba5f9ce8 100644
--- a/py4DSTEM/classes/methods/datacube_methods.py
+++ b/py4DSTEM/classes/methods/datacube_methods.py
@@ -1252,8 +1252,11 @@ def find_Bragg_disks(
     def get_beamstop_mask(
         self,
         threshold = 0.25,
-        distance_edge = 4.0,
+        distance_edge = 2.0,
         include_edges = True,
+        sigma = 0,
+        use_max_dp = False,
+        scale_radial = None,
         name = "mask_beamstop",
         returncalc = True,
         ):
@@ -1268,6 +1271,12 @@ def get_beamstop_mask(
             distance_edge (float): How many pixels to expand the mask.
             include_edges (bool): If set to True, edge pixels will be included
                 in the mask.
+            sigma (float):
+                Gaussain blur std to apply to image before thresholding.
+            use_max_dp (bool):
+                Use the max DP instead of the mean DP.
+            scale_radial (float):
+                Scale from center of image by this factor (can help with edge)
             name (string): Name of the output array.
             returncalc (bool): Set to true to return the result.
 
@@ -1276,19 +1285,41 @@ def get_beamstop_mask(
 
         """
 
-        # Calculate dp_mean if needed
-        if not "dp_mean" in self._branch.keys():
-            self.get_dp_mean();
-
-        # normalized dp_mean
-        int_sort = np.sort(self.tree("dp_mean").data.ravel())
+        if scale_radial is not None:
+            x = np.arange(self.data.shape[2]) * 2.0 / self.data.shape[2]
+            y = np.arange(self.data.shape[3]) * 2.0 / self.data.shape[3]
+            ya, xa = np.meshgrid(y - np.mean(y), x - np.mean(x))
+            im_scale = 1.0 + np.sqrt(xa**2 + ya**2)*scale_radial
+
+        # Get image for beamstop mask
+        if use_max_dp:
+            # if not "dp_mean" in self.tree.keys():
+            #     self.get_dp_max();
+            # im = self.tree["dp_max"].data.astype('float')
+            if not "dp_max" in self._branch.keys():
+                self.get_dp_max();
+            im = self.tree("dp_max")
+        else:
+            if not "dp_mean" in self._branch.keys():
+                self.get_dp_mean();
+            im = self.tree("dp_mean")
+            # if not "dp_mean" in self.tree.keys():
+            #     self.get_dp_mean();
+            # im = self.tree["dp_mean"].data.astype('float')
+
+        # smooth and scale if needed
+        if sigma > 0.0:
+            im = gaussian_filter(im, sigma, mode='nearest')
+        if scale_radial is not None:
+            im *= im_scale
+
+        # Calculate beamstop mask
+        int_sort = np.sort(im.ravel())
         ind = np.round(np.clip(
                 int_sort.shape[0]*threshold,
                 0,int_sort.shape[0])).astype('int')
         intensity_threshold = int_sort[ind]
-
-        # Use threshold to calculate initial mask
-        mask_beamstop = self.tree("dp_mean").data >= intensity_threshold
+        mask_beamstop = im >= intensity_threshold
 
         # clean up mask
         mask_beamstop = np.logical_not(binary_fill_holes(np.logical_not(mask_beamstop)))

From 6fd464aa42d95c5b4ff4492ddd967c6431bb5517 Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Thu, 6 Jul 2023 15:37:56 -0700
Subject: [PATCH 125/362] Fixing beamstop updates

---
 py4DSTEM/classes/methods/datacube_methods.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/py4DSTEM/classes/methods/datacube_methods.py b/py4DSTEM/classes/methods/datacube_methods.py
index 1ba5f9ce8..54f781668 100644
--- a/py4DSTEM/classes/methods/datacube_methods.py
+++ b/py4DSTEM/classes/methods/datacube_methods.py
@@ -1,7 +1,7 @@
 # Functions to become DataCube methods
 
 import numpy as np
-from scipy.ndimage import distance_transform_edt, binary_fill_holes, gaussian_filter1d
+from scipy.ndimage import distance_transform_edt, binary_fill_holes, gaussian_filter1d, gaussian_filter
 from scipy.interpolate import interp1d
 
 from emdfile import Array, Metadata, Node
@@ -1298,11 +1298,11 @@ def get_beamstop_mask(
             # im = self.tree["dp_max"].data.astype('float')
             if not "dp_max" in self._branch.keys():
                 self.get_dp_max();
-            im = self.tree("dp_max")
+            im = self.tree("dp_max").data.astype('float')
         else:
             if not "dp_mean" in self._branch.keys():
                 self.get_dp_mean();
-            im = self.tree("dp_mean")
+            im = self.tree("dp_mean").data
             # if not "dp_mean" in self.tree.keys():
             #     self.get_dp_mean();
             # im = self.tree["dp_mean"].data.astype('float')

From 1f69562bd3c12e7a145571f8ad3ed616c67c2bfc Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <37132012+sezelt@users.noreply.github.com>
Date: Thu, 6 Jul 2023 18:44:09 -0400
Subject: [PATCH 126/362] add option to override default arguments to ptycho

Co-authored-by: Georgios Varnavides <gvarnavides@berkeley.edu>
---
 py4DSTEM/process/phase/parameter_optimize.py | 26 +++++++++++++-------
 1 file changed, 17 insertions(+), 9 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 2df443d0a..fbdeaae1d 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -467,19 +467,27 @@ def f(**kwargs):
 
         return f
 
-    def _set_optimizer_defaults(self):
+    def _set_optimizer_defaults(
+        verbose = False,
+        plot_center_of_mass = False,
+        plot_rotation = False,
+        plot_probe_overlaps = False,
+        progress_bar = False,
+        store_iterations = False,
+        reset = True,
+        ):
         """
-        Set all of the verbose and plotting to False
+        Set all of the verbose and plotting to False, allowing for user-overwrite.
         """
-        self._init_static_args["verbose"] = False
+        self._init_static_args["verbose"] = verbose
 
-        self._preprocess_static_args["plot_center_of_mass"] = False
-        self._preprocess_static_args["plot_rotation"] = False
-        self._preprocess_static_args["plot_probe_overlaps"] = False
+        self._preprocess_static_args["plot_center_of_mass"] = plot_center_of_mass
+        self._preprocess_static_args["plot_rotation"] = plot_rotation
+        self._preprocess_static_args["plot_probe_overlaps"] = plot_probe_overlaps
 
-        self._reconstruction_static_args["progress_bar"] = False
-        self._reconstruction_static_args["store_iterations"] = False
-        self._reconstruction_static_args["reset"] = True
+        self._reconstruction_static_args["progress_bar"] = progress_bar
+        self._reconstruction_static_args["store_iterations"] = store_iterations
+        self._reconstruction_static_args["reset"] = reset
 
 
 class OptimizationParameter:

From c2cd3fc1809ed8ab6be7b50bed3617dbadadec8e Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Thu, 6 Jul 2023 18:47:24 -0400
Subject: [PATCH 127/362] bugfix in optimizer defaults

---
 py4DSTEM/process/phase/parameter_optimize.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index ccaa8d88f..f871a3a0e 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -481,6 +481,7 @@ def f(**kwargs):
         return f
 
     def _set_optimizer_defaults(
+        self,
         verbose = False,
         plot_center_of_mass = False,
         plot_rotation = False,

From b2087e7c50f545d206c3f6b6e9b3c6cbb82d020e Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Thu, 6 Jul 2023 21:46:34 -0400
Subject: [PATCH 128/362] updates, mv VirtImage, mv DataCube

---
 py4DSTEM/__init__.py                          |  10 +-
 py4DSTEM/classes/__init__.py                  |   1 -
 py4DSTEM/classes/virtualimage.py              |  54 --
 py4DSTEM/data/__init__.py                     |   1 -
 py4DSTEM/datacube/__init__.py                 |   6 +
 py4DSTEM/{data => datacube}/datacube.py       | 202 +----
 py4DSTEM/datacube/virtualimage.py             | 822 ++++++++++++++++++
 py4DSTEM/io/filereaders/empad.py              |   2 +-
 py4DSTEM/io/filereaders/read_K2.py            |   2 +-
 py4DSTEM/io/filereaders/read_dm.py            |   2 +-
 py4DSTEM/io/filereaders/read_mib.py           |   2 +-
 py4DSTEM/io/legacy/legacy12/read_v0_12.py     |   2 +-
 py4DSTEM/io/legacy/legacy12/read_v0_5.py      |   2 +-
 py4DSTEM/io/legacy/legacy12/read_v0_6.py      |   2 +-
 py4DSTEM/io/legacy/legacy12/read_v0_7.py      |   2 +-
 py4DSTEM/io/legacy/legacy12/read_v0_9.py      |   2 +-
 py4DSTEM/io/legacy/legacy13/v13_to_14.py      |   6 +-
 py4DSTEM/process/__init__.py                  |   1 -
 py4DSTEM/process/calibration/origin.py        |   2 +-
 py4DSTEM/process/classification/classutils.py |   2 +-
 .../process/diskdetection/diskdetection.py    |   3 +-
 .../diskdetection/probe_gen_methods.py        |   2 +-
 .../process/phase/iterative_base_class.py     |   3 +-
 py4DSTEM/process/phase/iterative_dpc.py       |   3 +-
 .../iterative_singleslice_ptychography.py     |   2 +-
 py4DSTEM/process/polar/polar_datacube.py      |   2 +-
 py4DSTEM/process/virtualimage.py              | 537 ------------
 py4DSTEM/visualize/__init__.py                |   1 -
 py4DSTEM/visualize/virtualimage.py            | 129 ---
 py4DSTEM/visualize/vis_RQ.py                  |   5 +-
 py4DSTEM/visualize/vis_special.py             |  16 +-
 test/test_native_io/test_single_object_io.py  |  10 +-
 32 files changed, 886 insertions(+), 952 deletions(-)
 delete mode 100644 py4DSTEM/classes/virtualimage.py
 create mode 100644 py4DSTEM/datacube/__init__.py
 rename py4DSTEM/{data => datacube}/datacube.py (88%)
 create mode 100644 py4DSTEM/datacube/virtualimage.py
 delete mode 100644 py4DSTEM/process/virtualimage.py
 delete mode 100644 py4DSTEM/visualize/virtualimage.py

diff --git a/py4DSTEM/__init__.py b/py4DSTEM/__init__.py
index de56213d0..ba086dc27 100644
--- a/py4DSTEM/__init__.py
+++ b/py4DSTEM/__init__.py
@@ -15,16 +15,18 @@
 
 # processing classes
 from py4DSTEM.data import (
-    DataCube,
+    Data,
+    Calibration,
     DiffractionSlice,
     RealSlice,
     QPoints,
-    Calibration,
-    Data,
+)
+from py4DSTEM.datacube import (
+    DataCube,
+    VirtualImage
 )
 from py4DSTEM.classes import (
     VirtualDiffraction,
-    VirtualImage,
 )
 from py4DSTEM.process.diskdetection import (
     Probe,
diff --git a/py4DSTEM/classes/__init__.py b/py4DSTEM/classes/__init__.py
index 750c8a9bb..0bacd8a70 100644
--- a/py4DSTEM/classes/__init__.py
+++ b/py4DSTEM/classes/__init__.py
@@ -1,6 +1,5 @@
 _emd_hook = True
 
 from py4DSTEM.classes.virtualdiffraction import VirtualDiffraction
-from py4DSTEM.classes.virtualimage import VirtualImage
 
 
diff --git a/py4DSTEM/classes/virtualimage.py b/py4DSTEM/classes/virtualimage.py
deleted file mode 100644
index 8a9bf8c9e..000000000
--- a/py4DSTEM/classes/virtualimage.py
+++ /dev/null
@@ -1,54 +0,0 @@
-
-from typing import Optional
-import numpy as np
-
-from py4DSTEM.data import RealSlice,Data
-
-
-
-class VirtualImage(RealSlice,Data):
-    """
-    Stores a real-space shaped 2D image with metadata
-    indicating how this image was generated from a datacube.
-    """
-    def __init__(
-        self,
-        data: np.ndarray,
-        name: Optional[str] = 'virtualimage',
-        ):
-        """
-        Args:
-            data (np.ndarray) : the 2D data
-            name (str) : the name
-
-        Returns:
-            A new VirtualImage instance
-        """
-        # initialize as a RealSlice
-        RealSlice.__init__(
-            self,
-            data = data,
-            name = name,
-        )
-
-
-
-    # read
-    @classmethod
-    def _get_constructor_args(cls,group):
-        """
-        Returns a dictionary of args/values to pass to the class constructor
-        """
-        ar_constr_args = RealSlice._get_constructor_args(group)
-        args = {
-            'data' : ar_constr_args['data'],
-            'name' : ar_constr_args['name'],
-        }
-        return args
-
-
-
-
-
-
-
diff --git a/py4DSTEM/data/__init__.py b/py4DSTEM/data/__init__.py
index f8cd284e5..ff9429fe0 100644
--- a/py4DSTEM/data/__init__.py
+++ b/py4DSTEM/data/__init__.py
@@ -2,7 +2,6 @@
 
 from py4DSTEM.data.calibration import Calibration
 from py4DSTEM.data.data import Data
-from py4DSTEM.data.datacube import DataCube
 from py4DSTEM.data.diffractionslice import DiffractionSlice
 from py4DSTEM.data.realslice import RealSlice
 from py4DSTEM.data.qpoints import QPoints
diff --git a/py4DSTEM/datacube/__init__.py b/py4DSTEM/datacube/__init__.py
new file mode 100644
index 000000000..f1f6e5b99
--- /dev/null
+++ b/py4DSTEM/datacube/__init__.py
@@ -0,0 +1,6 @@
+_emd_hook = True
+
+from py4DSTEM.datacube.datacube import DataCube
+from py4DSTEM.datacube.virtualimage import VirtualImage
+
+
diff --git a/py4DSTEM/data/datacube.py b/py4DSTEM/datacube/datacube.py
similarity index 88%
rename from py4DSTEM/data/datacube.py
rename to py4DSTEM/datacube/datacube.py
index dc19a9443..d5da96fc6 100644
--- a/py4DSTEM/data/datacube.py
+++ b/py4DSTEM/datacube/datacube.py
@@ -9,10 +9,14 @@
 
 from emdfile import Array, Metadata, Node, Root, tqdmnd
 from py4DSTEM.data import Data, Calibration
+from py4DSTEM.datacube.virtualimage import DataCubeVirtualImager
 
 
-
-class DataCube(Array,Data):
+class DataCube(
+    Array,
+    Data,
+    DataCubeVirtualImager
+    ):
     """
     Storage and processing methods for 4D-STEM datasets.
     """
@@ -943,200 +947,6 @@ def get_dp_median(
 
 
 
-    # Virtual imaging
-
-    def get_virtual_image(
-        self,
-        mode,
-        geometry,
-        centered = False,
-        calibrated = False,
-        shift_center = False,
-        verbose = True,
-        dask = False,
-        return_mask = False,
-        name = 'virtual_image',
-        returncalc = True,
-        test_config = False
-        ):
-        """
-        Get a virtual image and store it in `datacube`s tree under `name`.
-        The kind of virtual image is specified by the `mode` argument.
-
-        Args:
-            mode (str): defines geometry mode for calculating virtual image
-                options:
-                    - 'point' uses singular point as detector
-                    - 'circle' or 'circular' uses round detector, like bright
-                      field
-                    - 'annular' or 'annulus' uses annular detector, like dark
-                      field
-                    - 'rectangle', 'square', 'rectangular', uses rectangular
-                      detector
-                    - 'mask' flexible detector, any 2D array
-            geometry (variable) : valid entries are determined by the `mode`,
-                values in
-            pixels argument, as follows:
-                - 'point': 2-tuple, (qx,qy), ints
-                - 'circle' or 'circular': nested 2-tuple, ((qx,qy),radius),
-                - 'annular' or 'annulus': nested 2-tuple,
-                  ((qx,qy),(radius_i,radius_o)),
-                - 'rectangle', 'square', 'rectangular': 4-tuple,
-                  (xmin,xmax,ymin,ymax)
-                - `mask`: any boolean or floating point 2D array with the same
-                  size as datacube.Qshape
-            centered (bool): if False, the origin is in the upper left corner.
-                 If True, the origin is set to the mean origin in the datacube
-                 calibrations, so that a bright-field image could be specified
-                 with, e.g., geometry = ((0,0),R).  The origin can set with
-                 datacube.calibration.set_origin().  For `mode="mask"`,
-                 has no effect. Default is False.
-            calibrated (bool): if True, geometry is specified in units of 'A^-1'
-                instead of pixels. The datacube's calibrations must have its
-                `"Q_pixel_units"` parameter set to "A^-1". For `mode="mask"`, has
-                no effect. Default is False.
-            shift_center (bool): if True, the mask is shifted at each real space
-                position to account for any shifting of the origin of the
-                diffraction images. The datacube's calibration['origin']
-                parameter must be set. The shift applied to each pattern is the
-                difference between the local origin position and the mean origin
-                position over all patterns, rounded to the nearest integer for
-                speed. Default is False.
-            verbose (bool): if True, show progress bar
-            dask (bool): if True, use dask arrays
-            return_mask (bool): if False (default) returns a virtual image as
-                usual. If True, does *not* generate or return a virtual image,
-                instead returning the mask that would be used in virtual image
-                computation for any call to this function where
-                `shift_center = False`. Otherwise, must be a 2-tuple of integers
-                corresponding to a scan position (rx,ry); in this case, returns
-                the mask that would be used for virtual image computation at this
-                scan position with `shift_center` set to `True`. Setting
-                return_mask to True does not add anything to the datacube's tree
-            name (str): the output object's name
-            returncalc (bool): if True, returns the output
-        Returns:
-            (Optional): if returncalc is True, returns the VirtualImage
-        """
-        # perform computation
-        from py4DSTEM.classes.virtualimage import VirtualImage
-        from py4DSTEM.process.virtualimage import get_virtual_image
-        im = get_virtual_image(
-            self,
-            mode = mode,
-            geometry = geometry,
-            centered = centered,
-            calibrated = calibrated,
-            shift_center = shift_center,
-            verbose = verbose,
-            dask = dask,
-            return_mask = return_mask,
-            test_config = test_config
-        )
-
-        # if a mask is requested, skip the remaining i/o functionality
-        if return_mask is not False:
-            return im
-
-        # wrap with a py4dstem class
-        im = VirtualImage(
-            data = im,
-            name = name,
-        )
-
-        # add generating params as metadata
-        im.metadata = Metadata(
-            name = 'gen_params',
-            data = {
-                'mode' : mode,
-                'geometry' : geometry,
-                'shift_center' : shift_center,
-                'centered' : centered,
-                'calibrated' : calibrated,
-                'verbose' : verbose,
-                'dask' : dask,
-                'return_mask' : return_mask,
-                'test_config' : test_config
-            }
-        )
-
-        # add to the tree
-        self.attach( im )
-
-        # return
-        if returncalc:
-            return im
-
-
-    # Position detector
-
-    def position_detector(
-        self,
-        mode,
-        geometry,
-        scan_position = None,
-        centered = None,
-        calibrated = None,
-        shift_center = None,
-        invert = False,
-        color = 'r',
-        alpha = 0.7,
-    ):
-        """
-        Display a diffraction space image with an overlaid mask representing
-        a virtual detector.
-
-        Args:
-            mode: see py4DSTEM.process.get_virtual_image
-            geometry: see py4DSTEM.process.get_virtual_image
-            scan_position: if None, positions the unshifted detector over the
-                mean or max diffraction pattern. Otherwise, must be a tuple
-                (rx,ry) of ints, and a detector is positioned over the
-                diffraction pattern at this position, including shifts if they
-                would be applied for this dataset (i.e. if it contains the
-                appropriate calibrations)
-            centered (bool): if False, the origin is in the upper left corner.
-                 If True, the origin is set to the mean origin in the datacube
-                 calibrations, so that a bright-field image could be specified
-                 with, e.g., geometry = ((0,0),R). The origin can set with
-                 datacube.calibration.set_origin().  For `mode="mask"`,
-                 has no effect. Default is False.
-            calibrated (bool): if True, geometry is specified in units of 'A^-1'
-                instead of pixels. The datacube's calibrations must have its
-                `"Q_pixel_units"` parameter set to "A^-1". For `mode="mask"`, has
-                no effect.
-            shift_center (bool): if True, the mask is shifted at each real space
-                position to account for any shifting of the origin of the
-                diffraction images. The datacube's calibration['origin']
-                parameter must be set. The shift applied to each pattern is the
-                difference between the local origin position and the mean origin
-                position over all patterns, rounded to the nearest integer for
-                speed.
-            invert (bool): if True, invert the display mask
-        """
-
-        # parse inputs
-        if scan_position is None:
-            data = self
-        else:
-            data = (self,scan_position[0],scan_position[1])
-
-        # make and show visualization
-        from py4DSTEM.visualize import position_detector
-        position_detector(
-            data,
-            mode,
-            geometry,
-            centered,
-            calibrated,
-            shift_center,
-            invert = invert,
-            color = color,
-            alpha = alpha,
-        )
-
-
-
 
     # Probe
 
diff --git a/py4DSTEM/datacube/virtualimage.py b/py4DSTEM/datacube/virtualimage.py
new file mode 100644
index 000000000..ae0b67b62
--- /dev/null
+++ b/py4DSTEM/datacube/virtualimage.py
@@ -0,0 +1,822 @@
+# Methods and classes for generating virtual images
+
+# includes
+# --------
+# VirtualImage - a container for virtual image data + metadata
+# DataCubeVirtualImager - methods inherited by DataCube for virt imaging
+# BraggVectorsVirtualImager - methods inherited by BraggVectors for virt imaging
+
+
+import numpy as np
+import dask.array as da
+from typing import Optional
+
+from emdfile import tqdmnd,Metadata
+from py4DSTEM.data import Calibration, RealSlice, Data
+from py4DSTEM.visualize.show import show
+
+
+
+# Virtual image class
+# a container for the final virtual image data/metadata
+
+class VirtualImage(RealSlice,Data):
+    """
+    A container for storing virtual image data and metadata,
+    including the real-space shaped 2D image and metadata
+    indicating how this image was generated from a datacube.
+    """
+    def __init__(
+        self,
+        data: np.ndarray,
+        name: Optional[str] = 'virtualimage',
+        ):
+        """
+        Parameters
+        ----------
+        data : np.ndarray
+            the 2D data
+        name : str
+            the name
+        """
+        # initialize as a RealSlice
+        RealSlice.__init__(
+            self,
+            data = data,
+            name = name,
+        )
+
+    # read
+    @classmethod
+    def _get_constructor_args(cls,group):
+        """
+        Returns a dictionary of args/values to pass to the class constructor
+        """
+        ar_constr_args = RealSlice._get_constructor_args(group)
+        args = {
+            'data' : ar_constr_args['data'],
+            'name' : ar_constr_args['name'],
+        }
+        return args
+
+
+
+
+
+# DataCubeVirtualImage class
+# inherited by DataCube, adding the methods performing
+# virtual image computations
+
+class DataCubeVirtualImager:
+
+    def __init__(self):
+        pass
+
+
+    def get_virtual_image(
+        self,
+        mode,
+        geometry,
+        centered = False,
+        calibrated = False,
+        shift_center = False,
+        verbose = True,
+        dask = False,
+        return_mask = False,
+        name = 'virtual_image',
+        returncalc = True,
+        test_config = False
+        ):
+        """
+        Calculate a virtual image.
+
+        The detector is determined by the combination of the `mode` and
+        `geometry` arguments, supporting point, circular, rectangular,
+        annular, and custom mask detectors. The values passed to geometry
+        may be given with respect to an origin at the corner of the detector
+        array or with respect to the calibrated center position, and in units of
+        pixels or real calibrated units, depending on the values of the
+        `centered` and `calibrated` arguments, respectively.  The mask may be
+        shifted pattern-by-pattern to account for diffraction scan shifts using
+        the `shift_center` argument.
+
+        The computed virtual image is stored in the datacube's tree, and is
+        also returned by default.
+
+        Parameters
+        ----------
+        mode : str
+            defines geometry mode for calculating virtual image, and the
+            expected input for the `geometry` argument. options:
+              - 'point': uses a single pixel detector
+              - 'circle', 'circular': uses a round detector, like bright
+                field
+              - 'annular', 'annulus': uses an annular detector, like dark
+                field
+              - 'rectangle', 'square', 'rectangular': uses rectangular
+                detector
+              - 'mask': any diffraction-space shaped 2D array, representing
+                a flexible detector
+        geometry : variable
+            the expected value of this argument is determined by `mode` as
+            follows:
+              - 'point': 2-tuple, (qx,qy), ints
+              - 'circle', 'circular': nested 2-tuple, ((qx,qy),radius),
+              - 'annular', 'annulus': nested 2-tuple,
+                ((qx,qy),(radius_i,radius_o)),
+              - 'rectangle', 'square', 'rectangular': 4-tuple,
+                (xmin,xmax,ymin,ymax)
+              - `mask`: any boolean or floating point 2D array with the same
+                  size as datacube.Qshape
+        centered : bool
+            if False, the origin is in the upper left corner. If True, the origin
+            is set to the mean origin in the datacube calibrations, so that a
+            bright-field image could be specified with, e.g., geometry=((0,0),R).
+            The origin can set with datacube.calibration.set_origin().  For
+            `mode="mask"`, has no effect. Default is False.
+        calibrated : bool
+            if True, geometry is specified in units of 'A^-1' instead of pixels.
+            The datacube's calibrations must have its `"Q_pixel_units"` parameter
+            set to "A^-1". For `mode="mask"`, has no effect. Default is False.
+        shift_center : bool
+            if True, the mask is shifted at each real space position to account
+            for any shifting of the origin of the diffraction images. The
+            datacube's calibration['origin'] parameter must be set. The shift
+            applied to each pattern is the difference between the local origin
+            position and the mean origin position over all patterns, rounded to
+            the nearest integer for speed. Default is False. If `shift_center` is
+            True, `centered` is automatically set to True.
+        verbose : bool
+            toggles a progress bar
+        dask : bool
+            if True, use dask to distribute the calculation
+        return_mask : bool
+            if False (default) returns a virtual image as usual. Otherwise does
+            *not* compute or return a virtual image, instead finding and
+            returning the mask that will be used in subsequent calls to this
+            function using these same parameters. In this case, must be either
+            `True` or a 2-tuple of integers corresponding to `(rx,ry)`. If True
+            is passed, returns the mask used if `shift_center` is set to False.
+            If a 2-tuple is passed, returns the mask used at scan position
+            (rx,ry) if `shift_center` is set to True. Nothing is added to the
+            datacube's tree.
+        name : str
+            the output object's name
+        returncalc : bool
+            if True, returns the output
+        test_config : bool
+            if True, prints the Boolean values of
+            (`centered`,`calibrated`,`shift_center`). Does not compute the
+            virtual image.
+
+        Returns
+        -------
+        virt_im : VirtualImage (optional, if returncalc is True)
+        """
+        # parse inputs
+        assert mode in ('point', 'circle', 'circular', 'annulus', 'annular', 'rectangle', 'square', 'rectangular', 'mask'),\
+        'check doc strings for supported modes'
+        if shift_center == True:
+            centered = True
+        if test_config:
+            for x,y in zip(['centered','calibrated','shift_center'],
+                           [centered,calibrated,shift_center]):
+                print(f"{x} = {y}")
+
+        # Get geometry
+        g = self.get_calibrated_detector_geometry(
+            self.calibration,
+            mode,
+            geometry,
+            centered,
+            calibrated
+        )
+
+        # Get mask
+        mask = self.make_detector(self.Qshape, mode, g)
+        # if return_mask is True, skip computation
+        if return_mask == True and shift_center == False:
+            return mask
+
+
+        # Calculate virtual image
+
+        # no center shifting
+        if shift_center == False:
+
+            # single CPU
+            if not dask:
+
+                # allocate space
+                if mask.dtype == 'complex':
+                    virtual_image = np.zeros(self.Rshape, dtype = 'complex')
+                else:
+                    virtual_image = np.zeros(self.Rshape)
+                # compute
+                for rx,ry in tqdmnd(
+                    self.R_Nx,
+                    self.R_Ny,
+                    disable = not verbose,
+                ):
+                    virtual_image[rx,ry] = np.sum(self.data[rx,ry]*mask)
+
+            # dask 
+            if dask == True:
+
+                # set up a generalized universal function for dask distribution
+                def _apply_mask_dask(self,mask):
+                    virtual_image = np.sum(np.multiply(self.data,mask), dtype=np.float64)
+                apply_mask_dask = da.as_gufunc(
+                    _apply_mask_dask,signature='(i,j),(i,j)->()',
+                    output_dtypes=np.float64,
+                    axes=[(2,3),(0,1),()],
+                    vectorize=True
+                )
+
+                # compute
+                virtual_image = apply_mask_dask(self.data, mask)
+
+        # with center shifting
+        else:
+
+            # get shifts
+            assert(self.calibration.get_origin_shift() is not None), "origin need to be calibrated"
+            qx_shift,qy_shift = self.calibration.get_origin_shift()
+            qx_shift = qx_shift.round().astype(int)
+            qy_shift = qy_shift.round().astype(int)
+
+            # if return_mask is True, get+return the mask and skip the computation
+            if return_mask is not False:
+                try:
+                    rx,ry = return_mask
+                except TypeError:
+                    raise Exception(f"if `shift_center=True`, return_mask must be a 2-tuple of ints or False, but revieced inpute value of {return_mask}")
+                _mask = np.roll(
+                    mask,
+                    (qx_shift[rx,ry], qy_shift[rx,ry]),
+                    axis=(0,1)
+                )
+                return _mask
+
+            # allocate space
+            if mask.dtype == 'complex':
+                virtual_image = np.zeros(self.Rshape, dtype = 'complex')
+            else:
+                virtual_image = np.zeros(self.Rshape)
+
+            # loop
+            for rx,ry in tqdmnd(
+                self.R_Nx,
+                self.R_Ny,
+                disable = not verbose,
+            ):
+                # get shifted mask
+                _mask = np.roll(
+                    mask,
+                    (qx_shift[rx,ry], qy_shift[rx,ry]),
+                    axis=(0,1)
+                )
+                # add to output array
+                virtual_image[rx,ry] = np.sum(self.data[rx,ry]*_mask)
+
+
+        # data handling
+
+        # wrap with a py4dstem class
+        ans = VirtualImage(
+            data = virtual_image,
+            name = name,
+        )
+
+        # add generating params as metadata
+        ans.metadata = Metadata(
+            name = 'gen_params',
+            data = {
+                'mode' : mode,
+                'geometry' : geometry,
+                'centered' : centered,
+                'calibrated' : calibrated,
+                'shift_center' : shift_center,
+                'verbose' : verbose,
+                'dask' : dask,
+                'return_mask' : return_mask,
+                'name' : name,
+                'returncalc' : True,
+                'test_config' : test_config
+            }
+        )
+
+        # add to the tree
+        self.attach( ans )
+
+        # return
+        if returncalc:
+            return ans
+
+
+
+
+    # Position detector
+
+    def position_detector(
+        self,
+        mode,
+        geometry,
+        data = None,
+        centered = None,
+        calibrated = None,
+        shift_center = None,
+        scan_position = None,
+        invert = False,
+        color = 'r',
+        alpha = 0.7,
+        **kwargs
+    ):
+        """
+        Position a virtual detector by displaying a mask over a diffraction
+        space image.  Calling `.get_virtual_image()` using the same `mode`
+        and `geometry` parameters will compute a virtual image using this
+        detector.
+
+        Parameters
+        ----------
+        mode : str
+            see the DataCube.get_virtual_image docstring
+        geometry : variable
+            see the DataCube.get_virtual_image docstring
+        data : None or 2d-array or 2-tuple of ints
+            The diffraction image to overlay the mask on. If `None` (default),
+            looks for a max or mean or median diffraction image in this order
+            and if found, uses it, otherwise, uses the diffraction pattern at
+            scan position (0,0).  If a 2d array is passed, must be diffraction
+            space shaped array.  If a 2-tuple is passed, uses the diffraction
+            pattern at scan position (rx,ry).
+        centered : bool
+            see the DataCube.get_virtual_image docstring
+        calibrated : bool
+            see the DataCube.get_virtual_image docstring
+        shift_center : None or bool or 2-tuple of ints
+            If `None` (default) and `data` is either None or an array, the mask
+            is not shifted.  If `None` and `data` is a 2-tuple, shifts the mask
+            according to the origin at the scan position (rx,ry) specified in
+            `data`.  If False, does not shift the mask.  If True and `data` is
+            a 2-tuple, shifts the mask accordingly, and if True and `data` is
+            any other value, raises an error.  If `shift_center` is a 2-tuple,
+            shifts the mask according to the origin value at this 2-tuple
+            regardless of the value of `data` (enabling e.g. overlaying the
+            mask for a specific scan position on a max or mean diffraction
+            image.)
+        invert : bool
+            if True, invert the masked pixel (i.e. pixels *outside* the detector
+            are overlaid with a mask)
+        color : any matplotlib color specification
+            the mask color
+        alpha : number
+            the mask transparency
+        kwargs : dict
+            Any additional arguments are passed on to the show() function
+        """
+        # parse inputs
+
+        # mode
+        assert mode in ('point', 'circle', 'circular', 'annulus', 'annular', 'rectangle', 'square', 'rectangular', 'mask'),\
+        'check doc strings for supported modes'
+
+        # data
+        if data is None:
+            keys = ['dp_mean','dp_max','dp_median']
+            for k in keys:
+                image = None
+                try:
+                    image = data.tree(k)
+                    break
+                except:
+                    pass
+                if image is None:
+                    image = self[0,0]
+        elif isinstance(data, np.ndarray):
+            assert(data.shape == self.Qshape), f"Can't position a detector over an image with a shape that is different from diffraction space.  Diffraction space in this dataset has shape {self.Qshape} but the image passed has shape {data.shape}"
+        elif isinstance(data,tuple):
+            rx,ry = data[:2]
+            image = self[rx,ry]
+        else:
+            raise Exception(f"Invalid argument passed to `data`. Expected None or np.ndarray or tuple, not type {type(data)}")
+
+        # shift center
+        if shift_center is None:
+            if isinstance(data,tuple):
+                shift_center = True
+            else:
+                shift_center = False
+        elif shift_center == True:
+            assert(isinstance(data,tuple)), "If shift_center is set to True, `data` should be a 2-tuple (rx,ry). To shift the detector mask while using some other input for `data`, set `shift_center` to a 2-tuple (rx,ry)"
+        elif isinstance(shift_center,tuple):
+            rx,ry = shift_center[:2]
+            shift_center = True
+        else:
+            shift_center = False
+
+
+        # Get the mask
+
+        # Get geometry
+        g = self.get_calibrated_detector_geometry(
+            calibration = self.calibration,
+            mode = mode,
+            geometry = geometry,
+            centered = centered,
+            calibrated = calibrated
+        )
+
+        # Get mask
+        mask = self.make_detector(image.shape, mode, g)
+        if not(invert):
+            mask = np.logical_not(mask)
+
+        # Shift center
+        if shift_center:
+            try:
+                rx,ry
+            except NameError:
+                raise Exception("if `shift_center` is True then `data` must be the 3-tuple (DataCube,rx,ry)")
+            # get shifts
+            assert(self.calibration.get_origin_shift() is not None), "origin shifts need to be calibrated"
+            qx_shift,qy_shift = cal.get_origin_shift()
+            qx_shift = int(np.round(qx_shift[rx,ry]))
+            qy_shift = int(np.round(qy_shift[rx,ry]))
+            mask = np.roll(
+                mask,
+                (qx_shift, qy_shift),
+                axis=(0,1)
+            )
+
+        # Show
+        show(
+            image,
+            mask = mask,
+            mask_color = color,
+            mask_alpha = alpha,
+            **kwargs
+        )
+        return
+
+
+
+    @staticmethod
+    def get_calibrated_detector_geometry(
+        calibration,
+        mode,
+        geometry,
+        centered,
+        calibrated
+        ):
+        """
+        Determine the detector geometry in pixels, given some mode and geometry
+        in calibrated units, where the calibration state is specified by {
+        centered, calibrated}
+
+        Parameters
+        ----------
+        calibration : Calibration
+            Used to retrieve the center positions. If `None`, confirms that
+            centered and calibrated are False then passes, otherwise raises
+            an exception
+        mode : str
+            see the DataCube.get_virtual_image docstring
+        geometry : variable
+            see the DataCube.get_virtual_image docstring
+        centered : bool
+            see the DataCube.get_virtual_image docstring
+        calibrated : bool
+            see the DataCube.get_virtual_image docstring
+
+        Returns
+        -------
+        geo : tuple
+            the geometry in detector pixels
+        """
+        # Parse inputs
+        g = geometry
+        if calibration is None:
+            assert calibrated is False and centered is False, "No calibration found - set a calibration or set `centered` and `calibrated` to False"
+            return g
+        else:
+            assert(isinstance(calibration, Calibration))
+            cal = calibration
+
+        # Get calibration metadata
+        if centered:
+            assert cal.get_qx0_mean() is not None, "origin needs to be calibrated"
+            x0_mean, y0_mean = cal.get_origin_mean()
+
+        if calibrated:
+            assert cal['Q_pixel_units'] == 'A^-1', \
+            'check calibration - must be calibrated in A^-1 to use `calibrated=True`'
+            unit_conversion = cal.get_Q_pixel_size()
+
+
+        # Convert units into detector pixels
+
+        # Shift center
+        if centered == True:
+            if mode == 'point':
+                g = (g[0] + x0_mean, g[1] + y0_mean)
+            if mode in('circle', 'circular', 'annulus', 'annular'):
+                g = ((g[0][0] + x0_mean, g[0][1] + y0_mean), g[1])
+            if mode in('rectangle', 'square', 'rectangular') :
+                 g = (g[0] + x0_mean, g[1] + x0_mean, g[2] + y0_mean, g[3] + y0_mean)
+
+        # Scale by the detector pixel size
+        if calibrated == True:
+            if mode == 'point':
+                g = (g[0]/unit_conversion, g[1]/unit_conversion)
+            if mode in('circle', 'circular'):
+                g = ((g[0][0]/unit_conversion, g[0][1]/unit_conversion),
+                    (g[1]/unit_conversion))
+            if mode in('annulus', 'annular'):
+                g = ((g[0][0]/unit_conversion, g[0][1]/unit_conversion),
+                    (g[1][0]/unit_conversion, g[1][1]/unit_conversion))
+            if mode in('rectangle', 'square', 'rectangular') :
+                g = (g[0]/unit_conversion, g[1]/unit_conversion,
+                     g[2]/unit_conversion, g[3]/unit_conversion)
+
+        return g
+
+
+    @staticmethod
+    def make_detector(
+        shape,
+        mode,
+        geometry,
+    ):
+        '''
+        Generate a 2D mask representing a detector function.
+
+        Parameters
+        ----------
+        shape : 2-tuple
+            defines shape of mask. Should be the shape of diffraction space.
+        mode : str
+            defines geometry mode for calculating virtual image. See the
+            docstring for DataCube.get_virtual_image
+        geometry : variable
+            defines geometry for calculating virtual image. See the
+            docstring for DataCube.get_virtual_image
+
+        Returns
+        -------
+        detector_mask : 2d array
+        '''
+        g = geometry
+
+        #point mask 
+        if mode == 'point':
+            assert(isinstance(g,tuple) and len(g)==2), 'specify qx and qy as tuple (qx, qy)'
+            mask = np.zeros(shape, dtype=bool)
+
+            qx = int(g[0])
+            qy = int(g[1])
+
+            mask[qx,qy] = 1
+
+        #circular mask
+        if mode in('circle', 'circular'):
+            assert(isinstance(g,tuple) and len(g)==2 and len(g[0])==2 and isinstance(g[1],(float,int))), \
+            'specify qx, qy, radius_i as ((qx, qy), radius)'
+
+            qxa, qya = np.indices(shape)
+            mask = (qxa - g[0][0]) ** 2 + (qya - g[0][1]) ** 2 < g[1] ** 2
+
+        #annular mask 
+        if mode in('annulus', 'annular'):
+            assert(isinstance(g,tuple) and len(g)==2 and len(g[0])==2 and len(g[1])==2), \
+            'specify qx, qy, radius_i, radius_0 as ((qx, qy), (radius_i, radius_o))'
+
+            assert g[1][1] > g[1][0], "Inner radius must be smaller than outer radius"
+
+            qxa, qya = np.indices(shape)
+            mask1 = (qxa - g[0][0]) ** 2 + (qya - g[0][1]) ** 2 > g[1][0] ** 2
+            mask2 = (qxa - g[0][0]) ** 2 + (qya - g[0][1]) ** 2 < g[1][1] ** 2
+            mask = np.logical_and(mask1, mask2)
+
+        #rectangle mask 
+        if mode in('rectangle', 'square', 'rectangular') :
+            assert(isinstance(g,tuple) and len(g)==4), \
+           'specify x_min, x_max, y_min, y_max as (x_min, x_max, y_min, y_max)'
+            mask = np.zeros(shape, dtype=bool)
+
+            xmin = int(np.round(g[0]))
+            xmax = int(np.round(g[1]))
+            ymin = int(np.round(g[2]))
+            ymax = int(np.round(g[3]))
+
+            mask[xmin:xmax, ymin:ymax] = 1
+
+        #flexible mask
+        if mode == 'mask':
+            assert type(g) == np.ndarray, '`geometry` type should be `np.ndarray`'
+            assert (g.shape == shape), 'mask and diffraction pattern shapes do not match'
+            mask = g
+        return mask
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# TODO - where does this go?
+
+def make_bragg_mask(
+    Qshape,
+    g1,
+    g2,
+    radius,
+    origin,
+    max_q,
+    return_sum = True,
+    **kwargs,
+    ):
+    '''
+    Creates and returns a mask consisting of circular disks
+    about the points of a 2D lattice.
+
+    Args:
+        Qshape (2 tuple): the shape of diffraction space
+        g1,g2 (len 2 array or tuple): the lattice vectors
+        radius (number): the disk radius
+        origin (len 2 array or tuple): the origin
+        max_q (nuumber): the maxima distance to tile to
+        return_sum (bool): if False, return a 3D array, where each
+            slice contains a single disk; if False, return a single
+            2D masks of all disks
+
+    Returns:
+        (2 or 3D array) the mask
+    '''
+    nas = np.asarray
+    g1,g2,origin = nas(g1),nas(g2),nas(origin)
+
+    # Get N,M, the maximum indices to tile out to
+    L1 = np.sqrt(np.sum(g1**2))
+    H = int(max_q/L1) + 1
+    L2 = np.hypot(-g2[0]*g1[1],g2[1]*g1[0])/np.sqrt(np.sum(g1**2))
+    K = int(max_q/L2) + 1
+
+    # Compute number of points
+    N = 0
+    for h in range(-H,H+1):
+        for k in range(-K,K+1):
+            v = h*g1 + k*g2
+            if np.sqrt(v.dot(v)) < max_q:
+                N += 1
+
+    #create mask
+    mask = np.zeros((Qshape[0], Qshape[1], N), dtype=bool)
+    N = 0
+    for h in range(-H,H+1):
+        for k in range(-K,K+1):
+            v = h*g1 + k*g2
+            if np.sqrt(v.dot(v)) < max_q:
+                center = origin + v
+                mask[:,:,N] = make_detector(
+                    Qshape,
+                    mode = 'circle',
+                    geometry = (center, radius),
+                )
+                N += 1
+
+
+    if return_sum:
+        mask = np.sum(mask, axis = 2)
+    return mask
+
+
+
+# TODO - these need to move elsewhere!
+
+def get_virtual_image_pointlistarray(
+    peaks,
+    mode = None,
+    geometry = None,
+    ):
+    """
+    Make a virtual image from a pointlist array.
+    TODO - implement more virtual detectors.
+
+    Args:
+        peaks (PointListArray): List of all peaks and intensities.
+        mode (str)          : defines geometry mode for calculating virtual image.
+            Options:
+                - 'circular' or 'circle' uses round detector, like bright field
+                - 'annular' or 'annulus' uses annular detector, like dark field
+        geometry (variable) : valid entries are determined by the `mode`, values in pixels
+                              argument, as follows:
+                - 'circle' or 'circular': nested 2-tuple, ((qx,qy),radius),
+                   qx, qy and radius, are each single float or int
+                - 'annular' or 'annulus': nested 2-tuple, ((qx,qy),(radius_i,radius_o)),
+                   qx, qy, radius_i, and radius_o are each single float or integer
+                - Note that (qx,qy) can be skipped, which assumes peaks centered at (0,0)
+
+    Returns:
+        im_virtual (2D numpy array): the calculated virtual image
+    """
+
+    # Set geometry
+    if mode is None:
+        if geometry is None:
+            center = None
+            radial_range = np.array((0,np.inf))
+        else:
+            if len(geometry[0]) == 0:
+                center = None
+            else:
+                center = np.array(geometry[0])
+            if isinstance(geometry[1], int) or isinstance(geometry[1], float):
+                radial_range = np.array((0,geometry[1]))
+            elif len(geometry[1]) == 0:
+                radial_range = None
+            else:
+                radial_range = np.array(geometry[1])
+    elif mode == 'circular' or mode == 'circle':
+        radial_range = np.array((0,geometry[1]))
+        if len(geometry[0]) == 0:
+                center = None
+        else:
+            center = np.array(geometry[0])
+    elif mode == 'annular' or mode == 'annulus':
+        radial_range = np.array(geometry[1])
+        if len(geometry[0]) == 0:
+                center = None
+        else:
+            center = np.array(geometry[0])
+
+
+
+    # init
+    im_virtual = np.zeros(peaks.shape)
+
+    # Generate image
+    for rx,ry in tqdmnd(peaks.shape[0],peaks.shape[1]):
+        p = peaks.get_pointlist(rx,ry)
+        if p.data.shape[0] > 0:
+            if radial_range is None:
+                im_virtual[rx,ry] = np.sum(p.data['intensity'])
+            else:
+                if center is None:
+                    qr = np.hypot(p.data['qx'],p.data['qy'])
+                else:
+                    qr = np.hypot(p.data['qx'] - center[0],p.data['qy'] - center[1])
+                sub = np.logical_and(
+                    qr >= radial_range[0],
+                    qr <  radial_range[1])
+                if np.sum(sub) > 0:
+                    im_virtual[rx,ry] = np.sum(p.data['intensity'][sub])
+
+    return im_virtual
+
+
+def get_virtual_image_braggvectors(
+    bragg_peaks,
+    mode = None,
+    geometry = None,
+    ):
+    '''
+    Function to calculate virtual images from braggvectors / pointlist arrays.
+    TODO - implement these detectors for braggvectors
+
+    Args:
+        bragg_peaks (BraggVectors) : BraggVectors class object which stores bragg peaks
+        mode (str)          : defines geometry mode for calculating virtual image.
+            Options:
+                - 'circular' or 'circle' uses round detector, like bright field
+                - 'annular' or 'annulus' uses annular detector, like dark field
+        geometry (variable) : valid entries are determined by the `mode`, values in pixels
+                              argument, as follows:
+                - 'circle' or 'circular': nested 2-tuple, ((qx,qy),radius),
+                   qx, qy and radius, are each single float or int
+                - 'annular' or 'annulus': nested 2-tuple, ((qx,qy),(radius_i,radius_o)),
+                   qx, qy, radius_i, and radius_o are each single float or integer
+                - Note that (qx,qy) can be skipped, which assumes peaks centered at (0,0)
+
+    Returns:
+        im_virtual (2D numpy array): the calculated virtual image
+    '''
+
+    virtual_image = get_virtual_image_pointlistarray(
+        bragg_peaks.vectors,
+        mode = mode,
+        geometry = geometry,
+        )
+
+    return virtual_image
diff --git a/py4DSTEM/io/filereaders/empad.py b/py4DSTEM/io/filereaders/empad.py
index 4aef6ee77..98b515863 100644
--- a/py4DSTEM/io/filereaders/empad.py
+++ b/py4DSTEM/io/filereaders/empad.py
@@ -8,7 +8,7 @@
 import numpy as np
 from pathlib import Path
 from emdfile import tqdmnd
-from py4DSTEM.data import DataCube
+from py4DSTEM.datacube import DataCube
 from py4DSTEM.preprocess.utils import bin2D
 
 
diff --git a/py4DSTEM/io/filereaders/read_K2.py b/py4DSTEM/io/filereaders/read_K2.py
index cf5dd8be6..c03de98d3 100644
--- a/py4DSTEM/io/filereaders/read_K2.py
+++ b/py4DSTEM/io/filereaders/read_K2.py
@@ -9,7 +9,7 @@
 except ImportError:
     pass
 from emdfile import tqdmnd
-from py4DSTEM.data import DataCube
+from py4DSTEM.datacube import DataCube
 
 
 def read_gatan_K2_bin(fp, mem="MEMMAP", binfactor=1, metadata=False, **kwargs):
diff --git a/py4DSTEM/io/filereaders/read_dm.py b/py4DSTEM/io/filereaders/read_dm.py
index 6762ab9f8..bc41695e1 100644
--- a/py4DSTEM/io/filereaders/read_dm.py
+++ b/py4DSTEM/io/filereaders/read_dm.py
@@ -5,7 +5,7 @@
 from ncempy.io import dm
 from emdfile import tqdmnd, Array
 
-from py4DSTEM.data import DataCube
+from py4DSTEM.datacube import DataCube
 from py4DSTEM.preprocess.utils import bin2D
 
 
diff --git a/py4DSTEM/io/filereaders/read_mib.py b/py4DSTEM/io/filereaders/read_mib.py
index b8e42ee4f..e9dccff90 100644
--- a/py4DSTEM/io/filereaders/read_mib.py
+++ b/py4DSTEM/io/filereaders/read_mib.py
@@ -3,7 +3,7 @@
 # Based on the PyXEM load_mib module https://github.com/pyxem/pyxem/blob/563a3bb5f3233f46cd3e57f3cd6f9ddf7af55ad0/pyxem/utils/io_utils.py
 
 import numpy as np
-from py4DSTEM.data import DataCube
+from py4DSTEM.datacube import DataCube
 import os
 
 def load_mib(
diff --git a/py4DSTEM/io/legacy/legacy12/read_v0_12.py b/py4DSTEM/io/legacy/legacy12/read_v0_12.py
index 9622f0a0e..470e64075 100644
--- a/py4DSTEM/io/legacy/legacy12/read_v0_12.py
+++ b/py4DSTEM/io/legacy/legacy12/read_v0_12.py
@@ -10,10 +10,10 @@
     PointListArray
 )
 from py4DSTEM.data import (
-    DataCube,
     DiffractionSlice,
     RealSlice,
 )
+from py4DSTEM.datacube import DataCube
 from emdfile import tqdmnd
 
 def read_v0_12(fp, **kwargs):
diff --git a/py4DSTEM/io/legacy/legacy12/read_v0_5.py b/py4DSTEM/io/legacy/legacy12/read_v0_5.py
index fa53fb7cb..ae89ba86b 100644
--- a/py4DSTEM/io/legacy/legacy12/read_v0_5.py
+++ b/py4DSTEM/io/legacy/legacy12/read_v0_5.py
@@ -10,10 +10,10 @@
     PointListArray
 )
 from py4DSTEM.data import (
-    DataCube,
     DiffractionSlice,
     RealSlice,
 )
+from py4DSTEM.datacube import DataCube
 from emdfile import tqdmnd
 
 def read_v0_5(fp, **kwargs):
diff --git a/py4DSTEM/io/legacy/legacy12/read_v0_6.py b/py4DSTEM/io/legacy/legacy12/read_v0_6.py
index bec2e6d69..d3b6d0d5f 100644
--- a/py4DSTEM/io/legacy/legacy12/read_v0_6.py
+++ b/py4DSTEM/io/legacy/legacy12/read_v0_6.py
@@ -10,10 +10,10 @@
     PointListArray
 )
 from py4DSTEM.data import (
-    DataCube,
     DiffractionSlice,
     RealSlice,
 )
+from py4DSTEM.datacube import DataCube
 from emdfile import tqdmnd
 
 def read_v0_6(fp, **kwargs):
diff --git a/py4DSTEM/io/legacy/legacy12/read_v0_7.py b/py4DSTEM/io/legacy/legacy12/read_v0_7.py
index 7e3b782df..34fd917f4 100644
--- a/py4DSTEM/io/legacy/legacy12/read_v0_7.py
+++ b/py4DSTEM/io/legacy/legacy12/read_v0_7.py
@@ -10,10 +10,10 @@
     PointListArray
 )
 from py4DSTEM.data import (
-    DataCube,
     DiffractionSlice,
     RealSlice,
 )
+from py4DSTEM.datacube import DataCube
 from emdfile import tqdmnd
 
 def read_v0_7(fp, **kwargs):
diff --git a/py4DSTEM/io/legacy/legacy12/read_v0_9.py b/py4DSTEM/io/legacy/legacy12/read_v0_9.py
index 71bf7adaf..37e995871 100644
--- a/py4DSTEM/io/legacy/legacy12/read_v0_9.py
+++ b/py4DSTEM/io/legacy/legacy12/read_v0_9.py
@@ -10,10 +10,10 @@
     PointListArray
 )
 from py4DSTEM.data import (
-    DataCube,
     DiffractionSlice,
     RealSlice,
 )
+from py4DSTEM.datacube import DataCube
 from emdfile import tqdmnd
 
 def read_v0_9(fp, **kwargs):
diff --git a/py4DSTEM/io/legacy/legacy13/v13_to_14.py b/py4DSTEM/io/legacy/legacy13/v13_to_14.py
index c9509d9f3..5ac2a843a 100644
--- a/py4DSTEM/io/legacy/legacy13/v13_to_14.py
+++ b/py4DSTEM/io/legacy/legacy13/v13_to_14.py
@@ -39,13 +39,15 @@
 
 from py4DSTEM.data import (
     Calibration,
-    DataCube,
     DiffractionSlice,
     RealSlice,
     QPoints,
 )
+from py4DSTEM.datacube import (
+    DataCube,
+    VirtualImage
+)
 from py4DSTEM.classes import (
-    VirtualImage,
     VirtualDiffraction,
 )
 from py4DSTEM.process.diskdetection import BraggVectors, Probe
diff --git a/py4DSTEM/process/__init__.py b/py4DSTEM/process/__init__.py
index da88ec4ba..510870f50 100644
--- a/py4DSTEM/process/__init__.py
+++ b/py4DSTEM/process/__init__.py
@@ -2,7 +2,6 @@
 
 from py4DSTEM.process import diskdetection
 from py4DSTEM.process import virtualdiffraction
-from py4DSTEM.process import virtualimage
 from py4DSTEM.process import latticevectors
 from py4DSTEM.process import phase
 from py4DSTEM.process import calibration
diff --git a/py4DSTEM/process/calibration/origin.py b/py4DSTEM/process/calibration/origin.py
index b3a141231..0b27f5a85 100644
--- a/py4DSTEM/process/calibration/origin.py
+++ b/py4DSTEM/process/calibration/origin.py
@@ -6,7 +6,7 @@
 from scipy.optimize import leastsq
 
 from emdfile import tqdmnd, PointListArray
-from py4DSTEM.data import DataCube
+from py4DSTEM.datacube import DataCube
 from py4DSTEM.process.calibration.probe import get_probe_size
 from py4DSTEM.process.fit import plane,parabola,bezier_two,fit_2D
 from py4DSTEM.process.utils import get_CoM, add_to_2D_array_from_floats, get_maxima_2D
diff --git a/py4DSTEM/process/classification/classutils.py b/py4DSTEM/process/classification/classutils.py
index b2381c26f..bd4d0a053 100644
--- a/py4DSTEM/process/classification/classutils.py
+++ b/py4DSTEM/process/classification/classutils.py
@@ -3,7 +3,7 @@
 import numpy as np
 
 from emdfile import tqdmnd, PointListArray
-from py4DSTEM.data import DataCube
+from py4DSTEM.datacube import DataCube
 from py4DSTEM.process.utils import get_shifted_ar
 
 def get_class_DP(datacube, class_image, thresh=0.01, xshifts=None, yshifts=None,
diff --git a/py4DSTEM/process/diskdetection/diskdetection.py b/py4DSTEM/process/diskdetection/diskdetection.py
index 1c7916a51..077b267f7 100644
--- a/py4DSTEM/process/diskdetection/diskdetection.py
+++ b/py4DSTEM/process/diskdetection/diskdetection.py
@@ -6,7 +6,8 @@
 
 from emdfile import tqdmnd
 from py4DSTEM.process.diskdetection.braggvectors import BraggVectors
-from py4DSTEM.data import DataCube, QPoints
+from py4DSTEM.data import QPoints
+from py4DSTEM.datacube import DataCube
 from py4DSTEM.preprocess.utils import get_maxima_2D
 from py4DSTEM.process.utils.cross_correlate import get_cross_correlation_FT
 from py4DSTEM.process.diskdetection.diskdetection_aiml import find_Bragg_disks_aiml
diff --git a/py4DSTEM/process/diskdetection/probe_gen_methods.py b/py4DSTEM/process/diskdetection/probe_gen_methods.py
index 8e7b1d717..e40208a11 100644
--- a/py4DSTEM/process/diskdetection/probe_gen_methods.py
+++ b/py4DSTEM/process/diskdetection/probe_gen_methods.py
@@ -5,7 +5,7 @@
     binary_opening, binary_dilation, distance_transform_edt)
 
 from emdfile import tqdmnd
-from py4DSTEM.data import DataCube
+from py4DSTEM.datacube import DataCube
 from py4DSTEM.process.diskdetection import Probe
 from py4DSTEM.process.utils import get_shifted_ar, get_shift
 
diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index 42e207d97..e3dfa1cd7 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -18,7 +18,8 @@
     cp = None
 
 from emdfile import Array, Custom, Metadata, _read_metadata, tqdmnd
-from py4DSTEM.data import Calibration, DataCube
+from py4DSTEM.data import Calibration
+from py4DSTEM.datacube import DataCube
 from py4DSTEM.process.calibration import fit_origin
 from py4DSTEM.process.phase.iterative_ptychographic_constraints import (
     PtychographicConstraints,
diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index 16381c4d8..ca0cdf10d 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -17,7 +17,8 @@
     cp = None
 
 from emdfile import Array, Custom, Metadata, _read_metadata, tqdmnd
-from py4DSTEM.data import Calibration, DataCube
+from py4DSTEM.data import Calibration
+from py4DSTEM.datacube import DataCube
 from py4DSTEM.process.phase.iterative_base_class import PhaseReconstruction
 
 warnings.simplefilter(action="always", category=UserWarning)
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index ce298967d..3efe50810 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -18,7 +18,7 @@
     cp = None
 
 from emdfile import Custom, tqdmnd
-from py4DSTEM.data import DataCube
+from py4DSTEM.datacube import DataCube
 from py4DSTEM.process.phase.iterative_base_class import PtychographicReconstruction
 from py4DSTEM.process.phase.utils import (
     ComplexProbe,
diff --git a/py4DSTEM/process/polar/polar_datacube.py b/py4DSTEM/process/polar/polar_datacube.py
index 9aa93d678..f1d4277fb 100644
--- a/py4DSTEM/process/polar/polar_datacube.py
+++ b/py4DSTEM/process/polar/polar_datacube.py
@@ -1,5 +1,5 @@
 import numpy as np
-from py4DSTEM.data import DataCube
+from py4DSTEM.datacube import DataCube
 from scipy.ndimage import binary_opening,binary_closing, gaussian_filter1d
 
 
diff --git a/py4DSTEM/process/virtualimage.py b/py4DSTEM/process/virtualimage.py
deleted file mode 100644
index d6fe79566..000000000
--- a/py4DSTEM/process/virtualimage.py
+++ /dev/null
@@ -1,537 +0,0 @@
-# Functions for generating virtual images
-import numpy as np
-import dask.array as da
-from emdfile import tqdmnd
-from py4DSTEM.data import Calibration
-
-def get_virtual_image(
-    datacube,
-    mode,
-    geometry,
-    centered = False,
-    calibrated = False,
-    shift_center = False,
-    verbose = True,
-    dask = False,
-    return_mask = False,
-    test_config = False
-):
-    '''
-    Function to calculate virtual image
-
-    Args:
-        datacube (Datacube) : datacube class object which stores 4D-dataset
-            needed for calculation
-        mode (str)          : defines geometry mode for calculating virtual image.
-            Options:
-                - 'point' uses singular point as detector
-                - 'circle' or 'circular' uses round detector, like bright field
-                - 'annular' or 'annulus' uses annular detector, like dark field
-                - 'rectangle', 'square', 'rectangular', uses rectangular detector
-                - 'mask' flexible detector, any 2D array
-        geometry (variable) : valid entries are determined by the `mode`, values
-            in pixels argument, as follows:
-                - 'point': 2-tuple, (qx,qy),
-                   qx and qy are each single float or int to define center
-                - 'circle' or 'circular': nested 2-tuple, ((qx,qy),radius),
-                   qx, qy and radius, are each single float or int
-                - 'annular' or 'annulus': nested 2-tuple, ((qx,qy),
-                  (radius_i,radius_o))
-                - 'rectangle', 'square', 'rectangular': a 4-tuple,
-                  (xmin,xmax,ymin,ymax)
-                - `mask`: flexible detector, any boolean or floating point
-                  2D array with the same shape as datacube.Qshape
-        centered (bool): if False (default), the origin is in the upper left
-            corner. If True, the mean measured origin in the datacube
-            calibrations is set as center. The measured origin is set with
-            datacube.calibration.set_origin(). In this case, for example, a
-            centered bright field image could be defined by
-            geometry = ((0,0), R). For `mode="mask"`, has no effect.
-        calibrated (bool): if True, geometry is specified in units of 'A^-1'
-            instead of pixels. The datacube's calibrations must have its
-            `"Q_pixel_units"` parameter set to "A^-1". For `mode="mask"`, has
-             no effect.
-        shift_center (bool): if True, the mask is shifted at each real space
-            position to account for any shifting of the origin of the
-            diffraction images. The datacube's calibration['origin'] parameter
-            must be set (centered = True). The shift applied to each pattern is
-            the difference between the local origin position and the mean origin
-            position over all patterns, rounded to the nearest integer for speed.
-        verbose (bool): if True, show progress bar
-        dask (bool): if True, use dask arrays
-        return_mask (bool or tuple): if False (default) returns a virtual image
-            as usual. If True, does *not* generate or return a virtual image,
-            instead returning the mask that would be used in virtual image
-            computation for any call to this function where
-            `shift_center = False`. Otherwise, must be a 2-tuple of integers
-            corresponding to a scan position (rx,ry); in this case, returns the
-            mask that would be used for virtual image computation at this scan
-            position with `shift_center` set to `True`.
-        test_config: if True, returns the Boolean value of (`centered`,
-            `calibrated`,`shift_center`). Does not compute the virtual image.
-
-    Returns:
-        (2D array) virtual image
-    '''
-
-    assert mode in ('point', 'circle', 'circular', 'annulus', 'annular', 'rectangle', 'square', 'rectangular', 'mask'),\
-    'check doc strings for supported modes'
-    if shift_center == True:
-        assert centered, "centered must be True if shift_center is True"
-    if test_config:
-        for x,y in zip(['centered','calibrated','shift_center'],
-                       [centered,calibrated,shift_center]):
-            print(f"{x} = {y}")
-
-    # Get geometry
-    g = get_calibrated_geometry(
-        datacube,
-        mode,
-        geometry,
-        centered,
-        calibrated
-    )
-
-    # Get mask
-    mask = make_detector(datacube.Qshape, mode, g)
-    # if return_mask is True, skip computation
-    if return_mask == True and shift_center == False:
-        return mask
-
-
-    # Calculate images
-
-    # no center shifting
-    if shift_center == False:
-        # dask 
-        if dask == True:
-
-            # set up a generalized universal function for dask distribution
-            def _apply_mask_dask(datacube,mask):
-                virtual_image = np.sum(np.multiply(datacube.data,mask), dtype=np.float64)
-            apply_mask_dask = da.as_gufunc(
-                _apply_mask_dask,signature='(i,j),(i,j)->()',
-                output_dtypes=np.float64,
-                axes=[(2,3),(0,1),()],
-                vectorize=True
-            )
-
-            # compute
-            virtual_image = apply_mask_dask(datacube.data, mask)
-
-        # non-dask
-        else:
-
-            # compute
-            if mask.dtype == 'complex':
-                virtual_image = np.zeros(datacube.Rshape, dtype = 'complex')
-            else:
-                virtual_image = np.zeros(datacube.Rshape)
-            for rx,ry in tqdmnd(
-                datacube.R_Nx,
-                datacube.R_Ny,
-                disable = not verbose,
-            ):
-                virtual_image[rx,ry] = np.sum(datacube.data[rx,ry]*mask)
-
-    # with center shifting
-    else:
-
-        # get shifts
-        assert datacube.calibration.get_origin_shift(), "origin need to be calibrated"
-        qx_shift,qy_shift = datacube.calibration.get_origin_shift()
-        qx_shift = qx_shift.round().astype(int)
-        qy_shift = qy_shift.round().astype(int)
-
-        # if return_mask is True, skip computation
-        if return_mask is not False:
-            try:
-                rx,ry = return_mask
-            except TypeError:
-                raise Exception("when `shift_center` is True, return_mask must be a 2-tuple of ints or False")
-            # get shifted mask
-            _mask = np.roll(
-                mask,
-                (qx_shift[rx,ry], qy_shift[rx,ry]),
-                axis=(0,1)
-            )
-            return _mask
-
-        # compute
-        if mask.dtype == 'complex':
-            virtual_image = np.zeros(datacube.Rshape, dtype = 'complex')
-        else:
-            virtual_image = np.zeros(datacube.Rshape)
-
-        for rx,ry in tqdmnd(
-            datacube.R_Nx,
-            datacube.R_Ny,
-            disable = not verbose,
-        ):
-            # get shifted mask
-            _mask = np.roll(
-                mask,
-                (qx_shift[rx,ry], qy_shift[rx,ry]),
-                axis=(0,1)
-            )
-            virtual_image[rx,ry] = np.sum(datacube.data[rx,ry]*_mask)
-
-    return virtual_image
-
-
-def get_calibrated_geometry(
-    calibration,
-    mode,
-    geometry,
-    centered,
-    calibrated
-    ):
-    """
-    Determine the detector geometry in pixels, given some mode and geometry
-    in calibrated units, where the calibration state is specified by {
-    centered, calibrated}
-
-    Args:
-        calibration (Calibration, DataCube, any object with a .calibration attr,
-        or None) Used to retrieve the center positions. If `None`, confirms that
-        centered and calibrated are False then passes
-        mode: see py4DSTEM.process.virtualimage.get_virtual_image
-        geometry: see py4DSTEM.process.virtualimage.get_virtual_image
-        centered: see py4DSTEM.process.virtualimage.get_virtual_image
-        calibrated: see py4DSTEM.process.virtualimage.get_virtual_image
-
-    Returns:
-        (tuple) the geometry in detector pixels
-    """
-    # Parse inputs
-    g = geometry
-    if calibration is None:
-        assert calibrated is False and centered is False
-        return g
-    elif isinstance(calibration, Calibration):
-        cal = calibration
-    else:
-        try:
-            cal = calibration.calibration
-            assert isinstance(cal, Calibration), "`calibration.calibration` must be a Calibration instance"
-        except AttributeError:
-            raise Exception("`calibration` must either be a Calibration instance or have a .calibration attribute")
-
-    # Get calibration metadata
-    if centered:
-        assert cal.get_qx0_mean(), "origin needs to be calibrated"
-        x0_mean, y0_mean = cal.get_origin_mean()
-
-    if calibrated:
-        assert cal['Q_pixel_units'] == 'A^-1', \
-        'check calibration - must be calibrated in A^-1 to use `calibrated=True`'
-        unit_conversion = cal.get_Q_pixel_size()
-
-
-    # Convert units into detector pixels
-
-    # Shift center
-    if centered == True:
-        if mode == 'point':
-            g = (g[0] + x0_mean, g[1] + y0_mean)
-        if mode in('circle', 'circular', 'annulus', 'annular'):
-            g = ((g[0][0] + x0_mean, g[0][1] + y0_mean), g[1])
-        if mode in('rectangle', 'square', 'rectangular') :
-             g = (g[0] + x0_mean, g[1] + x0_mean, g[2] + y0_mean, g[3] + y0_mean)
-
-    # Scale by the detector pixel size
-    if calibrated == True:
-        if mode == 'point':
-            g = (g[0]/unit_conversion, g[1]/unit_conversion)
-        if mode in('circle', 'circular'):
-            g = ((g[0][0]/unit_conversion, g[0][1]/unit_conversion),
-                (g[1]/unit_conversion))
-        if mode in('annulus', 'annular'):
-            g = ((g[0][0]/unit_conversion, g[0][1]/unit_conversion),
-                (g[1][0]/unit_conversion, g[1][1]/unit_conversion))
-        if mode in('rectangle', 'square', 'rectangular') :
-            g = (g[0]/unit_conversion, g[1]/unit_conversion,
-                 g[2]/unit_conversion, g[3]/unit_conversion)
-
-    return g
-
-
-
-def make_detector(
-    shape,
-    mode,
-    geometry,
-):
-    '''
-    Function to return 2D mask
-
-    Args:
-        shape (tuple)      : defines shape of mask, for example (Q_Nx, Q_Ny) where Q_Nx and Q_Ny are mask sizes
-        mode (str)         : defines geometry mode for calculating virtual image
-            options:
-                - 'point' uses singular point as detector
-                - 'circle' or 'circular' uses round detector, like bright field
-                - 'annular' or 'annulus' uses annular detector, like dark field
-                - 'rectangle', 'square', 'rectangular', uses rectangular detector
-                - 'mask' flexible detector, any boolean or floating point 2D array with
-                    the same shape as datacube.Qshape or datacube.Rshape for virtual image
-                    or diffraction image respectively
-        geometry (variable) : valid entries are determined by the `mode`, values in pixels
-            argument, as follows:
-                - 'point': 2-tuple, (qx,qy),
-                   qx and qy are each single float or int to define center
-                - 'circle' or 'circular': nested 2-tuple, ((qx,qy),radius),
-                   qx, qy and radius, are each single float or int
-                - 'annular' or 'annulus': nested 2-tuple, ((qx,qy),(radius_i,radius_o)),
-                   qx, qy, radius_i, and radius_o are each single float or integer
-                - 'rectangle', 'square', 'rectangular': 4-tuple, (xmin,xmax,ymin,ymax)
-                - `mask`: flexible detector, any boolean or floating point 2D array with the
-                    same shape as datacube.Qshape or datacube.Rshapefor virtual image
-                    or diffraction image respectively
-
-    Returns:
-        virtual detector in the form of a 2D mask (array)
-    '''
-    g = geometry
-
-    #point mask 
-    if mode == 'point':
-        assert(isinstance(g,tuple) and len(g)==2), 'specify qx and qy as tuple (qx, qy)'
-        mask = np.zeros(shape, dtype=bool)
-
-        qx = int(g[0])
-        qy = int(g[1])
-
-        mask[qx,qy] = 1
-
-    #circular mask
-    if mode in('circle', 'circular'):
-        assert(isinstance(g,tuple) and len(g)==2 and len(g[0])==2 and isinstance(g[1],(float,int))), \
-        'specify qx, qy, radius_i as ((qx, qy), radius)'
-
-        qxa, qya = np.indices(shape)
-        mask = (qxa - g[0][0]) ** 2 + (qya - g[0][1]) ** 2 < g[1] ** 2
-
-    #annular mask 
-    if mode in('annulus', 'annular'):
-        assert(isinstance(g,tuple) and len(g)==2 and len(g[0])==2 and len(g[1])==2), \
-        'specify qx, qy, radius_i, radius_0 as ((qx, qy), (radius_i, radius_o))'
-
-        assert g[1][1] > g[1][0], "Inner radius must be smaller than outer radius"
-
-        qxa, qya = np.indices(shape)
-        mask1 = (qxa - g[0][0]) ** 2 + (qya - g[0][1]) ** 2 > g[1][0] ** 2
-        mask2 = (qxa - g[0][0]) ** 2 + (qya - g[0][1]) ** 2 < g[1][1] ** 2
-        mask = np.logical_and(mask1, mask2)
-
-    #rectangle mask 
-    if mode in('rectangle', 'square', 'rectangular') :
-        assert(isinstance(g,tuple) and len(g)==4), \
-       'specify x_min, x_max, y_min, y_max as (x_min, x_max, y_min, y_max)'
-        mask = np.zeros(shape, dtype=bool)
-
-        xmin = int(np.round(g[0]))
-        xmax = int(np.round(g[1]))
-        ymin = int(np.round(g[2]))
-        ymax = int(np.round(g[3]))
-
-        mask[xmin:xmax, ymin:ymax] = 1
-
-    #flexible mask
-    if mode == 'mask':
-        assert type(g) == np.ndarray, '`geometry` type should be `np.ndarray`'
-        assert (g.shape == shape), 'mask and diffraction pattern shapes do not match'
-        mask = g
-    return mask
-
-def make_bragg_mask(
-    Qshape,
-    g1,
-    g2,
-    radius,
-    origin,
-    max_q,
-    return_sum = True,
-    **kwargs,
-    ):
-    '''
-    Creates and returns a mask consisting of circular disks
-    about the points of a 2D lattice.
-
-    Args:
-        Qshape (2 tuple): the shape of diffraction space
-        g1,g2 (len 2 array or tuple): the lattice vectors
-        radius (number): the disk radius
-        origin (len 2 array or tuple): the origin
-        max_q (nuumber): the maxima distance to tile to
-        return_sum (bool): if False, return a 3D array, where each
-            slice contains a single disk; if False, return a single
-            2D masks of all disks
-
-    Returns:
-        (2 or 3D array) the mask
-    '''
-    nas = np.asarray
-    g1,g2,origin = nas(g1),nas(g2),nas(origin)
-
-    # Get N,M, the maximum indices to tile out to
-    L1 = np.sqrt(np.sum(g1**2))
-    H = int(max_q/L1) + 1
-    L2 = np.hypot(-g2[0]*g1[1],g2[1]*g1[0])/np.sqrt(np.sum(g1**2))
-    K = int(max_q/L2) + 1
-
-    # Compute number of points
-    N = 0
-    for h in range(-H,H+1):
-        for k in range(-K,K+1):
-            v = h*g1 + k*g2
-            if np.sqrt(v.dot(v)) < max_q:
-                N += 1
-
-    #create mask
-    mask = np.zeros((Qshape[0], Qshape[1], N), dtype=bool)
-    N = 0
-    for h in range(-H,H+1):
-        for k in range(-K,K+1):
-            v = h*g1 + k*g2
-            if np.sqrt(v.dot(v)) < max_q:
-                center = origin + v
-                mask[:,:,N] = make_detector(
-                    Qshape,
-                    mode = 'circle',
-                    geometry = (center, radius),
-                )
-                N += 1
-
-
-    if return_sum:
-        mask = np.sum(mask, axis = 2)
-    return mask
-
-
-
-
-
-
-
-
-
-
-
-
-
-def get_virtual_image_pointlistarray(
-    peaks,
-    mode = None,
-    geometry = None,
-    ):
-    """
-    Make a virtual image from a pointlist array.
-    TODO - implement more virtual detectors.
-
-    Args:
-        peaks (PointListArray): List of all peaks and intensities.
-        mode (str)          : defines geometry mode for calculating virtual image.
-            Options:
-                - 'circular' or 'circle' uses round detector, like bright field
-                - 'annular' or 'annulus' uses annular detector, like dark field
-        geometry (variable) : valid entries are determined by the `mode`, values in pixels
-                              argument, as follows:
-                - 'circle' or 'circular': nested 2-tuple, ((qx,qy),radius),
-                   qx, qy and radius, are each single float or int
-                - 'annular' or 'annulus': nested 2-tuple, ((qx,qy),(radius_i,radius_o)),
-                   qx, qy, radius_i, and radius_o are each single float or integer
-                - Note that (qx,qy) can be skipped, which assumes peaks centered at (0,0)
-
-    Returns:
-        im_virtual (2D numpy array): the calculated virtual image
-    """
-
-    # Set geometry
-    if mode is None:
-        if geometry is None:
-            center = None
-            radial_range = np.array((0,np.inf))
-        else:
-            if len(geometry[0]) == 0:
-                center = None
-            else:
-                center = np.array(geometry[0])
-            if isinstance(geometry[1], int) or isinstance(geometry[1], float):
-                radial_range = np.array((0,geometry[1]))
-            elif len(geometry[1]) == 0:
-                radial_range = None
-            else:
-                radial_range = np.array(geometry[1])
-    elif mode == 'circular' or mode == 'circle':
-        radial_range = np.array((0,geometry[1]))
-        if len(geometry[0]) == 0:
-                center = None
-        else:
-            center = np.array(geometry[0])
-    elif mode == 'annular' or mode == 'annulus':
-        radial_range = np.array(geometry[1])
-        if len(geometry[0]) == 0:
-                center = None
-        else:
-            center = np.array(geometry[0])
-
-
-
-    # init
-    im_virtual = np.zeros(peaks.shape)
-
-    # Generate image
-    for rx,ry in tqdmnd(peaks.shape[0],peaks.shape[1]):
-        p = peaks.get_pointlist(rx,ry)
-        if p.data.shape[0] > 0:
-            if radial_range is None:
-                im_virtual[rx,ry] = np.sum(p.data['intensity'])
-            else:
-                if center is None:
-                    qr = np.hypot(p.data['qx'],p.data['qy'])
-                else:
-                    qr = np.hypot(p.data['qx'] - center[0],p.data['qy'] - center[1])
-                sub = np.logical_and(
-                    qr >= radial_range[0],
-                    qr <  radial_range[1])
-                if np.sum(sub) > 0:
-                    im_virtual[rx,ry] = np.sum(p.data['intensity'][sub])
-
-    return im_virtual
-
-
-def get_virtual_image_braggvectors(
-    bragg_peaks,
-    mode = None,
-    geometry = None,
-    ):
-    '''
-    Function to calculate virtual images from braggvectors / pointlist arrays.
-    TODO - implement these detectors for braggvectors
-
-    Args:
-        bragg_peaks (BraggVectors) : BraggVectors class object which stores bragg peaks
-        mode (str)          : defines geometry mode for calculating virtual image.
-            Options:
-                - 'circular' or 'circle' uses round detector, like bright field
-                - 'annular' or 'annulus' uses annular detector, like dark field
-        geometry (variable) : valid entries are determined by the `mode`, values in pixels
-                              argument, as follows:
-                - 'circle' or 'circular': nested 2-tuple, ((qx,qy),radius),
-                   qx, qy and radius, are each single float or int
-                - 'annular' or 'annulus': nested 2-tuple, ((qx,qy),(radius_i,radius_o)),
-                   qx, qy, radius_i, and radius_o are each single float or integer
-                - Note that (qx,qy) can be skipped, which assumes peaks centered at (0,0)
-
-    Returns:
-        im_virtual (2D numpy array): the calculated virtual image
-    '''
-
-    virtual_image = get_virtual_image_pointlistarray(
-        bragg_peaks.vectors,
-        mode = mode,
-        geometry = geometry,
-        )
-
-    return virtual_image
diff --git a/py4DSTEM/visualize/__init__.py b/py4DSTEM/visualize/__init__.py
index 40fdedca6..d5c183ab5 100644
--- a/py4DSTEM/visualize/__init__.py
+++ b/py4DSTEM/visualize/__init__.py
@@ -3,5 +3,4 @@
 from py4DSTEM.visualize.vis_RQ import *
 from py4DSTEM.visualize.vis_grid import *
 from py4DSTEM.visualize.vis_special import *
-from py4DSTEM.visualize.virtualimage import *
 
diff --git a/py4DSTEM/visualize/virtualimage.py b/py4DSTEM/visualize/virtualimage.py
deleted file mode 100644
index 830fde5c5..000000000
--- a/py4DSTEM/visualize/virtualimage.py
+++ /dev/null
@@ -1,129 +0,0 @@
-import numpy as np
-
-from py4DSTEM.data import Calibration, DataCube, DiffractionSlice
-from py4DSTEM.visualize.show import show
-
-
-def position_detector(
-    data,
-    mode,
-    geometry,
-    centered,
-    calibrated,
-    shift_center,
-    invert = False,
-    color = 'r',
-    alpha = 0.7,
-    **kwargs
-):
-    """
-    Display a diffraction space image with an overlaid mask representing
-    a virtual detector.
-
-    Args:
-        data (DataCube, DiffractionSlice, array, tuple):
-            behavoir depends on the argument type:
-                DataCube - check to see if this datacube has a mean, max,
-                    or median diffraction pattern, and if found, uses it
-                    (order of preference as written here). If not found,
-                    raises an exception.
-                DiffractionSlice - use the first slice
-                array - use this array. This mode only works when
-                    centered, calibrated, and shift_center are False.
-                    Otherwise, use the tuple entry (array, Calibration)
-                tuple - must be either:
-                    - (DataCube, rx, ry) for rx,ry integers.
-                    Use the diffraction pattern at this scan position.
-                    `shift_center` is auto set to True in this mode.
-                    - (array, Calibration)
-        mode: see py4DSTEM.process.get_virtual_image
-        geometry: see py4DSTEM.process.get_virtual_image
-        centered: see py4DSTEM.process.get_virtual_image
-        calibrated: see py4DSTEM.process.get_virtual_image
-        shift_center: see py4DSTEM.process.get_virtual_image; if True, `data`
-            should be a 3-tuple (DataCube, rx, ry)
-        invert: if True, invert the mask
-        **kwargs: all additional arguments are passed on to `show`
-    """
-    # Parse data
-    if isinstance(data, DataCube):
-        cal = data.calibration
-        keys = ['dp_mean','dp_max','dp_median']
-        for k in keys:
-            try:
-                image = data.tree(k)
-                break
-            except:
-                pass
-        else:
-            raise Exception("No mean, max, or median diffraction image found; try calling datacube.get_mean_dp() first")
-    elif isinstance(data, DiffractionSlice):
-        cal = data.calibration
-        try:
-            image = data[:,:,0]
-        except IndexError:
-            image = data[:,:]
-    elif isinstance(data, np.ndarray):
-        er = "centered and calibrated must be False to pass an uncalibrated array; set these to False or try using `data = (array, Calibration)`"
-        assert all([x is False for x in [centered,calibrated]]), er
-        image = data
-        cal = None
-    elif isinstance(data, tuple):
-        if len(data)==2:
-            image,cal = data
-            assert isinstance(image, np.ndarray)
-            assert isinstance(cal, Calibration)
-        elif len(data)==3:
-            data,rx,ry = data
-            image = data[rx,ry,:,:]
-            cal = data.calibration
-    else:
-        raise Exception(f"Invalid entry {data} for argument `data`")
-
-
-    # Get geometry
-    from py4DSTEM.process.virtualimage import get_calibrated_geometry
-    g = get_calibrated_geometry(
-        calibration = cal,
-        mode = mode,
-        geometry = geometry,
-        centered = centered,
-        calibrated = calibrated
-    )
-
-    # Get mask
-    from py4DSTEM.process.virtualimage import make_detector
-    mask = make_detector(image.shape, mode, g)
-    if not(invert):
-        mask = np.logical_not(mask)
-
-    # Shift center
-    if shift_center:
-        try:
-            rx,ry
-        except NameError:
-            raise Exception("if `shift_center` is True then `data` must be the 3-tuple (DataCube,rx,ry)")
-        # get shifts
-        assert cal.get_origin_shift(), "origin shifts need to be calibrated"
-        qx_shift,qy_shift = cal.get_origin_shift()
-        qx_shift = int(np.round(qx_shift[rx,ry]))
-        qy_shift = int(np.round(qy_shift[rx,ry]))
-        mask = np.roll(
-            mask,
-            (qx_shift, qy_shift),
-            axis=(0,1)
-        )
-
-    # Display
-
-    show(
-        image,
-        mask = mask,
-        mask_color = color,
-        mask_alpha = alpha,
-        **kwargs
-    )
-
-    return
-
-
diff --git a/py4DSTEM/visualize/vis_RQ.py b/py4DSTEM/visualize/vis_RQ.py
index 4e6f1d20a..72c50a396 100644
--- a/py4DSTEM/visualize/vis_RQ.py
+++ b/py4DSTEM/visualize/vis_RQ.py
@@ -3,7 +3,6 @@
 from matplotlib.axes import Axes
 
 from py4DSTEM.visualize.show import show,show_points
-from py4DSTEM.process.calibration.rotation import get_Qvector_from_Rvector,get_Rvector_from_Qvector
 
 
 
@@ -79,6 +78,7 @@ def ax_addvector_RtoQ(ax,vx,vy,vlength,x0,y0,QR_rotation,width=1,color='r'):
                                     the counterclockwise rotation of real space
                                     with respect to diffraction space. In degrees.
     """
+    from py4DSTEM.process.calibration.rotation import get_Qvector_from_Rvector
     _,_,vx,vy = get_Qvector_from_Rvector(vx,vy,QR_rotation)
     vx,vy = vx*vlength,vy*vlength
     ax.arrow(y0,x0,vy,vx,color=color,width=width,length_includes_head=True)
@@ -102,6 +102,7 @@ def ax_addvector_QtoR(ax,vx,vy,vlength,x0,y0,QR_rotation,width=1,color='r'):
                                     the counterclockwise rotation of real space
                                     with respect to diffraction space. In degrees.
     """
+    from py4DSTEM.process.calibration.rotation import get_Rvector_from_Qvector
     vx,vy,_,_ = get_Rvector_from_Qvector(vx,vy,QR_rotation)
     vx,vy = vx*vlength,vy*vlength
     ax.arrow(y0,x0,vy,vx,color=color,width=width,length_includes_head=True)
@@ -278,6 +279,7 @@ def ax_addaxes_QtoR(ax,vx,vy,vlength,x0,y0,QR_rotation,width=1,color='r',
                                     the counterclockwise rotation of real space
                                     with respect to diffraction space. In degrees.
     """
+    from py4DSTEM.process.calibration.rotation import get_Rvector_from_Qvector
     vx,vy,_,_ = get_Rvector_from_Qvector(vx,vy,QR_rotation)
     ax_addaxes(ax,vx,vy,vlength,x0,y0,width=width,color=color,labelaxes=labelaxes,
                labelsize=labelsize,labelcolor=labelcolor,righthandedcoords=True)
@@ -304,6 +306,7 @@ def ax_addaxes_RtoQ(ax,vx,vy,vlength,x0,y0,QR_rotation,width=1,color='r',
                                     the counterclockwise rotation of real space
                                     with respect to diffraction space. In degrees.
     """
+    from py4DSTEM.process.calibration.rotation import get_Qvector_from_Rvector
     _,_,vx,vy = get_Qvector_from_Rvector(vx,vy,QR_rotation)
     ax_addaxes(ax,vx,vy,vlength,x0,y0,width=width,color=color,labelaxes=labelaxes,
                labelsize=labelsize,labelcolor=labelcolor,righthandedcoords=True)
diff --git a/py4DSTEM/visualize/vis_special.py b/py4DSTEM/visualize/vis_special.py
index d6ce64cf5..b487048e2 100644
--- a/py4DSTEM/visualize/vis_special.py
+++ b/py4DSTEM/visualize/vis_special.py
@@ -6,10 +6,6 @@
 from scipy.spatial import Voronoi
 
 from emdfile import PointList
-from py4DSTEM.data import DataCube,Calibration
-from py4DSTEM.process.utils import get_voronoi_vertices,convert_ellipse_params
-from py4DSTEM.process.calibration import double_sided_gaussian
-from py4DSTEM.process.latticevectors import get_selected_lattice_vectors
 from py4DSTEM.visualize import show
 from py4DSTEM.visualize.overlay import (
     add_pointlabels,
@@ -24,6 +20,8 @@
 
 
 
+
+
 def show_elliptical_fit(ar,fitradii,p_ellipse,fill=True,
                         color_ann='y',color_ell='r',alpha_ann=0.2,alpha_ell=0.7,
                         linewidth_ann=2,linewidth_ell=2,returnfig=False,**kwargs):
@@ -93,6 +91,8 @@ def show_amorphous_ring_fit(dp,fitradii,p_dsg,N=12,cmap=('gray','gray'),
         ellipse (bool): if True, overlay an ellipse
         returnfig (bool): if True, returns the figure
     """
+    from py4DSTEM.process.calibration import double_sided_gaussian
+    from py4DSTEM.process.utils import convert_ellipse_params
     assert(len(p_dsg)==11)
     assert(isinstance(N,(int,np.integer)))
     if isinstance(cmap,tuple):
@@ -258,6 +258,7 @@ def show_voronoi(ar,x,y,color_points='r',color_lines='w',max_dist=None,
     """
     words
     """
+    from py4DSTEM.process.utils import get_voronoi_vertices
     Nx,Ny = ar.shape
     points = np.vstack((x,y)).T
     voronoi = Voronoi(points)
@@ -604,6 +605,8 @@ def select_lattice_vectors(ar,gx,gy,i0,i1,i2,
         if returnfig==False:    g1,g2
         if returnfig==True      g1,g2,fig,ax
     """
+    from py4DSTEM.process.latticevectors import get_selected_lattice_vectors
+
     # Make the figure
     fig,(ax1,ax2) = plt.subplots(1,2,figsize=figsize)
     show(ar,figax=(fig,ax1),**kwargs)
@@ -702,6 +705,8 @@ def show_origin_meas(data):
     Args:
         data (DataCube or Calibration or 2-tuple of arrays (qx0,qy0))
     """
+    from py4DSTEM.data import Calibration
+    from py4DSTEM.datacube import DataCube
     if isinstance(data,tuple):
         assert len(data)==2
         qx,qy = data
@@ -722,6 +727,8 @@ def show_origin_fit(data):
         data (DataCube or Calibration or (3,2)-tuple of arrays
             ((qx0_meas,qy0_meas),(qx0_fit,qy0_fit),(qx0_residuals,qy0_residuals))
     """
+    from py4DSTEM.data import Calibration
+    from py4DSTEM.datacube import DataCube
     if isinstance(data,tuple):
         assert len(data)==3
         qx0_meas,qy_meas = data[0]
@@ -764,6 +771,7 @@ def show_selected_dps(datacube,positions,im,bragg_pos=None,
         **kwargs (dict): arguments passed to visualize.show for the
             *diffraction patterns*. Default is `scaling='log'`
     """
+    from py4DSTEM.datacube import DataCube
     assert isinstance(datacube,DataCube)
     N = len(positions)
     assert(all([len(x)==2 for x in positions])), "Improperly formated argument `positions`"
diff --git a/test/test_native_io/test_single_object_io.py b/test/test_native_io/test_single_object_io.py
index 6687274c5..d1a826c5f 100644
--- a/test/test_native_io/test_single_object_io.py
+++ b/test/test_native_io/test_single_object_io.py
@@ -7,15 +7,17 @@
 from py4DSTEM import save,read
 import emdfile as emd
 
-from py4DSTEM.data import (
-    DataCube,
+from py4DSTEM import (
     Calibration,
     DiffractionSlice,
     RealSlice,
     QPoints,
+    DataCube,
+    VirtualImage,
+    VirtualDiffraction,
+    BraggVectors,
+    Probe
 )
-from py4DSTEM.process.diskdetection import BraggVectors,Probe
-from py4DSTEM.classes import VirtualDiffraction, VirtualImage
 
 # Set paths
 dirpath = py4DSTEM._TESTPATH

From 8b5e39e846c60dfc5ea89186cfc3b84a34770c99 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Fri, 7 Jul 2023 01:04:25 -0400
Subject: [PATCH 129/362] updates

---
 py4DSTEM/__init__.py                          |  69 ++++++++---
 py4DSTEM/braggvectors/__init__.py             |   9 ++
 .../braggvector_methods.py                    | 115 +++++++++++++++++-
 .../braggvectors.py                           |   2 +-
 .../diskdetection.py                          |  12 +-
 .../diskdetection_aiml.py                     |   8 +-
 .../diskdetection_aiml_cuda.py                |  10 +-
 .../diskdetection_cuda.py                     |   2 +-
 .../diskdetection_parallel.py                 |   0
 .../diskdetection_parallel_new.py             |   2 +-
 .../diskdetection => braggvectors}/kernels.py |   0
 .../multicorr_col_kernel.cu                   |   0
 .../multicorr_row_kernel.cu                   |   0
 .../diskdetection => braggvectors}/probe.py   |   0
 .../probe_gen_methods.py                      |   2 +-
 .../threshold.py                              |   0
 py4DSTEM/braggvectors/virtualimage.py         |  77 ++++++++++++
 py4DSTEM/datacube/datacube.py                 |   4 +-
 py4DSTEM/datacube/virtualimage.py             |  21 ++--
 py4DSTEM/io/legacy/legacy13/v13_to_14.py      |   3 +-
 py4DSTEM/process/__init__.py                  |   1 -
 py4DSTEM/process/calibration/probe.py         |   2 +-
 py4DSTEM/process/diskdetection/__init__.py    |   9 --
 test/test_braggvectors.py                     |   2 +-
 24 files changed, 282 insertions(+), 68 deletions(-)
 create mode 100644 py4DSTEM/braggvectors/__init__.py
 rename py4DSTEM/{process/diskdetection => braggvectors}/braggvector_methods.py (87%)
 rename py4DSTEM/{process/diskdetection => braggvectors}/braggvectors.py (99%)
 rename py4DSTEM/{process/diskdetection => braggvectors}/diskdetection.py (98%)
 rename py4DSTEM/{process/diskdetection => braggvectors}/diskdetection_aiml.py (99%)
 rename py4DSTEM/{process/diskdetection => braggvectors}/diskdetection_aiml_cuda.py (98%)
 rename py4DSTEM/{process/diskdetection => braggvectors}/diskdetection_cuda.py (99%)
 rename py4DSTEM/{process/diskdetection => braggvectors}/diskdetection_parallel.py (100%)
 rename py4DSTEM/{process/diskdetection => braggvectors}/diskdetection_parallel_new.py (99%)
 rename py4DSTEM/{process/diskdetection => braggvectors}/kernels.py (100%)
 rename py4DSTEM/{process/diskdetection => braggvectors}/multicorr_col_kernel.cu (100%)
 rename py4DSTEM/{process/diskdetection => braggvectors}/multicorr_row_kernel.cu (100%)
 rename py4DSTEM/{process/diskdetection => braggvectors}/probe.py (100%)
 rename py4DSTEM/{process/diskdetection => braggvectors}/probe_gen_methods.py (99%)
 rename py4DSTEM/{process/diskdetection => braggvectors}/threshold.py (100%)
 create mode 100644 py4DSTEM/braggvectors/virtualimage.py
 delete mode 100644 py4DSTEM/process/diskdetection/__init__.py

diff --git a/py4DSTEM/__init__.py b/py4DSTEM/__init__.py
index ba086dc27..bf1b0554d 100644
--- a/py4DSTEM/__init__.py
+++ b/py4DSTEM/__init__.py
@@ -2,7 +2,9 @@
 from emdfile import tqdmnd
 
 
-# io classes
+### io
+
+# substructure
 from emdfile import (
     Node,
     Root,
@@ -10,10 +12,20 @@
     Array,
     PointList,
     PointListArray,
-    Custom
+    Custom,
+    print_h5_tree,
 )
+_emd_hook = True
+
+# structure
+from py4DSTEM import io
+from py4DSTEM.io import import_file,read,save
 
-# processing classes
+
+
+### basic data classes
+
+# data
 from py4DSTEM.data import (
     Data,
     Calibration,
@@ -21,47 +33,64 @@
     RealSlice,
     QPoints,
 )
+
+# datacube
 from py4DSTEM.datacube import (
     DataCube,
     VirtualImage
 )
-from py4DSTEM.classes import (
-    VirtualDiffraction,
-)
-from py4DSTEM.process.diskdetection import (
+
+
+
+### visualization
+
+from py4DSTEM import visualize
+from py4DSTEM.visualize import show
+
+
+
+### analysis classes
+
+# braggvectors
+from py4DSTEM.braggvectors import (
     Probe,
     BraggVectors,
     BraggVectorMap,
 )
+
+# TODO - crystal
+# TODO - ptycho
+# TODO - others?
+
+# TODO - where?
 from py4DSTEM.process import (
     PolarDatacube,
 )
 
+# TODO - to datacube
+from py4DSTEM.classes import (
+    VirtualDiffraction,
+)
+
 
 
-# submodules
-from py4DSTEM import io
+### more submodules
+# TODO
+
 from py4DSTEM import preprocess
 from py4DSTEM import process
-from py4DSTEM import classes
-from py4DSTEM import visualize
 
 
 
+### utilities
 
-# functions
-from emdfile import print_h5_tree
-from py4DSTEM.visualize import show
-from py4DSTEM.io import import_file,read,save
+# config
 from py4DSTEM.utils.configuration_checker import check_config
+# TODO - config .toml
 
-
-# test paths
+# testing
 from os.path import dirname,join
 _TESTPATH = join(dirname(__file__), "../test/unit_test_data")
 
 
-# hook for emd _get_class
-_emd_hook = True
-
 
diff --git a/py4DSTEM/braggvectors/__init__.py b/py4DSTEM/braggvectors/__init__.py
new file mode 100644
index 000000000..ed09c04fc
--- /dev/null
+++ b/py4DSTEM/braggvectors/__init__.py
@@ -0,0 +1,9 @@
+from py4DSTEM.braggvectors.probe import Probe
+from py4DSTEM.braggvectors.braggvectors import BraggVectors
+from py4DSTEM.braggvectors.braggvector_methods import BraggVectorMap
+from py4DSTEM.braggvectors.diskdetection import *
+from py4DSTEM.braggvectors.probe import *
+from py4DSTEM.braggvectors.probe_gen_methods import *
+#from .diskdetection_aiml import *
+#from .diskdetection_parallel_new import *
+
diff --git a/py4DSTEM/process/diskdetection/braggvector_methods.py b/py4DSTEM/braggvectors/braggvector_methods.py
similarity index 87%
rename from py4DSTEM/process/diskdetection/braggvector_methods.py
rename to py4DSTEM/braggvectors/braggvector_methods.py
index d55332214..48dbbb17f 100644
--- a/py4DSTEM/process/diskdetection/braggvector_methods.py
+++ b/py4DSTEM/braggvectors/braggvector_methods.py
@@ -22,7 +22,8 @@ def histogram(
         weights_thresh = 0.005,
         ):
         """
-        Returns a 2D histogram of Bragg vector intensities in diffraction space.
+        Returns a 2D histogram of Bragg vector intensities in diffraction space,
+        aka a Bragg vector map.
 
         Parameters
         ----------
@@ -176,6 +177,118 @@ def histogram(
 
 
 
+    # bragg virtual imaging
+
+    def get_virtual_image(
+        self,
+        mode = None,
+        geometry = None,
+        returncalc = True
+        ):
+        '''
+        Calculates a virtual image based on the values of the Braggvectors
+        integrated over some detector function determined by `mode` and
+        `geometry`.
+
+        Parameters
+        ----------
+        mode : str
+            defines the type of detector used. Options:
+              - 'circular', 'circle': uses round detector, like bright field
+              - 'annular', 'annulus': uses annular detector, like dark field
+        geometry : variable
+            expected value depends on the value of `mode`, as follows:
+              - 'circle', 'circular': nested 2-tuple, ((qx,qy),radius)
+              - 'annular' or 'annulus': nested 2-tuple,
+                ((qx,qy),(radius_i,radius_o))
+             All values are in pixels.  Note that (qx,qy) can be skipped, which
+             assumes peaks centered at (0,0)
+
+        Returns
+        -------
+        virtual_im : VirtualImage
+        '''
+        # parse inputs
+        circle_modes = ['circular','circle']
+        annulus_modes = ['annular','annulus']
+        modes = circle_modes + annulus_modes + [None]
+        assert(mode in modes), f"Unrecognized mode {mode}"
+
+        # set geometry
+#         if mode is None:
+#             if geometry is None:
+#                 center = None
+#                 radial_range = np.array((0,np.inf))
+#             else:
+#                 if len(geometry[0]) == 0:
+#                     center = None
+#                 else:
+#                     center = np.array(geometry[0])
+#                 if isinstance(geometry[1], int) or isinstance(geometry[1], float):
+#                     radial_range = np.array((0,geometry[1]))
+#                 elif len(geometry[1]) == 0:
+#                     radial_range = None
+#                 else:
+#                     radial_range = np.array(geometry[1])
+#         elif mode == 'circular' or mode == 'circle':
+#             radial_range = np.array((0,geometry[1]))
+#             if len(geometry[0]) == 0:
+#                     center = None
+#             else:
+#                 center = np.array(geometry[0])
+#         elif mode == 'annular' or mode == 'annulus':
+#             radial_range = np.array(geometry[1])
+#             if len(geometry[0]) == 0:
+#                     center = None
+#             else:
+#                 center = np.array(geometry[0])
+
+
+
+        # allocate space
+        im_virtual = np.zeros(peaks.shape)
+
+        # generate image
+        for rx,ry in tqdmnd(peaks.shape[0],peaks.shape[1]):
+            p = peaks.get_pointlist(rx,ry)
+            if p.data.shape[0] > 0:
+                if radial_range is None:
+                    im_virtual[rx,ry] = np.sum(p.data['intensity'])
+                else:
+                    if center is None:
+                        qr = np.hypot(p.data['qx'],p.data['qy'])
+                    else:
+                        qr = np.hypot(p.data['qx'] - center[0],p.data['qy'] - center[1])
+                    sub = np.logical_and(
+                        qr >= radial_range[0],
+                        qr <  radial_range[1])
+                    if np.sum(sub) > 0:
+                        im_virtual[rx,ry] = np.sum(p.data['intensity'][sub])
+
+#         # generate image
+#         for rx,ry in tqdmnd(peaks.shape[0],peaks.shape[1]):
+#             p = peaks.get_pointlist(rx,ry)
+#             if p.data.shape[0] > 0:
+#                 if radial_range is None:
+#                     im_virtual[rx,ry] = np.sum(p.data['intensity'])
+#                 else:
+#                     if center is None:
+#                         qr = np.hypot(p.data['qx'],p.data['qy'])
+#                     else:
+#                         qr = np.hypot(p.data['qx'] - center[0],p.data['qy'] - center[1])
+#                     sub = np.logical_and(
+#                         qr >= radial_range[0],
+#                         qr <  radial_range[1])
+#                     if np.sum(sub) > 0:
+#                         im_virtual[rx,ry] = np.sum(p.data['intensity'][sub])
+
+        # TODO wrap in VirtualImage
+
+        return im_virtual
+
+
+
+
     # calibration measurements
 
     def measure_origin(
diff --git a/py4DSTEM/process/diskdetection/braggvectors.py b/py4DSTEM/braggvectors/braggvectors.py
similarity index 99%
rename from py4DSTEM/process/diskdetection/braggvectors.py
rename to py4DSTEM/braggvectors/braggvectors.py
index 1b84dc8b6..ebd5e7389 100644
--- a/py4DSTEM/process/diskdetection/braggvectors.py
+++ b/py4DSTEM/braggvectors/braggvectors.py
@@ -2,7 +2,7 @@
 
 from py4DSTEM.data import Data
 from emdfile import Custom,PointListArray,PointList,Metadata
-from py4DSTEM.process.diskdetection.braggvector_methods import BraggVectorMethods
+from py4DSTEM.braggvectors.braggvector_methods import BraggVectorMethods
 from os.path import basename
 import numpy as np
 from warnings import warn
diff --git a/py4DSTEM/process/diskdetection/diskdetection.py b/py4DSTEM/braggvectors/diskdetection.py
similarity index 98%
rename from py4DSTEM/process/diskdetection/diskdetection.py
rename to py4DSTEM/braggvectors/diskdetection.py
index 077b267f7..fb7755349 100644
--- a/py4DSTEM/process/diskdetection/diskdetection.py
+++ b/py4DSTEM/braggvectors/diskdetection.py
@@ -5,12 +5,12 @@
 from scipy.ndimage import gaussian_filter
 
 from emdfile import tqdmnd
-from py4DSTEM.process.diskdetection.braggvectors import BraggVectors
+from py4DSTEM.braggvectors.braggvectors import BraggVectors
 from py4DSTEM.data import QPoints
 from py4DSTEM.datacube import DataCube
 from py4DSTEM.preprocess.utils import get_maxima_2D
 from py4DSTEM.process.utils.cross_correlate import get_cross_correlation_FT
-from py4DSTEM.process.diskdetection.diskdetection_aiml import find_Bragg_disks_aiml
+from py4DSTEM.braggvectors.diskdetection_aiml import find_Bragg_disks_aiml
 
 
 
@@ -573,7 +573,7 @@ def _find_Bragg_disks_CUDA_unbatched(
     ):
 
     # compute
-    from py4DSTEM.process.diskdetection.diskdetection_cuda import find_Bragg_disks_CUDA
+    from py4DSTEM.braggvectors.diskdetection_cuda import find_Bragg_disks_CUDA
     peaks = find_Bragg_disks_CUDA(
         datacube,
         probe,
@@ -619,7 +619,7 @@ def _find_Bragg_disks_CUDA_batched(
     ):
 
     # compute
-    from py4DSTEM.process.diskdetection.diskdetection_cuda import find_Bragg_disks_CUDA
+    from py4DSTEM.braggvectors.diskdetection_cuda import find_Bragg_disks_CUDA
     peaks = find_Bragg_disks_CUDA(
         datacube,
         probe,
@@ -669,7 +669,7 @@ def _find_Bragg_disks_ipp(
     ):
 
     # compute
-    from py4DSTEM.process.diskdetection.diskdetection_parallel import find_Bragg_disks_ipp
+    from py4DSTEM.braggvectors.diskdetection_parallel import find_Bragg_disks_ipp
     peaks = find_Bragg_disks_ipp(
         datacube,
         probe,
@@ -721,7 +721,7 @@ def _find_Bragg_disks_dask(
     ):
 
     # compute
-    from py4DSTEM.process.diskdetection.diskdetection_parallel import find_Bragg_disks_dask
+    from py4DSTEM.braggvectors.diskdetection_parallel import find_Bragg_disks_dask
     peaks = find_Bragg_disks_dask(
         datacube,
         probe,
diff --git a/py4DSTEM/process/diskdetection/diskdetection_aiml.py b/py4DSTEM/braggvectors/diskdetection_aiml.py
similarity index 99%
rename from py4DSTEM/process/diskdetection/diskdetection_aiml.py
rename to py4DSTEM/braggvectors/diskdetection_aiml.py
index 8f82dce9a..6d9bea623 100644
--- a/py4DSTEM/process/diskdetection/diskdetection_aiml.py
+++ b/py4DSTEM/braggvectors/diskdetection_aiml.py
@@ -14,10 +14,10 @@
 from numbers import Number
 
 from emdfile import tqdmnd, PointList, PointListArray
-from py4DSTEM.process.diskdetection.braggvectors import BraggVectors
+from py4DSTEM.braggvectors.braggvectors import BraggVectors
 from py4DSTEM.data import QPoints
 from py4DSTEM.process.utils import get_maxima_2D
-# from py4DSTEM.process.diskdetection import universal_threshold
+# from py4DSTEM.braggvectors import universal_threshold
 
 def find_Bragg_disks_aiml_single_DP(DP, probe,
                                      num_attempts = 5,
@@ -430,7 +430,7 @@ def find_Bragg_disks_aiml_serial(datacube, probe,
                                                                    int(t2/60), int(t2%60)))
 
     if global_threshold == True:
-        from py4DSTEM.process.diskdetection import universal_threshold
+        from py4DSTEM.braggvectors import universal_threshold
 
         peaks = universal_threshold(peaks, minGlobalIntensity, metric, minPeakSpacing,
                                     maxNumPeaks)
@@ -624,7 +624,7 @@ def _parse_distributed(distributed):
                                                 name=name,
                                                 filter_function=filter_function)
         elif _check_cuda_device_available():
-            from py4DSTEM.process.diskdetection.diskdetection_aiml_cuda import find_Bragg_disks_aiml_CUDA
+            from py4DSTEM.braggvectors.diskdetection_aiml_cuda import find_Bragg_disks_aiml_CUDA
             return find_Bragg_disks_aiml_CUDA(datacube,
                                               probe,
                                               num_attempts = num_attempts,
diff --git a/py4DSTEM/process/diskdetection/diskdetection_aiml_cuda.py b/py4DSTEM/braggvectors/diskdetection_aiml_cuda.py
similarity index 98%
rename from py4DSTEM/process/diskdetection/diskdetection_aiml_cuda.py
rename to py4DSTEM/braggvectors/diskdetection_aiml_cuda.py
index fbc9339a0..d714feda9 100644
--- a/py4DSTEM/process/diskdetection/diskdetection_aiml_cuda.py
+++ b/py4DSTEM/braggvectors/diskdetection_aiml_cuda.py
@@ -7,12 +7,12 @@
 from time import time
 
 from emdfile import tqdmnd
-from py4DSTEM.process.diskdetection.braggvectors import BraggVectors
+from py4DSTEM.braggvectors.braggvectors import BraggVectors
 from emdfile import PointList, PointListArray
 from py4DSTEM.data import QPoints
-from py4DSTEM.process.diskdetection.kernels import kernels
-from py4DSTEM.process.diskdetection.diskdetection_aiml import _get_latest_model
-# from py4DSTEM.process.diskdetection.diskdetection import universal_threshold
+from py4DSTEM.braggvectors.kernels import kernels
+from py4DSTEM.braggvectors.diskdetection_aiml import _get_latest_model
+# from py4DSTEM.braggvectors.diskdetection import universal_threshold
 
 try:
     import cupy as cp
@@ -195,7 +195,7 @@ def find_Bragg_disks_aiml_CUDA(datacube, probe,
     print("Analyzed {} diffraction patterns in {}h {}m {}s".format(datacube.R_N, int(t2/3600),
                                                                    int(t2/60), int(t2%60)))
     if global_threshold == True:
-        from py4DSTEM.process.diskdetection import universal_threshold
+        from py4DSTEM.braggvectors import universal_threshold
         peaks = universal_threshold(peaks, minGlobalIntensity, metric, minPeakSpacing,
                                     maxNumPeaks)
     peaks.name = name
diff --git a/py4DSTEM/process/diskdetection/diskdetection_cuda.py b/py4DSTEM/braggvectors/diskdetection_cuda.py
similarity index 99%
rename from py4DSTEM/process/diskdetection/diskdetection_cuda.py
rename to py4DSTEM/braggvectors/diskdetection_cuda.py
index df5793b47..b912bde48 100644
--- a/py4DSTEM/process/diskdetection/diskdetection_cuda.py
+++ b/py4DSTEM/braggvectors/diskdetection_cuda.py
@@ -12,7 +12,7 @@
 
 from emdfile import tqdmnd
 from py4DSTEM import PointList, PointListArray
-from py4DSTEM.process.diskdetection.kernels import kernels
+from py4DSTEM.braggvectors.kernels import kernels
 
 
 def find_Bragg_disks_CUDA(
diff --git a/py4DSTEM/process/diskdetection/diskdetection_parallel.py b/py4DSTEM/braggvectors/diskdetection_parallel.py
similarity index 100%
rename from py4DSTEM/process/diskdetection/diskdetection_parallel.py
rename to py4DSTEM/braggvectors/diskdetection_parallel.py
diff --git a/py4DSTEM/process/diskdetection/diskdetection_parallel_new.py b/py4DSTEM/braggvectors/diskdetection_parallel_new.py
similarity index 99%
rename from py4DSTEM/process/diskdetection/diskdetection_parallel_new.py
rename to py4DSTEM/braggvectors/diskdetection_parallel_new.py
index af011cb8e..241cae2f7 100644
--- a/py4DSTEM/process/diskdetection/diskdetection_parallel_new.py
+++ b/py4DSTEM/braggvectors/diskdetection_parallel_new.py
@@ -18,7 +18,7 @@
 
 import py4DSTEM
 from emdfile import PointListArray, PointList
-from py4DSTEM.process.diskdetection.diskdetection import _find_Bragg_disks_single_DP_FK
+from py4DSTEM.braggvectors.diskdetection import _find_Bragg_disks_single_DP_FK
 
 
 
diff --git a/py4DSTEM/process/diskdetection/kernels.py b/py4DSTEM/braggvectors/kernels.py
similarity index 100%
rename from py4DSTEM/process/diskdetection/kernels.py
rename to py4DSTEM/braggvectors/kernels.py
diff --git a/py4DSTEM/process/diskdetection/multicorr_col_kernel.cu b/py4DSTEM/braggvectors/multicorr_col_kernel.cu
similarity index 100%
rename from py4DSTEM/process/diskdetection/multicorr_col_kernel.cu
rename to py4DSTEM/braggvectors/multicorr_col_kernel.cu
diff --git a/py4DSTEM/process/diskdetection/multicorr_row_kernel.cu b/py4DSTEM/braggvectors/multicorr_row_kernel.cu
similarity index 100%
rename from py4DSTEM/process/diskdetection/multicorr_row_kernel.cu
rename to py4DSTEM/braggvectors/multicorr_row_kernel.cu
diff --git a/py4DSTEM/process/diskdetection/probe.py b/py4DSTEM/braggvectors/probe.py
similarity index 100%
rename from py4DSTEM/process/diskdetection/probe.py
rename to py4DSTEM/braggvectors/probe.py
diff --git a/py4DSTEM/process/diskdetection/probe_gen_methods.py b/py4DSTEM/braggvectors/probe_gen_methods.py
similarity index 99%
rename from py4DSTEM/process/diskdetection/probe_gen_methods.py
rename to py4DSTEM/braggvectors/probe_gen_methods.py
index e40208a11..a6afb1506 100644
--- a/py4DSTEM/process/diskdetection/probe_gen_methods.py
+++ b/py4DSTEM/braggvectors/probe_gen_methods.py
@@ -6,7 +6,7 @@
 
 from emdfile import tqdmnd
 from py4DSTEM.datacube import DataCube
-from py4DSTEM.process.diskdetection import Probe
+from py4DSTEM.braggvectors import Probe
 from py4DSTEM.process.utils import get_shifted_ar, get_shift
 
 
diff --git a/py4DSTEM/process/diskdetection/threshold.py b/py4DSTEM/braggvectors/threshold.py
similarity index 100%
rename from py4DSTEM/process/diskdetection/threshold.py
rename to py4DSTEM/braggvectors/threshold.py
diff --git a/py4DSTEM/braggvectors/virtualimage.py b/py4DSTEM/braggvectors/virtualimage.py
new file mode 100644
index 000000000..0bfd9eb61
--- /dev/null
+++ b/py4DSTEM/braggvectors/virtualimage.py
@@ -0,0 +1,77 @@
+import numpy as np
+from emdfile import tqdmnd
+
+
+
+
+
+
+## TODO
+
+
+def make_bragg_mask(
+    Qshape,
+    g1,
+    g2,
+    radius,
+    origin,
+    max_q,
+    return_sum = True,
+    **kwargs,
+    ):
+    '''
+    Creates and returns a mask consisting of circular disks
+    about the points of a 2D lattice.
+
+    Args:
+        Qshape (2 tuple): the shape of diffraction space
+        g1,g2 (len 2 array or tuple): the lattice vectors
+        radius (number): the disk radius
+        origin (len 2 array or tuple): the origin
+        max_q (nuumber): the maxima distance to tile to
+        return_sum (bool): if False, return a 3D array, where each
+            slice contains a single disk; if False, return a single
+            2D masks of all disks
+
+    Returns:
+        (2 or 3D array) the mask
+    '''
+    nas = np.asarray
+    g1,g2,origin = nas(g1),nas(g2),nas(origin)
+
+    # Get N,M, the maximum indices to tile out to
+    L1 = np.sqrt(np.sum(g1**2))
+    H = int(max_q/L1) + 1
+    L2 = np.hypot(-g2[0]*g1[1],g2[1]*g1[0])/np.sqrt(np.sum(g1**2))
+    K = int(max_q/L2) + 1
+
+    # Compute number of points
+    N = 0
+    for h in range(-H,H+1):
+        for k in range(-K,K+1):
+            v = h*g1 + k*g2
+            if np.sqrt(v.dot(v)) < max_q:
+                N += 1
+
+    #create mask
+    mask = np.zeros((Qshape[0], Qshape[1], N), dtype=bool)
+    N = 0
+    for h in range(-H,H+1):
+        for k in range(-K,K+1):
+            v = h*g1 + k*g2
+            if np.sqrt(v.dot(v)) < max_q:
+                center = origin + v
+                mask[:,:,N] = make_detector(
+                    Qshape,
+                    mode = 'circle',
+                    geometry = (center, radius),
+                )
+                N += 1
+
+
+    if return_sum:
+        mask = np.sum(mask, axis = 2)
+    return mask
+
+
+
diff --git a/py4DSTEM/datacube/datacube.py b/py4DSTEM/datacube/datacube.py
index d5da96fc6..55428bddc 100644
--- a/py4DSTEM/datacube/datacube.py
+++ b/py4DSTEM/datacube/datacube.py
@@ -1003,7 +1003,7 @@ def get_vacuum_probe(
             the vacuum probe
         """
         from py4DSTEM.process.utils import get_shifted_ar, get_shift
-        from py4DSTEM.process.diskdetection import Probe
+        from py4DSTEM.braggvectors import Probe
 
         # parse region to use
         if ROI is None:
@@ -1319,7 +1319,7 @@ def find_Bragg_disks(
         variable
             See above.
         """
-        from py4DSTEM.process.diskdetection import find_Bragg_disks
+        from py4DSTEM.braggvectors import find_Bragg_disks
 
         sigma_cc = sigma if sigma is not None else sigma_cc
 
diff --git a/py4DSTEM/datacube/virtualimage.py b/py4DSTEM/datacube/virtualimage.py
index ae0b67b62..3d721431b 100644
--- a/py4DSTEM/datacube/virtualimage.py
+++ b/py4DSTEM/datacube/virtualimage.py
@@ -1,11 +1,8 @@
-# Methods and classes for generating virtual images
-
-# includes
-# --------
-# VirtualImage - a container for virtual image data + metadata
-# DataCubeVirtualImager - methods inherited by DataCube for virt imaging
-# BraggVectorsVirtualImager - methods inherited by BraggVectors for virt imaging
-
+# Virtual imaging from a datacube. Includes:
+#  * VirtualImage - a container for virtual image data + metadata
+#  * DataCubeVirtualImager - methods inherited by DataCube for virt imaging
+#
+# for bragg virtual imaging methods, goto diskdetection.virtualimage.py
 
 import numpy as np
 import dask.array as da
@@ -17,8 +14,7 @@
 
 
 
-# Virtual image class
-# a container for the final virtual image data/metadata
+# Virtual image container class
 
 class VirtualImage(RealSlice,Data):
     """
@@ -63,9 +59,7 @@ def _get_constructor_args(cls,group):
 
 
 
-# DataCubeVirtualImage class
-# inherited by DataCube, adding the methods performing
-# virtual image computations
+# DataCube virtual imaging methods
 
 class DataCubeVirtualImager:
 
@@ -820,3 +814,4 @@ def get_virtual_image_braggvectors(
         )
 
     return virtual_image
+
diff --git a/py4DSTEM/io/legacy/legacy13/v13_to_14.py b/py4DSTEM/io/legacy/legacy13/v13_to_14.py
index 5ac2a843a..825892fa9 100644
--- a/py4DSTEM/io/legacy/legacy13/v13_to_14.py
+++ b/py4DSTEM/io/legacy/legacy13/v13_to_14.py
@@ -50,7 +50,6 @@
 from py4DSTEM.classes import (
     VirtualDiffraction,
 )
-from py4DSTEM.process.diskdetection import BraggVectors, Probe
 
 
 
@@ -179,6 +178,7 @@ def _v13_to_14_cls(obj):
         pass
 
     elif isinstance(obj, Probe13):
+        from py4DSTEM.braggvectors import Probe
         x = Probe(
             name = obj.name,
             data = obj.data
@@ -191,6 +191,7 @@ def _v13_to_14_cls(obj):
         )
 
     elif isinstance(obj, BraggVectors13):
+        from py4DSTEM.braggvectors import BraggVectors
         x = BraggVectors(
             name = obj.name,
             Rshape = obj.Rshape,
diff --git a/py4DSTEM/process/__init__.py b/py4DSTEM/process/__init__.py
index 510870f50..833466cd3 100644
--- a/py4DSTEM/process/__init__.py
+++ b/py4DSTEM/process/__init__.py
@@ -1,6 +1,5 @@
 from py4DSTEM.process.polar import PolarDatacube
 
-from py4DSTEM.process import diskdetection
 from py4DSTEM.process import virtualdiffraction
 from py4DSTEM.process import latticevectors
 from py4DSTEM.process import phase
diff --git a/py4DSTEM/process/calibration/probe.py b/py4DSTEM/process/calibration/probe.py
index 8d9a87ae2..c239590c5 100644
--- a/py4DSTEM/process/calibration/probe.py
+++ b/py4DSTEM/process/calibration/probe.py
@@ -34,7 +34,7 @@ def get_probe_size(DP, thresh_lower=0.01, thresh_upper=0.99, N=100):
             * **x0**: *(float)* the x position of the central disk center
             * **y0**: *(float)* the y position of the central disk center
     """
-    from py4DSTEM.process.diskdetection import Probe
+    from py4DSTEM.braggvectors import Probe
 
     # parse input
     if isinstance(DP,Probe):
diff --git a/py4DSTEM/process/diskdetection/__init__.py b/py4DSTEM/process/diskdetection/__init__.py
deleted file mode 100644
index 6ea191fbd..000000000
--- a/py4DSTEM/process/diskdetection/__init__.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from py4DSTEM.process.diskdetection.probe import Probe
-from py4DSTEM.process.diskdetection.braggvectors import BraggVectors
-from py4DSTEM.process.diskdetection.braggvector_methods import BraggVectorMap
-from py4DSTEM.process.diskdetection.diskdetection import *
-from py4DSTEM.process.diskdetection.probe import * 
-from py4DSTEM.process.diskdetection.probe_gen_methods import * 
-#from .diskdetection_aiml import *
-#from .diskdetection_parallel_new import *
-
diff --git a/test/test_braggvectors.py b/test/test_braggvectors.py
index f250f7a0f..36ec138a0 100644
--- a/test/test_braggvectors.py
+++ b/test/test_braggvectors.py
@@ -61,7 +61,7 @@ def setup_class(cls):
 
     def test_BraggVectors_import(self):
 
-        from py4DSTEM.process.diskdetection import BraggVectors
+        from py4DSTEM.braggvectors import BraggVectors
         pass
 
 

From edf163914bd3e0666423729ff7f31660aab11b47 Mon Sep 17 00:00:00 2001
From: gvarnavi <gvarnavi@mit.edu>
Date: Fri, 7 Jul 2023 08:59:18 -0700
Subject: [PATCH 130/362] ptychoptimize formatting

---
 py4DSTEM/process/phase/__init__.py           |  1 +
 py4DSTEM/process/phase/parameter_optimize.py | 97 ++++++++++++--------
 2 files changed, 58 insertions(+), 40 deletions(-)

diff --git a/py4DSTEM/process/phase/__init__.py b/py4DSTEM/process/phase/__init__.py
index 207e44b56..ee542524f 100644
--- a/py4DSTEM/process/phase/__init__.py
+++ b/py4DSTEM/process/phase/__init__.py
@@ -10,5 +10,6 @@
 from py4DSTEM.process.phase.iterative_parallax import ParallaxReconstruction
 from py4DSTEM.process.phase.iterative_simultaneous_ptychography import SimultaneousPtychographicReconstruction
 from py4DSTEM.process.phase.iterative_singleslice_ptychography import SingleslicePtychographicReconstruction
+from py4DSTEM.process.phase.utils import OptimizationParameter, PtychographyOptimizer
 
 # fmt: on
diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index f871a3a0e..da1cf3d7b 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -22,7 +22,7 @@
 class PtychographyOptimizer:
     """
     Optimize ptychographic hyperparameters with Bayesian Optimization of a
-    Gaussian process. Any of the scalar-valued real or integer,  boolean, or categorical 
+    Gaussian process. Any of the scalar-valued real or integer,  boolean, or categorical
     arguments to the ptychographic init-preprocess-reconstruct pipeline can be optimized over.
     """
 
@@ -135,7 +135,7 @@ def optimize(
                 'std': negative standard deviation of cropped object
                 'std-phase': negative standard deviation of
                     phase of the cropped object
-                'entropy-phase': entropy of the phase of the 
+                'entropy-phase': entropy of the phase of the
                     cropped object
             When passed as a Callable, a function that takes the
                 PhaseReconstruction object as its only argument
@@ -216,49 +216,54 @@ def visualize(
         if ndims == 1:
             if plot_convergence:
                 figsize = kwargs.pop("figsize", (9, 9))
-                spec = GridSpec(nrows=2,ncols=1,height_ratios=[2,1], hspace=0.15)
+                spec = GridSpec(nrows=2, ncols=1, height_ratios=[2, 1], hspace=0.15)
             else:
                 figsize = kwargs.pop("figsize", (9, 6))
-                spec = GridSpec(nrows=1,ncols=1)
+                spec = GridSpec(nrows=1, ncols=1)
 
-            fig = plt.figure(figsize = figsize)
+            fig = plt.figure(figsize=figsize)
             ax = fig.add_subplot(spec[0])
-            skopt_plot_gaussian_process(self._skopt_result,ax=ax, **kwargs)
+            skopt_plot_gaussian_process(self._skopt_result, ax=ax, **kwargs)
 
             if plot_convergence:
                 ax = fig.add_subplot(spec[1])
-                skopt_plot_convergence(self._skopt_result,ax=ax)
+                skopt_plot_convergence(self._skopt_result, ax=ax)
 
         else:
             if plot_convergence:
-                figsize = kwargs.pop("figsize", (4*ndims, 4*(ndims+0.5)))
-                spec = GridSpec(nrows=ndims+1,ncols=ndims,height_ratios=[2]*ndims+[1], hspace=0.15)
+                figsize = kwargs.pop("figsize", (4 * ndims, 4 * (ndims + 0.5)))
+                spec = GridSpec(
+                    nrows=ndims + 1,
+                    ncols=ndims,
+                    height_ratios=[2] * ndims + [1],
+                    hspace=0.15,
+                )
             else:
-                figsize = kwargs.pop("figsize", (4*ndims, 4*ndims))
-                spec = GridSpec(nrows=ndims,ncols=ndims, hspace=0.15)
+                figsize = kwargs.pop("figsize", (4 * ndims, 4 * ndims))
+                spec = GridSpec(nrows=ndims, ncols=ndims, hspace=0.15)
 
             if plot_evaluations:
                 axs = skopt_plot_evaluations(self._skopt_result)
             elif plot_objective:
-                cmap = kwargs.pop("cmap", 'magma')
-                axs = skopt_plot_objective(self._skopt_result, cmap=cmap,**kwargs)
+                cmap = kwargs.pop("cmap", "magma")
+                axs = skopt_plot_objective(self._skopt_result, cmap=cmap, **kwargs)
             elif plot_convergence:
                 skopt_plot_convergence(self._skopt_result)
                 return self
 
-            fig = axs[0,0].figure
+            fig = axs[0, 0].figure
             fig.set_size_inches(figsize)
             for i in range(ndims):
                 for j in range(ndims):
-                    ax = axs[i,j]
+                    ax = axs[i, j]
                     ax.remove()
                     ax.figure = fig
                     fig.add_axes(ax)
-                    ax.set_subplotspec(spec[i,j])
+                    ax.set_subplotspec(spec[i, j])
 
             if plot_convergence:
-                ax = fig.add_subplot(spec[ndims,:])
-                skopt_plot_convergence(self._skopt_result,ax=ax)
+                ax = fig.add_subplot(spec[ndims, :])
+                skopt_plot_convergence(self._skopt_result, ax=ax)
 
         spec.tight_layout(fig)
 
@@ -275,14 +280,20 @@ def get_optimized_arguments(self):
             where the OptimizationParameter items have been replaced with the optimal
             values obtained from the optimizer
         """
-        optimized_dict = {p.name: v for p,v in zip(self._parameter_list,self._skopt_result.x)}
-        
-        filtered_dict = { k: v for k,v in optimized_dict.items() if k in self._init_args }
+        optimized_dict = {
+            p.name: v for p, v in zip(self._parameter_list, self._skopt_result.x)
+        }
+
+        filtered_dict = {
+            k: v for k, v in optimized_dict.items() if k in self._init_args
+        }
         init_opt = self._init_args | filtered_dict
-        
-        filtered_dict = { k: v for k,v in optimized_dict.items() if k in self._affine_args }
+
+        filtered_dict = {
+            k: v for k, v in optimized_dict.items() if k in self._affine_args
+        }
         affine_opt = self._affine_args | filtered_dict
-        
+
         affine_transform = partial(AffineTransform, **self._affine_static_args)(
             **affine_opt
         )
@@ -290,13 +301,17 @@ def get_optimized_arguments(self):
             affine_transform, init_opt["datacube"]
         )
         init_opt["initial_scan_positions"] = scan_positions
-        
-        filtered_dict = { k: v for k,v in optimized_dict.items() if k in self._preprocess_args }
+
+        filtered_dict = {
+            k: v for k, v in optimized_dict.items() if k in self._preprocess_args
+        }
         prep_opt = self._preprocess_args | filtered_dict
-        
-        filtered_dict = { k: v for k,v in optimized_dict.items() if k in self._reconstruction_args }
+
+        filtered_dict = {
+            k: v for k, v in optimized_dict.items() if k in self._reconstruction_args
+        }
         reco_opt = self._reconstruction_args | filtered_dict
-        
+
         return init_opt, prep_opt, reco_opt
 
     def _split_static_and_optimization_vars(self, argdict):
@@ -385,10 +400,13 @@ def f(ptycho):
                 return -np.std(np.angle(ptycho.object_cropped))
 
         elif error_metric == "entropy-phase":
+
             def f(ptycho):
                 obj = np.angle(ptycho.object_cropped)
-                gx,gy = np.gradient(obj)
-                ghist,_,_ = np.histogram2d(gx.ravel(),gy.ravel(),bins=obj.shape,density=True)
+                gx, gy = np.gradient(obj)
+                ghist, _, _ = np.histogram2d(
+                    gx.ravel(), gy.ravel(), bins=obj.shape, density=True
+                )
                 nz = ghist > 0
                 S = np.sum(ghist[nz] * np.log2(ghist[nz]))
                 return S
@@ -482,14 +500,14 @@ def f(**kwargs):
 
     def _set_optimizer_defaults(
         self,
-        verbose = False,
-        plot_center_of_mass = False,
-        plot_rotation = False,
-        plot_probe_overlaps = False,
-        progress_bar = False,
-        store_iterations = False,
-        reset = True,
-        ):
+        verbose=False,
+        plot_center_of_mass=False,
+        plot_rotation=False,
+        plot_probe_overlaps=False,
+        progress_bar=False,
+        store_iterations=False,
+        reset=True,
+    ):
         """
         Set all of the verbose and plotting to False, allowing for user-overwrite.
         """
@@ -539,7 +557,6 @@ def __init__(
         if space not in ("real", "integer", "bool", "categorical"):
             raise ValueError(f"Unknown Parameter type: {space}")
 
-
         scaling = scaling.lower()
         if scaling not in ("uniform", "log-uniform"):
             raise ValueError(f"Unknown scaling: {scaling}")

From f653ff1cb1bebc6d1733f04f2ea9fe85f08d383e Mon Sep 17 00:00:00 2001
From: gvarnavi <gvarnavi@mit.edu>
Date: Fri, 7 Jul 2023 09:00:23 -0700
Subject: [PATCH 131/362] ptychoptimize imports ordering

---
 py4DSTEM/process/phase/parameter_optimize.py | 27 +++++++++-----------
 1 file changed, 12 insertions(+), 15 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index da1cf3d7b..91a71cb30 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -1,22 +1,19 @@
-from tqdm import tqdm
-from skopt import gp_minimize
-from skopt.space import Real, Integer, Categorical
-from skopt.plots import (
-    plot_convergence as skopt_plot_convergence,
-    plot_gaussian_process as skopt_plot_gaussian_process,
-    plot_evaluations as skopt_plot_evaluations,
-    plot_objective as skopt_plot_objective,
-)
-from skopt.utils import use_named_args
-import matplotlib.pyplot as plt
-from matplotlib.gridspec import GridSpec
-import numpy as np
-
 from functools import partial
-from typing import Union, Callable
+from typing import Callable, Union
 
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.gridspec import GridSpec
 from py4DSTEM.process.phase.iterative_base_class import PhaseReconstruction
 from py4DSTEM.process.phase.utils import AffineTransform
+from skopt import gp_minimize
+from skopt.plots import plot_convergence as skopt_plot_convergence
+from skopt.plots import plot_evaluations as skopt_plot_evaluations
+from skopt.plots import plot_gaussian_process as skopt_plot_gaussian_process
+from skopt.plots import plot_objective as skopt_plot_objective
+from skopt.space import Categorical, Integer, Real
+from skopt.utils import use_named_args
+from tqdm import tqdm
 
 
 class PtychographyOptimizer:

From 20494d11b4270b0a2ed8b434a0f51dc09bf3a8a4 Mon Sep 17 00:00:00 2001
From: gvarnavi <gvarnavi@mit.edu>
Date: Fri, 7 Jul 2023 09:03:57 -0700
Subject: [PATCH 132/362] init bugfix

---
 py4DSTEM/process/phase/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/process/phase/__init__.py b/py4DSTEM/process/phase/__init__.py
index ee542524f..cb9176375 100644
--- a/py4DSTEM/process/phase/__init__.py
+++ b/py4DSTEM/process/phase/__init__.py
@@ -10,6 +10,6 @@
 from py4DSTEM.process.phase.iterative_parallax import ParallaxReconstruction
 from py4DSTEM.process.phase.iterative_simultaneous_ptychography import SimultaneousPtychographicReconstruction
 from py4DSTEM.process.phase.iterative_singleslice_ptychography import SingleslicePtychographicReconstruction
-from py4DSTEM.process.phase.utils import OptimizationParameter, PtychographyOptimizer
+from py4DSTEM.process.phase.parameter_optimize import OptimizationParameter, PtychographyOptimizer
 
 # fmt: on

From a57cfe39efab88976cdc77e18d66773f4ee82639 Mon Sep 17 00:00:00 2001
From: gvarnavi <gvarnavi@mit.edu>
Date: Fri, 7 Jul 2023 09:36:17 -0700
Subject: [PATCH 133/362] making generalized-projections
 ptychoptimize-compatible

---
 .../iterative_mixedstate_ptychography.py      | 30 +++++++++++++----
 .../iterative_multislice_ptychography.py      | 32 +++++++++++++------
 .../iterative_overlap_magnetic_tomography.py  | 32 +++++++++++++------
 .../phase/iterative_overlap_tomography.py     | 32 +++++++++++++------
 .../iterative_simultaneous_ptychography.py    | 30 +++++++++++++----
 .../iterative_singleslice_ptychography.py     | 30 +++++++++++++----
 6 files changed, 138 insertions(+), 48 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
index 8d4574aa4..3450d1b13 100644
--- a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
@@ -1259,6 +1259,9 @@ def reconstruct(
         max_iter: int = 64,
         reconstruction_method: str = "gradient-descent",
         reconstruction_parameter: float = 1.0,
+        reconstruction_parameter_a: float = None,
+        reconstruction_parameter_b: float = None,
+        reconstruction_parameter_c: float = None,
         max_batch_size: int = None,
         seed_random: int = None,
         step_size: float = 0.5,
@@ -1303,7 +1306,7 @@ def reconstruct(
             Maximum number of iterations to run
         reconstruction_method: str, optional
             Specifies which reconstruction algorithm to use, one of:
-            "generalized-projection",
+            "generalized-projections",
             "DM_AP" (or "difference-map_alternating-projections"),
             "RAAR" (or "relaxed-averaged-alternating-reflections"),
             "RRR" (or "relax-reflect-reflect"),
@@ -1311,6 +1314,12 @@ def reconstruct(
             "GD" (or "gradient_descent")
         reconstruction_parameter: float, optional
             Reconstruction parameter for various reconstruction methods above.
+        reconstruction_parameter_a: float, optional
+            Reconstruction parameter a for reconstruction_method='generalized-projections'.
+        reconstruction_parameter_b: float, optional
+            Reconstruction parameter b for reconstruction_method='generalized-projections'.
+        reconstruction_parameter_c: float, optional
+            Reconstruction parameter c for reconstruction_method='generalized-projections'.
         max_batch_size: int, optional
             Max number of probes to update at once
         seed_random: int, optional
@@ -1390,17 +1399,23 @@ def reconstruct(
 
         # Reconstruction method
 
-        if reconstruction_method == "generalized-projection":
-            if np.array(reconstruction_parameter).shape != (3,):
+        if reconstruction_method == "generalized-projections":
+            if (
+                reconstruction_parameter_a is None
+                or reconstruction_parameter_b is None
+                or reconstruction_parameter_c is None
+            ):
                 raise ValueError(
                     (
-                        "reconstruction_parameter must be a list of three numbers "
-                        "when using `reconstriction_method`=generalized-projection."
+                        "reconstruction_parameter_a/b/c must all be specified "
+                        "when using reconstruction_method='generalized-projections'."
                     )
                 )
 
             use_projection_scheme = True
-            projection_a, projection_b, projection_c = reconstruction_parameter
+            projection_a = reconstruction_parameter_a
+            projection_b = reconstruction_parameter_b
+            projection_c = reconstruction_parameter_c
             step_size = None
         elif (
             reconstruction_method == "DM_AP"
@@ -1459,7 +1474,8 @@ def reconstruct(
         else:
             raise ValueError(
                 (
-                    "reconstruction_method must be one of 'DM_AP' (or 'difference-map_alternating-projections'), "
+                    "reconstruction_method must be one of 'generalized-projections', "
+                    "'DM_AP' (or 'difference-map_alternating-projections'), "
                     "'RAAR' (or 'relaxed-averaged-alternating-reflections'), "
                     "'RRR' (or 'relax-reflect-reflect'), "
                     "'SUPERFLIP' (or 'charge-flipping'), "
diff --git a/py4DSTEM/process/phase/iterative_multislice_ptychography.py b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
index 36b44b77e..f9f8c2d29 100644
--- a/py4DSTEM/process/phase/iterative_multislice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
@@ -1653,6 +1653,9 @@ def reconstruct(
         max_iter: int = 64,
         reconstruction_method: str = "gradient-descent",
         reconstruction_parameter: float = 1.0,
+        reconstruction_parameter_a: float = None,
+        reconstruction_parameter_b: float = None,
+        reconstruction_parameter_c: float = None,
         max_batch_size: int = None,
         seed_random: int = None,
         step_size: float = 0.5,
@@ -1703,7 +1706,7 @@ def reconstruct(
             Maximum number of iterations to run
         reconstruction_method: str, optional
             Specifies which reconstruction algorithm to use, one of:
-            "generalized-projection",
+            "generalized-projections",
             "DM_AP" (or "difference-map_alternating-projections"),
             "RAAR" (or "relaxed-averaged-alternating-reflections"),
             "RRR" (or "relax-reflect-reflect"),
@@ -1711,8 +1714,12 @@ def reconstruct(
             "GD" (or "gradient_descent")
         reconstruction_parameter: float, optional
             Reconstruction parameter for various reconstruction methods above.
-        reconstruction_parameter: float, optional
-            Tuning parameter to interpolate b/w DM-AP and DM-RAAR
+        reconstruction_parameter_a: float, optional
+            Reconstruction parameter a for reconstruction_method='generalized-projections'.
+        reconstruction_parameter_b: float, optional
+            Reconstruction parameter b for reconstruction_method='generalized-projections'.
+        reconstruction_parameter_c: float, optional
+            Reconstruction parameter c for reconstruction_method='generalized-projections'.
         max_batch_size: int, optional
             Max number of probes to update at once
         seed_random: int, optional
@@ -1804,17 +1811,23 @@ def reconstruct(
 
         # Reconstruction method
 
-        if reconstruction_method == "generalized-projection":
-            if np.array(reconstruction_parameter).shape != (3,):
+        if reconstruction_method == "generalized-projections":
+            if (
+                reconstruction_parameter_a is None
+                or reconstruction_parameter_b is None
+                or reconstruction_parameter_c is None
+            ):
                 raise ValueError(
                     (
-                        "reconstruction_parameter must be a list of three numbers "
-                        "when using `reconstriction_method`=generalized-projection."
+                        "reconstruction_parameter_a/b/c must all be specified "
+                        "when using reconstruction_method='generalized-projections'."
                     )
                 )
 
             use_projection_scheme = True
-            projection_a, projection_b, projection_c = reconstruction_parameter
+            projection_a = reconstruction_parameter_a
+            projection_b = reconstruction_parameter_b
+            projection_c = reconstruction_parameter_c
             step_size = None
         elif (
             reconstruction_method == "DM_AP"
@@ -1873,7 +1886,8 @@ def reconstruct(
         else:
             raise ValueError(
                 (
-                    "reconstruction_method must be one of 'DM_AP' (or 'difference-map_alternating-projections'), "
+                    "reconstruction_method must be one of 'generalized-projections', "
+                    "'DM_AP' (or 'difference-map_alternating-projections'), "
                     "'RAAR' (or 'relaxed-averaged-alternating-reflections'), "
                     "'RRR' (or 'relax-reflect-reflect'), "
                     "'SUPERFLIP' (or 'charge-flipping'), "
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 7497183da..0c751cd33 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -1877,6 +1877,9 @@ def reconstruct(
         max_iter: int = 64,
         reconstruction_method: str = "gradient-descent",
         reconstruction_parameter: float = 1.0,
+        reconstruction_parameter_a: float = None,
+        reconstruction_parameter_b: float = None,
+        reconstruction_parameter_c: float = None,
         max_batch_size: int = None,
         seed_random: int = None,
         step_size: float = 0.5,
@@ -1923,7 +1926,7 @@ def reconstruct(
             Maximum number of iterations to run
         reconstruction_method: str, optional
             Specifies which reconstruction algorithm to use, one of:
-            "generalized-projection",
+            "generalized-projections",
             "DM_AP" (or "difference-map_alternating-projections"),
             "RAAR" (or "relaxed-averaged-alternating-reflections"),
             "RRR" (or "relax-reflect-reflect"),
@@ -1931,8 +1934,12 @@ def reconstruct(
             "GD" (or "gradient_descent")
         reconstruction_parameter: float, optional
             Reconstruction parameter for various reconstruction methods above.
-        reconstruction_parameter: float, optional
-            Tuning parameter to interpolate b/w DM-AP and DM-RAAR
+        reconstruction_parameter_a: float, optional
+            Reconstruction parameter a for reconstruction_method='generalized-projections'.
+        reconstruction_parameter_b: float, optional
+            Reconstruction parameter b for reconstruction_method='generalized-projections'.
+        reconstruction_parameter_c: float, optional
+            Reconstruction parameter c for reconstruction_method='generalized-projections'.
         max_batch_size: int, optional
             Max number of probes to update at once
         seed_random: int, optional
@@ -2010,17 +2017,23 @@ def reconstruct(
 
         # Reconstruction method
 
-        if reconstruction_method == "generalized-projection":
-            if np.array(reconstruction_parameter).shape != (3,):
+        if reconstruction_method == "generalized-projections":
+            if (
+                reconstruction_parameter_a is None
+                or reconstruction_parameter_b is None
+                or reconstruction_parameter_c is None
+            ):
                 raise ValueError(
                     (
-                        "reconstruction_parameter must be a list of three numbers "
-                        "when using `reconstriction_method`=generalized-projection."
+                        "reconstruction_parameter_a/b/c must all be specified "
+                        "when using reconstruction_method='generalized-projections'."
                     )
                 )
 
             use_projection_scheme = True
-            projection_a, projection_b, projection_c = reconstruction_parameter
+            projection_a = reconstruction_parameter_a
+            projection_b = reconstruction_parameter_b
+            projection_c = reconstruction_parameter_c
             step_size = None
         elif (
             reconstruction_method == "DM_AP"
@@ -2079,7 +2092,8 @@ def reconstruct(
         else:
             raise ValueError(
                 (
-                    "reconstruction_method must be one of 'DM_AP' (or 'difference-map_alternating-projections'), "
+                    "reconstruction_method must be one of 'generalized-projections', "
+                    "'DM_AP' (or 'difference-map_alternating-projections'), "
                     "'RAAR' (or 'relaxed-averaged-alternating-reflections'), "
                     "'RRR' (or 'relax-reflect-reflect'), "
                     "'SUPERFLIP' (or 'charge-flipping'), "
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index 82d1caac3..037a3c805 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -1690,6 +1690,9 @@ def reconstruct(
         max_iter: int = 64,
         reconstruction_method: str = "gradient-descent",
         reconstruction_parameter: float = 1.0,
+        reconstruction_parameter_a: float = None,
+        reconstruction_parameter_b: float = None,
+        reconstruction_parameter_c: float = None,
         max_batch_size: int = None,
         seed_random: int = None,
         step_size: float = 0.5,
@@ -1733,7 +1736,7 @@ def reconstruct(
             Maximum number of iterations to run
         reconstruction_method: str, optional
             Specifies which reconstruction algorithm to use, one of:
-            "generalized-projection",
+            "generalized-projections",
             "DM_AP" (or "difference-map_alternating-projections"),
             "RAAR" (or "relaxed-averaged-alternating-reflections"),
             "RRR" (or "relax-reflect-reflect"),
@@ -1741,8 +1744,12 @@ def reconstruct(
             "GD" (or "gradient_descent")
         reconstruction_parameter: float, optional
             Reconstruction parameter for various reconstruction methods above.
-        reconstruction_parameter: float, optional
-            Tuning parameter to interpolate b/w DM-AP and DM-RAAR
+        reconstruction_parameter_a: float, optional
+            Reconstruction parameter a for reconstruction_method='generalized-projections'.
+        reconstruction_parameter_b: float, optional
+            Reconstruction parameter b for reconstruction_method='generalized-projections'.
+        reconstruction_parameter_c: float, optional
+            Reconstruction parameter c for reconstruction_method='generalized-projections'.
         max_batch_size: int, optional
             Max number of probes to update at once
         seed_random: int, optional
@@ -1818,17 +1825,23 @@ def reconstruct(
 
         # Reconstruction method
 
-        if reconstruction_method == "generalized-projection":
-            if np.array(reconstruction_parameter).shape != (3,):
+        if reconstruction_method == "generalized-projections":
+            if (
+                reconstruction_parameter_a is None
+                or reconstruction_parameter_b is None
+                or reconstruction_parameter_c is None
+            ):
                 raise ValueError(
                     (
-                        "reconstruction_parameter must be a list of three numbers "
-                        "when using `reconstriction_method`=generalized-projection."
+                        "reconstruction_parameter_a/b/c must all be specified "
+                        "when using reconstruction_method='generalized-projections'."
                     )
                 )
 
             use_projection_scheme = True
-            projection_a, projection_b, projection_c = reconstruction_parameter
+            projection_a = reconstruction_parameter_a
+            projection_b = reconstruction_parameter_b
+            projection_c = reconstruction_parameter_c
             step_size = None
         elif (
             reconstruction_method == "DM_AP"
@@ -1887,7 +1900,8 @@ def reconstruct(
         else:
             raise ValueError(
                 (
-                    "reconstruction_method must be one of 'DM_AP' (or 'difference-map_alternating-projections'), "
+                    "reconstruction_method must be one of 'generalized-projections', "
+                    "'DM_AP' (or 'difference-map_alternating-projections'), "
                     "'RAAR' (or 'relaxed-averaged-alternating-reflections'), "
                     "'RRR' (or 'relax-reflect-reflect'), "
                     "'SUPERFLIP' (or 'charge-flipping'), "
diff --git a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
index 9e4b39cf5..629108b54 100644
--- a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
@@ -2405,6 +2405,9 @@ def reconstruct(
         max_iter: int = 64,
         reconstruction_method: str = "gradient-descent",
         reconstruction_parameter: float = 1.0,
+        reconstruction_parameter_a: float = None,
+        reconstruction_parameter_b: float = None,
+        reconstruction_parameter_c: float = None,
         max_batch_size: int = None,
         seed_random: int = None,
         step_size: float = 0.5,
@@ -2453,7 +2456,7 @@ def reconstruct(
             Maximum number of iterations to run
         reconstruction_method: str, optional
             Specifies which reconstruction algorithm to use, one of:
-            "generalized-projection",
+            "generalized-projections",
             "DM_AP" (or "difference-map_alternating-projections"),
             "RAAR" (or "relaxed-averaged-alternating-reflections"),
             "RRR" (or "relax-reflect-reflect"),
@@ -2461,6 +2464,12 @@ def reconstruct(
             "GD" (or "gradient_descent")
         reconstruction_parameter: float, optional
             Reconstruction parameter for various reconstruction methods above.
+        reconstruction_parameter_a: float, optional
+            Reconstruction parameter a for reconstruction_method='generalized-projections'.
+        reconstruction_parameter_b: float, optional
+            Reconstruction parameter b for reconstruction_method='generalized-projections'.
+        reconstruction_parameter_c: float, optional
+            Reconstruction parameter c for reconstruction_method='generalized-projections'.
         max_batch_size: int, optional
             Max number of probes to update at once
         seed_random: int, optional
@@ -2549,17 +2558,23 @@ def reconstruct(
 
         # Reconstruction method
 
-        if reconstruction_method == "generalized-projection":
-            if np.array(reconstruction_parameter).shape != (3,):
+        if reconstruction_method == "generalized-projections":
+            if (
+                reconstruction_parameter_a is None
+                or reconstruction_parameter_b is None
+                or reconstruction_parameter_c is None
+            ):
                 raise ValueError(
                     (
-                        "reconstruction_parameter must be a list of three numbers "
-                        "when using `reconstriction_method`=generalized-projection."
+                        "reconstruction_parameter_a/b/c must all be specified "
+                        "when using reconstruction_method='generalized-projections'."
                     )
                 )
 
             use_projection_scheme = True
-            projection_a, projection_b, projection_c = reconstruction_parameter
+            projection_a = reconstruction_parameter_a
+            projection_b = reconstruction_parameter_b
+            projection_c = reconstruction_parameter_c
             step_size = None
         elif (
             reconstruction_method == "DM_AP"
@@ -2618,7 +2633,8 @@ def reconstruct(
         else:
             raise ValueError(
                 (
-                    "reconstruction_method must be one of 'DM_AP' (or 'difference-map_alternating-projections'), "
+                    "reconstruction_method must be one of 'generalized-projections', "
+                    "'DM_AP' (or 'difference-map_alternating-projections'), "
                     "'RAAR' (or 'relaxed-averaged-alternating-reflections'), "
                     "'RRR' (or 'relax-reflect-reflect'), "
                     "'SUPERFLIP' (or 'charge-flipping'), "
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index 6004b2a98..4e0aaa17e 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -1167,6 +1167,9 @@ def reconstruct(
         max_iter: int = 64,
         reconstruction_method: str = "gradient-descent",
         reconstruction_parameter: float = 1.0,
+        reconstruction_parameter_a: float = None,
+        reconstruction_parameter_b: float = None,
+        reconstruction_parameter_c: float = None,
         max_batch_size: int = None,
         seed_random: int = None,
         step_size: float = 0.5,
@@ -1211,7 +1214,7 @@ def reconstruct(
             Maximum number of iterations to run
         reconstruction_method: str, optional
             Specifies which reconstruction algorithm to use, one of:
-            "generalized-projection",
+            "generalized-projections",
             "DM_AP" (or "difference-map_alternating-projections"),
             "RAAR" (or "relaxed-averaged-alternating-reflections"),
             "RRR" (or "relax-reflect-reflect"),
@@ -1219,6 +1222,12 @@ def reconstruct(
             "GD" (or "gradient_descent")
         reconstruction_parameter: float, optional
             Reconstruction parameter for various reconstruction methods above.
+        reconstruction_parameter_a: float, optional
+            Reconstruction parameter a for reconstruction_method='generalized-projections'.
+        reconstruction_parameter_b: float, optional
+            Reconstruction parameter b for reconstruction_method='generalized-projections'.
+        reconstruction_parameter_c: float, optional
+            Reconstruction parameter c for reconstruction_method='generalized-projections'.
         max_batch_size: int, optional
             Max number of probes to update at once
         seed_random: int, optional
@@ -1301,17 +1310,23 @@ def reconstruct(
 
         # Reconstruction method
 
-        if reconstruction_method == "generalized-projection":
-            if np.array(reconstruction_parameter).shape != (3,):
+        if reconstruction_method == "generalized-projections":
+            if (
+                reconstruction_parameter_a is None
+                or reconstruction_parameter_b is None
+                or reconstruction_parameter_c is None
+            ):
                 raise ValueError(
                     (
-                        "reconstruction_parameter must be a list of three numbers "
-                        "when using `reconstriction_method`=generalized-projection."
+                        "reconstruction_parameter_a/b/c must all be specified "
+                        "when using reconstruction_method='generalized-projections'."
                     )
                 )
 
             use_projection_scheme = True
-            projection_a, projection_b, projection_c = reconstruction_parameter
+            projection_a = reconstruction_parameter_a
+            projection_b = reconstruction_parameter_b
+            projection_c = reconstruction_parameter_c
             step_size = None
         elif (
             reconstruction_method == "DM_AP"
@@ -1370,7 +1385,8 @@ def reconstruct(
         else:
             raise ValueError(
                 (
-                    "reconstruction_method must be one of 'DM_AP' (or 'difference-map_alternating-projections'), "
+                    "reconstruction_method must be one of 'generalized-projections', "
+                    "'DM_AP' (or 'difference-map_alternating-projections'), "
                     "'RAAR' (or 'relaxed-averaged-alternating-reflections'), "
                     "'RRR' (or 'relax-reflect-reflect'), "
                     "'SUPERFLIP' (or 'charge-flipping'), "

From 03549f56de34d2e8552beac84733d81dc0578cbf Mon Sep 17 00:00:00 2001
From: gvarnavi <gvarnavi@mit.edu>
Date: Fri, 7 Jul 2023 09:43:38 -0700
Subject: [PATCH 134/362] centered Fourier-probe extent

---
 .../phase/iterative_mixedstate_ptychography.py  | 16 ++++++++--------
 .../phase/iterative_multislice_ptychography.py  | 17 ++++++++---------
 .../phase/iterative_overlap_tomography.py       | 17 ++++++++---------
 .../iterative_simultaneous_ptychography.py      |  8 ++++----
 .../phase/iterative_singleslice_ptychography.py | 16 ++++++++--------
 5 files changed, 36 insertions(+), 38 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
index 3450d1b13..d4e2e5346 100644
--- a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
@@ -1838,10 +1838,10 @@ def _visualize_last_iteration(
 
         if plot_fourier_probe:
             probe_extent = [
-                0,
-                self.angular_sampling[1] * self._region_of_interest_shape[1],
-                self.angular_sampling[0] * self._region_of_interest_shape[0],
-                0,
+                -self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
+                -self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
             ]
         elif plot_probe:
             probe_extent = [
@@ -2075,10 +2075,10 @@ def _visualize_all_iterations(
 
         if plot_fourier_probe:
             probe_extent = [
-                0,
-                self.angular_sampling[1] * self._region_of_interest_shape[1],
-                self.angular_sampling[0] * self._region_of_interest_shape[0],
-                0,
+                -self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
+                -self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
             ]
         elif plot_probe:
             probe_extent = [
diff --git a/py4DSTEM/process/phase/iterative_multislice_ptychography.py b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
index f9f8c2d29..d477da8ce 100644
--- a/py4DSTEM/process/phase/iterative_multislice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
@@ -2269,12 +2269,11 @@ def _visualize_last_iteration(
 
         if plot_fourier_probe:
             probe_extent = [
-                0,
-                self.angular_sampling[1] * self._region_of_interest_shape[1],
-                self.angular_sampling[0] * self._region_of_interest_shape[0],
-                0,
+                -self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
+                -self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
             ]
-
         elif plot_probe:
             probe_extent = [
                 0,
@@ -2510,10 +2509,10 @@ def _visualize_all_iterations(
 
         if plot_fourier_probe:
             probe_extent = [
-                0,
-                self.angular_sampling[1] * self._region_of_interest_shape[1],
-                self.angular_sampling[0] * self._region_of_interest_shape[0],
-                0,
+                -self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
+                -self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
             ]
         elif plot_probe:
             probe_extent = [
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index 037a3c805..61d40473d 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -2460,12 +2460,11 @@ def _visualize_last_iteration(
 
         if plot_fourier_probe:
             probe_extent = [
-                0,
-                self.angular_sampling[1] * self._region_of_interest_shape[1],
-                self.angular_sampling[0] * self._region_of_interest_shape[0],
-                0,
+                -self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
+                -self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
             ]
-
         elif plot_probe:
             probe_extent = [
                 0,
@@ -2717,10 +2716,10 @@ def _visualize_all_iterations(
 
         if plot_fourier_probe:
             probe_extent = [
-                0,
-                self.angular_sampling[1] * self._region_of_interest_shape[1],
-                self.angular_sampling[0] * self._region_of_interest_shape[0],
-                0,
+                -self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
+                -self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
             ]
         elif plot_probe:
             probe_extent = [
diff --git a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
index 629108b54..545900634 100644
--- a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
@@ -3052,10 +3052,10 @@ def _visualize_last_iteration(
 
         if plot_fourier_probe:
             probe_extent = [
-                0,
-                self.angular_sampling[1] * self._region_of_interest_shape[1],
-                self.angular_sampling[0] * self._region_of_interest_shape[0],
-                0,
+                -self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
+                -self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
             ]
         elif plot_probe:
             probe_extent = [
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index 4e0aaa17e..bed535665 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -1751,10 +1751,10 @@ def _visualize_last_iteration(
 
         if plot_fourier_probe:
             probe_extent = [
-                0,
-                self.angular_sampling[1] * self._region_of_interest_shape[1],
-                self.angular_sampling[0] * self._region_of_interest_shape[0],
-                0,
+                -self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
+                -self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
             ]
         elif plot_probe:
             probe_extent = [
@@ -1988,10 +1988,10 @@ def _visualize_all_iterations(
 
         if plot_fourier_probe:
             probe_extent = [
-                0,
-                self.angular_sampling[1] * self._region_of_interest_shape[1],
-                self.angular_sampling[0] * self._region_of_interest_shape[0],
-                0,
+                -self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
+                -self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
             ]
         elif plot_probe:
             probe_extent = [

From 8bffee7b618fd890a4fb7531c88e7a7a7d0e3051 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Fri, 7 Jul 2023 15:22:46 -0400
Subject: [PATCH 135/362] updates, completes rm classes/

---
 py4DSTEM/__init__.py                          |  11 +-
 py4DSTEM/braggvectors/braggvector_methods.py  | 119 ++---
 py4DSTEM/braggvectors/braggvectors.py         |   8 +-
 py4DSTEM/braggvectors/virtualimage.py         |  77 ----
 py4DSTEM/classes/__init__.py                  |   5 -
 py4DSTEM/classes/virtualdiffraction.py        |  50 ---
 py4DSTEM/datacube/__init__.py                 |   1 +
 py4DSTEM/datacube/datacube.py                 | 407 +-----------------
 py4DSTEM/datacube/virtualdiffraction.py       | 362 ++++++++++++++++
 py4DSTEM/datacube/virtualimage.py             | 135 +-----
 py4DSTEM/io/legacy/legacy13/v13_to_14.py      |   4 +-
 .../iterative_overlap_magnetic_tomography.py  |   2 +-
 12 files changed, 446 insertions(+), 735 deletions(-)
 delete mode 100644 py4DSTEM/braggvectors/virtualimage.py
 delete mode 100644 py4DSTEM/classes/__init__.py
 delete mode 100644 py4DSTEM/classes/virtualdiffraction.py
 create mode 100644 py4DSTEM/datacube/virtualdiffraction.py

diff --git a/py4DSTEM/__init__.py b/py4DSTEM/__init__.py
index bf1b0554d..17d255d92 100644
--- a/py4DSTEM/__init__.py
+++ b/py4DSTEM/__init__.py
@@ -37,7 +37,8 @@
 # datacube
 from py4DSTEM.datacube import (
     DataCube,
-    VirtualImage
+    VirtualImage,
+    VirtualDiffraction
 )
 
 
@@ -60,17 +61,13 @@
 
 # TODO - crystal
 # TODO - ptycho
-# TODO - others?
+# TODO - others
 
-# TODO - where?
+# TODO - where
 from py4DSTEM.process import (
     PolarDatacube,
 )
 
-# TODO - to datacube
-from py4DSTEM.classes import (
-    VirtualDiffraction,
-)
 
 
 
diff --git a/py4DSTEM/braggvectors/braggvector_methods.py b/py4DSTEM/braggvectors/braggvector_methods.py
index 48dbbb17f..c6289a253 100644
--- a/py4DSTEM/braggvectors/braggvector_methods.py
+++ b/py4DSTEM/braggvectors/braggvector_methods.py
@@ -2,9 +2,12 @@
 
 import numpy as np
 from scipy.ndimage import gaussian_filter
+import inspect
+
 from emdfile import Array,Metadata
 from emdfile import _read_metadata
 from py4DSTEM.process.utils import get_CoM
+from py4DSTEM.datacube import VirtualImage
 
 
 class BraggVectorMethods:
@@ -183,6 +186,7 @@ def get_virtual_image(
         self,
         mode = None,
         geometry = None,
+        name = 'bragg_virtual_image',
         returncalc = True
         ):
         '''
@@ -215,76 +219,77 @@ def get_virtual_image(
         assert(mode in modes), f"Unrecognized mode {mode}"
 
         # set geometry
-#         if mode is None:
-#             if geometry is None:
-#                 center = None
-#                 radial_range = np.array((0,np.inf))
-#             else:
-#                 if len(geometry[0]) == 0:
-#                     center = None
-#                 else:
-#                     center = np.array(geometry[0])
-#                 if isinstance(geometry[1], int) or isinstance(geometry[1], float):
-#                     radial_range = np.array((0,geometry[1]))
-#                 elif len(geometry[1]) == 0:
-#                     radial_range = None
-#                 else:
-#                     radial_range = np.array(geometry[1])
-#         elif mode == 'circular' or mode == 'circle':
-#             radial_range = np.array((0,geometry[1]))
-#             if len(geometry[0]) == 0:
-#                     center = None
-#             else:
-#                 center = np.array(geometry[0])
-#         elif mode == 'annular' or mode == 'annulus':
-#             radial_range = np.array(geometry[1])
-#             if len(geometry[0]) == 0:
-#                     center = None
-#             else:
-#                 center = np.array(geometry[0])
-
-
+        if mode is None:
+            if geometry is None:
+                center = None
+                radial_range = np.array((0,np.inf))
+            else:
+                if len(geometry[0]) == 0:
+                    center = None
+                else:
+                    center = np.array(geometry[0])
+                if isinstance(geometry[1], int) or isinstance(geometry[1], float):
+                    radial_range = np.array((0,geometry[1]))
+                elif len(geometry[1]) == 0:
+                    radial_range = None
+                else:
+                    radial_range = np.array(geometry[1])
+        elif mode == 'circular' or mode == 'circle':
+            radial_range = np.array((0,geometry[1]))
+            if len(geometry[0]) == 0:
+                    center = None
+            else:
+                center = np.array(geometry[0])
+        elif mode == 'annular' or mode == 'annulus':
+            radial_range = np.array(geometry[1])
+            if len(geometry[0]) == 0:
+                    center = None
+            else:
+                center = np.array(geometry[0])
 
         # allocate space
-        im_virtual = np.zeros(peaks.shape)
+        im_virtual = np.zeros(self.shape)
 
         # generate image
-        for rx,ry in tqdmnd(peaks.shape[0],peaks.shape[1]):
-            p = peaks.get_pointlist(rx,ry)
+        for rx,ry in tqdmnd(self.shape[0],self.shape[1]):
+            p = self.raw[rx,ry]
             if p.data.shape[0] > 0:
                 if radial_range is None:
-                    im_virtual[rx,ry] = np.sum(p.data['intensity'])
+                    im_virtual[rx,ry] = np.sum(p.I)
                 else:
                     if center is None:
-                        qr = np.hypot(p.data['qx'],p.data['qy'])
+                        qr = np.hypot(p.qx,p.qy)
                     else:
-                        qr = np.hypot(p.data['qx'] - center[0],p.data['qy'] - center[1])
+                        qr = np.hypot(p.qx - center[0],p.qy - center[1])
                     sub = np.logical_and(
                         qr >= radial_range[0],
                         qr <  radial_range[1])
                     if np.sum(sub) > 0:
-                        im_virtual[rx,ry] = np.sum(p.data['intensity'][sub])
-
-#         # generate image
-#         for rx,ry in tqdmnd(peaks.shape[0],peaks.shape[1]):
-#             p = peaks.get_pointlist(rx,ry)
-#             if p.data.shape[0] > 0:
-#                 if radial_range is None:
-#                     im_virtual[rx,ry] = np.sum(p.data['intensity'])
-#                 else:
-#                     if center is None:
-#                         qr = np.hypot(p.data['qx'],p.data['qy'])
-#                     else:
-#                         qr = np.hypot(p.data['qx'] - center[0],p.data['qy'] - center[1])
-#                     sub = np.logical_and(
-#                         qr >= radial_range[0],
-#                         qr <  radial_range[1])
-#                     if np.sum(sub) > 0:
-#                         im_virtual[rx,ry] = np.sum(p.data['intensity'][sub])
-
-        # TODO wrap in VirtualImage
-
-        return im_virtual
+                        im_virtual[rx,ry] = np.sum(p.I[sub])
+
+        # wrap in Virtual Image class
+        ans = VirtualImage(
+            data = im_virtual,
+            name = name
+        )
+        # add generating params as metadta
+        ans.metadata = Metadata(
+            name = 'gen_params',
+            data = {
+                '_calling_method' : inspect.stack()[0][3],
+                '_calling_class' : __class__.__name__,
+                'mode' : mode,
+                'geometry' : geometry,
+                'name' : name,
+                'returncalc' : returncalc
+            }
+        )
+        # attach to the tree
+        self.attach( ans)
+
+        # return
+        if returncalc:
+            return ans
 
 
 
diff --git a/py4DSTEM/braggvectors/braggvectors.py b/py4DSTEM/braggvectors/braggvectors.py
index ebd5e7389..d32997673 100644
--- a/py4DSTEM/braggvectors/braggvectors.py
+++ b/py4DSTEM/braggvectors/braggvectors.py
@@ -72,7 +72,6 @@ def __init__(
         Data.__init__(self,calibration=calibration)
 
         self.Rshape = Rshape
-        self.shape = self.Rshape
         self.Qshape = Qshape
         self.verbose = verbose
 
@@ -102,6 +101,8 @@ def __init__(
         self._set_cal_vector_getter()
 
 
+    # calibration state, vector getters
+
     @property
     def calstate(self):
         return self._calstate
@@ -115,6 +116,10 @@ def _set_cal_vector_getter(self):
         )
 
 
+    # shape
+    @property
+    def shape(self):
+        return self.Rshape
 
 
     # raw vectors
@@ -132,7 +137,6 @@ def raw(self):
         return self._raw_vector_getter
 
 
-
     # calibrated vectors
 
     @property
diff --git a/py4DSTEM/braggvectors/virtualimage.py b/py4DSTEM/braggvectors/virtualimage.py
deleted file mode 100644
index 0bfd9eb61..000000000
--- a/py4DSTEM/braggvectors/virtualimage.py
+++ /dev/null
@@ -1,77 +0,0 @@
-import numpy as np
-from emdfile import tqdmnd
-
-
-
-
-
-
-## TODO
-
-
-def make_bragg_mask(
-    Qshape,
-    g1,
-    g2,
-    radius,
-    origin,
-    max_q,
-    return_sum = True,
-    **kwargs,
-    ):
-    '''
-    Creates and returns a mask consisting of circular disks
-    about the points of a 2D lattice.
-
-    Args:
-        Qshape (2 tuple): the shape of diffraction space
-        g1,g2 (len 2 array or tuple): the lattice vectors
-        radius (number): the disk radius
-        origin (len 2 array or tuple): the origin
-        max_q (nuumber): the maxima distance to tile to
-        return_sum (bool): if False, return a 3D array, where each
-            slice contains a single disk; if False, return a single
-            2D masks of all disks
-
-    Returns:
-        (2 or 3D array) the mask
-    '''
-    nas = np.asarray
-    g1,g2,origin = nas(g1),nas(g2),nas(origin)
-
-    # Get N,M, the maximum indices to tile out to
-    L1 = np.sqrt(np.sum(g1**2))
-    H = int(max_q/L1) + 1
-    L2 = np.hypot(-g2[0]*g1[1],g2[1]*g1[0])/np.sqrt(np.sum(g1**2))
-    K = int(max_q/L2) + 1
-
-    # Compute number of points
-    N = 0
-    for h in range(-H,H+1):
-        for k in range(-K,K+1):
-            v = h*g1 + k*g2
-            if np.sqrt(v.dot(v)) < max_q:
-                N += 1
-
-    #create mask
-    mask = np.zeros((Qshape[0], Qshape[1], N), dtype=bool)
-    N = 0
-    for h in range(-H,H+1):
-        for k in range(-K,K+1):
-            v = h*g1 + k*g2
-            if np.sqrt(v.dot(v)) < max_q:
-                center = origin + v
-                mask[:,:,N] = make_detector(
-                    Qshape,
-                    mode = 'circle',
-                    geometry = (center, radius),
-                )
-                N += 1
-
-
-    if return_sum:
-        mask = np.sum(mask, axis = 2)
-    return mask
-
-
-
diff --git a/py4DSTEM/classes/__init__.py b/py4DSTEM/classes/__init__.py
deleted file mode 100644
index 0bacd8a70..000000000
--- a/py4DSTEM/classes/__init__.py
+++ /dev/null
@@ -1,5 +0,0 @@
-_emd_hook = True
-
-from py4DSTEM.classes.virtualdiffraction import VirtualDiffraction
-
-
diff --git a/py4DSTEM/classes/virtualdiffraction.py b/py4DSTEM/classes/virtualdiffraction.py
deleted file mode 100644
index 3831bbefe..000000000
--- a/py4DSTEM/classes/virtualdiffraction.py
+++ /dev/null
@@ -1,50 +0,0 @@
-
-from typing import Optional
-import numpy as np
-
-from py4DSTEM.data import DiffractionSlice,Data
-
-
-
-class VirtualDiffraction(DiffractionSlice,Data):
-    """
-    Stores a diffraction-space shaped 2D image with metadata
-    indicating how this image was generated from a datacube.
-    """
-    def __init__(
-        self,
-        data: np.ndarray,
-        name: Optional[str] = 'virtualdiffraction',
-        ):
-        """
-        Args:
-            data (np.ndarray) : the 2D data
-            name (str) : the name
-
-        Returns:
-            A new VirtualDiffraction instance
-        """
-        # initialize as a DiffractionSlice
-        DiffractionSlice.__init__(
-            self,
-            data = data,
-            name = name,
-        )
-
-
-    # read
-    @classmethod
-    def _get_constructor_args(cls,group):
-        """
-        Returns a dictionary of args/values to pass to the class constructor
-        """
-        ar_constr_args = DiffractionSlice._get_constructor_args(group)
-        args = {
-            'data' : ar_constr_args['data'],
-            'name' : ar_constr_args['name'],
-        }
-        return args
-
-
-
-
diff --git a/py4DSTEM/datacube/__init__.py b/py4DSTEM/datacube/__init__.py
index f1f6e5b99..881966e2f 100644
--- a/py4DSTEM/datacube/__init__.py
+++ b/py4DSTEM/datacube/__init__.py
@@ -2,5 +2,6 @@
 
 from py4DSTEM.datacube.datacube import DataCube
 from py4DSTEM.datacube.virtualimage import VirtualImage
+from py4DSTEM.datacube.virtualdiffraction import VirtualDiffraction
 
 
diff --git a/py4DSTEM/datacube/datacube.py b/py4DSTEM/datacube/datacube.py
index 55428bddc..96ec950ba 100644
--- a/py4DSTEM/datacube/datacube.py
+++ b/py4DSTEM/datacube/datacube.py
@@ -1,21 +1,22 @@
 # Defines the DataCube class, which stores 4D-STEM datacubes
 
 import numpy as np
-from scipy.ndimage import distance_transform_edt, binary_fill_holes, gaussian_filter1d
 from scipy.interpolate import interp1d
-from scipy.ndimage import (
-    binary_opening, binary_dilation, distance_transform_edt)
+from scipy.ndimage import (binary_opening, binary_dilation,
+    distance_transform_edt, binary_fill_holes, gaussian_filter1d)
 from typing import Optional,Union
 
 from emdfile import Array, Metadata, Node, Root, tqdmnd
 from py4DSTEM.data import Data, Calibration
 from py4DSTEM.datacube.virtualimage import DataCubeVirtualImager
+from py4DSTEM.datacube.virtualdiffraction import DataCubeVirtualDiffraction
 
 
 class DataCube(
     Array,
     Data,
-    DataCubeVirtualImager
+    DataCubeVirtualImager,
+    DataCubeVirtualDiffraction,
     ):
     """
     Storage and processing methods for 4D-STEM datasets.
@@ -550,404 +551,6 @@ def filter_hot_pixels(
 
 
 
-
-
-
-    # Diffraction imaging
-
-    def get_virtual_diffraction(
-        self,
-        method = 'max',
-        mode = None,
-        geometry = None,
-        calibrated = False,
-        shift_center = False,
-        verbose = True,
-        name = 'virtual_diffracton',
-        returncalc = True,
-        ):
-        """
-        Function to calculate virtual diffraction patterns
-
-        Args:
-            datacube (Datacube) : datacube class object which stores 4D-dataset
-                needed for calculation
-            method (str) : defines method used for diffraction pattern, options
-                are 'mean', 'median', and 'max'
-            mode (str) : defines mode for selecting area in real space to use
-                for virtual diffraction. The default is None, which means no
-                geometry will be applied and the whole datacube will be used
-                for the calculation. Options:
-                    - 'point' uses singular point as detector
-                    - 'circle' or 'circular' uses round detector, like bright
-                      field
-                    - 'annular' or 'annulus' uses annular detector, like dark
-                      field
-                    - 'rectangle', 'square', 'rectangular', uses rectangular
-                      detector
-                    - 'mask' flexible detector, any 2D array
-            geometry (variable) : valid entries are determined by the `mode`,
-                values in pixels argument, as follows. The default is None, which
-                means no geometry will be applied and the whole datacube will be
-                used for the calculation. If mode is None the geometry will not
-                be applied.
-                    - 'point': 2-tuple, (rx,ry), ints
-                    - 'circle' or 'circular': nested 2-tuple, ((rx,ry),radius),
-                    - 'annular' or 'annulus': nested 2-tuple,
-                      ((rx,ry),(radius_i,radius_o))
-                    - 'rectangle', 'square', 'rectangular': 4-tuple,
-                      (rxmin,rxmax,rymin,rymax)
-                    - `mask`: flexible detector, any boolean or floating point 2D
-                      array with the same shape as datacube.Rshape
-            calibrated (bool): if True, geometry is specified in units of 'A'
-                instead of pixels. The datacube's calibrations must have its
-                `"R_pixel_units"` parameter set to "A". If mode is None the
-                geometry and calibration will not be applied.
-            shift_center (bool): if True, the difraction patterns are shifted to
-                account for beam shift or the changing of the origin through the
-                scan. The datacube's calibration['origin'] parameter must be set.
-                Only 'max' and 'mean' supported for this option.
-            verbose (bool): if True, show progress bar
-
-        Returns:
-            (VirtualDiffraction): the diffraction image
-        """
-
-        # perform computation
-        from py4DSTEM.classes.virtualdiffraction import VirtualDiffraction
-        from py4DSTEM.process.virtualdiffraction import get_virtual_diffraction
-        dp = get_virtual_diffraction(
-            self,
-            method = method,
-            mode = mode,
-            geometry = geometry,
-            shift_center = shift_center,
-            calibrated = calibrated,
-            verbose = verbose,
-        )
-
-        # wrap with a py4dstem class
-        dp = VirtualDiffraction(
-            data = dp,
-            name = name
-        )
-
-        # add the args used to gen this dp as metadata
-        dp.metadata = Metadata(
-            name='gen_params',
-            data = {
-                #'gen_func' : 
-                'method' : method,
-                'mode' : mode,
-                'geometry' : geometry,
-                'shift_center' : shift_center,
-                'calibrated' : calibrated,
-            }
-        )
-
-        # add to the tree
-        self.attach( dp )
-
-        # return
-        if returncalc:
-            return dp
-
-
-    def get_dp_max(
-        self,
-        method = 'max',
-        mode = None,
-        geometry = None,
-        calibrated = False,
-        shift_center = False,
-        verbose = True,
-        name = 'dp_max',
-        returncalc = True,
-        ):
-        """
-        Function to calculate maximum virtual diffraction. Default captures
-        pattern across entire 4D-dataset.
-
-        Args:
-            datacube (Datacube) : datacube class object which stores 4D-dataset
-                needed for calculation
-            mode (str) : defines mode for selecting area in real space to use for
-                virtual diffraction. The default is None, which means no
-                geometry will be applied and the whole datacube will be used
-                for the calculation. Options:
-                    - 'point' uses singular point as detector
-                    - 'circle' or 'circular' uses round detector, like bright
-                      field
-                    - 'annular' or 'annulus' uses annular detector, like dark
-                      field
-                    - 'rectangle', 'square', 'rectangular', uses rectangular
-                      detector
-                    - 'mask' flexible detector, any 2D array
-            geometry (variable) : valid entries are determined by the `mode`,
-                values in pixels argument, as follows. The default is None, which
-                means no geometry will be applied and the whole datacube will be
-                used for the calculation. If mode is None the geometry will not
-                be applied.
-                    - 'point': 2-tuple, (rx,ry),
-                       rx and ry are each single float or int to define center
-                    - 'circle' or 'circular': nested 2-tuple, ((rx,ry),radius),
-                    - 'annular' or 'annulus': nested 2-tuple,
-                      ((rx,ry),(radius_i,radius_o)),
-                    - 'rectangle', 'square', 'rectangular': 4-tuple,
-                      (xmin,xmax,ymin,ymax)
-                    - `mask`: flexible detector, any boolean or floating point 2D
-                      array with the same shape as datacube.Rshape
-            calibrated (bool): if True, geometry is specified in units of 'A'
-                instead of pixels. The datacube's calibrations must have its
-                `"R_pixel_units"` parameter set to "A". If mode is None the
-                geometry and calibration will not be applied.
-            shift_center (bool) : if True, the difraction patterns are shifted to
-                account for beam shift or the changing of the origin through the
-                scan. The datacube's calibration['origin'] parameter must be set.
-                Only 'max' and 'mean' supported for this option.
-            verbose (bool): if True, show progress bar
-
-        Returns:
-            (VirtualDiffraction): the diffraction image
-        """
-
-        # perform computation
-        from py4DSTEM.classes.virtualdiffraction import VirtualDiffraction
-        from py4DSTEM.process.virtualdiffraction import get_virtual_diffraction
-        dp = get_virtual_diffraction(
-            self,
-            method = method,
-            mode = mode,
-            geometry = geometry,
-            shift_center = shift_center,
-            calibrated = calibrated,
-            verbose = verbose,
-        )
-
-        # wrap with a py4dstem class
-        dp = VirtualDiffraction(
-            data = dp,
-            name = name
-        )
-
-        # add the args used to gen this dp as metadata
-        dp.metadata = Metadata(
-            name='gen_params',
-            data = {
-                #'gen_func' : 
-                'method' : method,
-                'mode' : mode,
-                'geometry' : geometry,
-                'shift_center' : shift_center,
-                'calibrated' : calibrated,
-            }
-        )
-
-        # add to the tree
-        self.attach( dp )
-
-        # return
-        if returncalc:
-            return dp
-
-
-    def get_dp_mean(
-        self,
-        method = 'mean',
-        mode = None,
-        geometry = None,
-        calibrated = False,
-        shift_center = False,
-        verbose = True,
-        name = 'dp_mean',
-        returncalc = True,
-        ):
-        """
-        Function to calculate mean virtual diffraction. Default captures pattern
-        across entire 4D-dataset.
-
-        Args:
-            datacube (Datacube) : datacube class object which stores 4D-dataset
-                needed for calculation
-            mode (str) : defines mode for selecting area in real space to use for
-                virtual diffraction. The default is None, which means no
-                geometry will be applied and the whole datacube will be used
-                for the calculation. Options:
-                    - 'point' uses singular point as detector
-                    - 'circle' or 'circular' uses round detector, like bright
-                      field
-                    - 'annular' or 'annulus' uses annular detector, like dark
-                      field
-                    - 'rectangle', 'square', 'rectangular', uses rectangular
-                      detector
-                    - 'mask' flexible detector, any 2D array
-            geometry (variable) : valid entries are determined by the `mode`,
-                values in pixels argument, as follows. The default is None,
-                which means no geometry will be applied and the whole datacube
-                will be used for the calculation. If mode is None the geometry
-                will not be applied.
-                    - 'point': 2-tuple, (rx,ry),
-                       qx and qy are each single float or int to define center
-                    - 'circle' or 'circular': nested 2-tuple, ((rx,ry),radius),
-                       qx, qy and radius, are each single float or int
-                    - 'annular' or 'annulus': nested 2-tuple,
-                      ((rx,ry),(radius_i,radius_o)),
-                    - 'rectangle', 'square', 'rectangular': 4-tuple,
-                      (xmin,xmax,ymin,ymax)
-                    - `mask`: flexible detector, any boolean or floating point 2D
-                      array with the same shape as datacube.Rshape
-            calibrated (bool): if True, geometry is specified in units of 'A'
-                instead of pixels. The datacube's calibrations must have its
-                `"R_pixel_units"` parameter set to "A". If mode is None the
-                geometry and calibration will not be applied.
-            shift_center (bool): if True, the diffraction patterns are shifted to
-                account for beam shift or the changing of the origin through the
-                scan. The datacube's calibration['origin'] parameter must be set.
-                Only 'max' and 'mean' supported for this option.
-            verbose (bool) : if True, show progress bar
-
-        Returns:
-            (VirtualDiffraction): the diffraction image
-        """
-
-        # perform computation
-        from py4DSTEM.classes.virtualdiffraction import VirtualDiffraction
-        from py4DSTEM.process.virtualdiffraction import get_virtual_diffraction
-        dp = get_virtual_diffraction(
-            self,
-            method = method,
-            mode = mode,
-            geometry = geometry,
-            shift_center = shift_center,
-            calibrated = calibrated,
-            verbose = verbose,
-        )
-
-        # wrap with a py4dstem class
-        dp = VirtualDiffraction(
-            data = dp,
-            name = name,
-        )
-
-        # add the args used to gen this dp as metadata
-        dp.metadata = Metadata(
-            name='gen_params',
-            data = {
-                #'gen_func' : 
-                'method' : method,
-                'mode' : mode,
-                'geometry' : geometry,
-                'shift_center' : shift_center,
-                'calibrated' : calibrated,
-            }
-        )
-
-        # add to the tree
-        self.attach( dp )
-
-        # return
-        if returncalc:
-            return dp
-
-    def get_dp_median(
-        self,
-        method = 'median',
-        mode = None,
-        geometry = None,
-        calibrated = False,
-        shift_center = False,
-        verbose = True,
-        name = 'dp_median',
-        returncalc = True,
-        ):
-        """
-        Function to calculate median virtual diffraction. Default captures
-        pattern across entire 4D-dataset.
-
-        Args:
-            datacube (Datacube) : datacube class object which stores 4D-dataset
-                needed for calculation
-            mode (str) : defines mode for selecting area in real space to use for
-                virtual diffraction. The default is None, which means no
-                geometry will be applied and the whole datacube will be used
-                for the calculation. Options:
-                    - 'point' uses singular point as detector
-                    - 'circle' or 'circular' uses round detector, like bright
-                      field
-                    - 'annular' or 'annulus' uses annular detector, like dark
-                      field
-                    - 'rectangle', 'square', 'rectangular', uses rectangular
-                      detector
-                    - 'mask' flexible detector, any 2D array
-            geometry (variable) : valid entries are determined by the `mode`,
-                values in pixels argument, as follows. The default is None,
-                which means no geometry will be applied and the whole datacube
-                will be used for the calculation. If mode is None the geometry
-                will not be applied.
-                    - 'point': 2-tuple, (rx,ry),
-                    - 'circle' or 'circular': nested 2-tuple, ((rx,ry),radius),
-                    - 'annular' or 'annulus': nested 2-tuple,
-                      ((rx,ry),(radius_i,radius_o)),
-                    - 'rectangle', 'square', 'rectangular': 4-tuple,
-                      (xmin,xmax,ymin,ymax)
-                    - `mask`: flexible detector, any boolean or floating point 2D
-                      array with the same shape as datacube.Rshape
-            calibrated (bool): if True, geometry is specified in units of 'A'
-                instead of pixels. The datacube's calibrations must have its
-                `"R_pixel_units"` parameter set to "A". If mode is None the
-                geometry and calibration will not be applied.
-            shift_center (bool) : if True, the diffraction patterns are shifted to
-                account for beam shift or the changing of the origin through the
-                scan. The datacube's calibration['origin'] parameter must be set.
-                Only 'max' and 'mean' supported for this option.
-            verbose (bool): if True, show progress bar
-
-        Returns:
-            (VirtualDiffraction): the diffraction image
-        """
-
-        # perform computation
-        from py4DSTEM.classes.virtualdiffraction import VirtualDiffraction
-        from py4DSTEM.process.virtualdiffraction import get_virtual_diffraction
-        dp = get_virtual_diffraction(
-            self,
-            method = method,
-            mode = mode,
-            geometry = geometry,
-            shift_center = shift_center,
-            calibrated = calibrated,
-            verbose = verbose,
-        )
-
-        # wrap with a py4dstem class
-        dp = VirtualDiffraction(
-            data = dp,
-            name = name,
-        )
-
-        # add the args used to gen this dp as metadata
-        dp.metadata = Metadata(
-            name='gen_params',
-            data = {
-                #'gen_func' : 
-                'method' : method,
-                'mode' : mode,
-                'geometry' : geometry,
-                'shift_center' : shift_center,
-                'calibrated' : calibrated,
-            }
-        )
-
-        # add to the tree
-        self.attach( dp )
-
-        # return
-        if returncalc:
-            return dp
-
-
-
-
     # Probe
 
     def get_vacuum_probe(
diff --git a/py4DSTEM/datacube/virtualdiffraction.py b/py4DSTEM/datacube/virtualdiffraction.py
new file mode 100644
index 000000000..9d1aaa4b7
--- /dev/null
+++ b/py4DSTEM/datacube/virtualdiffraction.py
@@ -0,0 +1,362 @@
+# Virtual diffraction from a self. Includes:
+#  * VirtualDiffraction - a container for virtual diffraction data + metadata
+#  * DataCubeVirtualDiffraction - methods inherited by DataCube for virt diffraction
+
+import numpy as np
+import dask.array as da
+from typing import Optional
+import inspect
+
+from emdfile import tqdmnd,Metadata
+from py4DSTEM.data import Calibration, DiffractionSlice, Data
+from py4DSTEM.visualize.show import show
+
+# Virtual diffraction container class
+
+class VirtualDiffraction(DiffractionSlice,Data):
+    """
+    Stores a diffraction-space shaped 2D image with metadata
+    indicating how this image was generated from a self.
+    """
+    def __init__(
+        self,
+        data: np.ndarray,
+        name: Optional[str] = 'virtualdiffraction',
+        ):
+        """
+        Args:
+            data (np.ndarray) : the 2D data
+            name (str) : the name
+
+        Returns:
+            A new VirtualDiffraction instance
+        """
+        # initialize as a DiffractionSlice
+        DiffractionSlice.__init__(
+            self,
+            data = data,
+            name = name,
+        )
+
+    # read
+    @classmethod
+    def _get_constructor_args(cls,group):
+        """
+        Returns a dictionary of args/values to pass to the class constructor
+        """
+        ar_constr_args = DiffractionSlice._get_constructor_args(group)
+        args = {
+            'data' : ar_constr_args['data'],
+            'name' : ar_constr_args['name'],
+        }
+        return args
+
+
+# DataCube virtual diffraction methods
+
+class DataCubeVirtualDiffraction:
+
+    def __init__(self):
+        pass
+
+    def get_virtual_diffraction(
+        self,
+        method,
+        mask = None,
+        shift_center = False,
+        subpixel = False,
+        verbose = True,
+        name = 'virtual_diffraction',
+        returncalc = True
+    ):
+        """
+        Function to calculate virtual diffraction images.
+
+        Parameters
+        ----------
+        method : str
+            defines method used for averaging/combining diffraction patterns.
+            Options are ('mean', 'median', 'max')
+        mask : None or 2D array
+            if None (default), all pixels are used. Otherwise, must be a boolean
+            or floating point or complex array with the same shape as real space.
+            For bool arrays, only True pixels are used in the computation.
+            Otherwise a weighted average is performed.
+        shift_center : bool
+            toggles shifting the diffraction patterns to account for beam shift.
+            Currently only supported for 'max' and 'mean' modes. Default is
+            False.
+        subpixel : bool
+            if shift_center is True, toggles subpixel shifts via Fourier
+            interpolation. Ignored if shift_center is False.
+        verbose : bool
+            toggles progress bar
+        name : string
+            name for the output DiffractionImage instance
+        returncalc : bool
+            toggles returning the output
+
+        Returns
+        -------
+        diff_im : DiffractionImage
+        """
+        # parse inputs
+        assert method in ('max', 'median', 'mean'), 'check doc strings for supported types'
+        assert(mask is None or mask.shape == self.Rshape), "mask must be None or real-space shaped"
+
+
+        # Calculate 
+
+        # ...with no center shifting
+        if shift_center == False:
+
+            # ...for the whole pattern
+            if mask is None:
+                if method == 'mean':
+                    virtual_diffraction = np.mean(self.data, axis=(0,1))
+                elif method == 'max':
+                    virtual_diffraction = np.max(self.data, axis=(0,1))
+                else:
+                    virtual_diffraction = np.median(self.data, axis=(0,1))
+
+            # ...for boolean masks
+            elif mask.dtype == bool:
+                mask_indices = np.nonzero(mask)
+                if method == 'mean':
+                    virtual_diffraction = np.mean(
+                        self.data[mask_indices[0],mask_indices[1],:,:], axis=0)
+                elif method == 'max':
+                    virtual_diffraction = np.max(
+                        self.data[mask_indices[0],mask_indices[1],:,:], axis=0)
+                else:
+                    virtual_diffraction = np.median(
+                        self.data[mask_indices[0],mask_indices[1],:,:], axis=0)
+
+            # ...for complex and floating point masks
+            else:
+                # allocate space
+                if mask.dtype == 'complex':
+                    virtual_diffraction = np.zeros(self.Qshape, dtype='complex')
+                else:
+                    virtual_diffraction = np.zeros(self.Qshape)
+                # set computation method
+                if method == 'mean':
+                    fn = np.sum
+                elif method == 'max':
+                    fn = np.max
+                else:
+                    fn = np.median
+                # loop
+                for qx,qy in tqdmnd(
+                    self.Q_Nx,
+                    self.Q_Ny,
+                    disable = not verbose,
+                ):
+                    virtual_diffraction[qx,qy] = fn( np.squeeze(self.data[:,:,qx,qy])*mask )
+                # normalize weighted means
+                if method == 'mean':
+                    virtual_diffraction /= np.sum(mask)
+
+
+        # ...with center shifting
+        else:
+            assert method in ('max', 'mean'),\
+                "only 'mean' and 'max' are supported for center-shifted virtual diffraction"
+
+            # Get calibration metadata
+            assert(self.calibration.get_origin() is not None), "origin is not calibrated"
+            x0, y0 = self.calibration.get_origin()
+            x0_mean, y0_mean = self.calibration.get_origin_mean()
+
+            # get shifts
+            qx_shift = x0_mean-x0
+            qy_shift = y0_mean-y0
+
+
+            # ...for integer shifts
+            if not subpixel:
+
+                # round shifts -> int
+                qx_shift = qshift.round().astype(int)
+                qy_shift = qshift.round().astype(int)
+
+                # ...for boolean masks and unmasked
+                if mask is None or mask.dtype==bool:
+                    # get scan points
+                    mask = np.ones(self.Rshape,dtype=bool) if mask is None else mask
+                    mask_indices = np.nonzero(mask)
+                    # allocate space
+                    virtual_diffraction = np.zeros(self.Qshape)
+                    # loop
+                    for rx,ry in zip(mask_indices[0],mask_indices[1]):
+                        # get shifted DP
+                        DP = np.roll(
+                            self.data[rx,ry, :,:,],
+                            (qx_shift[rx,ry], qy_shift[rx,ry]),
+                            axis=(0,1),
+                            )
+                        # compute
+                        if method == 'mean':
+                            virtual_diffraction += DP
+                        elif method == 'max':
+                            virtual_diffraction = np.maximum(virtual_diffraction, DP)
+                    # normalize means
+                    if method == 'mean':
+                        virtual_diffraction /= len(mask_indices[0])
+
+                # ...for floating point and complex masks
+                else:
+                    # allocate space
+                    if mask.dtype == 'complex':
+                        virtual_diffraction = np.zeros(self.Qshape, dtype = 'complex')
+                    else:
+                        virtual_diffraction = np.zeros(self.Qshape)
+                    # loop
+                    for rx,ry in tqdmnd(
+                        self.R_Nx,
+                        self.R_Ny,
+                        disable = not verbose,
+                    ):
+                        # get shifted DP
+                        DP = np.roll(
+                            self.data[rx,ry, :,:,],
+                            (qx_shift[rx,ry], qy_shift[rx,ry]),
+                            axis=(0,1),
+                            )
+                        # compute
+                        w = mask[rx,ry]
+                        if method == 'mean':
+                            virtual_diffraction += DP*w
+                        elif method == 'max':
+                            virtual_diffraction = np.maximum(virtual_diffraction, DP*w)
+                    if method == 'mean':
+                        virtual_diffraction /= np.sum(mask)
+
+            # TODO subpixel shifting
+            else:
+                raise Exception("subpixel shifting has not been implemented yet!")
+                pass
+
+
+        # wrap, add to tree, and return
+
+        # wrap in DiffractionImage
+        ans = VirtualDiffraction(
+            data = virtual_diffraction,
+            name = name
+        )
+
+        # add the args used to gen this dp as metadata
+        ans.metadata = Metadata(
+            name='gen_params',
+            data = {
+                '_calling_method' : inspect.stack()[0][3],
+                '_calling_class' : __class__.__name__,
+                'method' : method,
+                'mask' : mask,
+                'shift_center' : shift_center,
+                'subpixel' : subpixel,
+                'verbose' : verbose,
+                'name' : name,
+                'returncalc' : returncalc
+            }
+        )
+
+        # add to the tree
+        self.attach( ans )
+
+        # return
+        if returncalc:
+            return ans
+
+
+
+    # additional interfaces
+
+    def get_dp_max(
+        self,
+        returncalc = True,
+        ):
+        """
+        Calculates the max diffraction pattern.
+
+        Calls `DataCube.get_virtual_diffraction` - see that method's docstring
+        for more custimizable virtual diffraction.
+
+        Parameters
+        ----------
+        returncalc : bool
+            toggles returning the answer
+
+        Returns
+        -------
+        max_dp : VirtualDiffraction
+        """
+        return self.get_virtual_diffraction(
+            method = 'max',
+            mask = None,
+            shift_center = False,
+            subpixel = False,
+            verbose = True,
+            name = 'dp_max',
+            returncalc = True
+        )
+
+    def get_dp_mean(
+        self,
+        returncalc = True,
+        ):
+        """
+        Calculates the mean diffraction pattern.
+
+        Calls `DataCube.get_virtual_diffraction` - see that method's docstring
+        for more custimizable virtual diffraction.
+
+        Parameters
+        ----------
+        returncalc : bool
+            toggles returning the answer
+
+        Returns
+        -------
+        mean_dp : VirtualDiffraction
+        """
+        return self.get_virtual_diffraction(
+            method = 'mean',
+            mask = None,
+            shift_center = False,
+            subpixel = False,
+            verbose = True,
+            name = 'dp_mean',
+            returncalc = True
+        )
+
+    def get_dp_median(
+        self,
+        returncalc = True,
+        ):
+        """
+        Calculates the max diffraction pattern.
+
+        Calls `DataCube.get_virtual_diffraction` - see that method's docstring
+        for more custimizable virtual diffraction.
+
+        Parameters
+        ----------
+        returncalc : bool
+            toggles returning the answer
+
+        Returns
+        -------
+        max_dp : VirtualDiffraction
+        """
+        return self.get_virtual_diffraction(
+            method = 'median',
+            mask = None,
+            shift_center = False,
+            subpixel = False,
+            verbose = True,
+            name = 'dp_median',
+            returncalc = True
+        )
+
diff --git a/py4DSTEM/datacube/virtualimage.py b/py4DSTEM/datacube/virtualimage.py
index 3d721431b..7b7b315be 100644
--- a/py4DSTEM/datacube/virtualimage.py
+++ b/py4DSTEM/datacube/virtualimage.py
@@ -7,6 +7,7 @@
 import numpy as np
 import dask.array as da
 from typing import Optional
+import inspect
 
 from emdfile import tqdmnd,Metadata
 from py4DSTEM.data import Calibration, RealSlice, Data
@@ -286,6 +287,8 @@ def _apply_mask_dask(self,mask):
         ans.metadata = Metadata(
             name = 'gen_params',
             data = {
+                '_calling_method' : inspect.stack()[0][3],
+                '_calling_class' : __class__.__name__,
                 'mode' : mode,
                 'geometry' : geometry,
                 'centered' : centered,
@@ -617,19 +620,7 @@ def make_detector(
 
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-# TODO - where does this go?
+# TODO - where should this go?
 
 def make_bragg_mask(
     Qshape,
@@ -697,121 +688,3 @@ def make_bragg_mask(
 
 
 
-# TODO - these need to move elsewhere!
-
-def get_virtual_image_pointlistarray(
-    peaks,
-    mode = None,
-    geometry = None,
-    ):
-    """
-    Make a virtual image from a pointlist array.
-    TODO - implement more virtual detectors.
-
-    Args:
-        peaks (PointListArray): List of all peaks and intensities.
-        mode (str)          : defines geometry mode for calculating virtual image.
-            Options:
-                - 'circular' or 'circle' uses round detector, like bright field
-                - 'annular' or 'annulus' uses annular detector, like dark field
-        geometry (variable) : valid entries are determined by the `mode`, values in pixels
-                              argument, as follows:
-                - 'circle' or 'circular': nested 2-tuple, ((qx,qy),radius),
-                   qx, qy and radius, are each single float or int
-                - 'annular' or 'annulus': nested 2-tuple, ((qx,qy),(radius_i,radius_o)),
-                   qx, qy, radius_i, and radius_o are each single float or integer
-                - Note that (qx,qy) can be skipped, which assumes peaks centered at (0,0)
-
-    Returns:
-        im_virtual (2D numpy array): the calculated virtual image
-    """
-
-    # Set geometry
-    if mode is None:
-        if geometry is None:
-            center = None
-            radial_range = np.array((0,np.inf))
-        else:
-            if len(geometry[0]) == 0:
-                center = None
-            else:
-                center = np.array(geometry[0])
-            if isinstance(geometry[1], int) or isinstance(geometry[1], float):
-                radial_range = np.array((0,geometry[1]))
-            elif len(geometry[1]) == 0:
-                radial_range = None
-            else:
-                radial_range = np.array(geometry[1])
-    elif mode == 'circular' or mode == 'circle':
-        radial_range = np.array((0,geometry[1]))
-        if len(geometry[0]) == 0:
-                center = None
-        else:
-            center = np.array(geometry[0])
-    elif mode == 'annular' or mode == 'annulus':
-        radial_range = np.array(geometry[1])
-        if len(geometry[0]) == 0:
-                center = None
-        else:
-            center = np.array(geometry[0])
-
-
-
-    # init
-    im_virtual = np.zeros(peaks.shape)
-
-    # Generate image
-    for rx,ry in tqdmnd(peaks.shape[0],peaks.shape[1]):
-        p = peaks.get_pointlist(rx,ry)
-        if p.data.shape[0] > 0:
-            if radial_range is None:
-                im_virtual[rx,ry] = np.sum(p.data['intensity'])
-            else:
-                if center is None:
-                    qr = np.hypot(p.data['qx'],p.data['qy'])
-                else:
-                    qr = np.hypot(p.data['qx'] - center[0],p.data['qy'] - center[1])
-                sub = np.logical_and(
-                    qr >= radial_range[0],
-                    qr <  radial_range[1])
-                if np.sum(sub) > 0:
-                    im_virtual[rx,ry] = np.sum(p.data['intensity'][sub])
-
-    return im_virtual
-
-
-def get_virtual_image_braggvectors(
-    bragg_peaks,
-    mode = None,
-    geometry = None,
-    ):
-    '''
-    Function to calculate virtual images from braggvectors / pointlist arrays.
-    TODO - implement these detectors for braggvectors
-
-    Args:
-        bragg_peaks (BraggVectors) : BraggVectors class object which stores bragg peaks
-        mode (str)          : defines geometry mode for calculating virtual image.
-            Options:
-                - 'circular' or 'circle' uses round detector, like bright field
-                - 'annular' or 'annulus' uses annular detector, like dark field
-        geometry (variable) : valid entries are determined by the `mode`, values in pixels
-                              argument, as follows:
-                - 'circle' or 'circular': nested 2-tuple, ((qx,qy),radius),
-                   qx, qy and radius, are each single float or int
-                - 'annular' or 'annulus': nested 2-tuple, ((qx,qy),(radius_i,radius_o)),
-                   qx, qy, radius_i, and radius_o are each single float or integer
-                - Note that (qx,qy) can be skipped, which assumes peaks centered at (0,0)
-
-    Returns:
-        im_virtual (2D numpy array): the calculated virtual image
-    '''
-
-    virtual_image = get_virtual_image_pointlistarray(
-        bragg_peaks.vectors,
-        mode = mode,
-        geometry = geometry,
-        )
-
-    return virtual_image
-
diff --git a/py4DSTEM/io/legacy/legacy13/v13_to_14.py b/py4DSTEM/io/legacy/legacy13/v13_to_14.py
index 825892fa9..a9d188b03 100644
--- a/py4DSTEM/io/legacy/legacy13/v13_to_14.py
+++ b/py4DSTEM/io/legacy/legacy13/v13_to_14.py
@@ -45,9 +45,7 @@
 )
 from py4DSTEM.datacube import (
     DataCube,
-    VirtualImage
-)
-from py4DSTEM.classes import (
+    VirtualImage,
     VirtualDiffraction,
 )
 
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 9eda852a1..2c413c5d2 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -327,7 +327,7 @@ def _euler_angle_rotate_volume(
         """
         Rotate 3D volume using alpha, beta, gamma Euler angles according to convention:
 
-        - \-alpha tilt around first axis (z)
+        - \alpha tilt around first axis (z)
         - \beta tilt around second axis (x)
         - \alpha tilt around first axis (z)
 

From 2db764a0c4e6772f478bdac86af8663a65aa4610 Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Fri, 7 Jul 2023 12:56:59 -0700
Subject: [PATCH 136/362] Background modeling

---
 py4DSTEM/process/polar/polar_datacube.py |   2 +
 py4DSTEM/process/polar/polar_peaks.py    | 249 ++++++++++++++++++++---
 2 files changed, 226 insertions(+), 25 deletions(-)

diff --git a/py4DSTEM/process/polar/polar_datacube.py b/py4DSTEM/process/polar/polar_datacube.py
index 4610364a9..e9b3fcbfa 100644
--- a/py4DSTEM/process/polar/polar_datacube.py
+++ b/py4DSTEM/process/polar/polar_datacube.py
@@ -102,9 +102,11 @@ def __init__(
     from py4DSTEM.process.polar.polar_peaks import (
         find_peaks_single_pattern,
         find_peaks,
+        refine_peaks_local,
         refine_peaks,
         plot_radial_peaks,
         plot_radial_background,
+        model_radial_background,
         make_orientation_histogram,
     )
 
diff --git a/py4DSTEM/process/polar/polar_peaks.py b/py4DSTEM/process/polar/polar_peaks.py
index dda307188..c9584d95f 100644
--- a/py4DSTEM/process/polar/polar_peaks.py
+++ b/py4DSTEM/process/polar/polar_peaks.py
@@ -244,13 +244,13 @@ def find_peaks_single_pattern(
     # Output data as a pointlist
     peaks_polar = PointList(
             peaks_all.ravel().view([
-            ('qt', np.float),
-            ('qr', np.float),
-            ('intensity', np.float),
-            ('prom_annular', np.float),
-            ('sigma_annular', np.float),
-            ('prom_radial', np.float),
-            ('sigma_radial', np.float),
+            ('qt', float),
+            ('qr', float),
+            ('intensity', float),
+            ('prom_annular', float),
+            ('sigma_annular', float),
+            ('prom_radial', float),
+            ('sigma_radial', float),
         ]),
         name = 'peaks_polar')
     
@@ -415,10 +415,10 @@ def find_peaks(
         self.background_radial_mask[rx,ry] = sig_bg_mask
 
 
-def refine_peaks(
+def refine_peaks_local(
     self,
     mask = None,
-    radial_background_subtract = True,
+    radial_background_subtract = False,
     reset_fits_to_init_positions = False,
     fit_range_sigma_annular = 2.0,
     fit_range_sigma_radial = 2.0,
@@ -592,9 +592,11 @@ def refine_peaks(
 
 def plot_radial_peaks(
     self,
+    q_pixel_units = False,
     qmin = None,
     qmax = None,
     qstep = None,
+    label_y_axis = False,
     figsize = (8,4),
     returnfig = False,
     ):
@@ -606,7 +608,10 @@ def plot_radial_peaks(
     # Get all peak data
     vects = np.concatenate(
         [self.peaks[i,j].data for i in range(self._datacube.Rshape[0]) for j in range(self._datacube.Rshape[1])])
-    qr = vects['qr'] * self._radial_step 
+    if q_pixel_units:
+        qr = vects['qr']
+    else:
+        qr = (vects['qr'] + self.qmin) * self._radial_step
     intensity = vects['intensity']
 
     # bins
@@ -618,9 +623,11 @@ def plot_radial_peaks(
         qstep = self.qq[1] - self.qq[0]
     q_bins = np.arange(qmin,qmax,qstep)
     q_num = q_bins.shape[0]
+    if q_pixel_units:
+        q_bins /= self._radial_step
 
     # histogram
-    q_ind = (qr - qmin) / qstep
+    q_ind = (qr - q_bins[0]) / (q_bins[1] - q_bins[0])
     qf = np.floor(q_ind).astype("int")
     dq = q_ind - qf
 
@@ -647,23 +654,184 @@ def plot_radial_peaks(
         linewidth = 2,
         )
     ax.set_xlim((q_bins[0],q_bins[-1]))
-    ax.set_xlabel(
-        'Scattering Angle (' + self.calibration.get_Q_pixel_units() +')',
-        fontsize = 14,
-        )
+    if q_pixel_units:
+        ax.set_xlabel(
+            'Scattering Angle (pixels)',
+            fontsize = 14,
+            )
+    else:
+        ax.set_xlabel(
+            'Scattering Angle (' + self.calibration.get_Q_pixel_units() +')',
+            fontsize = 14,
+            )
     ax.set_ylabel(
         'Total Peak Signal',
         fontsize = 14,
         )
+    if not label_y_axis:
+        ax.tick_params(
+            left = False,
+            labelleft = False)
 
     if returnfig:
         return fig,ax
 
 
+def model_radial_background(
+    self,
+    ring_position = None,
+    ring_sigma = None,
+    ring_int = None,
+    refine_model = True,
+    plot_result = True,
+    ):
+    """
+    User provided radial background model, of the form:
+
+    int = int_const
+        + int_0 * exp( - q**2 / (2*s0**2) )
+        + int_1 * exp( - (q - q_1)**2 / (2*s1**2) )
+        + ...
+        + int_n * exp( - (q - q_n)**2 / (2*sn**2) )
+
+    where n is the number of amorphous halos / rings included in the fit.
+        
+    """
+
+    # Get mean radial background and mask
+    self.background_radial_mean = np.sum(
+        self.background_radial * self.background_radial_mask,
+        axis=(0,1))
+    background_radial_mean_norm = np.sum(
+        self.background_radial_mask,
+        axis=(0,1))
+    self.background_mask = \
+        background_radial_mean_norm > (np.max(background_radial_mean_norm)*0.05)
+    self.background_radial_mean[self.background_mask] \
+        /= background_radial_mean_norm[self.background_mask]
+    self.background_radial_mean[np.logical_not(self.background_mask)] = 0
+
+    # init
+    if ring_position is not None:
+        ring_position = np.atleast_1d(np.array(ring_position))
+        num_rings = ring_position.shape[0]
+    else:
+        num_rings = 0
+    self.background_coefs = np.zeros(3 + 3*num_rings)
+
+    if ring_sigma is None:
+        ring_sigma = np.atleast_1d(np.ones(num_rings)) \
+            * self.polar_shape[1] * 0.05 * self._radial_step
+    else:
+        ring_sigma = np.atleast_1d(np.array(ring_sigma))
+
+    # Background model initial parameters
+    int_const = np.min(self.background_radial_mean)
+    int_0 = np.max(self.background_radial_mean) - int_const
+    sigma_0 = self.polar_shape[1] * 0.25 * self._radial_step
+    self.background_coefs[0] = int_const
+    self.background_coefs[1] = int_0
+    self.background_coefs[2] = sigma_0
+
+    # Additional Gaussians
+    if ring_int is None:
+        # Estimate peak intensities
+        sig_0 = int_const + int_0*np.exp(self.qq**2/(-2*sigma_0**2))
+        sig_peaks = np.maximum(self.background_radial_mean - sig_0, 0.0)
+
+        ring_int = np.atleast_1d(np.zeros(num_rings))
+        for a0 in range(num_rings):
+            ind = np.argmin(np.abs(self.qq - ring_position[a0]))
+            ring_int[a0] = sig_peaks[ind]
+
+    else:
+        ring_int = np.atleast_1d(np.array(ring_int))
+    for a0 in range(num_rings):
+        self.background_coefs[3*a0+3] = ring_int[a0]
+        self.background_coefs[3*a0+4] = ring_sigma[a0]
+        self.background_coefs[3*a0+5] = ring_position[a0]
+
+    # Create background model
+    def background_model(q, *coefs):
+        coefs = np.squeeze(np.array(coefs))
+        num_rings = np.round((coefs.shape[0] - 3)/3).astype('int')
+
+        sig = np.ones(q.shape[0])*coefs[0]
+        sig += coefs[1]*np.exp(q**2/(-2*coefs[2]**2))
+
+        for a0 in range(num_rings):
+            sig += coefs[3*a0+3]*np.exp(
+                (q-coefs[3*a0+5])**2 / (-2*coefs[3*a0+4]**2))
+
+        return sig
+
+    self.background_model = background_model
+
+    # Refine background model coefficients
+    if refine_model:
+        self.background_coefs = curve_fit(
+            self.background_model, 
+            self.qq[self.background_mask], 
+            self.background_radial_mean[self.background_mask], 
+            p0 = self.background_coefs,
+            xtol = 1e-12,
+            # bounds = (lb,ub),
+        )[0]
+
+    # plotting
+    if plot_result:
+        self.plot_radial_background(
+                q_pixel_units = False,   
+                plot_background_model = True,
+            )
+
+
+
+def refine_peaks(
+    self,
+    mask = None,
+    # reset_fits_to_init_positions = False,
+    min_num_pixels_fit = 10,
+    progress_bar = True,
+    ):
+    """
+    Use global fitting model for all images. Requires an background model 
+    specified with self.model_radial_background().
+
+    Parameters
+    --------
+    mask: np.array
+        Mask image to apply to all images
+    radial_background_subtract: bool
+        Subtract radial background before fitting
+    reset_fits_to_init_positions: bool
+        Use the initial peak parameters for fitting
+    min_num_pixels_fit: int
+        Minimum number of pixels to perform fitting
+    progress_bar: bool
+        Enable progress bar
+
+    Returns
+    --------
+
+    """
+
+    # init
+    
+
+
+    # Main loop
+
+
+
+
 
 
 def plot_radial_background(
     self,
+    q_pixel_units = False,
+    label_y_axis = False,
+    plot_background_model = False,
     figsize = (8,4),
     returnfig = False,
     ):
@@ -696,9 +864,14 @@ def plot_radial_background(
     self.background_radial_std = np.sqrt(self.background_radial_var)
 
 
+    if q_pixel_units:
+        q_axis = np.arange(self.polar_shape[1])
+    else:
+        q_axis = self.qq[self.background_mask]
+
     fig,ax = plt.subplots(figsize = figsize)
     ax.fill_between(
-        self.qq[self.background_mask], 
+        q_axis, 
         self.background_radial_mean[self.background_mask] \
         - self.background_radial_std[self.background_mask], 
         self.background_radial_mean[self.background_mask] \
@@ -707,22 +880,48 @@ def plot_radial_background(
         alpha=0.2,
         )
     ax.plot(
-        self.qq[self.background_mask],
+        q_axis,
         self.background_radial_mean[self.background_mask],
         color = 'r',
         linewidth = 2,
         )
+
+    # overlay fitting model
+    if plot_background_model:
+        sig = self.background_model(
+            self.qq,
+            self.background_coefs,
+            )
+        ax.plot(
+            q_axis,
+            sig,
+            color = 'k',
+            linewidth = 2,
+            linestyle = '--'
+            )
+
+    # plot appearance
     ax.set_xlim((
-        self.qq[0],
-        self.qq[-1]))
-    ax.set_xlabel(
-        'Scattering Angle (' + self.calibration.get_Q_pixel_units() +')',
-        fontsize = 14,
-        )
+        q_axis[0],
+        q_axis[-1]))
+    if q_pixel_units:
+        ax.set_xlabel(
+            'Scattering Angle (pixels)',
+            fontsize = 14,
+            )
+    else:
+        ax.set_xlabel(
+            'Scattering Angle (' + self.calibration.get_Q_pixel_units() +')',
+            fontsize = 14,
+            )
     ax.set_ylabel(
         'Background Signal',
         fontsize = 14,
         )
+    if not label_y_axis:
+        ax.tick_params(
+            left = False,
+            labelleft = False)
 
     if returnfig:
         return fig,ax
@@ -820,10 +1019,10 @@ def make_orientation_histogram(
             dy = y - yF
 
             add_data = False
-
-            q = self.peaks[rx,ry]['qr'] * self._radial_step
+            q = (self.peaks[rx,ry]['qr'] + self.qmin) * self._radial_step
             r2 = q**2
             sub = np.logical_and(r2 >= radial_ranges_2[a0,0], r2 < radial_ranges_2[a0,1])                
+
             if np.any(sub):
                 add_data = True
                 intensity = self.peaks[rx,ry]['intensity'][sub]

From 4db8eb50be296dd56cd59d1faf1690a48fe2bc4f Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Fri, 7 Jul 2023 13:22:31 -0700
Subject: [PATCH 137/362] Adding full refinement

---
 py4DSTEM/process/polar/polar_peaks.py | 72 +++++++++++++++++++++++++--
 1 file changed, 69 insertions(+), 3 deletions(-)

diff --git a/py4DSTEM/process/polar/polar_peaks.py b/py4DSTEM/process/polar/polar_peaks.py
index c9584d95f..e040e4027 100644
--- a/py4DSTEM/process/polar/polar_peaks.py
+++ b/py4DSTEM/process/polar/polar_peaks.py
@@ -798,6 +798,8 @@ def refine_peaks(
     Use global fitting model for all images. Requires an background model 
     specified with self.model_radial_background().
 
+    TODO: add fitting reset
+
     Parameters
     --------
     mask: np.array
@@ -817,14 +819,78 @@ def refine_peaks(
     """
 
     # init
-    
+    self.peaks_refine = PointListArray(
+        dtype = [
+        ('qt', '<f8'), 
+        ('qr', '<f8'), 
+        ('intensity', '<f8'), 
+        ('prom_annular', '<f8'), 
+        ('sigma_annular', '<f8'), 
+        ('prom_radial', '<f8'), 
+        ('sigma_radial', '<f8')],
+        shape = self._datacube.Rshape,
+        name = 'peaks_polardata_refined',
+        )
+
+    # coordinate scaling
+    t_step = self._annular_step
+    q_step = self._radial_step
 
+    # Background model params
+    num_rings = np.round((self.background_coefs.shape[0]-3)/3).astype('int')
 
-    # Main loop
+    # basis
+    basis = np.zeros((self.qq.shape[0],2))
+    basis[:,0] = self.qq
+    basis[1,0] = num_rings
 
+    # Main loop over probe positions
+    for rx, ry in tqdmnd(
+        np.arange(40,41),#self._datacube.shape[0],
+        np.arange(20,21),#self._datacube.shape[1],
+        desc="Refining peaks ",
+        unit=" probe positions",
+        disable=not progress_bar):
+
+        # Get transformed image and normalization array
+        im_polar, im_polar_norm, norm_array, mask_bool = self.transform(
+                self._datacube.data[rx,ry],
+                mask = mask,
+                returnval = 'all_zeros', 
+            )
+        # Change sign convention of mask
+        mask_bool = np.logical_not(mask_bool)
+
+        # Get initial peaks, in dimensioned units
+        p = self.peaks[rx,ry]
+        num_peaks = p.data.shape[0]
+        qt = p.data['qt'] * t_step
+        qr = (p.data['qr'] + self.qmin) * q_step
+        int_peaks = p.data['intensity']
+        s_annular = p.data['sigma_annular'] * t_step
+        s_radial = (p.data['sigma_radial'] + self.qmin) * q_step
+
+        # unified coefficients
+        basis[1,1] = num_peaks
+        coefs_all = np.hstack((
+            self.background_coefs,
+            self.background_coefs,
+            ))
+        print(coefs_all.shape)
 
 
+        # Construct fitting model
+        def fit_image(basis,coefs):
 
+            pass
+
+
+
+    fig,ax = plt.subplots(figsize=(8,4))
+    ax.imshow(
+        im_polar,
+        cmap = 'turbo',
+        )
 
 
 def plot_radial_background(
@@ -865,7 +931,7 @@ def plot_radial_background(
 
 
     if q_pixel_units:
-        q_axis = np.arange(self.polar_shape[1])
+        q_axis = np.arange(self.qq.shape[0])
     else:
         q_axis = self.qq[self.background_mask]
 

From f41e19f1323735106f2bdf867eb8781fa485a660 Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Fri, 7 Jul 2023 14:32:25 -0700
Subject: [PATCH 138/362] Full pattern fitting for polar images is working!

---
 py4DSTEM/process/polar/polar_peaks.py | 134 ++++++++++++++++++++------
 1 file changed, 103 insertions(+), 31 deletions(-)

diff --git a/py4DSTEM/process/polar/polar_peaks.py b/py4DSTEM/process/polar/polar_peaks.py
index e040e4027..dceb13859 100644
--- a/py4DSTEM/process/polar/polar_peaks.py
+++ b/py4DSTEM/process/polar/polar_peaks.py
@@ -791,6 +791,7 @@ def refine_peaks(
     self,
     mask = None,
     # reset_fits_to_init_positions = False,
+    scale_sigma_estimate = 0.5,
     min_num_pixels_fit = 10,
     progress_bar = True,
     ):
@@ -808,6 +809,8 @@ def refine_peaks(
         Subtract radial background before fitting
     reset_fits_to_init_positions: bool
         Use the initial peak parameters for fitting
+    scale_sigma_estimate: float
+        Factor to reduce sigma of peaks by, to prevent fit from running away.
     min_num_pixels_fit: int
         Minimum number of pixels to perform fitting
     progress_bar: bool
@@ -818,20 +821,6 @@ def refine_peaks(
 
     """
 
-    # init
-    self.peaks_refine = PointListArray(
-        dtype = [
-        ('qt', '<f8'), 
-        ('qr', '<f8'), 
-        ('intensity', '<f8'), 
-        ('prom_annular', '<f8'), 
-        ('sigma_annular', '<f8'), 
-        ('prom_radial', '<f8'), 
-        ('sigma_radial', '<f8')],
-        shape = self._datacube.Rshape,
-        name = 'peaks_polardata_refined',
-        )
-
     # coordinate scaling
     t_step = self._annular_step
     q_step = self._radial_step
@@ -840,14 +829,37 @@ def refine_peaks(
     num_rings = np.round((self.background_coefs.shape[0]-3)/3).astype('int')
 
     # basis
-    basis = np.zeros((self.qq.shape[0],2))
-    basis[:,0] = self.qq
-    basis[1,0] = num_rings
+    qq,tt = np.meshgrid(
+        self.qq,
+        self.tt,
+        )
+    basis = np.zeros((qq.size,3))
+    basis[:,0] = tt.ravel()
+    basis[:,1] = qq.ravel()
+    basis[:,2] = num_rings
+
+    # init
+    self.peaks_refine = PointListArray(
+        dtype = [
+        ('qt', 'float'), 
+        ('qr', 'float'), 
+        ('intensity', 'float'), 
+        ('sigma_annular', 'float'), 
+        ('sigma_radial', 'float')],
+        shape = self._datacube.Rshape,
+        name = 'peaks_polardata_refined',
+        )
+    self.background_refine = np.zeros((
+        self.background_radial.shape[0],
+        self.background_radial.shape[0],
+        np.round(3*num_rings+3).astype('int'),
+        ))
+
 
     # Main loop over probe positions
     for rx, ry in tqdmnd(
         np.arange(40,41),#self._datacube.shape[0],
-        np.arange(20,21),#self._datacube.shape[1],
+        np.arange(70,71),#self._datacube.shape[1],
         desc="Refining peaks ",
         unit=" probe positions",
         disable=not progress_bar):
@@ -863,34 +875,94 @@ def refine_peaks(
 
         # Get initial peaks, in dimensioned units
         p = self.peaks[rx,ry]
-        num_peaks = p.data.shape[0]
         qt = p.data['qt'] * t_step
         qr = (p.data['qr'] + self.qmin) * q_step
         int_peaks = p.data['intensity']
         s_annular = p.data['sigma_annular'] * t_step
-        s_radial = (p.data['sigma_radial'] + self.qmin) * q_step
+        s_radial = p.data['sigma_radial'] * q_step
+        num_peaks = p['qt'].shape[0]
 
         # unified coefficients
-        basis[1,1] = num_peaks
+        # Note we sharpen sigma estimate for refinement
         coefs_all = np.hstack((
             self.background_coefs,
-            self.background_coefs,
+            qt,
+            qr,
+            int_peaks,
+            s_annular * scale_sigma_estimate,
+            s_radial * scale_sigma_estimate,
             ))
-        print(coefs_all.shape)
-
 
         # Construct fitting model
-        def fit_image(basis,coefs):
+        def fit_image(basis, *coefs):
+            coefs = np.squeeze(np.array(coefs))
 
-            pass
+            num_rings = np.round(basis[0,2]).astype('int')
+            num_peaks = np.round((coefs.shape[0] - (3*num_rings+3))/5).astype('int')
 
+            coefs_bg = coefs[:(3*num_rings+3)]
+            coefs_peaks = coefs[(3*num_rings+3):]
 
 
-    fig,ax = plt.subplots(figsize=(8,4))
-    ax.imshow(
-        im_polar,
-        cmap = 'turbo',
-        )
+            # Background
+            sig = self.background_model(
+                basis[:,1],
+                coefs_bg)
+
+            # add peaks
+            for a0 in range(num_peaks):
+                dt = np.mod(basis[:,0] - coefs_peaks[num_peaks*0+a0] + np.pi/2, np.pi) - np.pi/2
+                dq = basis[:,1] - coefs_peaks[num_peaks*1+a0]
+
+                sig += coefs_peaks[num_peaks*2+a0] \
+                    * np.exp(
+                        dt**2 / (-2*coefs_peaks[num_peaks*3+a0]**2) + \
+                        dq**2 / (-2*coefs_peaks[num_peaks*4+a0]**2))
+
+            return sig
+
+        # refine fitting model
+        coefs_all = curve_fit(
+            fit_image, 
+            basis[mask_bool.ravel(),:], 
+            im_polar[mask_bool], 
+            p0 = coefs_all,
+            xtol = 1e-12,
+            # bounds = (lb,ub),
+        )[0]
+
+        # Output refined parameters for background
+        coefs_bg = coefs_all[:(3*num_rings+3)]
+        self.background_refine[rx,ry] = coefs_bg
+
+        # Output refined peak parameters
+        coefs_peaks = np.reshape(
+            coefs_all[(3*num_rings+3):],
+            (5,num_peaks)).T
+        self.peaks_refine[rx,ry] = PointList(
+            coefs_peaks.ravel().view([
+                ('qt', float),
+                ('qr', float),
+                ('intensity', float),
+                ('sigma_annular', float),
+                ('sigma_radial', float),
+            ]),
+            name = 'peaks_polar')
+
+    # # Testing
+    # im_fit = np.reshape(
+    #     fit_image(basis,coefs_all),
+    #     self.polar_shape)
+
+
+    # fig,ax = plt.subplots(figsize=(8,6))
+    # ax.imshow(
+    #     np.vstack((
+    #         im_polar,
+    #         im_fit,
+    #     )),
+    #     cmap = 'turbo',
+    #     )
 
 
 def plot_radial_background(

From 4fadaaa6fbbd569871c6ac57e79a5ffa61baae29 Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Fri, 7 Jul 2023 14:43:12 -0700
Subject: [PATCH 139/362] Functional fitting code, cleaning up

---
 py4DSTEM/process/polar/polar_peaks.py | 63 ++++++++++++++++-----------
 1 file changed, 37 insertions(+), 26 deletions(-)

diff --git a/py4DSTEM/process/polar/polar_peaks.py b/py4DSTEM/process/polar/polar_peaks.py
index dceb13859..9383a194e 100644
--- a/py4DSTEM/process/polar/polar_peaks.py
+++ b/py4DSTEM/process/polar/polar_peaks.py
@@ -6,6 +6,7 @@
 from scipy.signal import peak_prominences
 from skimage.feature import peak_local_max
 from scipy.optimize import curve_fit
+import warnings
 
 # from emdfile import tqdmnd, PointList, PointListArray
 from py4DSTEM import tqdmnd, PointList, PointListArray
@@ -799,7 +800,9 @@ def refine_peaks(
     Use global fitting model for all images. Requires an background model 
     specified with self.model_radial_background().
 
-    TODO: add fitting reset
+    TODO:   add fitting reset
+            add min number pixels condition
+            track any failed fitting points, output as a boolean array
 
     Parameters
     --------
@@ -850,16 +853,16 @@ def refine_peaks(
         name = 'peaks_polardata_refined',
         )
     self.background_refine = np.zeros((
-        self.background_radial.shape[0],
-        self.background_radial.shape[0],
+        self._datacube.Rshape[0],
+        self._datacube.Rshape[1],
         np.round(3*num_rings+3).astype('int'),
         ))
 
 
     # Main loop over probe positions
     for rx, ry in tqdmnd(
-        np.arange(40,41),#self._datacube.shape[0],
-        np.arange(70,71),#self._datacube.shape[1],
+        self._datacube.shape[0],
+        self._datacube.shape[1],
         desc="Refining peaks ",
         unit=" probe positions",
         disable=not progress_bar):
@@ -922,32 +925,40 @@ def fit_image(basis, *coefs):
             return sig
 
         # refine fitting model
-        coefs_all = curve_fit(
-            fit_image, 
-            basis[mask_bool.ravel(),:], 
-            im_polar[mask_bool], 
-            p0 = coefs_all,
-            xtol = 1e-12,
-            # bounds = (lb,ub),
-        )[0]
+        try:
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore')
+                coefs_all = curve_fit(
+                    fit_image, 
+                    basis[mask_bool.ravel(),:], 
+                    im_polar[mask_bool], 
+                    p0 = coefs_all,
+                    xtol = 1e-12,
+                    # bounds = (lb,ub),
+                )[0]
+
+            # Output refined peak parameters
+            coefs_peaks = np.reshape(
+                coefs_all[(3*num_rings+3):],
+                (5,num_peaks)).T
+            self.peaks_refine[rx,ry] = PointList(
+                coefs_peaks.ravel().view([
+                    ('qt', float),
+                    ('qr', float),
+                    ('intensity', float),
+                    ('sigma_annular', float),
+                    ('sigma_radial', float),
+                ]),
+                name = 'peaks_polar')
+        except:
+            # if fitting has failed, we will output the mean background signal,
+            # but none of the peaks.
+            pass
 
         # Output refined parameters for background
         coefs_bg = coefs_all[:(3*num_rings+3)]
         self.background_refine[rx,ry] = coefs_bg
 
-        # Output refined peak parameters
-        coefs_peaks = np.reshape(
-            coefs_all[(3*num_rings+3):],
-            (5,num_peaks)).T
-        self.peaks_refine[rx,ry] = PointList(
-            coefs_peaks.ravel().view([
-                ('qt', float),
-                ('qr', float),
-                ('intensity', float),
-                ('sigma_annular', float),
-                ('sigma_radial', float),
-            ]),
-            name = 'peaks_polar')
 
     # # Testing
     # im_fit = np.reshape(

From 4b63a3a26a4f51f9e04ec6760bc96d2065fbf5d9 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 7 Jul 2023 17:21:08 -0700
Subject: [PATCH 140/362] Force COM measured for DPC

---
 .../process/phase/iterative_base_class.py     | 71 +++++++++++--------
 py4DSTEM/process/phase/iterative_dpc.py       | 24 +++++--
 .../iterative_overlap_magnetic_tomography.py  |  6 +-
 .../phase/iterative_overlap_tomography.py     |  6 +-
 4 files changed, 60 insertions(+), 47 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index 322de95bd..5888292c3 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -280,7 +280,7 @@ def _extract_intensities_and_calibrations_from_datacube(
 
         # Copies intensities to device casting to float32
         xp = self._xp
-        intensities = xp.asarray(datacube.data, dtype=xp.float32)
+        intensities = datacube.data
         self._grid_scan_shape = intensities.shape[:2]
 
         # Extracts calibrations
@@ -413,6 +413,7 @@ def _calculate_intensities_center_of_mass(
         dp_mask: np.ndarray = None,
         fit_function: str = "plane",
         com_shifts: np.ndarray = None,
+        com_measured: np.ndarray = None,
     ):
         """
         Common preprocessing function to compute and fit diffraction intensities CoM
@@ -425,9 +426,10 @@ def _calculate_intensities_center_of_mass(
             If not None, apply mask to datacube amplitude
         fit_function: str, optional
             2D fitting function for CoM fitting. One of 'plane','parabola','bezier_two'
-        com_shifts, np.ndarray, optional
+        com_shifts, tuple of ndarrays (CoMx measured, CoMy measured)
             If not None, com_shifts are fitted on the measured CoM values.
-
+        com_measured: tuple of ndarrays (CoMx measured, CoMy measured)
+            If not None, com_measured are passed as com_measured_x, com_measured_y
         Returns
         -------
 
@@ -448,39 +450,48 @@ def _calculate_intensities_center_of_mass(
         xp = self._xp
         asnumpy = self._asnumpy
 
-        # Coordinates
-        kx = xp.arange(intensities.shape[-2], dtype=xp.float32)
-        ky = xp.arange(intensities.shape[-1], dtype=xp.float32)
-        kya, kxa = xp.meshgrid(ky, kx)
+        intensities = xp.asarray(intensities, dtype=xp.float32)
+
+        # for ptycho
+        if com_measured:
+            com_measured_x, com_measured_y = com_measured
 
-        # calculate CoM
-        if dp_mask is not None:
-            if dp_mask.shape != intensities.shape[-2:]:
-                raise ValueError(
-                    (
-                        f"Mask shape should be (Qx,Qy):{intensities.shape[-2:]}, "
-                        f"not {dp_mask.shape}"
-                    )
-                )
-            intensities_mask = intensities * xp.asarray(dp_mask, dtype=xp.float32)
         else:
-            intensities_mask = intensities
+            # Coordinates
+            kx = xp.arange(intensities.shape[-2], dtype=xp.float32)
+            ky = xp.arange(intensities.shape[-1], dtype=xp.float32)
+            kya, kxa = xp.meshgrid(ky, kx)
 
-        intensities_sum = xp.sum(intensities_mask, axis=(-2, -1))
-        com_measured_x = (
-            xp.sum(intensities_mask * kxa[None, None], axis=(-2, -1)) / intensities_sum
-        )
-        com_measured_y = (
-            xp.sum(intensities_mask * kya[None, None], axis=(-2, -1)) / intensities_sum
-        )
+            # calculate CoM
+            if dp_mask is not None:
+                if dp_mask.shape != intensities.shape[-2:]:
+                    raise ValueError(
+                        (
+                            f"Mask shape should be (Qx,Qy):{intensities.shape[-2:]}, "
+                            f"not {dp_mask.shape}"
+                        )
+                    )
+                intensities_mask = intensities * xp.asarray(dp_mask, dtype=xp.float32)
+            else:
+                intensities_mask = intensities
+
+            intensities_sum = xp.sum(intensities_mask, axis=(-2, -1))
+            com_measured_x = (
+                xp.sum(intensities_mask * kxa[None, None], axis=(-2, -1))
+                / intensities_sum
+            )
+            com_measured_y = (
+                xp.sum(intensities_mask * kya[None, None], axis=(-2, -1))
+                / intensities_sum
+            )
 
-        # Fit function to center of mass
         if com_shifts is None:
             com_shifts = fit_origin(
                 (asnumpy(com_measured_x), asnumpy(com_measured_y)),
                 fitfunction=fit_function,
             )
 
+        # Fit function to center of mass
         com_fitted_x = xp.asarray(com_shifts[0], dtype=xp.float32)
         com_fitted_y = xp.asarray(com_shifts[1], dtype=xp.float32)
 
@@ -992,8 +1003,8 @@ def _solve_for_center_of_mass_relative_rotation(
             cmap = kwargs.pop("cmap", "RdBu_r")
             extent = [
                 0,
-                self._scan_sampling[1] * self._intensities.shape[1],
-                self._scan_sampling[0] * self._intensities.shape[0],
+                self._scan_sampling[1] * _com_measured_x.shape[1],
+                self._scan_sampling[0] * _com_measured_x.shape[0],
                 0,
             ]
 
@@ -1030,8 +1041,8 @@ def _solve_for_center_of_mass_relative_rotation(
 
             extent = [
                 0,
-                self._scan_sampling[1] * self._intensities.shape[1],
-                self._scan_sampling[0] * self._intensities.shape[0],
+                self._scan_sampling[1] * com_x.shape[1],
+                self._scan_sampling[0] * com_x.shape[0],
                 0,
             ]
 
diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index 583128da5..4be160c64 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -4,7 +4,7 @@
 """
 
 import warnings
-from typing import Tuple
+from typing import Tuple, Union, Sequence
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -238,7 +238,8 @@ def preprocess(
         fit_function: str = "plane",
         force_com_rotation: float = None,
         force_com_transpose: bool = None,
-        force_com_shifts: float = None,
+        force_com_shifts: Union[Sequence[np.ndarray], Sequence[float]] = None,
+        force_com_measured: Sequence[np.ndarray] = None,
         plot_center_of_mass: str = "default",
         plot_rotation: bool = True,
         **kwargs,
@@ -269,6 +270,8 @@ def preprocess(
             Force whether diffraction intensities need to be transposed.
         force_com_shifts: tuple of ndarrays (CoMx, CoMy)
             Force CoM fitted shifts
+        force_com_measured: tuple of ndarrays (CoMx measured, CoMy measured)
+            Force CoM measured shifts
         plot_center_of_mass: str, optional
             If 'default', the corrected CoM arrays will be displayed
             If 'all', the computed and fitted CoM arrays will be displayed
@@ -286,12 +289,18 @@ def preprocess(
         self._dp_mask = dp_mask
 
         if self._datacube is None:
-            raise ValueError(
-                (
-                    "The preprocess() method requires a DataCube. "
-                    "Please run dpc.attach_datacube(DataCube) first."
+            if force_com_measured is None:
+                raise ValueError(
+                    (
+                        "The preprocess() method requires either a DataCube "
+                        "or `force_com_measured`. "
+                        "Please run dpc.attach_datacube(DataCube) to attach DataCube."
+                    )
+                )
+            else:
+                self._datacube = DataCube(
+                    data=np.empty(force_com_measured[0].shape + (1, 1))
                 )
-            )
 
         self._intensities = self._extract_intensities_and_calibrations_from_datacube(
             self._datacube,
@@ -310,6 +319,7 @@ def preprocess(
             dp_mask=self._dp_mask,
             fit_function=fit_function,
             com_shifts=force_com_shifts,
+            com_measured=force_com_measured,
         )
 
         (
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 0c751cd33..7c88931a5 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -2488,11 +2488,7 @@ def reconstruct(
             if collective_tilt_updates:
                 self._object += collective_object / self._num_tilts
 
-                (
-                    self._object,
-                    self._probe,
-                    _,
-                ) = self._constraints(
+                (self._object, self._probe, _,) = self._constraints(
                     self._object,
                     self._probe,
                     None,
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index 61d40473d..6b0a16e2e 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -2212,11 +2212,7 @@ def reconstruct(
             if collective_tilt_updates:
                 self._object += collective_object / self._num_tilts
 
-                (
-                    self._object,
-                    self._probe,
-                    _,
-                ) = self._constraints(
+                (self._object, self._probe, _,) = self._constraints(
                     self._object,
                     self._probe,
                     None,

From 14c6865463c790c766938c1af3fba31378a8d110 Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Fri, 7 Jul 2023 18:45:23 -0700
Subject: [PATCH 141/362] New options for flowline orientation maps

Allowing peak sigma in bins
---
 py4DSTEM/process/polar/polar_peaks.py | 25 +++++++++++++++++++++++--
 py4DSTEM/visualize/show.py            |  8 ++++++--
 2 files changed, 29 insertions(+), 4 deletions(-)

diff --git a/py4DSTEM/process/polar/polar_peaks.py b/py4DSTEM/process/polar/polar_peaks.py
index 9383a194e..2bbac32e4 100644
--- a/py4DSTEM/process/polar/polar_peaks.py
+++ b/py4DSTEM/process/polar/polar_peaks.py
@@ -1083,6 +1083,9 @@ def make_orientation_histogram(
     orientation_offset_degrees: float = 0.0,
     orientation_separate_bins: bool = False,
     upsample_factor: float = 4.0,
+    use_refined_peaks = True,
+    use_peak_sigma = False,
+    peak_sigma_samples = 6,
     theta_step_deg: float = None,
     sigma_x: float = 1.0,
     sigma_y: float = 1.0,
@@ -1104,6 +1107,8 @@ def make_orientation_histogram(
         orientation_offset_degrees (float): Offset for orientation angles
         orientation_separate_bins (bool):   whether to place multiple angles into multiple radial bins.
         upsample_factor (float):            Upsample factor
+        use_refined_peaks (float):          Use refined peak positions
+        use_peak_sigma (float):             Spread signal along annular direction using measured std.
         theta_step_deg (float):             Step size along annular direction in degrees
         sigma_x (float):                    Smoothing in x direction before upsample
         sigma_y (float):                    Smoothing in x direction before upsample
@@ -1145,6 +1150,10 @@ def make_orientation_histogram(
         size_output[1],
         num_theta_bins])
 
+    if use_peak_sigma:
+        v_sigma = np.linspace(-2,2,2*peak_sigma_samples+1)
+        w_sigma = np.exp(-v_sigma**2/2)
+
     # Loop over all probe positions
     for a0 in range(num_radii):
         t = "Generating histogram " + str(a0)
@@ -1168,7 +1177,10 @@ def make_orientation_histogram(
             dy = y - yF
 
             add_data = False
-            q = (self.peaks[rx,ry]['qr'] + self.qmin) * self._radial_step
+            if use_refined_peaks:
+                q = self.peaks_refine[rx,ry]['qr']
+            else:
+                q = (self.peaks[rx,ry]['qr'] + self.qmin) * self._radial_step
             r2 = q**2
             sub = np.logical_and(r2 >= radial_ranges_2[a0,0], r2 < radial_ranges_2[a0,1])                
 
@@ -1177,13 +1189,22 @@ def make_orientation_histogram(
                 intensity = self.peaks[rx,ry]['intensity'][sub]
 
                 # Angles of all peaks
-                theta = self.peaks[rx,ry]['qt'][sub] * self._annular_step
+                if use_refined_peaks:
+                    theta = self.peaks_refine[rx,ry]['qt'][sub]
+                else:
+                    theta = self.peaks[rx,ry]['qt'][sub] * self._annular_step
                 if orientation_flip_sign:
                     theta *= -1
                 theta += orientation_offset_degrees
 
                 t = theta / dtheta
 
+                # If needed, expand signal using peak sigma to write into multiple bins
+                if use_peak_sigma:
+                    theta_std = self.peaks_refine[rx,ry]['sigma_annular'][sub] / dtheta
+                    t = (t[:,None] + theta_std[:,None]*v_sigma[None,:]).ravel()
+                    intensity = (intensity[:,None] * w_sigma[None,:]).ravel()
+
             if add_data:
                 tF = np.floor(t).astype('int')
                 dt = t - tF
diff --git a/py4DSTEM/visualize/show.py b/py4DSTEM/visualize/show.py
index 45a5b7395..b8df4047c 100644
--- a/py4DSTEM/visualize/show.py
+++ b/py4DSTEM/visualize/show.py
@@ -567,8 +567,12 @@ def show(
                     ax.matshow(mask_display,cmap=cmap,alpha=mask_alpha,vmin=vmin,vmax=vmax)
         # ...or, plot its histogram
         else:
-            hist,bin_edges = np.histogram(_ar,bins=np.linspace(np.min(_ar),
-                                                    np.max(_ar),num=n_bins))
+            # hist,bin_edges = np.histogram(
+            #     _ar,
+            #     bins=np.linspace(np.min(_ar),np.max(_ar),num=n_bins))
+            hist,bin_edges = np.histogram(
+                _ar,
+                bins=np.linspace(vmin,vmax,num=n_bins))
             w = bin_edges[1]-bin_edges[0]
             x = bin_edges[:-1]+w/2.
             ax.bar(x,hist,width=w)

From 696bc338a708896df122791f591d4278b6db369a Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Fri, 7 Jul 2023 18:47:13 -0700
Subject: [PATCH 142/362] Cleaning up

---
 py4DSTEM/process/polar/polar_peaks.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/py4DSTEM/process/polar/polar_peaks.py b/py4DSTEM/process/polar/polar_peaks.py
index 2bbac32e4..3f367b398 100644
--- a/py4DSTEM/process/polar/polar_peaks.py
+++ b/py4DSTEM/process/polar/polar_peaks.py
@@ -1157,9 +1157,7 @@ def make_orientation_histogram(
     # Loop over all probe positions
     for a0 in range(num_radii):
         t = "Generating histogram " + str(a0)
-        # for rx, ry in tqdmnd(
-        #         *bragg_peaks.shape, desc=t,unit=" probe positions", disable=not progress_bar
-        #     ):
+
         for rx, ry in tqdmnd(
                 *size_input, 
                 desc=t,

From 0e69450905db00584c7f88c25a8d71a5eb375c1d Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Sat, 8 Jul 2023 07:00:14 -0700
Subject: [PATCH 143/362] bug fix

---
 py4DSTEM/process/phase/iterative_parallax.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/py4DSTEM/process/phase/iterative_parallax.py b/py4DSTEM/process/phase/iterative_parallax.py
index 5ab4c6cdd..576342631 100644
--- a/py4DSTEM/process/phase/iterative_parallax.py
+++ b/py4DSTEM/process/phase/iterative_parallax.py
@@ -171,6 +171,7 @@ def preprocess(
             self._datacube,
             require_calibrations=True,
         )
+        self._intensities = xp.asarray(self._intensities, dtype=xp.float32)
 
         # make sure mean diffraction pattern is shaped correctly
         if (self._dp_mean.shape[0] != self._intensities.shape[2]) or (

From 1990b8e9ea456dd9eedd2578565bcc5067e8b981 Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Sun, 9 Jul 2023 19:04:59 -0700
Subject: [PATCH 144/362] Adding probe amplitude regularization

---
 py4DSTEM/process/phase/utils.py | 242 ++++++++++++++++++++++++++++++++
 1 file changed, 242 insertions(+)

diff --git a/py4DSTEM/process/phase/utils.py b/py4DSTEM/process/phase/utils.py
index d57ad820a..8442b6cbc 100644
--- a/py4DSTEM/process/phase/utils.py
+++ b/py4DSTEM/process/phase/utils.py
@@ -3,6 +3,7 @@
 import matplotlib.pyplot as plt
 import numpy as np
 import functools
+from scipy.optimize import curve_fit
 
 try:
     import cupy as cp
@@ -1274,3 +1275,244 @@ def nesterov_gamma(zero_indexed_iter_num):
     return (1 - nesterov_lambda(one_indexed_iter_num)) / nesterov_lambda(
         one_indexed_iter_num + 1
     )
+
+
+
+
+
+
+def regularize_probe_amp(
+    probe_init,
+    width_max_pixels = 2.0,
+    plot_polar = False,
+    plot_result = False,
+    figsize = (5,5),
+    ):
+    """
+    Assume that the probe is centered in Fourier space.  Note that I re-implemented the polar/cartesian transforms here for portability.
+    """
+
+    # Get probe intensity
+    probe_amp = np.abs(probe_init)
+    probe_int = probe_amp**2
+    
+    # coordinates
+    xa,ya = np.meshgrid(
+        np.arange(probe_init.shape[0]),
+        np.arange(probe_init.shape[1]),
+        indexing = 'ij',
+        )
+
+    # Center of mass for probe intensity
+    int_total = np.sum(probe_int)
+    xy_center = (
+        np.sum(probe_int * xa) / int_total,
+        np.sum(probe_int * ya) / int_total,
+        )
+
+    # Convert intensity to polar coordinates
+    polar_int = im_cart_to_polar(
+        probe_int,
+        xy_center = xy_center,
+        )
+
+    # Fit corrected probe intensity
+    radius = np.arange(polar_int.shape[1])
+
+    # estimate initial parameters
+    sub = polar_int > (np.max(polar_int)*0.5)
+    sig_0 = np.mean(polar_int[sub])
+    rad_0 = np.max(np.argwhere(np.sum(sub,axis=0)))
+    width = np.minimum(1.0, width_max_pixels)
+
+    # init
+    coefs_all = np.zeros((polar_int.shape[0],3))
+    coefs_all[:,0] = sig_0
+    coefs_all[:,1] = rad_0
+    coefs_all[:,2] = width
+
+    # bounds
+    lb = (0, 0, 0.5)
+    ub = (np.inf, np.inf, width_max_pixels)
+
+    # refine parameters, generate polar image
+    polar_fit = np.zeros_like(polar_int)
+    for a0 in range(polar_int.shape[0]):
+        coefs_all[a0,:] = curve_fit(
+                step_model, 
+                radius, 
+                polar_int[a0,:], 
+                p0 = coefs_all[a0,:],
+                xtol = 1e-12,
+                bounds = (lb,ub),
+            )[0]
+        polar_fit[a0,:] = step_model(
+            radius,
+            coefs_all[a0,:])
+
+    # Compute best-fit constant intensity inside probe
+    sig_0 = np.median(coefs_all[:,0])
+    coefs_all[:,0] = sig_0
+    lb = (sig_0-1e-8, 0, 0.5)
+    ub = (sig_0+1e-8, np.inf, width_max_pixels)
+
+    # refine parameters, generate polar image
+    polar_int_corr = np.zeros_like(polar_int)
+    for a0 in range(polar_int.shape[0]):
+        coefs_all[a0,:] = curve_fit(
+                step_model, 
+                radius, 
+                polar_int[a0,:], 
+                p0 = coefs_all[a0,:],
+                xtol = 1e-12,
+                bounds = (lb,ub),
+            )[0]
+        polar_int_corr[a0,:] = step_model(
+            radius,
+            coefs_all[a0,:])
+
+    # Convert back to cartesian coordinates
+    int_corr = im_polar_to_cart(
+        polar_int_corr,
+        xy_size = probe_init.shape, 
+        xy_center = xy_center,
+        )
+
+    # Assemble output probe
+    probe_corr = np.sqrt(np.maximum(int_corr,0)) \
+        * np.exp(1j*np.angle(probe_init))
+
+    # plotting
+    if plot_result:
+        fig,ax = plt.subplots(figsize = (figsize[0]*2, figsize[1]))
+        ax.imshow(
+            np.hstack((
+                probe_int,
+                int_corr,
+            )),
+            cmap = 'turbo',
+            )
+    if plot_polar:
+        fig,ax = plt.subplots(figsize = figsize)
+        ax.imshow(
+            np.hstack((
+                polar_int,
+                polar_fit,
+                polar_int_corr,
+            )),
+            cmap = 'turbo',
+            )    
+
+    return probe_corr
+    
+
+def step_model(radius, *coefs):
+    coefs = np.squeeze(np.array(coefs))
+
+    sig_0 = coefs[0]
+    rad_0 = coefs[1]
+    width = coefs[2]
+
+    return sig_0 * np.clip((rad_0 - radius) / width, 0, 1)
+
+
+def im_cart_to_polar(
+    im_cart,
+    xy_center,
+    num_theta_bins = 180,
+    radius_max = None,
+    ):
+    """
+    Quick cartesian to polar conversion.
+    """
+
+    # coordinates
+    xa,ya = np.meshgrid(
+        np.arange(im_cart.shape[0]),
+        np.arange(im_cart.shape[1]),
+        indexing = 'ij',
+        )    
+    if radius_max is None:
+        radius_max = np.ceil(np.sqrt(np.sum(
+            np.array(im_cart.shape).astype('float')**2
+            )) / 2.0).astype('int')
+    r = np.arange(radius_max)
+    t = np.linspace(
+        0,
+        2.0*np.pi,
+        num_theta_bins,
+        endpoint = False,
+        )
+    ra,ta = np.meshgrid(r,t)
+
+    # resampling coordinates
+    x = (ra * np.cos(ta) + xy_center[0])
+    y = (ra * np.sin(ta) + xy_center[1])
+    xf = np.floor(x).astype('int')
+    yf = np.floor(y).astype('int')
+    dx = x - xf
+    dy = y - yf
+
+    # resample image
+    im_polar = \
+        im_cart.ravel()[np.ravel_multi_index(
+            (xf,    yf),
+            im_cart.shape,
+            mode='clip',
+            )] * (1-dx) * (1-dy) + \
+        im_cart.ravel()[np.ravel_multi_index(
+            (xf+1,  yf),
+            im_cart.shape,
+            mode='clip',
+            )] * (  dx) * (1-dy) + \
+        im_cart.ravel()[np.ravel_multi_index(
+            (xf,    yf+1),
+            im_cart.shape,
+            mode='clip',
+            )] * (1-dx) * (  dy) + \
+        im_cart.ravel()[np.ravel_multi_index(
+            (xf+1,  yf+1),
+            im_cart.shape,
+            mode='clip',
+            )] * (  dx) * (  dy)
+
+    return im_polar
+
+
+def im_polar_to_cart(
+    im_polar,
+    xy_size,
+    xy_center,
+    ):
+    """
+    Quick cartesian to polar conversion.
+    """
+
+    # coordinates
+    xa,ya = np.meshgrid(
+        np.arange(xy_size[0]) - xy_center[0],
+        np.arange(xy_size[1]) - xy_center[1],
+        indexing = 'ij',
+        )  
+    ra = np.sqrt(xa**2 + ya**2)
+    ta = np.arctan2(ya,xa)
+    t = np.linspace(0,2*np.pi,im_polar.shape[0],endpoint = False)
+    t_step = t[1] - t[0]
+
+    # resampling coordinates
+    t_ind = ta / t_step
+    r_ind = ra.copy()
+    tf = np.floor(t_ind).astype('int')
+    rf = np.floor(r_ind).astype('int')
+    dt = t_ind - tf
+    dr = r_ind - rf
+
+    # resample image
+    im_cart = im_polar.ravel()[np.ravel_multi_index(
+            (np.mod(tf, im_polar.shape[0]),    rf),
+            im_polar.shape,
+            mode='clip',
+            )]
+
+    return im_cart
+

From af6f030b56ff50f1edf84545c774685536177e48 Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Sun, 9 Jul 2023 19:08:45 -0700
Subject: [PATCH 145/362] Adding docstrings

---
 py4DSTEM/process/phase/utils.py | 32 ++++++++++++++++++++++++++++++--
 1 file changed, 30 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/process/phase/utils.py b/py4DSTEM/process/phase/utils.py
index 8442b6cbc..112b1242c 100644
--- a/py4DSTEM/process/phase/utils.py
+++ b/py4DSTEM/process/phase/utils.py
@@ -1284,12 +1284,40 @@ def nesterov_gamma(zero_indexed_iter_num):
 def regularize_probe_amp(
     probe_init,
     width_max_pixels = 2.0,
-    plot_polar = False,
     plot_result = False,
+    plot_polar = False,
+    cmap = 'turbo',
     figsize = (5,5),
     ):
     """
-    Assume that the probe is centered in Fourier space.  Note that I re-implemented the polar/cartesian transforms here for portability.
+    Assume that the probe is centered in Fourier space.  Note we 
+    re-implemented the polar/cartesian transforms here for portability.
+    
+    Parameters
+    --------
+    probe_init: np.array
+        2D complex image of the probe in Fourier space.
+    width_max_pixels: float
+        Maximum edge width of the probe in pixels.
+    plot_result: bool
+        Plot the input and output probes.
+    plot_polar: bool
+        Plot the polar transformed images:
+        1 - initial probe
+        2 - best fit of step model for each line
+        3 - best fit enforcing constant intensity inside aperture
+    cmap: string
+        colormap of the plots.
+    figsize: tuple
+        size of the output figures.
+        (will be doubled along horizontal axis for cartesian images)
+
+    Returns
+    --------
+    probe_corr: np.array
+        2D complex image of the corrected probe in Fourier space.
+
+
     """
 
     # Get probe intensity

From c41a93fe96666679167494a4e255f2798b36de0b Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Sun, 9 Jul 2023 19:23:55 -0700
Subject: [PATCH 146/362] adding more options, cleaning up

---
 py4DSTEM/process/phase/utils.py | 64 ++++++++++++++++++++-------------
 1 file changed, 40 insertions(+), 24 deletions(-)

diff --git a/py4DSTEM/process/phase/utils.py b/py4DSTEM/process/phase/utils.py
index 112b1242c..29b76165c 100644
--- a/py4DSTEM/process/phase/utils.py
+++ b/py4DSTEM/process/phase/utils.py
@@ -1284,6 +1284,8 @@ def nesterov_gamma(zero_indexed_iter_num):
 def regularize_probe_amp(
     probe_init,
     width_max_pixels = 2.0,
+    enforce_constant_intensity = True,
+    return_coefs = False,
     plot_result = False,
     plot_polar = False,
     cmap = 'turbo',
@@ -1299,6 +1301,10 @@ def regularize_probe_amp(
         2D complex image of the probe in Fourier space.
     width_max_pixels: float
         Maximum edge width of the probe in pixels.
+    enforce_constant_intensity: bool
+        Set to true to make intensity inside the aperture constant.
+    return_coefs: bool
+        If true, fitting coefficients will also be returned.
     plot_result: bool
         Plot the input and output probes.
     plot_polar: bool
@@ -1316,6 +1322,9 @@ def regularize_probe_amp(
     --------
     probe_corr: np.array
         2D complex image of the corrected probe in Fourier space.
+    coefs_all: np.array (optional)
+        coefficients for the 
+
 
 
     """
@@ -1323,7 +1332,7 @@ def regularize_probe_amp(
     # Get probe intensity
     probe_amp = np.abs(probe_init)
     probe_int = probe_amp**2
-    
+
     # coordinates
     xa,ya = np.meshgrid(
         np.arange(probe_init.shape[0]),
@@ -1351,7 +1360,7 @@ def regularize_probe_amp(
     sub = polar_int > (np.max(polar_int)*0.5)
     sig_0 = np.mean(polar_int[sub])
     rad_0 = np.max(np.argwhere(np.sum(sub,axis=0)))
-    width = np.minimum(1.0, width_max_pixels)
+    width = width_max_pixels * 0.5
 
     # init
     coefs_all = np.zeros((polar_int.shape[0],3))
@@ -1360,7 +1369,7 @@ def regularize_probe_amp(
     coefs_all[:,2] = width
 
     # bounds
-    lb = (0, 0, 0.5)
+    lb = (0.0, 0.0, 1e-4)
     ub = (np.inf, np.inf, width_max_pixels)
 
     # refine parameters, generate polar image
@@ -1378,26 +1387,30 @@ def regularize_probe_amp(
             radius,
             coefs_all[a0,:])
 
-    # Compute best-fit constant intensity inside probe
-    sig_0 = np.median(coefs_all[:,0])
-    coefs_all[:,0] = sig_0
-    lb = (sig_0-1e-8, 0, 0.5)
-    ub = (sig_0+1e-8, np.inf, width_max_pixels)
+    if enforce_constant_intensity:
+        # Compute best-fit constant intensity inside probe, update bounds
+        sig_0 = np.median(coefs_all[:,0])
+        coefs_all[:,0] = sig_0
+        lb = (sig_0-1e-8, 0.0, 1e-4)
+        ub = (sig_0+1e-8, np.inf, width_max_pixels)
+
+        # refine parameters, generate polar image
+        polar_int_corr = np.zeros_like(polar_int)
+        for a0 in range(polar_int.shape[0]):
+            coefs_all[a0,:] = curve_fit(
+                    step_model, 
+                    radius, 
+                    polar_int[a0,:], 
+                    p0 = coefs_all[a0,:],
+                    xtol = 1e-12,
+                    bounds = (lb,ub),
+                )[0]
+            polar_int_corr[a0,:] = step_model(
+                radius,
+                coefs_all[a0,:])
 
-    # refine parameters, generate polar image
-    polar_int_corr = np.zeros_like(polar_int)
-    for a0 in range(polar_int.shape[0]):
-        coefs_all[a0,:] = curve_fit(
-                step_model, 
-                radius, 
-                polar_int[a0,:], 
-                p0 = coefs_all[a0,:],
-                xtol = 1e-12,
-                bounds = (lb,ub),
-            )[0]
-        polar_int_corr[a0,:] = step_model(
-            radius,
-            coefs_all[a0,:])
+    else:
+        polar_int_corr = polar_fit
 
     # Convert back to cartesian coordinates
     int_corr = im_polar_to_cart(
@@ -1431,7 +1444,10 @@ def regularize_probe_amp(
             cmap = 'turbo',
             )    
 
-    return probe_corr
+    if return_coefs:
+        return probe_corr, coefs_all
+    else:
+        return probe_corr
     
 
 def step_model(radius, *coefs):
@@ -1441,7 +1457,7 @@ def step_model(radius, *coefs):
     rad_0 = coefs[1]
     width = coefs[2]
 
-    return sig_0 * np.clip((rad_0 - radius) / width, 0, 1)
+    return sig_0 * np.clip((rad_0 - radius) / width, 0.0, 1.0)
 
 
 def im_cart_to_polar(

From df7e9b42787638437593f531d9cf05468bd8ee42 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Sun, 9 Jul 2023 21:44:02 -0700
Subject: [PATCH 147/362] updated Colins code to work with corner-centered
 probes. will clean up and port to constraints tomorrow morning.

---
 py4DSTEM/process/phase/utils.py | 283 ++++++++++++++++----------------
 1 file changed, 140 insertions(+), 143 deletions(-)

diff --git a/py4DSTEM/process/phase/utils.py b/py4DSTEM/process/phase/utils.py
index 29b76165c..c92f0d38b 100644
--- a/py4DSTEM/process/phase/utils.py
+++ b/py4DSTEM/process/phase/utils.py
@@ -14,6 +14,7 @@
 
 from py4DSTEM.process.utils.cross_correlate import align_and_shift_images
 from py4DSTEM.process.utils.utils import electron_wavelength_angstrom
+from py4DSTEM.process.utils import get_CoM
 from scipy.ndimage import gaussian_filter
 
 # fmt: off
@@ -1277,24 +1278,20 @@ def nesterov_gamma(zero_indexed_iter_num):
     )
 
 
-
-
-
-
 def regularize_probe_amp(
     probe_init,
-    width_max_pixels = 2.0,
-    enforce_constant_intensity = True,
-    return_coefs = False,
-    plot_result = False,
-    plot_polar = False,
-    cmap = 'turbo',
-    figsize = (5,5),
-    ):
+    width_max_pixels=2.0,
+    enforce_constant_intensity=True,
+    return_coefs=False,
+    plot_result=False,
+    plot_polar=False,
+    cmap="turbo",
+    figsize=(5, 5),
+):
     """
-    Assume that the probe is centered in Fourier space.  Note we 
+    Assumes the probe is corner-centered in Fourier space.  Note we
     re-implemented the polar/cartesian transforms here for portability.
-    
+
     Parameters
     --------
     probe_init: np.array
@@ -1323,50 +1320,36 @@ def regularize_probe_amp(
     probe_corr: np.array
         2D complex image of the corrected probe in Fourier space.
     coefs_all: np.array (optional)
-        coefficients for the 
-
-
-
+        coefficients for the
     """
 
     # Get probe intensity
     probe_amp = np.abs(probe_init)
     probe_int = probe_amp**2
 
-    # coordinates
-    xa,ya = np.meshgrid(
-        np.arange(probe_init.shape[0]),
-        np.arange(probe_init.shape[1]),
-        indexing = 'ij',
-        )
-
     # Center of mass for probe intensity
-    int_total = np.sum(probe_int)
-    xy_center = (
-        np.sum(probe_int * xa) / int_total,
-        np.sum(probe_int * ya) / int_total,
-        )
+    xy_center = get_CoM(probe_int, device="cpu", corner_centered=True)
 
     # Convert intensity to polar coordinates
-    polar_int = im_cart_to_polar(
+    polar_int = cartesian_to_polar_transform_2Ddata(
         probe_int,
-        xy_center = xy_center,
-        )
+        xy_center=xy_center,
+    )
 
     # Fit corrected probe intensity
     radius = np.arange(polar_int.shape[1])
 
     # estimate initial parameters
-    sub = polar_int > (np.max(polar_int)*0.5)
+    sub = polar_int > (np.max(polar_int) * 0.5)
     sig_0 = np.mean(polar_int[sub])
-    rad_0 = np.max(np.argwhere(np.sum(sub,axis=0)))
+    rad_0 = np.max(np.argwhere(np.sum(sub, axis=0)))
     width = width_max_pixels * 0.5
 
     # init
-    coefs_all = np.zeros((polar_int.shape[0],3))
-    coefs_all[:,0] = sig_0
-    coefs_all[:,1] = rad_0
-    coefs_all[:,2] = width
+    coefs_all = np.zeros((polar_int.shape[0], 3))
+    coefs_all[:, 0] = sig_0
+    coefs_all[:, 1] = rad_0
+    coefs_all[:, 2] = width
 
     # bounds
     lb = (0.0, 0.0, 1e-4)
@@ -1375,80 +1358,79 @@ def regularize_probe_amp(
     # refine parameters, generate polar image
     polar_fit = np.zeros_like(polar_int)
     for a0 in range(polar_int.shape[0]):
-        coefs_all[a0,:] = curve_fit(
-                step_model, 
-                radius, 
-                polar_int[a0,:], 
-                p0 = coefs_all[a0,:],
-                xtol = 1e-12,
-                bounds = (lb,ub),
-            )[0]
-        polar_fit[a0,:] = step_model(
+        coefs_all[a0, :] = curve_fit(
+            step_model,
             radius,
-            coefs_all[a0,:])
+            polar_int[a0, :],
+            p0=coefs_all[a0, :],
+            xtol=1e-12,
+            bounds=(lb, ub),
+        )[0]
+        polar_fit[a0, :] = step_model(radius, coefs_all[a0, :])
 
     if enforce_constant_intensity:
         # Compute best-fit constant intensity inside probe, update bounds
-        sig_0 = np.median(coefs_all[:,0])
-        coefs_all[:,0] = sig_0
-        lb = (sig_0-1e-8, 0.0, 1e-4)
-        ub = (sig_0+1e-8, np.inf, width_max_pixels)
+        sig_0 = np.median(coefs_all[:, 0])
+        coefs_all[:, 0] = sig_0
+        lb = (sig_0 - 1e-8, 0.0, 1e-4)
+        ub = (sig_0 + 1e-8, np.inf, width_max_pixels)
 
         # refine parameters, generate polar image
         polar_int_corr = np.zeros_like(polar_int)
         for a0 in range(polar_int.shape[0]):
-            coefs_all[a0,:] = curve_fit(
-                    step_model, 
-                    radius, 
-                    polar_int[a0,:], 
-                    p0 = coefs_all[a0,:],
-                    xtol = 1e-12,
-                    bounds = (lb,ub),
-                )[0]
-            polar_int_corr[a0,:] = step_model(
+            coefs_all[a0, :] = curve_fit(
+                step_model,
                 radius,
-                coefs_all[a0,:])
+                polar_int[a0, :],
+                p0=coefs_all[a0, :],
+                xtol=1e-12,
+                bounds=(lb, ub),
+            )[0]
+            polar_int_corr[a0, :] = step_model(radius, coefs_all[a0, :])
 
     else:
         polar_int_corr = polar_fit
 
     # Convert back to cartesian coordinates
-    int_corr = im_polar_to_cart(
+    int_corr = polar_to_cartesian_transform_2Ddata(
         polar_int_corr,
-        xy_size = probe_init.shape, 
-        xy_center = xy_center,
-        )
+        xy_size=probe_init.shape,
+        xy_center=xy_center,
+    )
 
     # Assemble output probe
-    probe_corr = np.sqrt(np.maximum(int_corr,0)) \
-        * np.exp(1j*np.angle(probe_init))
+    probe_corr = np.sqrt(np.maximum(int_corr, 0)) * np.exp(1j * np.angle(probe_init))
 
     # plotting
     if plot_result:
-        fig,ax = plt.subplots(figsize = (figsize[0]*2, figsize[1]))
+        fig, ax = plt.subplots(figsize=(figsize[0] * 2, figsize[1]))
         ax.imshow(
-            np.hstack((
-                probe_int,
-                int_corr,
-            )),
-            cmap = 'turbo',
-            )
+            np.hstack(
+                (
+                    np.fft.fftshift(probe_int),
+                    np.fft.fftshift(int_corr),
+                )
+            ),
+            cmap="turbo",
+        )
     if plot_polar:
-        fig,ax = plt.subplots(figsize = figsize)
+        fig, ax = plt.subplots(figsize=figsize)
         ax.imshow(
-            np.hstack((
-                polar_int,
-                polar_fit,
-                polar_int_corr,
-            )),
-            cmap = 'turbo',
-            )    
+            np.hstack(
+                (
+                    polar_int,
+                    polar_fit,
+                    polar_int_corr,
+                )
+            ),
+            cmap="turbo",
+        )
 
     if return_coefs:
         return probe_corr, coefs_all
     else:
         return probe_corr
-    
+
 
 def step_model(radius, *coefs):
     coefs = np.squeeze(np.array(coefs))
@@ -1460,103 +1442,118 @@ def step_model(radius, *coefs):
     return sig_0 * np.clip((rad_0 - radius) / width, 0.0, 1.0)
 
 
-def im_cart_to_polar(
+def cartesian_to_polar_transform_2Ddata(
     im_cart,
     xy_center,
-    num_theta_bins = 180,
-    radius_max = None,
-    ):
+    num_theta_bins=180,
+    radius_max=None,
+):
     """
     Quick cartesian to polar conversion.
     """
 
     # coordinates
-    xa,ya = np.meshgrid(
-        np.arange(im_cart.shape[0]),
-        np.arange(im_cart.shape[1]),
-        indexing = 'ij',
-        )    
     if radius_max is None:
-        radius_max = np.ceil(np.sqrt(np.sum(
-            np.array(im_cart.shape).astype('float')**2
-            )) / 2.0).astype('int')
+        radius_max = np.min(np.array(im_cart.shape) // 2)
+
     r = np.arange(radius_max)
     t = np.linspace(
         0,
-        2.0*np.pi,
+        2.0 * np.pi,
         num_theta_bins,
-        endpoint = False,
-        )
-    ra,ta = np.meshgrid(r,t)
+        endpoint=False,
+    )
+    ra, ta = np.meshgrid(r, t)
 
     # resampling coordinates
-    x = (ra * np.cos(ta) + xy_center[0])
-    y = (ra * np.sin(ta) + xy_center[1])
-    xf = np.floor(x).astype('int')
-    yf = np.floor(y).astype('int')
+    x = ra * np.cos(ta) + xy_center[0]
+    y = ra * np.sin(ta) + xy_center[1]
+
+    xf = np.floor(x).astype("int")
+    yf = np.floor(y).astype("int")
     dx = x - xf
     dy = y - yf
 
     # resample image
-    im_polar = \
-        im_cart.ravel()[np.ravel_multi_index(
-            (xf,    yf),
-            im_cart.shape,
-            mode='clip',
-            )] * (1-dx) * (1-dy) + \
-        im_cart.ravel()[np.ravel_multi_index(
-            (xf+1,  yf),
-            im_cart.shape,
-            mode='clip',
-            )] * (  dx) * (1-dy) + \
-        im_cart.ravel()[np.ravel_multi_index(
-            (xf,    yf+1),
-            im_cart.shape,
-            mode='clip',
-            )] * (1-dx) * (  dy) + \
-        im_cart.ravel()[np.ravel_multi_index(
-            (xf+1,  yf+1),
-            im_cart.shape,
-            mode='clip',
-            )] * (  dx) * (  dy)
+    im_polar = (
+        im_cart.ravel()[
+            np.ravel_multi_index(
+                (xf, yf),
+                im_cart.shape,
+                mode="wrap",
+            )
+        ]
+        * (1 - dx)
+        * (1 - dy)
+        + im_cart.ravel()[
+            np.ravel_multi_index(
+                (xf + 1, yf),
+                im_cart.shape,
+                mode="wrap",
+            )
+        ]
+        * (dx)
+        * (1 - dy)
+        + im_cart.ravel()[
+            np.ravel_multi_index(
+                (xf, yf + 1),
+                im_cart.shape,
+                mode="wrap",
+            )
+        ]
+        * (1 - dx)
+        * (dy)
+        + im_cart.ravel()[
+            np.ravel_multi_index(
+                (xf + 1, yf + 1),
+                im_cart.shape,
+                mode="wrap",
+            )
+        ]
+        * (dx)
+        * (dy)
+    )
 
     return im_polar
 
 
-def im_polar_to_cart(
+def polar_to_cartesian_transform_2Ddata(
     im_polar,
     xy_size,
     xy_center,
-    ):
+):
     """
     Quick cartesian to polar conversion.
     """
 
     # coordinates
-    xa,ya = np.meshgrid(
-        np.arange(xy_size[0]) - xy_center[0],
-        np.arange(xy_size[1]) - xy_center[1],
-        indexing = 'ij',
-        )  
-    ra = np.sqrt(xa**2 + ya**2)
-    ta = np.arctan2(ya,xa)
-    t = np.linspace(0,2*np.pi,im_polar.shape[0],endpoint = False)
+    sx, sy = xy_size
+    cx, cy = xy_center
+
+    x = np.fft.fftfreq(sx, d=1 / sx)
+    y = np.fft.fftfreq(sy, d=1 / sy)
+    xa, ya = np.meshgrid(x, y, indexing="ij")
+    ra = np.hypot(xa - cx, ya - cy)
+    ta = np.arctan2(ya, xa)
+
+    t = np.linspace(0, 2 * np.pi, im_polar.shape[0], endpoint=False)
     t_step = t[1] - t[0]
 
     # resampling coordinates
     t_ind = ta / t_step
     r_ind = ra.copy()
-    tf = np.floor(t_ind).astype('int')
-    rf = np.floor(r_ind).astype('int')
+    tf = np.floor(t_ind).astype("int")
+    rf = np.floor(r_ind).astype("int")
     dt = t_ind - tf
     dr = r_ind - rf
 
     # resample image
-    im_cart = im_polar.ravel()[np.ravel_multi_index(
-            (np.mod(tf, im_polar.shape[0]),    rf),
+    im_cart = im_polar.ravel()[
+        np.ravel_multi_index(
+            (tf, rf),
             im_polar.shape,
-            mode='clip',
-            )]
+            mode=("wrap", "clip"),
+        )
+    ]
 
     return im_cart
-

From 28eb4938d89ca2ea794391f0aeeb57034e45a747 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Mon, 10 Jul 2023 16:39:55 -0400
Subject: [PATCH 148/362] braggvects masking fix

---
 py4DSTEM/braggvectors/braggvector_methods.py | 125 ++++++++++++++-----
 py4DSTEM/braggvectors/braggvectors.py        |  11 ++
 2 files changed, 108 insertions(+), 28 deletions(-)

diff --git a/py4DSTEM/braggvectors/braggvector_methods.py b/py4DSTEM/braggvectors/braggvector_methods.py
index c6289a253..fe3e86d70 100644
--- a/py4DSTEM/braggvectors/braggvector_methods.py
+++ b/py4DSTEM/braggvectors/braggvector_methods.py
@@ -2,6 +2,7 @@
 
 import numpy as np
 from scipy.ndimage import gaussian_filter
+from warnings import warn
 import inspect
 
 from emdfile import Array,Metadata
@@ -896,52 +897,119 @@ def get_rotated_strain_map(self, mode, g_reference = None, returncalc = True, fl
             return strainmap
 
 
+    def mask_in_Q(
+        self,
+        mask,
+        update_inplace = False,
+        returncalc = True
+        ):
+        """
+        Remove peaks which fall inside the diffraction shaped boolean array
+        `mask`, in raw (uncalibrated) peak positions.
+
+        Parameters
+        ----------
+        mask : 2d boolean array
+            The mask. Must be diffraction space shaped
+        update_inplace : bool
+            If False (default) copies this BraggVectors instance and
+            removes peaks from the copied instance. If True, removes
+            peaks from this instance.
+        returncalc : bool
+            Toggles returning the answer
 
+        Returns
+        -------
+        bvects : BraggVectors
+        """
+        # Copy peaks, if requested
+        if update_inplace:
+            v = self._v_uncal
+        else:
+            v = self._v_uncal.copy( name='_v_uncal' )
+
+        # Loop and remove masked peaks
+        for rx in range(v.shape[0]):
+            for ry in range(v.shape[1]):
+                p = v[rx,ry]
+                xs = np.round(p.data["qx"]).astype(int)
+                ys = np.round(p.data["qy"]).astype(int)
+                sub = mask[xs,ys]
+                p.remove(sub)
+
+        # assign the return value
+        if update_inplace:
+            ans = self
+        else:
+            ans = self.copy( name=self.name+'_masked' )
+            ans.set_raw_vectors( v )
+
+        # return
+        if returncalc:
+            return ans
+        else:
+            return
+
+    # alias
     def get_masked_peaks(
         self,
         mask,
         update_inplace = False,
         returncalc = True):
         """
-        Removes all bragg peaks which fall inside `mask` in the raw
-        (uncalibrated) positions.
-
-        Args:
-            mask (bool): binary image where peaks will be deleted
-            update_inplace (bool): if True, removes peaks from this
-                BraggVectors instance. If False, returns a new
-                BraggVectors instance with the requested peaks removed
-            returncalc (bool): if True, return the BraggVectors
+        Alias for `mask_in_Q`.
+        """
+        warn("`.get_masked_peaks` is deprecated and will be removed in a future version. Use `.mask_in_Q`")
+        return self.mask_in_Q(
+            mask = mask,
+            update_inplace = update_inplace,
+            returncalc = returncalc
+        )
 
-        Returns:
-            (BraggVectors or None)
+    def mask_in_R(
+        self,
+        mask,
+        update_inplace = False,
+        returncalc = True
+        ):
         """
+        Remove peaks which fall inside the real space shaped boolean array
+        `mask`.
 
-        # Copy peaks
-        v = self._v_uncal.copy( name='_v_uncal' )
+        Parameters
+        ----------
+        mask : 2d boolean array
+            The mask. Must be real space shaped
+        update_inplace : bool
+            If False (default) copies this BraggVectors instance and
+            removes peaks from the copied instance. If True, removes
+            peaks from this instance.
+        returncalc : bool
+            Toggles returning the answer
 
-        # Loop over all peaks
+        Returns
+        -------
+        bvects : BraggVectors
+        """
+        # Copy peaks, if requested
+        if update_inplace:
+            v = self._v_uncal
+        else:
+            v = self._v_uncal.copy( name='_v_uncal' )
+
+        # Loop and remove masked peaks
         for rx in range(v.shape[0]):
             for ry in range(v.shape[1]):
-                p = v.get_pointlist(rx,ry)
-                sub = mask.ravel()[np.ravel_multi_index((
-                    np.round(p.data["qx"]).astype('int'),
-                    np.round(p.data["qy"]).astype('int')),
-                    self.Qshape)]
-                p.remove(sub)
+                if mask[rx,ry]:
+                    p = v[rx,ry]
+                    p.remove(np.ones(len(p),dtype=bool))
 
-        # if modifying this BraggVectors instance was requested
+        # assign the return value
         if update_inplace:
-            self._v_uncal = v
             ans = self
-
-        # if a new instance was requested
         else:
             ans = self.copy( name=self.name+'_masked' )
-            ans._v_uncal = v
-
-        # re-calibrate
-        ans.calibrate()
+            ans.set_raw_vectors( v )
 
         # return
         if returncalc:
@@ -952,6 +1020,7 @@ def get_masked_peaks(
 
 
 
+
 ######### END BraggVectorMethods CLASS ########
 
 
diff --git a/py4DSTEM/braggvectors/braggvectors.py b/py4DSTEM/braggvectors/braggvectors.py
index d32997673..da8ffd3b2 100644
--- a/py4DSTEM/braggvectors/braggvectors.py
+++ b/py4DSTEM/braggvectors/braggvectors.py
@@ -101,6 +101,17 @@ def __init__(
         self._set_cal_vector_getter()
 
 
+    # set new raw vectors
+    def set_raw_vectors(self,x):
+        """ Given some PointListArray x of the correct shape, sets this to the raw vectors
+        """
+        assert(isinstance(x,PointListArray)), f"Raw vectors must be set to a PointListArray, not type {type(x)}"
+        assert(x.shape == self.Rshape), "Shapes don't match!"
+        self._v_uncal = x
+        self._set_raw_vector_getter()
+        self._set_cal_vector_getter()
+
+
     # calibration state, vector getters
 
     @property

From b93fa847f401edc23933c869a07a75787ea42e2d Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Mon, 10 Jul 2023 16:40:16 -0400
Subject: [PATCH 149/362] cmap deprecation fix

---
 py4DSTEM/visualize/show.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/visualize/show.py b/py4DSTEM/visualize/show.py
index 20ed0be2b..3b9d99e43 100644
--- a/py4DSTEM/visualize/show.py
+++ b/py4DSTEM/visualize/show.py
@@ -553,7 +553,7 @@ def show(
 
 
         # Create colormap with mask_color for bad values
-        cm = copy(plt.colormaps.get_cmap(cmap))
+        cm = copy(plt.get_cmap(cmap))
         if mask_color=='empty':
             cm.set_bad(alpha=0)
         else:

From bad5239727ca08bae5d6366ead7b0e73b8894ea1 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Mon, 10 Jul 2023 17:03:00 -0400
Subject: [PATCH 150/362] flaker edits

---
 py4DSTEM/braggvectors/__init__.py            |   1 -
 py4DSTEM/braggvectors/braggvector_methods.py |   3 +-
 py4DSTEM/braggvectors/probe.py               |   3 +-
 py4DSTEM/braggvectors/probe_gen_methods.py   | 274 -------------------
 py4DSTEM/datacube/virtualdiffraction.py      |   4 +-
 py4DSTEM/datacube/virtualimage.py            | 133 +++++----
 6 files changed, 71 insertions(+), 347 deletions(-)
 delete mode 100644 py4DSTEM/braggvectors/probe_gen_methods.py

diff --git a/py4DSTEM/braggvectors/__init__.py b/py4DSTEM/braggvectors/__init__.py
index ed09c04fc..030fe6358 100644
--- a/py4DSTEM/braggvectors/__init__.py
+++ b/py4DSTEM/braggvectors/__init__.py
@@ -3,7 +3,6 @@
 from py4DSTEM.braggvectors.braggvector_methods import BraggVectorMap
 from py4DSTEM.braggvectors.diskdetection import *
 from py4DSTEM.braggvectors.probe import *
-from py4DSTEM.braggvectors.probe_gen_methods import *
 #from .diskdetection_aiml import *
 #from .diskdetection_parallel_new import *
 
diff --git a/py4DSTEM/braggvectors/braggvector_methods.py b/py4DSTEM/braggvectors/braggvector_methods.py
index fe3e86d70..cf267b42d 100644
--- a/py4DSTEM/braggvectors/braggvector_methods.py
+++ b/py4DSTEM/braggvectors/braggvector_methods.py
@@ -5,8 +5,7 @@
 from warnings import warn
 import inspect
 
-from emdfile import Array,Metadata
-from emdfile import _read_metadata
+from emdfile import Array, Metadata, tqdmnd, _read_metadata
 from py4DSTEM.process.utils import get_CoM
 from py4DSTEM.datacube import VirtualImage
 
diff --git a/py4DSTEM/braggvectors/probe.py b/py4DSTEM/braggvectors/probe.py
index 3525e42be..32adfe1f2 100644
--- a/py4DSTEM/braggvectors/probe.py
+++ b/py4DSTEM/braggvectors/probe.py
@@ -2,6 +2,7 @@
 
 import numpy as np
 from typing import Optional
+from warnings import warn
 
 from py4DSTEM.data import DiffractionSlice, Data
 from py4DSTEM.process.calibration import get_probe_size
@@ -425,7 +426,7 @@ def get_probe_kernel_flat(
             xCoM,yCoM = origin
 
         # Normalize
-        probe = self.probe/np.sum(probe)
+        probe = probe/np.sum(probe)
 
         # Shift center to corners of array
         probe_kernel = get_shifted_ar(probe, -xCoM, -yCoM, bilinear=bilinear)
diff --git a/py4DSTEM/braggvectors/probe_gen_methods.py b/py4DSTEM/braggvectors/probe_gen_methods.py
deleted file mode 100644
index a6afb1506..000000000
--- a/py4DSTEM/braggvectors/probe_gen_methods.py
+++ /dev/null
@@ -1,274 +0,0 @@
-# Functions for getting images of the vacuum probe
-
-import numpy as np
-from scipy.ndimage import (
-    binary_opening, binary_dilation, distance_transform_edt)
-
-from emdfile import tqdmnd
-from py4DSTEM.datacube import DataCube
-from py4DSTEM.braggvectors import Probe
-from py4DSTEM.process.utils import get_shifted_ar, get_shift
-
-
-
-
-
-def get_vacuum_probe(
-    data,
-    **kwargs
-    ):
-    """
-    Takes some data and computes a vacuum probe, using a method
-    selected based on the type and shape of `data`, and on other
-    arguments passed. In each case, points outside the center
-    disk are set to zero.
-
-    Args:
-        data (variable): behavior and additional arguments depend on
-            the type of `data`.  If `data` is a
-                - DataCube: computes a probe using all or some subset of
-                  the diffraction patterns in the datacube, aligning and
-                  averaging those patterns. The whole datacube is used
-                  if the `ROI` argument is not passed.  If `ROI` is
-                  passed, uses a subset of diffraction patterns based on
-                  the ROI argument's value, which may be a either an
-                  R-space shaped boolean mask, or a 4-tuple representing
-                  (Rxmin,Rxmax,Rymin,Rymax) of a rectangular region.
-                - 3D array: averages the stack with no alignment
-                - 2D array: uses this array as the probe.
-                - None: makes a synthetic probe. Additional required
-                  arguments are
-                    - radius (number): the probe radius
-                    - width (number): the width of the region where
-                      the probe intensity drops off from its maximum
-                      to 0.
-                    - Qshape (2 tuple): the shape of diffraction space
-
-    Returns:
-        (Probe) a Probe instance
-    """
-
-    # select mode of operation
-
-    if isinstance(data,DataCube):
-        mode = '4D'
-    elif isinstance(data,np.ndarray):
-        mode = str(data.ndim)+'D'
-    elif data is None:
-        mode = 'synth'
-    else:
-        er = f"invalid type {type(data)} for `data`."
-        er += f"must be in (DataCube,np.ndarray,None)"
-        raise Exception(er)
-
-    if mode == '4D':
-        if 'ROI' in kwargs.keys():
-            roi = kwargs['ROI']
-            if isinstance(roi, np.ndarray):
-                mode = '4D_roi_mask'
-            else:
-                mode = '4D_roi_lims'
-        else:
-            mode = '4D_full'
-
-
-
-    # choose and run a function
-    functions = {
-        '4D_full' : get_probe_from_vacuum_4Dscan,
-        '4D_roi_mask' : get_probe_from_4Dscan_ROI_mask,
-        '4D_roi_lims' : get_probe_from_4Dscan_ROI_lims,
-        '3D' : get_probe_from_vacuum_3Dstack,
-        '2D' : get_probe_from_vacuum_2Dimage,
-        'synth' : get_probe_synthetic
-        }
-    fn = functions[mode]
-    if mode == 'synth':
-        probe = fn(**kwargs)
-    else:
-        probe = fn(data,**kwargs)
-    return probe
-
-
-
-
-
-def get_probe_from_vacuum_4Dscan(
-    datacube,
-    mask_threshold=0.2,
-    mask_expansion=12,
-    mask_opening=3,
-    verbose=False,
-    align=True
-    ):
-    """
-    Averages all diffraction patterns in a datacube, assumed to be taken
-    over vacuum, to create and average vacuum probe. Optionally (default)
-    aligns the patterns.
-
-    Values outisde the average probe are zeroed, using a binary mask determined
-    by the optional parameters mask_threshold, mask_expansion, and mask_opening.
-    An initial binary mask is created using a threshold of less than
-    mask_threshold times the maximal probe value. A morphological opening of
-    mask_opening pixels is performed to eliminate stray pixels (e.g. from
-    x-rays), followed by a dilation of mask_expansion pixels to ensure the
-    entire probe is captured.
-
-    Args:
-        datacube (DataCube): a vacuum scan
-        mask_threshold (float): threshold determining mask which zeros values
-            outside of probe
-        mask_expansion (int): number of pixels by which the zeroing mask is
-        expanded to capture the full probe
-        mask_opening (int): size of binary opening used to eliminate stray
-            bright pixels
-        verbose (bool): if True, prints progress updates
-        align (bool): if True, aligns the probes before averaging
-
-    Returns:
-        (ndarray of shape (datacube.Q_Nx,datacube.Q_Ny)): the average probe
-    """
-
-    probe = datacube.data[0,0,:,:]
-    for n in tqdmnd(range(1,datacube.R_N)):
-        Rx,Ry = np.unravel_index(n,datacube.data.shape[:2])
-        curr_DP = datacube.data[Rx,Ry,:,:]
-        if verbose:
-            print(f"Shifting and averaging diffraction pattern {n} of {datacube.R_N}.")
-        if align:
-            xshift,yshift = get_shift(probe, curr_DP)
-            curr_DP = get_shifted_ar(curr_DP, xshift, yshift)
-        probe = probe*(n-1)/n + curr_DP/n
-
-    mask = probe > np.max(probe)*mask_threshold
-    mask = binary_opening(mask, iterations=mask_opening)
-    mask = binary_dilation(mask, iterations=1)
-    mask = np.cos((np.pi/2)*np.minimum(distance_transform_edt(np.logical_not(mask)) / mask_expansion, 1))**2
-
-    return probe*mask
-
-
-
-
-def get_probe_from_4Dscan_ROI_lims(
-    datacube,
-    ROI,
-    mask_threshold=0.2,
-    mask_expansion=12,
-    mask_opening=3,
-    verbose=False,
-    align=True
-    ):
-    """
-    Averages all diffraction patterns within a specified ROI of a datacube to
-    create an average vacuum probe. Optionally (default) aligns the patterns.
-
-    See documentation for get_average_probe_from_vacuum_scan for more detailed
-    discussion of the algorithm.
-
-    Args:
-        datacube (DataCube): a vacuum scan
-        ROI (len 4 list or tuple): the limits (rx_min, rx_max, ry_min, ry_max)
-            of the selected region.
-        mask_threshold (float): threshold determining mask which zeros values
-            outside of probe
-        mask_expansion (int): number of pixels by which the zeroing mask is
-            expanded to capture the full probe
-        mask_opening (int): size of binary opening used to eliminate stray
-            bright pixels
-        verbose (bool): if True, prints progress updates
-        align (bool): if True, aligns the probes before averaging
-        DP_mask (array): array of same shape as diffraction pattern to mask
-            probes
-
-    Returns:
-        (ndarray of shape (datacube.Q_Nx,datacube.Q_Ny)): the average probe
-    """
-    assert len(ROI) == 4
-
-    datacube = DataCube(
-        data = datacube.data[ROI[0]:ROI[1],ROI[2]:ROI[3]]
-    )
-    return get_probe_from_vacuum_4Dscan(
-        datacube,
-        mask_threshold = mask_threshold,
-        mask_expansion = mask_expansion,
-        mask_opening = mask_opening,
-        verbose = verbose,
-        align = align)
-
-
-
-
-def get_probe_from_4Dscan_ROI_mask(
-    datacube,
-    ROI,
-    mask_threshold=0.2,
-    mask_expansion=12,
-    mask_opening=3,
-    verbose=False,
-    align=True,
-    DP_mask=1
-    ):
-    """
-    Averages all diffraction patterns within a specified ROI of a datacube to
-    create an average vacuum probe. Optionally (default) aligns the patterns.
-
-    See documentation for get_average_probe_from_vacuum_scan for more detailed
-    discussion of the algorithm.
-
-    Args:
-        datacube (DataCube): a vacuum scan
-        ROI (ndarray of dtype=bool and shape (datacube.R_Nx,datacube.R_Ny)): An
-            array of boolean variables shaped like the real space scan. Only scan
-            positions where ROI==True are used to create the average probe.
-        mask_threshold (float): threshold determining mask which zeros values
-            outside of probe
-        mask_expansion (int): number of pixels by which the zeroing mask is
-            expanded to capture the full probe
-        mask_opening (int): size of binary opening used to eliminate stray
-            bright pixels
-        verbose (bool): if True, prints progress updates
-        align (bool): if True, aligns the probes before averaging
-        DP_mask (array): array of same shape as diffraction pattern to mask
-            probes
-
-    Returns:
-        (ndarray of shape (datacube.Q_Nx,datacube.Q_Ny)): the average probe
-    """
-    assert ROI.shape==(datacube.R_Nx,datacube.R_Ny)
-    length = ROI.sum()
-    xy = np.vstack(np.nonzero(ROI))
-    probe = datacube.data[xy[0,0],xy[1,0],:,:]
-    for n in tqdmnd(range(1,length)):
-        curr_DP = datacube.data[xy[0,n],xy[1,n],:,:] * DP_mask
-        if align:
-            xshift,yshift = get_shift(probe, curr_DP)
-            curr_DP = get_shifted_ar(curr_DP, xshift, yshift)
-        probe = probe*(n-1)/n + curr_DP/n
-
-    mask = probe > np.max(probe)*mask_threshold
-    mask = binary_opening(mask, iterations=mask_opening)
-    mask = binary_dilation(mask, iterations=1)
-    mask = np.cos((np.pi/2)*np.minimum(distance_transform_edt(np.logical_not(mask)) / mask_expansion, 1))**2
-
-    return probe*mask
-
-
-
-
-
-
-
-
-
-# Probe templates can be generated from vacuum scans, from a selected ROI of a
-# vacuum region of a scan, or synthetic probes.  Ultimately the purpose is to
-# generate a kernel for convolution with individual diffraction patterns to
-# identify Bragg disks.  Kernel generation will generally proceed in two steps,
-# which will each correspond to a function call: first, obtaining  or creating
-# the diffraction pattern of a probe over vacuum, and second, turning the probe
-# DP into a convolution kernel by shifting and normalizing.
-
-
-
diff --git a/py4DSTEM/datacube/virtualdiffraction.py b/py4DSTEM/datacube/virtualdiffraction.py
index 9d1aaa4b7..f211a35a9 100644
--- a/py4DSTEM/datacube/virtualdiffraction.py
+++ b/py4DSTEM/datacube/virtualdiffraction.py
@@ -177,8 +177,8 @@ def get_virtual_diffraction(
             if not subpixel:
 
                 # round shifts -> int
-                qx_shift = qshift.round().astype(int)
-                qy_shift = qshift.round().astype(int)
+                qx_shift = qx_shift.round().astype(int)
+                qy_shift = qy_shift.round().astype(int)
 
                 # ...for boolean masks and unmasked
                 if mask is None or mask.dtype==bool:
diff --git a/py4DSTEM/datacube/virtualimage.py b/py4DSTEM/datacube/virtualimage.py
index 7b7b315be..6731c0fd0 100644
--- a/py4DSTEM/datacube/virtualimage.py
+++ b/py4DSTEM/datacube/virtualimage.py
@@ -438,7 +438,7 @@ def position_detector(
                 raise Exception("if `shift_center` is True then `data` must be the 3-tuple (DataCube,rx,ry)")
             # get shifts
             assert(self.calibration.get_origin_shift() is not None), "origin shifts need to be calibrated"
-            qx_shift,qy_shift = cal.get_origin_shift()
+            qx_shift,qy_shift = self.calibration.cal.get_origin_shift()
             qx_shift = int(np.round(qx_shift[rx,ry]))
             qy_shift = int(np.round(qy_shift[rx,ry]))
             mask = np.roll(
@@ -619,72 +619,71 @@ def make_detector(
 
 
 
-
-# TODO - where should this go?
-
-def make_bragg_mask(
-    Qshape,
-    g1,
-    g2,
-    radius,
-    origin,
-    max_q,
-    return_sum = True,
-    **kwargs,
-    ):
-    '''
-    Creates and returns a mask consisting of circular disks
-    about the points of a 2D lattice.
-
-    Args:
-        Qshape (2 tuple): the shape of diffraction space
-        g1,g2 (len 2 array or tuple): the lattice vectors
-        radius (number): the disk radius
-        origin (len 2 array or tuple): the origin
-        max_q (nuumber): the maxima distance to tile to
-        return_sum (bool): if False, return a 3D array, where each
-            slice contains a single disk; if False, return a single
-            2D masks of all disks
-
-    Returns:
-        (2 or 3D array) the mask
-    '''
-    nas = np.asarray
-    g1,g2,origin = nas(g1),nas(g2),nas(origin)
-
-    # Get N,M, the maximum indices to tile out to
-    L1 = np.sqrt(np.sum(g1**2))
-    H = int(max_q/L1) + 1
-    L2 = np.hypot(-g2[0]*g1[1],g2[1]*g1[0])/np.sqrt(np.sum(g1**2))
-    K = int(max_q/L2) + 1
-
-    # Compute number of points
-    N = 0
-    for h in range(-H,H+1):
-        for k in range(-K,K+1):
-            v = h*g1 + k*g2
-            if np.sqrt(v.dot(v)) < max_q:
-                N += 1
-
-    #create mask
-    mask = np.zeros((Qshape[0], Qshape[1], N), dtype=bool)
-    N = 0
-    for h in range(-H,H+1):
-        for k in range(-K,K+1):
-            v = h*g1 + k*g2
-            if np.sqrt(v.dot(v)) < max_q:
-                center = origin + v
-                mask[:,:,N] = make_detector(
-                    Qshape,
-                    mode = 'circle',
-                    geometry = (center, radius),
-                )
-                N += 1
-
-
-    if return_sum:
-        mask = np.sum(mask, axis = 2)
-    return mask
+    # TODO where should this go?
+    def make_bragg_mask(
+        self,
+        Qshape,
+        g1,
+        g2,
+        radius,
+        origin,
+        max_q,
+        return_sum = True,
+        **kwargs,
+        ):
+        '''
+        Creates and returns a mask consisting of circular disks
+        about the points of a 2D lattice.
+
+        Args:
+            Qshape (2 tuple): the shape of diffraction space
+            g1,g2 (len 2 array or tuple): the lattice vectors
+            radius (number): the disk radius
+            origin (len 2 array or tuple): the origin
+            max_q (nuumber): the maxima distance to tile to
+            return_sum (bool): if False, return a 3D array, where each
+                slice contains a single disk; if False, return a single
+                2D masks of all disks
+
+        Returns:
+            (2 or 3D array) the mask
+        '''
+        nas = np.asarray
+        g1,g2,origin = nas(g1),nas(g2),nas(origin)
+
+        # Get N,M, the maximum indices to tile out to
+        L1 = np.sqrt(np.sum(g1**2))
+        H = int(max_q/L1) + 1
+        L2 = np.hypot(-g2[0]*g1[1],g2[1]*g1[0])/np.sqrt(np.sum(g1**2))
+        K = int(max_q/L2) + 1
+
+        # Compute number of points
+        N = 0
+        for h in range(-H,H+1):
+            for k in range(-K,K+1):
+                v = h*g1 + k*g2
+                if np.sqrt(v.dot(v)) < max_q:
+                    N += 1
+
+        #create mask
+        mask = np.zeros((Qshape[0], Qshape[1], N), dtype=bool)
+        N = 0
+        for h in range(-H,H+1):
+            for k in range(-K,K+1):
+                v = h*g1 + k*g2
+                if np.sqrt(v.dot(v)) < max_q:
+                    center = origin + v
+                    mask[:,:,N] = self.make_detector(
+                        Qshape,
+                        mode = 'circle',
+                        geometry = (center, radius),
+                    )
+                    N += 1
+
+
+        if return_sum:
+            mask = np.sum(mask, axis = 2)
+        return mask
 
 
 

From 4ae001dc4e15fcf6860042315cf6db388ab0ae79 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Mon, 10 Jul 2023 16:02:11 -0700
Subject: [PATCH 151/362] fix for WS2

---
 py4DSTEM/process/diffraction/crystal_ACOM.py | 44 ++++++++++++++++++--
 1 file changed, 41 insertions(+), 3 deletions(-)

diff --git a/py4DSTEM/process/diffraction/crystal_ACOM.py b/py4DSTEM/process/diffraction/crystal_ACOM.py
index 4d02dcb0b..7039cb88c 100644
--- a/py4DSTEM/process/diffraction/crystal_ACOM.py
+++ b/py4DSTEM/process/diffraction/crystal_ACOM.py
@@ -767,6 +767,18 @@ def match_orientations(
         num_x=bragg_peaks_array.shape[0],
         num_y=bragg_peaks_array.shape[1],
         num_matches=num_matches_return)
+    
+    #check cal state
+    if bragg_peaks_array.calstate['ellipse'] == False:
+        ellipse = False
+        print('Warning: bragg peaks not elliptically calibrated')
+    else:
+        ellipse = True
+    if bragg_peaks_array.calstate['rotate'] == False:
+        rotate = False
+        print('Warning: bragg peaks not rotationally calibrated')
+    else:
+        rotate = True
 
     for rx, ry in tqdmnd(
         *bragg_peaks_array.shape,
@@ -774,9 +786,17 @@ def match_orientations(
         unit=" PointList",
         disable=not progress_bar,
     ):
+        vectors = bragg_peaks_array.get_vectors(
+            scan_x=rx,
+            scan_y=ry,
+            center=True,
+            ellipse=ellipse,
+            pixel=True,
+            rotate=rotate
+        )
 
         orientation = self.match_single_pattern(
-            bragg_peaks_array.cal[rx, ry],
+            bragg_peaks=vectors,
             num_matches_return=num_matches_return,
             min_number_peaks=min_number_peaks,
             inversion_symmetry=inversion_symmetry,
@@ -1639,6 +1659,18 @@ def calculate_strain(
         corr_kernel_size = self.orientation_kernel_size
     radius_max_2 = corr_kernel_size**2
 
+    #check cal state
+    if bragg_peaks_array.calstate['ellipse'] == False:
+        ellipse = False
+        print('Warning: bragg peaks not elliptically calibrated')
+    else:
+        ellipse = True
+    if bragg_peaks_array.calstate['rotate'] == False:
+        rotate = False
+        print('Warning: bragg peaks not rotationally calibrated')
+    else:
+        rotate = True
+
     # Loop over all probe positions
     for rx, ry in tqdmnd(
         *bragg_peaks_array.shape,
@@ -1647,7 +1679,14 @@ def calculate_strain(
         disable=not progress_bar,
         ):
         # Get bragg peaks from experiment and reference
-        p = bragg_peaks_array.cal[rx,ry]
+        p = bragg_peaks_array.get_vectors(
+            scan_x=rx,
+            scan_y=ry,
+            center=True,
+            ellipse=ellipse,
+            pixel=True,
+            rotate=rotate
+        )
 
         if p.data.shape[0] >= min_num_peaks:
             p_ref = self.generate_diffraction_pattern(
@@ -2071,4 +2110,3 @@ def symmetry_reduce_directions(
 
     # "-3m": ["fiber", [0, 0, 1], [90.0, 60.0]],
     # "-3m": ["fiber", [0, 0, 1], [180.0, 30.0]],
-

From f1e3dbe78905166af7ae53577a0c9d24a04ebad7 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Mon, 10 Jul 2023 17:13:35 -0700
Subject: [PATCH 152/362] small fixes

---
 py4DSTEM/braggvectors/braggvectors.py        |  2 +-
 py4DSTEM/process/diffraction/crystal_ACOM.py | 10 ++++++----
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/py4DSTEM/braggvectors/braggvectors.py b/py4DSTEM/braggvectors/braggvectors.py
index da8ffd3b2..af1078981 100644
--- a/py4DSTEM/braggvectors/braggvectors.py
+++ b/py4DSTEM/braggvectors/braggvectors.py
@@ -226,7 +226,7 @@ def setcal(
         if pixel:
             assert(c.get_Q_pixel_size() is not None), "Requested calibration not found"
         if rotate:
-            assert(c.get_RQ_rotflip() is not None), "Requested calibration not found"
+            assert(c.get_QR_rotflip() is not None), "Requested calibration not found"
 
         # set the calibrations
         self._calstate = {
diff --git a/py4DSTEM/process/diffraction/crystal_ACOM.py b/py4DSTEM/process/diffraction/crystal_ACOM.py
index 7039cb88c..686de7847 100644
--- a/py4DSTEM/process/diffraction/crystal_ACOM.py
+++ b/py4DSTEM/process/diffraction/crystal_ACOM.py
@@ -8,6 +8,8 @@
 from py4DSTEM.process.diffraction.utils import Orientation, OrientationMap, axisEqual3D
 from py4DSTEM.process.utils import electron_wavelength_angstrom
 
+from warnings import warn
+
 from numpy.linalg import lstsq
 try:
     import cupy as cp
@@ -771,12 +773,12 @@ def match_orientations(
     #check cal state
     if bragg_peaks_array.calstate['ellipse'] == False:
         ellipse = False
-        print('Warning: bragg peaks not elliptically calibrated')
+        warn('Warning: bragg peaks not elliptically calibrated')
     else:
         ellipse = True
     if bragg_peaks_array.calstate['rotate'] == False:
         rotate = False
-        print('Warning: bragg peaks not rotationally calibrated')
+        warn('bragg peaks not rotationally calibrated')
     else:
         rotate = True
 
@@ -1662,12 +1664,12 @@ def calculate_strain(
     #check cal state
     if bragg_peaks_array.calstate['ellipse'] == False:
         ellipse = False
-        print('Warning: bragg peaks not elliptically calibrated')
+        warn('bragg peaks not elliptically calibrated')
     else:
         ellipse = True
     if bragg_peaks_array.calstate['rotate'] == False:
         rotate = False
-        print('Warning: bragg peaks not rotationally calibrated')
+        warn('bragg peaks not rotationally calibrated')
     else:
         rotate = True
 

From 8215ff28ed7910bf0536e2a8d851a4e823c07646 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Mon, 10 Jul 2023 18:46:00 -0700
Subject: [PATCH 153/362] else changes

---
 py4DSTEM/io/filereaders/read_abTEM.py | 10 ++++++----
 py4DSTEM/io/parsefiletype.py          |  2 ++
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/py4DSTEM/io/filereaders/read_abTEM.py b/py4DSTEM/io/filereaders/read_abTEM.py
index cf6892d76..ce3b7774d 100644
--- a/py4DSTEM/io/filereaders/read_abTEM.py
+++ b/py4DSTEM/io/filereaders/read_abTEM.py
@@ -1,5 +1,5 @@
 import h5py
-from py4DSTEM.classes import DataCube, VirtualDiffraction, VirtualImage
+from py4DSTEM.classes import DataCube, RealSlice, DiffractionSlice
 
 
 def read_abTEM(
@@ -33,6 +33,8 @@ def read_abTEM(
     sampling = datasets["sampling"]
     units = datasets["units"]
 
+    assert len(data.shape) in (2, 4), "abtem reader supports only 4D and 2D data"
+
     if len(data.shape) == 4:
 
         datacube = DataCube(data=data)
@@ -57,9 +59,9 @@ def read_abTEM(
 
         return datacube
 
-    elif len(data.shape) == 2:
+    else:
         if units[0] == b"mrad":
-            diffraction = VirtualDiffraction(data=data)
+            diffraction = DiffractionSlice(data=data)
             if sampling[0] != sampling[1]:
                 print(
                     "Warning: py4DSTEM currently only handles uniform qx,qy sampling. Setting sampling with x calibration"
@@ -68,7 +70,7 @@ def read_abTEM(
             diffraction.calibration.set_Q_pixel_size(sampling[0])
             return diffraction
         elif units[0] == b"\xc3\x85":
-            image = VirtualImage(data=data)
+            image = RealSlice(data=data)
             if sampling[0] != sampling[1]:
                 print(
                     "Warning: py4DSTEM currently only handles uniform x,y sampling. Setting sampling with x calibration"
diff --git a/py4DSTEM/io/parsefiletype.py b/py4DSTEM/io/parsefiletype.py
index 8d5870944..9e081c916 100644
--- a/py4DSTEM/io/parsefiletype.py
+++ b/py4DSTEM/io/parsefiletype.py
@@ -30,6 +30,8 @@ def _parse_filetype(fp):
 
         elif _is_abTEM(fp):
             return "abTEM"
+        else:
+            raise Exception("not supported `h5` data type")
 
     elif fext in [
         ".dm",

From 47cfac46b3d24ff1bf56dfed6033b56327bd9325 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Mon, 10 Jul 2023 20:23:35 -0700
Subject: [PATCH 154/362] adding probe aperture constraint, aberration fitting.
 Only changed single-slice, will do rest of the classes tomorrow.

---
 .../iterative_ptychographic_constraints.py    | 121 ++---
 .../iterative_singleslice_ptychography.py     | 105 +++--
 py4DSTEM/process/phase/utils.py               | 415 ++++++++++--------
 3 files changed, 304 insertions(+), 337 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
index 274e86f39..d3c5b34a9 100644
--- a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
+++ b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
@@ -3,6 +3,8 @@
     array_slice,
     estimate_global_transformation_ransac,
     fft_shift,
+    regularize_probe_amplitude,
+    fit_aberration_surface,
 )
 from py4DSTEM.process.utils import get_CoM
 
@@ -338,67 +340,6 @@ def _probe_center_of_mass_constraint(self, current_probe):
 
         return shifted_probe
 
-    def _probe_radial_symmetrization_constraint_base(
-        self,
-        current_probe,
-        num_bins=None,
-        center=None,
-    ):
-        xp = self._xp
-
-        sx, sy = current_probe.shape
-
-        if center is None:
-            center = (0, 0)
-
-        if num_bins is None:
-            num_bins = np.maximum(sx, sy) * 2 + 1
-
-        cx, cy = center
-        X = xp.fft.fftfreq(sx, d=1 / sx)[:, None]
-        Y = xp.fft.fftfreq(sy, d=1 / sy)[None]
-        r = xp.hypot(X - cx, Y - cy)
-
-        rbin = (num_bins * r / r.max()).astype("int")
-        num = xp.bincount(rbin.ravel(), current_probe.ravel())
-        denom = xp.bincount(rbin.ravel())
-        denom[denom == 0] = 1
-
-        radial_mean = num / denom
-
-        for r_bin, r_mean in enumerate(radial_mean):
-            if r_bin != 0.0:
-                current_probe[np.where(rbin == r_bin)] = r_mean
-
-        return current_probe
-
-    def _probe_radial_symmetrization_constraint(
-        self,
-        current_probe,
-        num_bins=None,
-        center=None,
-    ):
-        xp = self._xp
-
-        current_probe_sum = xp.sum(xp.abs(current_probe) ** 2)
-        fourier_probe = xp.fft.fft2(current_probe)
-
-        fourier_probe_real = fourier_probe.real.copy()
-        fourier_probe_imag = fourier_probe.imag.copy()
-
-        fourier_probe_real = self._probe_radial_symmetrization_constraint_base(
-            fourier_probe_real, num_bins, center
-        )
-        fourier_probe_imag = self._probe_radial_symmetrization_constraint_base(
-            fourier_probe_imag, num_bins, center
-        )
-
-        fourier_probe = fourier_probe_real + 1.0j * fourier_probe_imag
-        current_probe = xp.fft.ifft2(fourier_probe)
-        current_probe *= xp.sqrt(current_probe_sum / np.sum(np.abs(current_probe) ** 2))
-
-        return current_probe
-
     def _probe_amplitude_constraint(
         self, current_probe, relative_radius, relative_width
     ):
@@ -439,7 +380,10 @@ def _probe_amplitude_constraint(
         return updated_probe * normalization
 
     def _probe_fourier_amplitude_constraint(
-        self, current_probe, threshold, relative_width
+        self,
+        current_probe,
+        width_max_pixels,
+        enforce_constant_intensity,
     ):
         """
         Ptychographic top-hat filtering of Fourier probe.
@@ -460,27 +404,20 @@ def _probe_fourier_amplitude_constraint(
             Constrained probe estimate
         """
         xp = self._xp
-        erf = self._erf
+        asnumpy = self._asnumpy
 
         current_probe_sum = xp.sum(xp.abs(current_probe) ** 2)
         current_probe_fft = xp.fft.fft2(current_probe)
-        current_probe_fft_amp = xp.abs(current_probe_fft)
 
-        threshold_px = xp.argmax(
-            current_probe_fft_amp < xp.max(current_probe_fft_amp) * threshold
+        updated_probe_fft, _, _, _ = regularize_probe_amplitude(
+            asnumpy(current_probe_fft),
+            width_max_pixels=width_max_pixels,
+            enforce_constant_intensity=enforce_constant_intensity,
+            corner_centered=True,
         )
 
-        if threshold_px == 0:
-            return current_probe
-
-        qx = xp.fft.fftfreq(current_probe.shape[0], 1)
-        qy = xp.fft.fftfreq(current_probe.shape[1], 1)
-        qya, qxa = xp.meshgrid(qy, qx)
-        qra = xp.sqrt(qxa**2 + qya**2) - threshold_px / current_probe.shape[0]
-
-        sigma = np.sqrt(np.pi) / relative_width
-        tophat_mask = 0.5 * (1 - erf(sigma * qra / (1 - qra**2)))
-        updated_probe = xp.fft.ifft2(current_probe_fft * tophat_mask)
+        updated_probe_fft = xp.asarray(updated_probe_fft)
+        updated_probe = xp.fft.ifft2(updated_probe_fft)
         updated_probe_sum = xp.sum(xp.abs(updated_probe) ** 2)
         normalization = xp.sqrt(current_probe_sum / updated_probe_sum)
 
@@ -517,11 +454,11 @@ def _probe_aperture_constraint(
 
         return updated_probe * normalization
 
-    def _probe_residual_aberration_filtering_constraint(
+    def _probe_aberration_fitting_constraint(
         self,
         current_probe,
-        gaussian_filter_sigma,
-        fix_amplitude,
+        max_angular_order,
+        max_radial_order,
     ):
         """
         Ptychographic probe smoothing constraint.
@@ -543,24 +480,20 @@ def _probe_residual_aberration_filtering_constraint(
         """
 
         xp = self._xp
-        gaussian_filter = self._gaussian_filter
-        known_aberrations_array = self._known_aberrations_array
-        gaussian_filter_sigma /= self._reciprocal_sampling[0]
 
         fourier_probe = xp.fft.fft2(current_probe)
-        if fix_amplitude:
-            fourier_probe_abs = xp.abs(fourier_probe)
-
-        fourier_probe *= xp.conjugate(known_aberrations_array)
-        fourier_probe = gaussian_filter(
-            fourier_probe, gaussian_filter_sigma, mode="wrap"
+        fourier_probe_abs = xp.abs(fourier_probe)
+        sampling = self.sampling
+
+        fitted_angle = fit_aberration_surface(
+            fourier_probe,
+            sampling,
+            max_angular_order,
+            max_radial_order,
+            xp=xp,
         )
-        fourier_probe *= known_aberrations_array
-
-        if fix_amplitude:
-            fourier_probe_angle = xp.angle(fourier_probe)
-            fourier_probe = fourier_probe_abs * xp.exp(1.0j * fourier_probe_angle)
 
+        fourier_probe = fourier_probe_abs * xp.exp(1.0j * fitted_angle)
         current_probe = xp.fft.ifft2(fourier_probe)
 
         return current_probe
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index bed535665..ed26cf8ad 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -1000,15 +1000,15 @@ def _constraints(
         current_positions,
         pure_phase_object,
         fix_com,
-        symmetrize_probe,
-        probe_gaussian_filter,
-        probe_gaussian_filter_sigma,
-        probe_gaussian_filter_fix_amplitude,
+        fit_probe_aberrations,
+        fit_probe_aberrations_max_angular_order,
+        fit_probe_aberrations_max_radial_order,
         constrain_probe_amplitude,
         constrain_probe_amplitude_relative_radius,
         constrain_probe_amplitude_relative_width,
         constrain_probe_fourier_amplitude,
-        constrain_probe_fourier_amplitude_threshold,
+        constrain_probe_fourier_amplitude_max_width_pixels,
+        constrain_probe_fourier_amplitude_constant_intensity,
         fix_probe_aperture,
         initial_probe_aperture,
         fix_positions,
@@ -1038,14 +1038,12 @@ def _constraints(
             If True, object amplitude is set to unity
         fix_com: bool
             If True, probe CoM is fixed to the center
-        symmetrize_probe: bool
-            If True, the probe is radially-averaged
-        probe_gaussian_filter: bool
-            If True, applies reciprocal-space gaussian filtering on residual aberrations
-        probe_gaussian_filter_sigma: float
-            Standard deviation of gaussian kernel in A^-1
-        probe_gaussian_filter_fix_amplitude: bool
-            If True, only the probe phase is smoothed
+        fit_probe_aberrations: bool
+            If True, fits the probe aberrations to a low-order expansion
+        fit_probe_aberrations_max_angular_order: bool
+            Max angular order of probe aberrations basis functions
+        fit_probe_aberrations_max_radial_order: bool
+            Max radial order of probe aberrations basis functions
         constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
         constrain_probe_amplitude_relative_radius: float
@@ -1053,10 +1051,11 @@ def _constraints(
         constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
         constrain_probe_fourier_amplitude: bool
-            If True, probe fourier amplitude is constrained by top hat function
-        constrain_probe_fourier_amplitude_threshold: float
-            Threshold value for current probe fourier mask. Value should
-            be between 0 and 1, where higher values provide the most masking.
+            If True, probe aperture is constrained by fitting a sigmoid for each angular frequency.
+        constrain_probe_fourier_amplitude_max_width_pixels: float
+            Maximum pixel width of fitted sigmoid functions.
+        constrain_probe_fourier_amplitude_constant_intensity: bool
+            If True, the probe aperture is additionally constrained to a constant intensity.
         fix_probe_aperture: bool,
             If True, probe Fourier amplitude is replaced by initial probe aperture.
         initial_probe_aperture: np.ndarray,
@@ -1122,31 +1121,29 @@ def _constraints(
         if fix_com:
             current_probe = self._probe_center_of_mass_constraint(current_probe)
 
-        if probe_gaussian_filter:
-            current_probe = self._probe_residual_aberration_filtering_constraint(
-                current_probe,
-                probe_gaussian_filter_sigma,
-                probe_gaussian_filter_fix_amplitude,
-            )
-
-        if symmetrize_probe:
-            current_probe = self._probe_radial_symmetrization_constraint(current_probe)
-
         if fix_probe_aperture:
             current_probe = self._probe_aperture_constraint(
                 current_probe,
                 initial_probe_aperture,
             )
-        elif constrain_probe_amplitude:
-            current_probe = self._probe_amplitude_constraint(
-                current_probe,
-                constrain_probe_amplitude_relative_radius,
-                constrain_probe_amplitude_relative_width,
-            )
         elif constrain_probe_fourier_amplitude:
             current_probe = self._probe_fourier_amplitude_constraint(
                 current_probe,
-                constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_max_width_pixels,
+                constrain_probe_fourier_amplitude_constant_intensity,
+            )
+
+        if fit_probe_aberrations:
+            current_probe = self._probe_aberration_fitting_constraint(
+                current_probe,
+                fit_probe_aberrations_max_angular_order,
+                fit_probe_aberrations_max_radial_order,
+            )
+
+        if constrain_probe_amplitude:
+            current_probe = self._probe_amplitude_constraint(
+                current_probe,
+                constrain_probe_amplitude_relative_radius,
                 constrain_probe_amplitude_relative_width,
             )
 
@@ -1179,20 +1176,20 @@ def reconstruct(
         fix_com: bool = True,
         fix_probe_iter: int = 0,
         fix_probe_aperture_iter: int = 0,
-        symmetrize_probe_iter: int = 0,
         constrain_probe_amplitude_iter: int = 0,
         constrain_probe_amplitude_relative_radius: float = 0.5,
         constrain_probe_amplitude_relative_width: float = 0.05,
         constrain_probe_fourier_amplitude_iter: int = 0,
-        constrain_probe_fourier_amplitude_threshold: float = 0.9,
+        constrain_probe_fourier_amplitude_max_width_pixels: float = 3.0,
+        constrain_probe_fourier_amplitude_constant_intensity: bool = False,
         fix_positions_iter: int = np.inf,
         constrain_position_distance: float = None,
         global_affine_transformation: bool = True,
         gaussian_filter_sigma: float = None,
         gaussian_filter_iter: int = np.inf,
-        probe_gaussian_filter_sigma: float = None,
-        probe_gaussian_filter_residual_aberrations_iter: int = np.inf,
-        probe_gaussian_filter_fix_amplitude: bool = True,
+        fit_probe_aberrations_iter: int = 0,
+        fit_probe_aberrations_max_angular_order: int = 4,
+        fit_probe_aberrations_max_radial_order: int = 4,
         butterworth_filter_iter: int = np.inf,
         q_lowpass: float = None,
         q_highpass: float = None,
@@ -1246,19 +1243,18 @@ def reconstruct(
             Number of iterations to run with a fixed probe before updating probe estimate
         fix_probe_aperture_iter: int, optional
             Number of iterations to run with a fixed probe Fourier amplitude before updating probe estimate
-        symmetrize_probe_iter: int, optional
-            Number of iterations to run before radially-averaging the probe
-        constrain_probe_amplitude: bool
-            If True, probe amplitude is constrained by top hat function
+        constrain_probe_amplitude_iter: int, optional
+            Number of iterations to run while constraining the real-space probe with a top-hat support.
         constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
         constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        constrain_probe_fourier_amplitude: bool
-            If True, probe fourier amplitude is constrained by top hat function
-        constrain_probe_fourier_amplitude_threshold: float
-            Threshold value for current probe fourier mask. Value should
-            be between 0 and 1, where higher values provide the most masking.
+        constrain_probe_fourier_amplitude_iter: int, optional
+            Number of iterations to run while constraining the Fourier-space probe by fitting a sigmoid for each angular frequency.
+        constrain_probe_fourier_amplitude_max_width_pixels: float
+            Maximum pixel width of fitted sigmoid functions.
+        constrain_probe_fourier_amplitude_constant_intensity: bool
+            If True, the probe aperture is additionally constrained to a constant intensity.
         fix_positions_iter: int, optional
             Number of iterations to run with fixed positions before updating positions estimate
         constrain_position_distance: float, optional
@@ -1593,12 +1589,6 @@ def reconstruct(
                 self._probe,
                 self._positions_px,
                 fix_com=fix_com and a0 >= fix_probe_iter,
-                symmetrize_probe=a0 < symmetrize_probe_iter,
-                probe_gaussian_filter=a0
-                < probe_gaussian_filter_residual_aberrations_iter
-                and probe_gaussian_filter_sigma is not None,
-                probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
-                probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
                 constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                 and a0 >= fix_probe_iter,
                 constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
@@ -1606,7 +1596,12 @@ def reconstruct(
                 constrain_probe_fourier_amplitude=a0
                 < constrain_probe_fourier_amplitude_iter
                 and a0 >= fix_probe_iter,
-                constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_max_width_pixels=constrain_probe_fourier_amplitude_max_width_pixels,
+                constrain_probe_fourier_amplitude_constant_intensity=constrain_probe_fourier_amplitude_constant_intensity,
+                fit_probe_aberrations=a0 < fit_probe_aberrations_iter
+                and a0 >= fix_probe_iter,
+                fit_probe_aberrations_max_angular_order=fit_probe_aberrations_max_angular_order,
+                fit_probe_aberrations_max_radial_order=fit_probe_aberrations_max_radial_order,
                 fix_probe_aperture=a0 < fix_probe_aperture_iter,
                 initial_probe_aperture=self._probe_initial_aperture,
                 fix_positions=a0 < fix_positions_iter,
diff --git a/py4DSTEM/process/phase/utils.py b/py4DSTEM/process/phase/utils.py
index c92f0d38b..7f5287b3b 100644
--- a/py4DSTEM/process/phase/utils.py
+++ b/py4DSTEM/process/phase/utils.py
@@ -16,6 +16,7 @@
 from py4DSTEM.process.utils.utils import electron_wavelength_angstrom
 from py4DSTEM.process.utils import get_CoM
 from scipy.ndimage import gaussian_filter
+from skimage.restoration import unwrap_phase
 
 # fmt: off
 
@@ -1278,19 +1279,143 @@ def nesterov_gamma(zero_indexed_iter_num):
     )
 
 
-def regularize_probe_amp(
+def cartesian_to_polar_transform_2Ddata(
+    im_cart,
+    xy_center,
+    num_theta_bins=180,
+    radius_max=None,
+    corner_centered=False,
+    xp=np,
+):
+    """
+    Quick cartesian to polar conversion.
+    """
+
+    # coordinates
+    if radius_max is None:
+        if corner_centered:
+            radius_max = np.min(np.array(im_cart.shape) // 2)
+        else:
+            radius_max = np.sqrt(np.sum(np.array(im_cart.shape) ** 2)) // 2
+
+    r = xp.arange(radius_max)
+    t = xp.linspace(
+        0,
+        2.0 * np.pi,
+        num_theta_bins,
+        endpoint=False,
+    )
+    ra, ta = xp.meshgrid(r, t)
+
+    # resampling coordinates
+    x = ra * xp.cos(ta) + xy_center[0]
+    y = ra * xp.sin(ta) + xy_center[1]
+
+    xf = xp.floor(x).astype("int")
+    yf = xp.floor(y).astype("int")
+    dx = x - xf
+    dy = y - yf
+
+    mode = "wrap" if corner_centered else "clip"
+
+    # resample image
+    im_polar = (
+        im_cart.ravel()[
+            xp.ravel_multi_index(
+                (xf, yf),
+                im_cart.shape,
+                mode=mode,
+            )
+        ]
+        * (1 - dx)
+        * (1 - dy)
+        + im_cart.ravel()[
+            xp.ravel_multi_index(
+                (xf + 1, yf),
+                im_cart.shape,
+                mode=mode,
+            )
+        ]
+        * (dx)
+        * (1 - dy)
+        + im_cart.ravel()[
+            xp.ravel_multi_index(
+                (xf, yf + 1),
+                im_cart.shape,
+                mode=mode,
+            )
+        ]
+        * (1 - dx)
+        * (dy)
+        + im_cart.ravel()[
+            xp.ravel_multi_index(
+                (xf + 1, yf + 1),
+                im_cart.shape,
+                mode=mode,
+            )
+        ]
+        * (dx)
+        * (dy)
+    )
+
+    return im_polar
+
+
+def polar_to_cartesian_transform_2Ddata(
+    im_polar,
+    xy_size,
+    xy_center,
+    corner_centered=False,
+    xp=np,
+):
+    """
+    Quick polar to cartesian conversion.
+    """
+
+    # coordinates
+    sx, sy = xy_size
+    cx, cy = xy_center
+
+    if corner_centered:
+        x = xp.fft.fftfreq(sx, d=1 / sx)
+        y = xp.fft.fftfreq(sy, d=1 / sy)
+    else:
+        x = xp.arange(sx)
+        y = xp.arange(sy)
+
+    xa, ya = xp.meshgrid(x, y, indexing="ij")
+    ra = xp.hypot(xa - cx, ya - cy)
+    ta = xp.arctan2(ya - cy, xa - cx)
+
+    t = xp.linspace(0, 2 * np.pi, im_polar.shape[0], endpoint=False)
+    t_step = t[1] - t[0]
+
+    # resampling coordinates
+    t_ind = ta / t_step
+    r_ind = ra.copy()
+    tf = xp.floor(t_ind).astype("int")
+    rf = xp.floor(r_ind).astype("int")
+
+    # resample image
+    im_cart = im_polar.ravel()[
+        xp.ravel_multi_index(
+            (tf, rf),
+            im_polar.shape,
+            mode=("wrap", "clip"),
+        )
+    ]
+
+    return im_cart
+
+
+def regularize_probe_amplitude(
     probe_init,
     width_max_pixels=2.0,
     enforce_constant_intensity=True,
-    return_coefs=False,
-    plot_result=False,
-    plot_polar=False,
-    cmap="turbo",
-    figsize=(5, 5),
+    corner_centered=False,
 ):
     """
-    Assumes the probe is corner-centered in Fourier space.  Note we
-    re-implemented the polar/cartesian transforms here for portability.
+    Fits sigmoid for each angular direction.
 
     Parameters
     --------
@@ -1300,40 +1425,31 @@ def regularize_probe_amp(
         Maximum edge width of the probe in pixels.
     enforce_constant_intensity: bool
         Set to true to make intensity inside the aperture constant.
-    return_coefs: bool
-        If true, fitting coefficients will also be returned.
-    plot_result: bool
-        Plot the input and output probes.
-    plot_polar: bool
-        Plot the polar transformed images:
-        1 - initial probe
-        2 - best fit of step model for each line
-        3 - best fit enforcing constant intensity inside aperture
-    cmap: string
-        colormap of the plots.
-    figsize: tuple
-        size of the output figures.
-        (will be doubled along horizontal axis for cartesian images)
+    corner_centered: bool
+        If True, the probe is assumed to be corner-centered
 
     Returns
     --------
-    probe_corr: np.array
+    probe_corr: np.ndarray
         2D complex image of the corrected probe in Fourier space.
-    coefs_all: np.array (optional)
-        coefficients for the
+    coefs_all: np.ndarray
+        coefficients for the sigmoid fits
     """
 
     # Get probe intensity
     probe_amp = np.abs(probe_init)
+    probe_angle = np.angle(probe_init)
     probe_int = probe_amp**2
 
     # Center of mass for probe intensity
-    xy_center = get_CoM(probe_int, device="cpu", corner_centered=True)
+    xy_center = get_CoM(probe_int, device="cpu", corner_centered=corner_centered)
 
     # Convert intensity to polar coordinates
     polar_int = cartesian_to_polar_transform_2Ddata(
         probe_int,
         xy_center=xy_center,
+        corner_centered=corner_centered,
+        xp=np,
     )
 
     # Fit corrected probe intensity
@@ -1346,6 +1462,9 @@ def regularize_probe_amp(
     width = width_max_pixels * 0.5
 
     # init
+    def step_model(radius, sig_0, rad_0, width):
+        return sig_0 * np.clip((rad_0 - radius) / width, 0.0, 1.0)
+
     coefs_all = np.zeros((polar_int.shape[0], 3))
     coefs_all[:, 0] = sig_0
     coefs_all[:, 1] = rad_0
@@ -1366,194 +1485,114 @@ def regularize_probe_amp(
             xtol=1e-12,
             bounds=(lb, ub),
         )[0]
-        polar_fit[a0, :] = step_model(radius, coefs_all[a0, :])
-
-    if enforce_constant_intensity:
-        # Compute best-fit constant intensity inside probe, update bounds
-        sig_0 = np.median(coefs_all[:, 0])
-        coefs_all[:, 0] = sig_0
-        lb = (sig_0 - 1e-8, 0.0, 1e-4)
-        ub = (sig_0 + 1e-8, np.inf, width_max_pixels)
-
-        # refine parameters, generate polar image
-        polar_int_corr = np.zeros_like(polar_int)
-        for a0 in range(polar_int.shape[0]):
-            coefs_all[a0, :] = curve_fit(
-                step_model,
-                radius,
-                polar_int[a0, :],
-                p0=coefs_all[a0, :],
-                xtol=1e-12,
-                bounds=(lb, ub),
-            )[0]
-            polar_int_corr[a0, :] = step_model(radius, coefs_all[a0, :])
+        polar_fit[a0, :] = step_model(radius, *coefs_all[a0, :])
 
-    else:
-        polar_int_corr = polar_fit
+    # Compute best-fit constant intensity inside probe, update bounds
+    sig_0 = np.median(coefs_all[:, 0])
+    coefs_all[:, 0] = sig_0
+    lb = (sig_0 - 1e-8, 0.0, 1e-4)
+    ub = (sig_0 + 1e-8, np.inf, width_max_pixels)
+
+    # refine parameters, generate polar image
+    polar_int_corr = np.zeros_like(polar_int)
+    for a0 in range(polar_int.shape[0]):
+        coefs_all[a0, :] = curve_fit(
+            step_model,
+            radius,
+            polar_int[a0, :],
+            p0=coefs_all[a0, :],
+            xtol=1e-12,
+            bounds=(lb, ub),
+        )[0]
+        polar_int_corr[a0, :] = step_model(radius, *coefs_all[a0, :])
 
     # Convert back to cartesian coordinates
     int_corr = polar_to_cartesian_transform_2Ddata(
         polar_int_corr,
         xy_size=probe_init.shape,
         xy_center=xy_center,
+        corner_centered=corner_centered,
     )
 
-    # Assemble output probe
-    probe_corr = np.sqrt(np.maximum(int_corr, 0)) * np.exp(1j * np.angle(probe_init))
-
-    # plotting
-    if plot_result:
-        fig, ax = plt.subplots(figsize=(figsize[0] * 2, figsize[1]))
-        ax.imshow(
-            np.hstack(
-                (
-                    np.fft.fftshift(probe_int),
-                    np.fft.fftshift(int_corr),
-                )
-            ),
-            cmap="turbo",
-        )
-    if plot_polar:
-        fig, ax = plt.subplots(figsize=figsize)
-        ax.imshow(
-            np.hstack(
-                (
-                    polar_int,
-                    polar_fit,
-                    polar_int_corr,
-                )
-            ),
-            cmap="turbo",
-        )
-
-    if return_coefs:
-        return probe_corr, coefs_all
-    else:
-        return probe_corr
-
+    amp_corr = np.sqrt(np.maximum(int_corr, 0))
 
-def step_model(radius, *coefs):
-    coefs = np.squeeze(np.array(coefs))
+    # Assemble output probe
+    if not enforce_constant_intensity:
+        max_coeff = np.sqrt(coefs_all[:, 0]).max()
+        amp_corr = amp_corr / max_coeff * probe_amp
 
-    sig_0 = coefs[0]
-    rad_0 = coefs[1]
-    width = coefs[2]
+    probe_corr = amp_corr * np.exp(1j * probe_angle)
 
-    return sig_0 * np.clip((rad_0 - radius) / width, 0.0, 1.0)
+    return probe_corr, polar_int, polar_int_corr, coefs_all
 
 
-def cartesian_to_polar_transform_2Ddata(
-    im_cart,
-    xy_center,
-    num_theta_bins=180,
-    radius_max=None,
+def aberrations_basis_function(
+    probe_size,
+    probe_sampling,
+    max_angular_order,
+    max_radial_order,
+    xp=np,
 ):
-    """
-    Quick cartesian to polar conversion.
-    """
+    """ """
+    sx, sy = probe_size
+    dx, dy = probe_sampling
+    qx = xp.fft.fftfreq(sx, dx)
+    qy = xp.fft.fftfreq(sy, dy)
 
-    # coordinates
-    if radius_max is None:
-        radius_max = np.min(np.array(im_cart.shape) // 2)
+    qxa, qya = xp.meshgrid(qx, qy, indexing="ij")
+    q2 = qxa**2 + qya**2
+    theta = xp.arctan2(qya, qxa)
 
-    r = np.arange(radius_max)
-    t = np.linspace(
-        0,
-        2.0 * np.pi,
-        num_theta_bins,
-        endpoint=False,
-    )
-    ra, ta = np.meshgrid(r, t)
+    basis = []
+    index = []
 
-    # resampling coordinates
-    x = ra * np.cos(ta) + xy_center[0]
-    y = ra * np.sin(ta) + xy_center[1]
+    for n in range(max_angular_order + 1):
+        for m in range((max_radial_order - n) // 2 + 1):
+            basis.append((q2 ** (m + n / 2) * np.cos(n * theta)))
+            index.append((m, n, 0))
+            if n > 0:
+                basis.append((q2 ** (m + n / 2) * np.sin(n * theta)))
+                index.append((m, n, 1))
 
-    xf = np.floor(x).astype("int")
-    yf = np.floor(y).astype("int")
-    dx = x - xf
-    dy = y - yf
+    basis = xp.array(basis)
 
-    # resample image
-    im_polar = (
-        im_cart.ravel()[
-            np.ravel_multi_index(
-                (xf, yf),
-                im_cart.shape,
-                mode="wrap",
-            )
-        ]
-        * (1 - dx)
-        * (1 - dy)
-        + im_cart.ravel()[
-            np.ravel_multi_index(
-                (xf + 1, yf),
-                im_cart.shape,
-                mode="wrap",
-            )
-        ]
-        * (dx)
-        * (1 - dy)
-        + im_cart.ravel()[
-            np.ravel_multi_index(
-                (xf, yf + 1),
-                im_cart.shape,
-                mode="wrap",
-            )
-        ]
-        * (1 - dx)
-        * (dy)
-        + im_cart.ravel()[
-            np.ravel_multi_index(
-                (xf + 1, yf + 1),
-                im_cart.shape,
-                mode="wrap",
-            )
-        ]
-        * (dx)
-        * (dy)
-    )
-
-    return im_polar
+    return basis, index
 
 
-def polar_to_cartesian_transform_2Ddata(
-    im_polar,
-    xy_size,
-    xy_center,
+def fit_aberration_surface(
+    complex_probe,
+    probe_sampling,
+    max_angular_order,
+    max_radial_order,
+    seed=1,
+    xp=np,
 ):
-    """
-    Quick cartesian to polar conversion.
-    """
+    """ """
+    probe_amp = xp.abs(complex_probe)
+    probe_angle = xp.angle(complex_probe)
 
-    # coordinates
-    sx, sy = xy_size
-    cx, cy = xy_center
+    if xp is np:
+        unwrapped_angle = unwrap_phase(probe_angle, wrap_around=True, seed=seed)
+    else:
+        unwrapped_angle = xp.asarray(
+            unwrap_phase(xp.asnumpy(probe_angle), wrap_around=True, seed=seed)
+        )
 
-    x = np.fft.fftfreq(sx, d=1 / sx)
-    y = np.fft.fftfreq(sy, d=1 / sy)
-    xa, ya = np.meshgrid(x, y, indexing="ij")
-    ra = np.hypot(xa - cx, ya - cy)
-    ta = np.arctan2(ya, xa)
+    basis, _ = aberrations_basis_function(
+        complex_probe.shape,
+        probe_sampling,
+        max_angular_order,
+        max_radial_order,
+        xp=xp,
+    )
 
-    t = np.linspace(0, 2 * np.pi, im_polar.shape[0], endpoint=False)
-    t_step = t[1] - t[0]
+    raveled_basis = basis.reshape((basis.shape[0], -1))
+    raveled_weights = probe_amp.ravel()
 
-    # resampling coordinates
-    t_ind = ta / t_step
-    r_ind = ra.copy()
-    tf = np.floor(t_ind).astype("int")
-    rf = np.floor(r_ind).astype("int")
-    dt = t_ind - tf
-    dr = r_ind - rf
+    Aw = raveled_basis.T * raveled_weights[:, None]
+    bw = unwrapped_angle.ravel() * raveled_weights
+    coeff = xp.linalg.lstsq(Aw, bw, rcond=None)[0]
 
-    # resample image
-    im_cart = im_polar.ravel()[
-        np.ravel_multi_index(
-            (tf, rf),
-            im_polar.shape,
-            mode=("wrap", "clip"),
-        )
-    ]
+    fitted_angle = xp.tensordot(coeff, basis, axes=1)
 
-    return im_cart
+    return fitted_angle

From 64c7a3a871c7917178394ee48ef7830fdea3f189 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Tue, 11 Jul 2023 05:57:06 -0700
Subject: [PATCH 155/362] fix for virtualimage/virtualdiffraction scalebar=True

---
 py4DSTEM/visualize/show.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/visualize/show.py b/py4DSTEM/visualize/show.py
index 3b9d99e43..df6df1609 100644
--- a/py4DSTEM/visualize/show.py
+++ b/py4DSTEM/visualize/show.py
@@ -320,6 +320,9 @@ def show(
         if intensity_range is None:
             intensity_range = clipvals
 
+    if scalebar == True: 
+        scalebar = {}
+
     # plot a grid if `ar` is a list, or use multichannel functionality to make an RGBa image
     ar = ar[0] if (isinstance(ar,list) and len(ar) == 1) else ar
     if isinstance(ar,list):
@@ -391,8 +394,6 @@ def show(
             # Output image for plotting
             ar = ar_rgb
 
-    if scalebar == True: 
-        scalebar = {}
 
     # support for native data types
     elif not isinstance(ar,np.ndarray):

From 5da30395a4dfa5aa3455a935595235a3689c596a Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 11 Jul 2023 10:52:52 -0400
Subject: [PATCH 156/362] fix import paths w.r.t. new calpatch code

---
 py4DSTEM/io/filereaders/read_abTEM.py | 3 ++-
 py4DSTEM/io/filereaders/read_arina.py | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/io/filereaders/read_abTEM.py b/py4DSTEM/io/filereaders/read_abTEM.py
index ce3b7774d..d8d206914 100644
--- a/py4DSTEM/io/filereaders/read_abTEM.py
+++ b/py4DSTEM/io/filereaders/read_abTEM.py
@@ -1,5 +1,6 @@
 import h5py
-from py4DSTEM.classes import DataCube, RealSlice, DiffractionSlice
+from py4DSTEM.datacube import DataCube
+from py4DSTEM.data import RealSlice, DiffractionSlice
 
 
 def read_abTEM(
diff --git a/py4DSTEM/io/filereaders/read_arina.py b/py4DSTEM/io/filereaders/read_arina.py
index d42eb2803..2982d7f7f 100644
--- a/py4DSTEM/io/filereaders/read_arina.py
+++ b/py4DSTEM/io/filereaders/read_arina.py
@@ -1,7 +1,7 @@
 import h5py
 import hdf5plugin
 import numpy as np
-from py4DSTEM.classes import DataCube
+from py4DSTEM.datacube import DataCube
 from py4DSTEM.preprocess.utils import bin2D
 
 

From 08a3300b1863a0c65289fb71bda6cb1c06fbf4df Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 11 Jul 2023 10:56:47 -0400
Subject: [PATCH 157/362] more import fixes

---
 py4DSTEM/io/read.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/py4DSTEM/io/read.py b/py4DSTEM/io/read.py
index 979b2c216..746762434 100644
--- a/py4DSTEM/io/read.py
+++ b/py4DSTEM/io/read.py
@@ -8,6 +8,7 @@
 import emdfile as emd
 import py4DSTEM.io.legacy as legacy
 from py4DSTEM.io.parsefiletype import _parse_filetype
+from py4DSTEM.data import Data
 
 
 def read(
@@ -94,7 +95,7 @@ def read(
         if verbose: print("Data was read from file. Adding calibration links...")
 
         # add calibration links
-        if isinstance(data,py4DSTEM.Data):
+        if isinstance(data,Data):
             with warnings.catch_warnings():
                 warnings.simplefilter('ignore')
                 cal = data.calibration

From 9a9d9a2892a845c1f993bb6bd991e864b94be3bc Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 11 Jul 2023 10:58:38 -0400
Subject: [PATCH 158/362] more import fixes, all tests passing

---
 py4DSTEM/io/read.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/io/read.py b/py4DSTEM/io/read.py
index 746762434..db3823fa6 100644
--- a/py4DSTEM/io/read.py
+++ b/py4DSTEM/io/read.py
@@ -99,7 +99,7 @@ def read(
             with warnings.catch_warnings():
                 warnings.simplefilter('ignore')
                 cal = data.calibration
-        elif isinstance(data,py4DSTEM.Root):
+        elif isinstance(data,emd.Root):
             try:
                 cal = data.metadata['calibration']
             except KeyError:

From 470006b0fde9cb7b2e51cb83d3434971a3991734 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 11 Jul 2023 11:16:27 -0400
Subject: [PATCH 159/362] adds arina file download to test suite downloader

---
 py4DSTEM/io/google_drive_downloader.py | 57 ++++++++++++++++++++++++++
 test/gettestdata.py                    | 21 +++++-----
 2 files changed, 68 insertions(+), 10 deletions(-)

diff --git a/py4DSTEM/io/google_drive_downloader.py b/py4DSTEM/io/google_drive_downloader.py
index c8b410d47..69f4545f9 100644
--- a/py4DSTEM/io/google_drive_downloader.py
+++ b/py4DSTEM/io/google_drive_downloader.py
@@ -83,6 +83,50 @@
         'test_realslice_io.h5',
         '1siH80-eRJwG5R6AnU4vkoqGWByrrEz1y'
     ),
+    'test_arina_master' : (
+        'STO-STEM_bench_20us_master.h5',
+        '1q_4IjFuWRkw5VM84NhxrNTdIq4563BOC'
+    ),
+    'test_arina_01' : (
+        'STO-STEM_bench_20us_000001.h5',
+        '1_3Dbm22-hV58iffwK9x-3vqJUsEXZBFQ'
+    ),
+    'test_arina_02' : (
+        'STO-STEM_bench_20us_000002.h5',
+        '1x29RzHLnCzP0qthLhA1kdlUQ09ENViR8'
+    ),
+    'test_arina_03' : (
+        'STO-STEM_bench_20us_000003.h5',
+        '1qsbzdEVD8gt4DYKnpwjfoS_Mg4ggObAA'
+    ),
+    'test_arina_04' : (
+        'STO-STEM_bench_20us_000004.h5',
+        '1Lcswld0Y9fNBk4-__C9iJbc854BuHq-h'
+    ),
+    'test_arina_05' : (
+        'STO-STEM_bench_20us_000005.h5',
+        '13YTO2ABsTK5nObEr7RjOZYCV3sEk3gt9'
+    ),
+    'test_arina_06' : (
+        'STO-STEM_bench_20us_000006.h5',
+        '1RywPXt6HRbCvjgjSuYFf60QHWlOPYXwy'
+    ),
+    'test_arina_07' : (
+        'STO-STEM_bench_20us_000007.h5',
+        '1GRoBecCvAUeSIujzsPywv1vXKSIsNyoT'
+    ),
+    'test_arina_08' : (
+        'STO-STEM_bench_20us_000008.h5',
+        '1sTFuuvgKbTjZz1lVUfkZbbTDTQmwqhuU'
+    ),
+    'test_arina_09' : (
+        'STO-STEM_bench_20us_000009.h5',
+        '1JmBiMg16iMVfZ5wz8z_QqcNPVRym1Ezh'
+    ),
+    'test_arina_10' : (
+        'STO-STEM_bench_20us_000010.h5',
+        '1_90xAfclNVwMWwQ-YKxNNwBbfR1nfHoB'
+    ),
 }
 
 # collections of files
@@ -108,6 +152,19 @@
         'legacy_v0.14',
         'test_realslice_io',
     ),
+    'test_arina' : (
+        'test_arina_master',
+        'test_arina_01',
+        'test_arina_02',
+        'test_arina_03',
+        'test_arina_04',
+        'test_arina_05',
+        'test_arina_06',
+        'test_arina_07',
+        'test_arina_08',
+        'test_arina_09',
+        'test_arina_10',
+    ),
     'test_braggvectors' : (
         'Au_sim',
     )
diff --git a/test/gettestdata.py b/test/gettestdata.py
index 0b5608a7c..f6944e2df 100644
--- a/test/gettestdata.py
+++ b/test/gettestdata.py
@@ -19,7 +19,7 @@
 data_options = [
     'tutorials',
     'io',
-    'basic'
+    'basic',
 ]
 
 # Add arguments
@@ -52,21 +52,22 @@
 
 # Set data collection key
 if args.data == 'tutorials':
-    data = 'tutorials'
+    data = ['tutorials']
 elif args.data == 'io':
-    data = 'test_io'
+    data = ['test_io','test_arina']
 elif args.data == 'basic':
-    data = 'small_datacube'
+    data = ['small_datacube']
 else:
     raise Exception(f"invalid data choice, {parser.data}")
 
 # Download data
-download(
-    data,
-    destination = testpath,
-    overwrite = args.overwrite,
-    verbose = args.verbose
-)
+for d in data:
+    download(
+        d,
+        destination = testpath,
+        overwrite = args.overwrite,
+        verbose = args.verbose
+    )
 
 # Always download the basic datacube
 if args.data != 'basic':

From ee786aac9297260be970da164c90c26bca448097 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 11 Jul 2023 11:18:20 -0400
Subject: [PATCH 160/362] closes if/else clause

---
 py4DSTEM/io/filereaders/read_abTEM.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/io/filereaders/read_abTEM.py b/py4DSTEM/io/filereaders/read_abTEM.py
index d8d206914..0e9cdc23e 100644
--- a/py4DSTEM/io/filereaders/read_abTEM.py
+++ b/py4DSTEM/io/filereaders/read_abTEM.py
@@ -70,7 +70,7 @@ def read_abTEM(
             diffraction.calibration.set_Q_pixel_units(units[0].decode("utf-8"))
             diffraction.calibration.set_Q_pixel_size(sampling[0])
             return diffraction
-        elif units[0] == b"\xc3\x85":
+        else units[0] == b"\xc3\x85":
             image = RealSlice(data=data)
             if sampling[0] != sampling[1]:
                 print(

From f504924854ec940bea798964288d6019d1dce27a Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 11 Jul 2023 11:21:07 -0400
Subject: [PATCH 161/362] closes if/else clause

---
 py4DSTEM/io/filereaders/read_abTEM.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/io/filereaders/read_abTEM.py b/py4DSTEM/io/filereaders/read_abTEM.py
index 0e9cdc23e..8191b57ae 100644
--- a/py4DSTEM/io/filereaders/read_abTEM.py
+++ b/py4DSTEM/io/filereaders/read_abTEM.py
@@ -70,7 +70,7 @@ def read_abTEM(
             diffraction.calibration.set_Q_pixel_units(units[0].decode("utf-8"))
             diffraction.calibration.set_Q_pixel_size(sampling[0])
             return diffraction
-        else units[0] == b"\xc3\x85":
+        else:
             image = RealSlice(data=data)
             if sampling[0] != sampling[1]:
                 print(

From 01d9924ddf6cf475c2b4ed3186ef0902a28c3677 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 11 Jul 2023 11:25:37 -0400
Subject: [PATCH 162/362] adds test_arina unit test

---
 test/test_nonnative_io/test_arina.py | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 test/test_nonnative_io/test_arina.py

diff --git a/test/test_nonnative_io/test_arina.py b/test/test_nonnative_io/test_arina.py
new file mode 100644
index 000000000..bf9bf8e73
--- /dev/null
+++ b/test/test_nonnative_io/test_arina.py
@@ -0,0 +1,19 @@
+import py4DSTEM
+import emdfile
+from os.path import join
+
+
+# Set filepaths
+filepath = join(py4DSTEM._TESTPATH, "test_arina/STO-STEM_bench_20us_master.h5")
+
+
+def test_read_arina():
+
+    # read
+    data = py4DSTEM.import_file( filepath )
+
+    # check imported data
+    assert isinstance(data, emdfile.Array)
+    assert isinstance(data, py4DSTEM.DataCube)
+
+

From 01092c32dc5e4b82a3886a8afd8bfb330e233b2a Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Tue, 11 Jul 2023 09:51:28 -0700
Subject: [PATCH 163/362] a bit of gpu cleaning

---
 .../process/phase/iterative_base_class.py     |  3 ---
 py4DSTEM/process/phase/iterative_dpc.py       | 11 +++++++-
 .../iterative_mixedstate_ptychography.py      | 10 +++++++
 .../iterative_multislice_ptychography.py      | 10 +++++++
 .../iterative_overlap_magnetic_tomography.py  | 10 +++++++
 .../phase/iterative_overlap_tomography.py     | 10 +++++++
 py4DSTEM/process/phase/iterative_parallax.py  | 27 ++++++++++++++++++-
 .../iterative_simultaneous_ptychography.py    | 10 +++++++
 .../iterative_singleslice_ptychography.py     | 10 +++++++
 9 files changed, 96 insertions(+), 5 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index 5888292c3..e48dc03ba 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -160,8 +160,6 @@ def _preprocess_datacube_and_vacuum_probe(
                     "Datacube calibration can only handle uniform Q-sampling."
                 )
 
-            Q_pixel_size = datacube.calibration.get_Q_pixel_size()
-
             if com_shifts is not None:
                 com_shifts = (
                     com_shifts[0] * resampling_factor_x,
@@ -279,7 +277,6 @@ def _extract_intensities_and_calibrations_from_datacube(
         """
 
         # Copies intensities to device casting to float32
-        xp = self._xp
         intensities = datacube.data
         self._grid_scan_shape = intensities.shape[:2]
 
diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index 4be160c64..71edd85bd 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -367,6 +367,11 @@ def preprocess(
 
         self._preprocessed = True
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _forward(
@@ -511,7 +516,6 @@ def _object_gaussian_constraint(self, current_object, gaussian_filter_sigma):
         constrained_object: np.ndarray
             Constrained object estimate
         """
-        xp = self._xp
         gaussian_filter = self._gaussian_filter
 
         gaussian_filter_sigma /= self.sampling[0]
@@ -814,6 +818,11 @@ def reconstruct(
         ]
         self.object_phase = asnumpy(self._object_phase)
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _visualize_last_iteration(
diff --git a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
index d4e2e5346..c80ec1062 100644
--- a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
@@ -574,6 +574,11 @@ def preprocess(
 
         self._preprocessed = True
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _overlap_projection(self, current_object, current_probe):
@@ -1727,6 +1732,11 @@ def reconstruct(
         self.probe = self.probe_centered
         self.error = error.item()
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _visualize_last_iteration_figax(
diff --git a/py4DSTEM/process/phase/iterative_multislice_ptychography.py b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
index d477da8ce..66c943ec6 100644
--- a/py4DSTEM/process/phase/iterative_multislice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
@@ -673,6 +673,11 @@ def preprocess(
 
         self._preprocessed = True
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _overlap_projection(self, current_object, current_probe):
@@ -2149,6 +2154,11 @@ def reconstruct(
         self.probe = self.probe_centered
         self.error = error.item()
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _visualize_last_iteration_figax(
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 7c88931a5..c3f1e8fb7 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -905,6 +905,11 @@ def preprocess(
 
         self._preprocessed = True
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _overlap_projection(
@@ -2540,6 +2545,11 @@ def reconstruct(
         self.probe = self.probe_centered
         self.error = error.item()
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _crop_rotate_object_manually(
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index 6b0a16e2e..c8f4487b5 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -817,6 +817,11 @@ def preprocess(
 
         self._preprocessed = True
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _overlap_projection(self, current_object, current_probe):
@@ -2261,6 +2266,11 @@ def reconstruct(
         self.probe = self.probe_centered
         self.error = error.item()
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _crop_rotate_object_manually(
diff --git a/py4DSTEM/process/phase/iterative_parallax.py b/py4DSTEM/process/phase/iterative_parallax.py
index 576342631..d55d5c353 100644
--- a/py4DSTEM/process/phase/iterative_parallax.py
+++ b/py4DSTEM/process/phase/iterative_parallax.py
@@ -172,7 +172,6 @@ def preprocess(
             require_calibrations=True,
         )
         self._intensities = xp.asarray(self._intensities, dtype=xp.float32)
-
         # make sure mean diffraction pattern is shaped correctly
         if (self._dp_mean.shape[0] != self._intensities.shape[2]) or (
             self._dp_mean.shape[1] != self._intensities.shape[3]
@@ -377,6 +376,12 @@ def preprocess(
             ax.set_title("Average Bright Field Image")
 
         self._preprocessed = True
+
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def tune_angle_and_defocus(
@@ -827,6 +832,11 @@ def reconstruct(
 
         self.recon_BF = asnumpy(self._recon_BF)
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def aberration_fit(
@@ -876,6 +886,11 @@ def aberration_fit(
         ) / 2.0  # factor /2 for A1 astigmatism? /4?
         self.aberration_A1y = (m_aberration[1, 0] + m_aberration[0, 1]) / 2.0
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         # Print results
         if self._verbose:
             print(
@@ -1061,6 +1076,11 @@ def aberration_correct(
         self._recon_phase_corrected = xp.real(xp.fft.ifft2(im_fft_corr))
         self.recon_phase_corrected = asnumpy(self._recon_phase_corrected)
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         # plotting
         if plot_corrected_phase:
             figsize = kwargs.pop("figsize", (6, 6))
@@ -1219,6 +1239,11 @@ def depth_section(
                 ax.set_yticks([])
                 ax.set_title(f"Depth section: {dz}A")
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return stack_depth
 
     def _crop_padded_object(
diff --git a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
index 545900634..8904012b2 100644
--- a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
@@ -814,6 +814,11 @@ def preprocess(
 
         self._preprocessed = True
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _warmup_overlap_projection(self, current_object, current_probe):
@@ -2926,6 +2931,11 @@ def reconstruct(
         self.probe = self.probe_centered
         self.error = error.item()
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _visualize_last_iteration_figax(
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index ed26cf8ad..12604a287 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -542,6 +542,11 @@ def preprocess(
 
         self._preprocessed = True
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _overlap_projection(self, current_object, current_probe):
@@ -1633,6 +1638,11 @@ def reconstruct(
         self.probe = self.probe_centered
         self.error = error.item()
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _visualize_last_iteration_figax(

From 9e66b7a7d9fa77b878ad35bafc2eb2b3c55dbb86 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 11 Jul 2023 13:27:17 -0400
Subject: [PATCH 164/362] rm deprecated virtualdiffraction.py

---
 py4DSTEM/process/__init__.py           |   1 -
 py4DSTEM/process/virtualdiffraction.py | 223 -------------------------
 2 files changed, 224 deletions(-)
 delete mode 100644 py4DSTEM/process/virtualdiffraction.py

diff --git a/py4DSTEM/process/__init__.py b/py4DSTEM/process/__init__.py
index 833466cd3..76ad38d47 100644
--- a/py4DSTEM/process/__init__.py
+++ b/py4DSTEM/process/__init__.py
@@ -1,6 +1,5 @@
 from py4DSTEM.process.polar import PolarDatacube
 
-from py4DSTEM.process import virtualdiffraction
 from py4DSTEM.process import latticevectors
 from py4DSTEM.process import phase
 from py4DSTEM.process import calibration
diff --git a/py4DSTEM/process/virtualdiffraction.py b/py4DSTEM/process/virtualdiffraction.py
deleted file mode 100644
index ba31b778a..000000000
--- a/py4DSTEM/process/virtualdiffraction.py
+++ /dev/null
@@ -1,223 +0,0 @@
-# Functions for generating diffraction images
-
-import numpy as np
-from emdfile import tqdmnd
-
-def get_virtual_diffraction(
-    datacube,
-    method,
-    mode = None,
-    geometry = None,
-    calibrated = False,
-    shift_center = False,
-    verbose = True,
-    return_mask = False,
-):
-    '''
-    Function to calculate virtual diffraction
-
-    Args:
-        datacube (Datacube) : datacube class object which stores 4D-dataset
-            needed for calculation
-        method (str) : defines method used for diffraction pattern, options are
-            'mean', 'median', and 'max'
-        mode (str)  : defines mode for selecting area in real space to use for
-            virtual diffraction. The default is None, which means no
-            geometry will be applied and the whole datacube will be used
-            for the calculation. Options:
-                - 'point' uses singular point as detector
-                - 'circle' or 'circular' uses round detector, like bright field
-                - 'annular' or 'annulus' uses annular detector, like dark field
-                - 'rectangle', 'square', 'rectangular', uses rectangular detector
-                - 'mask' flexible detector, any 2D array
-        geometry (variable) : valid entries are determined by the `mode`, values
-            in pixels argument, as follows. The default is None, which means no
-            geometry will be applied and the whole datacube will be used for the
-            calculation. If mode is None the geometry will not be applied.
-                - 'point': 2-tuple, (rx,ry),
-                   qx and qy are each single float or int to define center
-                - 'circle' or 'circular': nested 2-tuple, ((rx,ry),radius),
-                   qx, qy and radius, are each single float or int
-                - 'annular' or 'annulus': nested 2-tuple, ((rx,ry),(radius_i,radius_o)),
-                   qx, qy, radius_i, and radius_o are each single float or integer
-                - 'rectangle', 'square', 'rectangular': 4-tuple, (xmin,xmax,ymin,ymax)
-                - `mask`: flexible detector, any boolean or floating point 2D array with
-                    the same shape as datacube.Rshape
-        calibrated (bool): if True, geometry is specified in units of 'A' instead
-            of pixels. The datacube's calibrations must have its `"R_pixel_units"`
-            parameter set to "A". If mode is None the geometry and calibration will
-            not be applied.
-        shift_center (bool): if True, the difraction pattern is shifted to account
-            for beam shift or the changing of the origin through the scan. The
-            datacube's calibration['origin'] parameter must be set Only 'max' and
-            'mean' supported for this option.
-        verbose (bool): if True, show progress bar
-        return_mask (bool): if False (default) returns a virtual image as usual.
-            If True, does *not* generate or return a virtual image, instead
-            returning the mask that would be used in virtual diffraction computation.
-
-    Returns:
-        (2D array): the diffraction image
-    '''
-
-    assert method in ('max', 'median', 'mean'),\
-        'check doc strings for supported types'
-
-    #create mask
-    if mode is not None:
-        use_all_points = False
-
-        from py4DSTEM.process.virtualimage import make_detector
-        assert mode in ('point', 'circle', 'circular', 'annulus', 'annular', 'rectangle', 'square', 'rectangular', 'mask'),\
-        'check doc strings for supported modes'
-        g = geometry
-
-        if calibrated == True:
-            assert datacube.calibration['R_pixel_units'] == 'A', \
-                'check datacube.calibration. datacube must be calibrated in A to use `calibrated=True`'
-
-            unit_conversion = datacube.calibration['R_pixel_size']
-            if mode == 'point':
-                g = (g[0]/unit_conversion, g[1]/unit_conversion)
-            if mode in('circle', 'circular'):
-                g = ((g[0][0]/unit_conversion, g[0][1]/unit_conversion),
-                    (g[1]/unit_conversion))
-            if mode in('annulus', 'annular'):
-                g = ((g[0][0]/unit_conversion, g[0][1]/unit_conversion),
-                    (g[1][0]/unit_conversion, g[1][1]/unit_conversion))
-            if mode in('rectangle', 'square', 'rectangular') :
-                g = (g[0]/unit_conversion, g[1]/unit_conversion,
-                     g[2]/unit_conversion, g[3]/unit_conversion)
-
-        # Get mask
-        mask = make_detector(datacube.Rshape, mode, g)
-
-        # Determine if mask is boolean and if so, vectorize
-        if mask.dtype == bool:
-            mask_is_boolean = True
-            mask_indices = np.nonzero(mask)
-        else:
-            mask_is_boolean = False
-
-    #if no mask 
-    else:
-        mask = np.ones(datacube.Rshape, dtype=bool)
-        mask_indices = np.nonzero(mask)
-        use_all_points = True
-        mask_is_boolean = False
-
-    # if return_mask is True, skip computation
-    if return_mask == True:
-        return mask
-
-    # Calculate diffracton pattern...
-
-    # ...with no center shifting
-    if shift_center == False:
-
-        # ...for the whole pattern
-        if use_all_points:
-            if method == 'mean':
-                virtual_diffraction = np.mean(datacube.data, axis=(0,1))
-            elif method == 'max':
-                virtual_diffraction = np.max(datacube.data, axis=(0,1))
-            else:
-                virtual_diffraction = np.median(datacube.data, axis=(0,1))
-
-        # ...for boolean masks
-        elif mask_is_boolean:
-            if method == 'mean':
-                virtual_diffraction = np.mean(datacube.data[mask_indices[0],mask_indices[1],:,:], axis=0)
-            elif method == 'max':
-                virtual_diffraction = np.max(datacube.data[mask_indices[0],mask_indices[1],:,:], axis=0)
-            else:
-                virtual_diffraction = np.median(datacube.data[mask_indices[0],mask_indices[1],:,:], axis=0)
-
-        # ...for floating point masks
-        else:
-            if mask.dtype == 'complex':
-                virtual_diffraction = np.zeros(datacube.Qshape, dtype = 'complex')
-            else:
-                virtual_diffraction = np.zeros(datacube.Qshape)
-            for qx,qy in tqdmnd(
-                datacube.Q_Nx,
-                datacube.Q_Ny,
-                disable = not verbose,
-            ):
-                if method == 'mean':
-                    virtual_diffraction[qx,qy] = np.sum( np.squeeze(datacube.data[:,:,qx,qy])*mask )
-                elif method == 'max':
-                    virtual_diffraction[qx,qy] = np.max( np.squeeze(datacube.data[:,:,qx,qy])*mask )
-                elif method == 'median':
-                    virtual_diffraction[qx,qy] = np.median( np.squeeze(datacube.data[:,:,qx,qy])*mask )
-
-        # norm by weighting term for means
-        if method == 'mean' and not use_all_points:
-            virtual_diffraction /= np.sum(mask)
-
-    # ...with center shifting
-    else:
-        assert method in ('max', 'mean'),\
-            "only 'mean' and 'max' are supported for center-shifted virtual diffraction"
-
-        # Get calibration metadata
-        assert datacube.calibration.get_origin(), "origin needs to be calibrated"
-        x0, y0 = datacube.calibration.get_origin()
-        x0_mean, y0_mean = datacube.calibration.get_origin_mean()
-
-        # get shifts
-        qx_shift = (x0_mean-x0).round().astype(int)
-        qy_shift = (y0_mean-y0).round().astype(int)
-
-
-        # compute...
-
-        # ...for boolean masks / whole datacubes
-        if mask_is_boolean or use_all_points:
-            virtual_diffraction = np.zeros(datacube.Qshape)
-            for rx,ry in zip(mask_indices[0],mask_indices[1]):
-                # get shifted DP
-                DP = np.roll(
-                    datacube.data[rx,ry, :,:,],
-                    (qx_shift[rx,ry], qy_shift[rx,ry]),
-                    axis=(0,1),
-                    )
-                # compute
-                if method == 'mean':
-                    virtual_diffraction += DP
-                elif method == 'max':
-                    virtual_diffraction = np.maximum(virtual_diffraction, DP)
-            if method == 'mean':
-                virtual_diffraction /= len(mask_indices[0])
-
-        # ...for floating point masks
-        else:
-            if mask.dtype == 'complex':
-                virtual_diffraction = np.zeros(datacube.Qshape, dtype = 'complex')
-            else:
-                virtual_diffraction = np.zeros(datacube.Qshape)
-            for rx,ry in tqdmnd(
-                datacube.R_Nx,
-                datacube.R_Ny,
-                disable = not verbose,
-            ):
-                # get shifted DP
-                DP = np.roll(
-                    datacube.data[rx,ry, :,:,],
-                    (qx_shift[rx,ry], qy_shift[rx,ry]),
-                    axis=(0,1),
-                    )
-                # compute
-                w = mask[rx,ry]
-                if w > 0:
-                    if method == 'mean':
-                        virtual_diffraction += DP*w
-                    elif method == 'max':
-                        virtual_diffraction = np.maximum(virtual_diffraction, DP*w)
-            if method == 'mean':
-                virtual_diffraction /= np.sum(mask)
-
-    # return
-    return virtual_diffraction
-
-

From e891c077af34ee65afd0841d718d981eb65896b5 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Tue, 11 Jul 2023 11:09:24 -0700
Subject: [PATCH 165/362] removing unnecessary self._xp

---
 py4DSTEM/process/phase/iterative_dpc.py                       | 2 --
 py4DSTEM/process/phase/iterative_mixedstate_ptychography.py   | 2 --
 py4DSTEM/process/phase/iterative_multislice_ptychography.py   | 2 --
 .../process/phase/iterative_overlap_magnetic_tomography.py    | 2 --
 py4DSTEM/process/phase/iterative_overlap_tomography.py        | 2 --
 py4DSTEM/process/phase/iterative_parallax.py                  | 4 ----
 py4DSTEM/process/phase/iterative_simultaneous_ptychography.py | 2 --
 py4DSTEM/process/phase/iterative_singleslice_ptychography.py  | 2 --
 8 files changed, 18 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index 71edd85bd..dc0df2ce6 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -368,7 +368,6 @@ def preprocess(
         self._preprocessed = True
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
@@ -819,7 +818,6 @@ def reconstruct(
         self.object_phase = asnumpy(self._object_phase)
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
diff --git a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
index c80ec1062..69b2d8c45 100644
--- a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
@@ -575,7 +575,6 @@ def preprocess(
         self._preprocessed = True
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
@@ -1733,7 +1732,6 @@ def reconstruct(
         self.error = error.item()
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
diff --git a/py4DSTEM/process/phase/iterative_multislice_ptychography.py b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
index 66c943ec6..4706decf9 100644
--- a/py4DSTEM/process/phase/iterative_multislice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
@@ -674,7 +674,6 @@ def preprocess(
         self._preprocessed = True
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
@@ -2155,7 +2154,6 @@ def reconstruct(
         self.error = error.item()
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index c3f1e8fb7..099d26bcb 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -906,7 +906,6 @@ def preprocess(
         self._preprocessed = True
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
@@ -2546,7 +2545,6 @@ def reconstruct(
         self.error = error.item()
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index c8f4487b5..b5a3f71fa 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -818,7 +818,6 @@ def preprocess(
         self._preprocessed = True
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
@@ -2267,7 +2266,6 @@ def reconstruct(
         self.error = error.item()
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
diff --git a/py4DSTEM/process/phase/iterative_parallax.py b/py4DSTEM/process/phase/iterative_parallax.py
index d55d5c353..80cdd8cd8 100644
--- a/py4DSTEM/process/phase/iterative_parallax.py
+++ b/py4DSTEM/process/phase/iterative_parallax.py
@@ -378,7 +378,6 @@ def preprocess(
         self._preprocessed = True
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
@@ -833,7 +832,6 @@ def reconstruct(
         self.recon_BF = asnumpy(self._recon_BF)
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
@@ -887,7 +885,6 @@ def aberration_fit(
         self.aberration_A1y = (m_aberration[1, 0] + m_aberration[0, 1]) / 2.0
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
@@ -1077,7 +1074,6 @@ def aberration_correct(
         self.recon_phase_corrected = asnumpy(self._recon_phase_corrected)
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
diff --git a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
index 8904012b2..cf243192e 100644
--- a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
@@ -815,7 +815,6 @@ def preprocess(
         self._preprocessed = True
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
@@ -2932,7 +2931,6 @@ def reconstruct(
         self.error = error.item()
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index 12604a287..2d5744e28 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -543,7 +543,6 @@ def preprocess(
         self._preprocessed = True
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
@@ -1639,7 +1638,6 @@ def reconstruct(
         self.error = error.item()
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 

From e3dbcb73a2350a54a23d10fae464fbf98ae803cc Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Tue, 11 Jul 2023 11:58:31 -0700
Subject: [PATCH 166/362] reformatting

---
 py4DSTEM/io/filereaders/read_abTEM.py |  2 +-
 py4DSTEM/io/read.py                   | 51 ++++++++++++++-------------
 2 files changed, 28 insertions(+), 25 deletions(-)

diff --git a/py4DSTEM/io/filereaders/read_abTEM.py b/py4DSTEM/io/filereaders/read_abTEM.py
index 8191b57ae..57c839c75 100644
--- a/py4DSTEM/io/filereaders/read_abTEM.py
+++ b/py4DSTEM/io/filereaders/read_abTEM.py
@@ -1,6 +1,6 @@
 import h5py
+from py4DSTEM.data import DiffractionSlice, RealSlice
 from py4DSTEM.datacube import DataCube
-from py4DSTEM.data import RealSlice, DiffractionSlice
 
 
 def read_abTEM(
diff --git a/py4DSTEM/io/read.py b/py4DSTEM/io/read.py
index db3823fa6..bab555eaf 100644
--- a/py4DSTEM/io/read.py
+++ b/py4DSTEM/io/read.py
@@ -1,14 +1,14 @@
 # Reader for native files
 
+import warnings
 from os.path import exists
 from pathlib import Path
-from typing import Optional,Union
-import warnings
+from typing import Optional, Union
 
 import emdfile as emd
 import py4DSTEM.io.legacy as legacy
-from py4DSTEM.io.parsefiletype import _parse_filetype
 from py4DSTEM.data import Data
+from py4DSTEM.io.parsefiletype import _parse_filetype
 
 
 def read(
@@ -75,48 +75,50 @@ def read(
 
     # support older `root` input
     if datapath is None:
-        if 'root' in kwargs:
-            datapath = kwargs['root']
+        if "root" in kwargs:
+            datapath = kwargs["root"]
 
     # EMD 1.0 formatted files (py4DSTEM v0.14+)
     if filetype == "emd":
 
         # check version
         version = emd._get_EMD_version(filepath)
-        if verbose: print(f"EMD version {version[0]}.{version[1]}.{version[2]} detected. Reading...")
-        assert emd._version_is_geq(version,(1,0,0)), f"EMD version {version} detected. Expected version >= 1.0.0"
+        if verbose:
+            print(
+                f"EMD version {version[0]}.{version[1]}.{version[2]} detected. Reading..."
+            )
+        assert emd._version_is_geq(
+            version, (1, 0, 0)
+        ), f"EMD version {version} detected. Expected version >= 1.0.0"
 
         # read
-        data = emd.read(
-            filepath,
-            emdpath = datapath,
-            tree = tree
-        )
-        if verbose: print("Data was read from file. Adding calibration links...")
+        data = emd.read(filepath, emdpath=datapath, tree=tree)
+        if verbose:
+            print("Data was read from file. Adding calibration links...")
 
         # add calibration links
-        if isinstance(data,Data):
+        if isinstance(data, Data):
             with warnings.catch_warnings():
-                warnings.simplefilter('ignore')
+                warnings.simplefilter("ignore")
                 cal = data.calibration
-        elif isinstance(data,emd.Root):
+        elif isinstance(data, emd.Root):
             try:
-                cal = data.metadata['calibration']
+                cal = data.metadata["calibration"]
             except KeyError:
                 cal = None
         else:
             cal = None
         if cal is not None:
             try:
-                root_treepath = cal['_root_treepath']
-                target_paths = cal['_target_paths']
-                del(cal._params['_target_paths'])
+                root_treepath = cal["_root_treepath"]
+                target_paths = cal["_target_paths"]
+                del cal._params["_target_paths"]
                 for p in target_paths:
                     try:
-                        p = p.replace(root_treepath,'')
+                        p = p.replace(root_treepath, "")
                         d = data.root.tree(p)
-                        cal.register_target( d )
-                        if hasattr(d,'setcal'):
+                        cal.register_target(d)
+                        if hasattr(d, "setcal"):
                             d.setcal()
                     except AssertionError:
                         pass
@@ -125,7 +127,8 @@ def read(
             cal.calibrate()
 
         # return
-        if verbose: print("Done.")
+        if verbose:
+            print("Done.")
         return data
 
     # legacy py4DSTEM files (v <= 0.13)

From 9dd77124111cff4d651d10caa8c855b8a2c55822 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 11 Jul 2023 15:03:33 -0400
Subject: [PATCH 167/362] adds new strain class, instantiation tests

---
 py4DSTEM/__init__.py                         |  3 +
 py4DSTEM/braggvectors/braggvector_methods.py |  2 +-
 py4DSTEM/braggvectors/probe.py               | 13 +++-
 py4DSTEM/process/__init__.py                 |  1 +
 py4DSTEM/process/strain.py                   | 82 ++++++++++++++++++++
 test/test_strain.py                          | 70 +++++++++++++++++
 6 files changed, 168 insertions(+), 3 deletions(-)
 create mode 100644 py4DSTEM/process/strain.py
 create mode 100644 test/test_strain.py

diff --git a/py4DSTEM/__init__.py b/py4DSTEM/__init__.py
index 17d255d92..21409c101 100644
--- a/py4DSTEM/__init__.py
+++ b/py4DSTEM/__init__.py
@@ -59,6 +59,9 @@
     BraggVectorMap,
 )
 
+# strain
+from py4DSTEM.process import StrainMap
+
 # TODO - crystal
 # TODO - ptycho
 # TODO - others
diff --git a/py4DSTEM/braggvectors/braggvector_methods.py b/py4DSTEM/braggvectors/braggvector_methods.py
index cf267b42d..e04a7558a 100644
--- a/py4DSTEM/braggvectors/braggvector_methods.py
+++ b/py4DSTEM/braggvectors/braggvector_methods.py
@@ -6,7 +6,6 @@
 import inspect
 
 from emdfile import Array, Metadata, tqdmnd, _read_metadata
-from py4DSTEM.process.utils import get_CoM
 from py4DSTEM.datacube import VirtualImage
 
 
@@ -358,6 +357,7 @@ def measure_origin(
                     np.argmax(gaussian_filter(bvm, 10)), (Q_Nx, Q_Ny)
                 )
             else:
+                from py4DSTEM.process.utils import get_CoM
                 x0, y0 = get_CoM(bvm)
         else:
             x0, y0 = center_guess
diff --git a/py4DSTEM/braggvectors/probe.py b/py4DSTEM/braggvectors/probe.py
index 32adfe1f2..9195d06bd 100644
--- a/py4DSTEM/braggvectors/probe.py
+++ b/py4DSTEM/braggvectors/probe.py
@@ -5,8 +5,6 @@
 from warnings import warn
 
 from py4DSTEM.data import DiffractionSlice, Data
-from py4DSTEM.process.calibration import get_probe_size
-from py4DSTEM.process.utils import get_CoM, get_shifted_ar
 from scipy.ndimage import (
     binary_opening, binary_dilation, distance_transform_edt)
 
@@ -245,6 +243,8 @@ def measure_disk(
         r, x0, y0 : (3-tuple)
             the radius and origin
         """
+        from py4DSTEM.process.utils import get_CoM
+
         # set the image
         im = self.probe if data is None else data
 
@@ -417,10 +417,13 @@ def get_probe_kernel_flat(
             the cross-correlation kernel corresponding to the probe, in real
             space
         """
+        from py4DSTEM.process.utils import get_shifted_ar
+
         Q_Nx, Q_Ny = probe.shape
 
         # Get CoM
         if origin is None:
+            from py4DSTEM.process.calibration import get_probe_size
             _,xCoM,yCoM = get_probe_size(probe)
         else:
             xCoM,yCoM = origin
@@ -466,10 +469,13 @@ def get_probe_kernel_edge_gaussian(
         kernel : ndarray
             the cross-correlation kernel
         """
+        from py4DSTEM.process.utils import get_shifted_ar
+
         Q_Nx, Q_Ny = probe.shape
 
         # Get CoM
         if origin is None:
+            from py4DSTEM.process.calibration import get_probe_size
             _,xCoM,yCoM = get_probe_size(probe)
         else:
             xCoM,yCoM = origin
@@ -526,6 +532,8 @@ def get_probe_kernel_edge_sigmoid(
         kernel : 2d array
             the cross-correlation kernel
         """
+        from py4DSTEM.process.utils import get_shifted_ar
+
         # parse inputs
         if isinstance(probe,Probe):
             probe = probe.probe
@@ -537,6 +545,7 @@ def get_probe_kernel_edge_sigmoid(
 
         # Get CoM
         if origin is None:
+            from py4DSTEM.process.calibration import get_probe_size
             _,xCoM,yCoM = get_probe_size(probe)
         else:
             xCoM,yCoM = origin
diff --git a/py4DSTEM/process/__init__.py b/py4DSTEM/process/__init__.py
index 76ad38d47..73088068b 100644
--- a/py4DSTEM/process/__init__.py
+++ b/py4DSTEM/process/__init__.py
@@ -1,4 +1,5 @@
 from py4DSTEM.process.polar import PolarDatacube
+from py4DSTEM.process.strain import StrainMap
 
 from py4DSTEM.process import latticevectors
 from py4DSTEM.process import phase
diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
new file mode 100644
index 000000000..159bc3265
--- /dev/null
+++ b/py4DSTEM/process/strain.py
@@ -0,0 +1,82 @@
+# Defines the Strain class
+
+import numpy as np
+from typing import Optional
+from py4DSTEM.data import RealSlice, Data
+from py4DSTEM.braggvectors import BraggVectors
+
+
+
+class StrainMap(RealSlice,Data):
+    """
+    Stores strain map.
+
+    TODO add docs
+
+    """
+
+    def __init__(
+        self,
+        braggvectors: BraggVectors,
+        name: Optional[str] = 'strainmap'
+        ):
+        """
+        TODO
+        """
+        # set up braggvectors
+        self.braggvectors = braggvectors
+        # TODO - how to handle changes to braggvectors
+        # TODO - ellipse cal or no?
+
+        # set up data
+        data = np.empty((
+            self.braggvectors.Rshape[0],
+            self.braggvectors.Rshape[1],
+            6
+        ))
+
+        # initialize as a RealSlice
+        RealSlice.__init__(
+            self,
+            name = name,
+            data = data,
+            slicelabels = [
+                'exx',
+                'eyy',
+                'exy',
+                'theta',
+                'mask',
+                'error'
+            ]
+        )
+
+
+    # braggvector properties
+
+    @property
+    def braggvectors(self):
+        return self._braggvectors
+    @braggvectors.setter
+    def braggvectors(self,x):
+        assert(isinstance(x,BraggVectors)), f".braggvectors must be BraggVectors, not type {type(x)}"
+        assert(x.calibration.origin is not None), f"braggvectors must have a calibrated origin"
+        self._braggvectors = x
+
+
+    # TODO - copy method
+
+    # read
+    @classmethod
+    def _get_constructor_args(cls,group):
+        """
+        Returns a dictionary of args/values to pass to the class constructor
+        """
+        ar_constr_args = RealSlice._get_constructor_args(group)
+        args = {
+            'data' : ar_constr_args['data'],
+            'name' : ar_constr_args['name'],
+        }
+        return args
+
+
+
diff --git a/test/test_strain.py b/test/test_strain.py
new file mode 100644
index 000000000..c62e51cf3
--- /dev/null
+++ b/test/test_strain.py
@@ -0,0 +1,70 @@
+import py4DSTEM
+from py4DSTEM import StrainMap
+from os.path import join
+from numpy import zeros
+
+
+# TODO add BVs file to test suite with calibration, remove disk detection here
+
+# set filepath
+path = join(py4DSTEM._TESTPATH,"test_io/legacy_v0.9_simAuNanoplatelet_bin.h5")
+
+
+
+class TestStrainMap:
+
+    # setup/teardown
+    def setup_class(cls):
+
+        # Read sim Au datacube
+        datacube = py4DSTEM.io.read(
+            path,
+            data_id = 'polyAu_4DSTEM'
+        )
+
+        # prepare a probe
+        mask = zeros(datacube.Rshape,dtype=bool)
+        mask[28:33,14:19] = 1
+        probe = datacube.get_vacuum_probe( ROI=mask )
+        alpha_pr,qx0_pr,qy0_pr = py4DSTEM.process.calibration.get_probe_size( probe.probe )
+        probe.get_kernel(
+            mode='sigmoid',
+            origin=(qx0_pr,qy0_pr),
+            radii=(alpha_pr,2*alpha_pr)
+        )
+
+        # Set disk detection parameters
+        detect_params = {
+            'corrPower': 1.0,
+            'sigma': 0,
+            'edgeBoundary': 2,
+            'minRelativeIntensity': 0,
+            'minAbsoluteIntensity': 8,
+            'minPeakSpacing': 4,
+            'subpixel' : 'poly',
+            'maxNumPeaks': 1000,
+        #     'CUDA': True,
+        }
+
+        # find bragg peaks
+        cls.braggpeaks = datacube.find_Bragg_disks(
+            template = probe.kernel,
+            **detect_params,
+        )
+
+        # set an arbitrary origin
+        cls.braggpeaks.calibration.set_origin((0,0))
+
+
+
+    # tests
+
+    def test_strainmap_instantiation(self):
+
+        strainmap = StrainMap(
+            braggvectors = self.braggpeaks,
+        )
+
+        assert(isinstance(strainmap, StrainMap))
+
+

From 2d5cc7547b4e0b6a40f06d634bce98ba6d1a3046 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Tue, 11 Jul 2023 15:55:20 -0700
Subject: [PATCH 168/362] bugfixes for probe constraints

---
 .../iterative_ptychographic_constraints.py    |  3 +-
 py4DSTEM/process/phase/utils.py               | 31 ++++++++++++++-----
 2 files changed, 25 insertions(+), 9 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
index d3c5b34a9..5fe1a1a35 100644
--- a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
+++ b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
@@ -412,6 +412,7 @@ def _probe_fourier_amplitude_constraint(
         updated_probe_fft, _, _, _ = regularize_probe_amplitude(
             asnumpy(current_probe_fft),
             width_max_pixels=width_max_pixels,
+            nearest_angular_neighbor_averaging=5,
             enforce_constant_intensity=enforce_constant_intensity,
             corner_centered=True,
         )
@@ -485,7 +486,7 @@ def _probe_aberration_fitting_constraint(
         fourier_probe_abs = xp.abs(fourier_probe)
         sampling = self.sampling
 
-        fitted_angle = fit_aberration_surface(
+        fitted_angle, _ = fit_aberration_surface(
             fourier_probe,
             sampling,
             max_angular_order,
diff --git a/py4DSTEM/process/phase/utils.py b/py4DSTEM/process/phase/utils.py
index 7f5287b3b..2d36284ee 100644
--- a/py4DSTEM/process/phase/utils.py
+++ b/py4DSTEM/process/phase/utils.py
@@ -12,10 +12,11 @@
     cp = None
     from scipy.fft import dstn, idstn
 
+
 from py4DSTEM.process.utils.cross_correlate import align_and_shift_images
 from py4DSTEM.process.utils.utils import electron_wavelength_angstrom
 from py4DSTEM.process.utils import get_CoM
-from scipy.ndimage import gaussian_filter
+from scipy.ndimage import gaussian_filter, uniform_filter1d
 from skimage.restoration import unwrap_phase
 
 # fmt: off
@@ -1282,7 +1283,7 @@ def nesterov_gamma(zero_indexed_iter_num):
 def cartesian_to_polar_transform_2Ddata(
     im_cart,
     xy_center,
-    num_theta_bins=180,
+    num_theta_bins=90,
     radius_max=None,
     corner_centered=False,
     xp=np,
@@ -1411,6 +1412,7 @@ def polar_to_cartesian_transform_2Ddata(
 def regularize_probe_amplitude(
     probe_init,
     width_max_pixels=2.0,
+    nearest_angular_neighbor_averaging=5,
     enforce_constant_intensity=True,
     corner_centered=False,
 ):
@@ -1423,6 +1425,8 @@ def regularize_probe_amplitude(
         2D complex image of the probe in Fourier space.
     width_max_pixels: float
         Maximum edge width of the probe in pixels.
+    nearest_angular_neighbor_averaging: int
+        Number of nearest angular neighbor pixels to average to make aperture less jagged.
     enforce_constant_intensity: bool
         Set to true to make intensity inside the aperture constant.
     corner_centered: bool
@@ -1504,6 +1508,17 @@ def step_model(radius, sig_0, rad_0, width):
             xtol=1e-12,
             bounds=(lb, ub),
         )[0]
+        # polar_int_corr[a0, :] = step_model(radius, *coefs_all[a0, :])
+
+    # make aperture less jagged, using moving mean
+    coefs_all = np.apply_along_axis(
+        uniform_filter1d,
+        0,
+        coefs_all,
+        size=nearest_angular_neighbor_averaging,
+        mode="wrap",
+    )
+    for a0 in range(polar_int.shape[0]):
         polar_int_corr[a0, :] = step_model(radius, *coefs_all[a0, :])
 
     # Convert back to cartesian coordinates
@@ -1564,7 +1579,6 @@ def fit_aberration_surface(
     probe_sampling,
     max_angular_order,
     max_radial_order,
-    seed=1,
     xp=np,
 ):
     """ """
@@ -1572,11 +1586,12 @@ def fit_aberration_surface(
     probe_angle = xp.angle(complex_probe)
 
     if xp is np:
-        unwrapped_angle = unwrap_phase(probe_angle, wrap_around=True, seed=seed)
+        probe_angle = probe_angle.astype(np.float64)
+        unwrapped_angle = unwrap_phase(probe_angle, wrap_around=True).astype(xp.float32)
     else:
-        unwrapped_angle = xp.asarray(
-            unwrap_phase(xp.asnumpy(probe_angle), wrap_around=True, seed=seed)
-        )
+        probe_angle = xp.asnumpy(probe_angle).astype(np.float64)
+        unwrapped_angle = unwrap_phase(probe_angle, wrap_around=True)
+        unwrapped_angle = xp.asarray(unwrapped_angle).astype(xp.float32)
 
     basis, _ = aberrations_basis_function(
         complex_probe.shape,
@@ -1595,4 +1610,4 @@ def fit_aberration_surface(
 
     fitted_angle = xp.tensordot(coeff, basis, axes=1)
 
-    return fitted_angle
+    return fitted_angle, coeff

From 4403ce85dec3179698e477d0ff5902abc4c22c1f Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 11 Jul 2023 19:21:34 -0400
Subject: [PATCH 169/362] new test

---
 test/test_misc.py | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 test/test_misc.py

diff --git a/test/test_misc.py b/test/test_misc.py
new file mode 100644
index 000000000..bac4d65ae
--- /dev/null
+++ b/test/test_misc.py
@@ -0,0 +1,19 @@
+import py4DSTEM
+import numpy as np
+
+
+def test_attach():
+
+    x = py4DSTEM.DiffractionSlice(np.ones((5,5)), name='x')
+    y = py4DSTEM.DiffractionSlice(np.ones((5,5)), name='y')
+
+
+    x.calibration.set_Q_pixel_size(50)
+    y.calibration.set_Q_pixel_size(2)
+
+    x.attach(y)
+
+    assert('y' in x.treekeys)
+    assert(x.calibration.get_Q_pixel_size() == 50)
+
+

From e83334de30feb8aaedc4e26906fb0cce6abd2ac9 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Tue, 11 Jul 2023 16:27:57 -0700
Subject: [PATCH 170/362] probe constraints for mixed-state

---
 .../iterative_mixedstate_ptychography.py      | 95 +++++++++----------
 .../iterative_singleslice_ptychography.py     | 12 +--
 2 files changed, 51 insertions(+), 56 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
index 69b2d8c45..56fec1004 100644
--- a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
@@ -1106,15 +1106,15 @@ def _constraints(
         current_positions,
         pure_phase_object,
         fix_com,
-        symmetrize_probe,
-        probe_gaussian_filter,
-        probe_gaussian_filter_sigma,
-        probe_gaussian_filter_fix_amplitude,
+        fit_probe_aberrations,
+        fit_probe_aberrations_max_angular_order,
+        fit_probe_aberrations_max_radial_order,
         constrain_probe_amplitude,
         constrain_probe_amplitude_relative_radius,
         constrain_probe_amplitude_relative_width,
         constrain_probe_fourier_amplitude,
-        constrain_probe_fourier_amplitude_threshold,
+        constrain_probe_fourier_amplitude_max_width_pixels,
+        constrain_probe_fourier_amplitude_constant_intensity,
         fix_probe_aperture,
         initial_probe_aperture,
         fix_positions,
@@ -1145,14 +1145,12 @@ def _constraints(
             If True, object amplitude is set to unity
         fix_com: bool
             If True, probe CoM is fixed to the center
-        probe_gaussian_filter: bool
-            If True, applies reciprocal-space gaussian filtering on residual aberrations
-        probe_gaussian_filter_sigma: float
-            Standard deviation of gaussian kernel in A^-1
-        probe_gaussian_filter_fix_amplitude: bool
-            If True, only the probe phase is smoothed
-        symmetrize_probe: bool
-            If True, the probe is radially-averaged
+        fit_probe_aberrations: bool
+            If True, fits the probe aberrations to a low-order expansion
+        fit_probe_aberrations_max_angular_order: bool
+            Max angular order of probe aberrations basis functions
+        fit_probe_aberrations_max_radial_order: bool
+            Max radial order of probe aberrations basis functions
         constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
         constrain_probe_amplitude_relative_radius: float
@@ -1160,10 +1158,11 @@ def _constraints(
         constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
         constrain_probe_fourier_amplitude: bool
-            If True, probe fourier amplitude is constrained by top hat function
-        constrain_probe_fourier_amplitude_threshold: float
-            Threshold value for current probe fourier mask. Value should
-            be between 0 and 1, where higher values provide the most masking.
+            If True, probe aperture is constrained by fitting a sigmoid for each angular frequency.
+        constrain_probe_fourier_amplitude_max_width_pixels: float
+            Maximum pixel width of fitted sigmoid functions.
+        constrain_probe_fourier_amplitude_constant_intensity: bool
+            If True, the probe aperture is additionally constrained to a constant intensity.
         fix_probe_aperture: bool,
             If True, probe fourier amplitude is replaced by initial probe aperture.
         initial_probe_aperture: np.ndarray
@@ -1232,16 +1231,14 @@ def _constraints(
             current_probe = self._probe_center_of_mass_constraint(current_probe)
 
         # These constraints don't _really_ make sense for mixed-state
-        if probe_gaussian_filter:
-            raise NotImplementedError()
-        if symmetrize_probe:
-            raise NotImplementedError()
         if fix_probe_aperture:
             raise NotImplementedError()
-        elif constrain_probe_amplitude:
-            raise NotImplementedError()
         elif constrain_probe_fourier_amplitude:
             raise NotImplementedError()
+        if fit_probe_aberrations:
+            raise NotImplementedError()
+        if constrain_probe_amplitude:
+            raise NotImplementedError()
 
         if orthogonalize_probe:
             current_probe = self._probe_orthogonalization_constraint(current_probe)
@@ -1276,19 +1273,19 @@ def reconstruct(
         orthogonalize_probe: bool = True,
         fix_probe_iter: int = 0,
         fix_probe_aperture_iter: int = 0,
-        symmetrize_probe_iter: int = 0,
         constrain_probe_amplitude_iter: int = 0,
         constrain_probe_amplitude_relative_radius: float = 0.5,
         constrain_probe_amplitude_relative_width: float = 0.05,
         constrain_probe_fourier_amplitude_iter: int = 0,
-        constrain_probe_fourier_amplitude_threshold: float = 0.9,
+        constrain_probe_fourier_amplitude_max_width_pixels: float = 3.0,
+        constrain_probe_fourier_amplitude_constant_intensity: bool = False,
         fix_positions_iter: int = np.inf,
         global_affine_transformation: bool = True,
         gaussian_filter_sigma: float = None,
         gaussian_filter_iter: int = np.inf,
-        probe_gaussian_filter_sigma: float = None,
-        probe_gaussian_filter_residual_aberrations_iter: int = np.inf,
-        probe_gaussian_filter_fix_amplitude: bool = True,
+        fit_probe_aberrations_iter: int = 0,
+        fit_probe_aberrations_max_angular_order: int = 4,
+        fit_probe_aberrations_max_radial_order: int = 4,
         butterworth_filter_iter: int = np.inf,
         q_lowpass: float = None,
         q_highpass: float = None,
@@ -1342,19 +1339,18 @@ def reconstruct(
             Number of iterations to run with a fixed probe before updating probe estimate
         fix_probe_aperture_iter: int, optional
             Number of iterations to run with a fixed probe fourier amplitude before updating probe estimate
-        symmetrize_probe_iter: int, optional
-            Number of iterations to run before radially-averaging the probe
-        constrain_probe_amplitude: bool
-            If True, probe amplitude is constrained by top hat function
+        constrain_probe_amplitude_iter: int, optional
+            Number of iterations to run while constraining the real-space probe with a top-hat support.
         constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
         constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        constrain_probe_fourier_amplitude: bool
-            If True, probe fourier amplitude is constrained by top hat function
-        constrain_probe_fourier_amplitude_threshold: float
-            Threshold value for current probe fourier mask. Value should
-            be between 0 and 1, where higher values provide the most masking.
+        constrain_probe_fourier_amplitude_iter: int, optional
+            Number of iterations to run while constraining the Fourier-space probe by fitting a sigmoid for each angular frequency.
+        constrain_probe_fourier_amplitude_max_width_pixels: float
+            Maximum pixel width of fitted sigmoid functions.
+        constrain_probe_fourier_amplitude_constant_intensity: bool
+            If True, the probe aperture is additionally constrained to a constant intensity.
         fix_positions_iter: int, optional
             Number of iterations to run with fixed positions before updating positions estimate
         global_affine_transformation: bool, optional
@@ -1363,12 +1359,12 @@ def reconstruct(
             Standard deviation of gaussian kernel in A
         gaussian_filter_iter: int, optional
             Number of iterations to run using object smoothness constraint
-        probe_gaussian_filter_sigma: float, optional
-            Standard deviation of probe gaussian kernel in A^-1
-        probe_gaussian_filter_residual_aberrations_iter: int, optional
-            Number of iterations to run using probe smoothing of residual aberrations
-        probe_gaussian_filter_fix_amplitude: bool
-            If True, only the probe phase is smoothed
+        fit_probe_aberrations_iter: int, optional
+            Number of iterations to run while fitting the probe aberrations to a low-order expansion
+        fit_probe_aberrations_max_angular_order: bool
+            Max angular order of probe aberrations basis functions
+        fit_probe_aberrations_max_radial_order: bool
+            Max radial order of probe aberrations basis functions
         butterworth_filter_iter: int, optional
             Number of iterations to run using high-pass butteworth filter
         q_lowpass: float
@@ -1685,12 +1681,6 @@ def reconstruct(
                 self._probe,
                 self._positions_px,
                 fix_com=fix_com and a0 >= fix_probe_iter,
-                symmetrize_probe=a0 < symmetrize_probe_iter,
-                probe_gaussian_filter=a0
-                < probe_gaussian_filter_residual_aberrations_iter
-                and probe_gaussian_filter_sigma is not None,
-                probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
-                probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
                 constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                 and a0 >= fix_probe_iter,
                 constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
@@ -1698,7 +1688,12 @@ def reconstruct(
                 constrain_probe_fourier_amplitude=a0
                 < constrain_probe_fourier_amplitude_iter
                 and a0 >= fix_probe_iter,
-                constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_max_width_pixels=constrain_probe_fourier_amplitude_max_width_pixels,
+                constrain_probe_fourier_amplitude_constant_intensity=constrain_probe_fourier_amplitude_constant_intensity,
+                fit_probe_aberrations=a0 < fit_probe_aberrations_iter
+                and a0 >= fix_probe_iter,
+                fit_probe_aberrations_max_angular_order=fit_probe_aberrations_max_angular_order,
+                fit_probe_aberrations_max_radial_order=fit_probe_aberrations_max_radial_order,
                 fix_probe_aperture=a0 < fix_probe_aperture_iter,
                 initial_probe_aperture=self._probe_initial_aperture,
                 fix_positions=a0 < fix_positions_iter,
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index 2d5744e28..b561892cb 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -1270,12 +1270,12 @@ def reconstruct(
             Standard deviation of gaussian kernel in A
         gaussian_filter_iter: int, optional
             Number of iterations to run using object smoothness constraint
-        probe_gaussian_filter_sigma: float, optional
-            Standard deviation of probe gaussian kernel in A^-1
-        probe_gaussian_filter_fix_amplitude: bool
-            If True, only the probe phase is smoothed
-        probe_gaussian_filter_residual_aberrations_iter: int, optional
-            Number of iterations to run using probe smoothing of residual aberrations
+        fit_probe_aberrations_iter: int, optional
+            Number of iterations to run while fitting the probe aberrations to a low-order expansion
+        fit_probe_aberrations_max_angular_order: bool
+            Max angular order of probe aberrations basis functions
+        fit_probe_aberrations_max_radial_order: bool
+            Max radial order of probe aberrations basis functions
         butterworth_filter_iter: int, optional
             Number of iterations to run using high-pass butteworth filter
         q_lowpass: float

From 9fe98ccd5c0fcc64a0f6c12fae884ddaa2b32d29 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 11 Jul 2023 19:29:59 -0400
Subject: [PATCH 171/362] get_probe_size fixes

---
 py4DSTEM/datacube/datacube.py         | 13 ++++++-------
 py4DSTEM/process/calibration/probe.py |  1 -
 2 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/py4DSTEM/datacube/datacube.py b/py4DSTEM/datacube/datacube.py
index 96ec950ba..3031b3ff9 100644
--- a/py4DSTEM/datacube/datacube.py
+++ b/py4DSTEM/datacube/datacube.py
@@ -657,7 +657,7 @@ def get_probe_size(
         thresh_lower=0.01,
         thresh_upper=0.99,
         N=100,
-        plot = True,
+        plot = False,
         returncal = True,
         write_to_cal = True,
         **kwargs,
@@ -707,13 +707,13 @@ def get_probe_size(
         from py4DSTEM.process.calibration import get_probe_size
 
         if dp is None:
-            assert 'dp_mean' in self._branch.keys(), "calculate .get_dp_mean()"
+            assert('dp_mean' in self.treekeys), "calculate .get_dp_mean() or pass a `dp` arg"
             DP = self.tree( 'dp_mean' ).data
         elif type(dp) == str:
-            assert dp in self._branch.keys(), "mode not found"
-            DP = self.attach( dp )
+            assert(dp in self.treekeys), f"mode {dp} not found in the tree"
+            DP = self.tree( dp )
         elif type(dp) == np.ndarray:
-            assert len(dp.shape) == 2, "must be a 2D array"
+            assert(dp.shape == self.Qshape), "must be a diffraction space shape 2D array"
             DP = dp
 
         x = get_probe_size(
@@ -728,8 +728,7 @@ def get_probe_size(
             try:
                 self.calibration.set_probe_param(x)
             except AttributeError:
-                # should we raise an error here?
-                pass
+                raise Exception('writing to calibrations were requested, but could not be completed')
 
         #plot results 
         if plot:
diff --git a/py4DSTEM/process/calibration/probe.py b/py4DSTEM/process/calibration/probe.py
index c239590c5..f42a353b6 100644
--- a/py4DSTEM/process/calibration/probe.py
+++ b/py4DSTEM/process/calibration/probe.py
@@ -45,7 +45,6 @@ def get_probe_size(DP, thresh_lower=0.01, thresh_upper=0.99, N=100):
 
     # Get r for each mask
     DPmax = np.max(DP)
-    print(DPmax)
     for i in range(len(thresh_vals)):
         thresh = thresh_vals[i]
         mask = DP > DPmax * thresh

From 2803c08f71e5b4f8c201a2295381efb985d4cff6 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Tue, 11 Jul 2023 16:35:19 -0700
Subject: [PATCH 172/362] remove print statement

---
 py4DSTEM/process/calibration/probe.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/py4DSTEM/process/calibration/probe.py b/py4DSTEM/process/calibration/probe.py
index c239590c5..f42a353b6 100644
--- a/py4DSTEM/process/calibration/probe.py
+++ b/py4DSTEM/process/calibration/probe.py
@@ -45,7 +45,6 @@ def get_probe_size(DP, thresh_lower=0.01, thresh_upper=0.99, N=100):
 
     # Get r for each mask
     DPmax = np.max(DP)
-    print(DPmax)
     for i in range(len(thresh_vals)):
         thresh = thresh_vals[i]
         mask = DP > DPmax * thresh

From 9ed2e36f0a9e11e160db3d031a7ef9a63fbacad7 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Tue, 11 Jul 2023 16:37:46 -0700
Subject: [PATCH 173/362] probe constraints for multislice

---
 .../iterative_multislice_ptychography.py      | 117 +++++++++---------
 1 file changed, 56 insertions(+), 61 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_multislice_ptychography.py b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
index 4706decf9..1e9bd2cbb 100644
--- a/py4DSTEM/process/phase/iterative_multislice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
@@ -1455,15 +1455,15 @@ def _constraints(
         current_probe,
         current_positions,
         fix_com,
-        symmetrize_probe,
-        probe_gaussian_filter,
-        probe_gaussian_filter_sigma,
-        probe_gaussian_filter_fix_amplitude,
+        fit_probe_aberrations,
+        fit_probe_aberrations_max_angular_order,
+        fit_probe_aberrations_max_radial_order,
         constrain_probe_amplitude,
         constrain_probe_amplitude_relative_radius,
         constrain_probe_amplitude_relative_width,
         constrain_probe_fourier_amplitude,
-        constrain_probe_fourier_amplitude_threshold,
+        constrain_probe_fourier_amplitude_max_width_pixels,
+        constrain_probe_fourier_amplitude_constant_intensity,
         fix_probe_aperture,
         initial_probe_aperture,
         fix_positions,
@@ -1498,14 +1498,12 @@ def _constraints(
             Current positions estimate
         fix_com: bool
             If True, probe CoM is fixed to the center
-        symmetrize_probe: bool
-            If True, the probe is radially-averaged
-        probe_gaussian_filter: bool
-            If True, applies reciprocal-space gaussian filtering on residual aberrations
-        probe_gaussian_filter_sigma: float
-            Standard deviation of gaussian kernel in A^-1
-        probe_gaussian_filter_fix_amplitude: bool
-            If True, only the probe phase is smoothed
+        fit_probe_aberrations: bool
+            If True, fits the probe aberrations to a low-order expansion
+        fit_probe_aberrations_max_angular_order: bool
+            Max angular order of probe aberrations basis functions
+        fit_probe_aberrations_max_radial_order: bool
+            Max radial order of probe aberrations basis functions
         constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
         constrain_probe_amplitude_relative_radius: float
@@ -1513,10 +1511,11 @@ def _constraints(
         constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
         constrain_probe_fourier_amplitude: bool
-            If True, probe fourier amplitude is constrained by top hat function
-        constrain_probe_fourier_amplitude_threshold: float
-            Threshold value for current probe fourier mask. Value should
-            be between 0 and 1, where higher values provide the most masking.
+            If True, probe aperture is constrained by fitting a sigmoid for each angular frequency.
+        constrain_probe_fourier_amplitude_max_width_pixels: float
+            Maximum pixel width of fitted sigmoid functions.
+        constrain_probe_fourier_amplitude_constant_intensity: bool
+            If True, the probe aperture is additionally constrained to a constant intensity.
         fix_probe_aperture: bool
             If True, probe Fourier amplitude is replaced by initial_probe_aperture
         initial_probe_aperture: np.ndarray
@@ -1612,31 +1611,29 @@ def _constraints(
         if fix_com:
             current_probe = self._probe_center_of_mass_constraint(current_probe)
 
-        if probe_gaussian_filter:
-            current_probe = self._probe_residual_aberration_filtering_constraint(
-                current_probe,
-                probe_gaussian_filter_sigma,
-                probe_gaussian_filter_fix_amplitude,
-            )
-
-        if symmetrize_probe:
-            current_probe = self._probe_radial_symmetrization_constraint(current_probe)
-
         if fix_probe_aperture:
             current_probe = self._probe_aperture_constraint(
                 current_probe,
                 initial_probe_aperture,
             )
-        elif constrain_probe_amplitude:
-            current_probe = self._probe_amplitude_constraint(
-                current_probe,
-                constrain_probe_amplitude_relative_radius,
-                constrain_probe_amplitude_relative_width,
-            )
         elif constrain_probe_fourier_amplitude:
             current_probe = self._probe_fourier_amplitude_constraint(
                 current_probe,
-                constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_max_width_pixels,
+                constrain_probe_fourier_amplitude_constant_intensity,
+            )
+
+        if fit_probe_aberrations:
+            current_probe = self._probe_aberration_fitting_constraint(
+                current_probe,
+                fit_probe_aberrations_max_angular_order,
+                fit_probe_aberrations_max_radial_order,
+            )
+
+        if constrain_probe_amplitude:
+            current_probe = self._probe_amplitude_constraint(
+                current_probe,
+                constrain_probe_amplitude_relative_radius,
                 constrain_probe_amplitude_relative_width,
             )
 
@@ -1668,20 +1665,20 @@ def reconstruct(
         fix_com: bool = True,
         fix_probe_iter: int = 0,
         fix_probe_aperture_iter: int = 0,
-        symmetrize_probe_iter: int = 0,
         constrain_probe_amplitude_iter: int = 0,
         constrain_probe_amplitude_relative_radius: float = 0.5,
         constrain_probe_amplitude_relative_width: float = 0.05,
         constrain_probe_fourier_amplitude_iter: int = 0,
-        constrain_probe_fourier_amplitude_threshold: float = 0.9,
+        constrain_probe_fourier_amplitude_max_width_pixels: float = 3.0,
+        constrain_probe_fourier_amplitude_constant_intensity: bool = False,
         fix_positions_iter: int = np.inf,
         constrain_position_distance: float = None,
         global_affine_transformation: bool = True,
         gaussian_filter_sigma: float = None,
         gaussian_filter_iter: int = np.inf,
-        probe_gaussian_filter_sigma: float = None,
-        probe_gaussian_filter_residual_aberrations_iter: int = np.inf,
-        probe_gaussian_filter_fix_amplitude: bool = True,
+        fit_probe_aberrations_iter: int = 0,
+        fit_probe_aberrations_max_angular_order: int = 4,
+        fit_probe_aberrations_max_radial_order: int = 4,
         butterworth_filter_iter: int = np.inf,
         q_lowpass: float = None,
         q_highpass: float = None,
@@ -1740,19 +1737,18 @@ def reconstruct(
             Number of iterations to run with a fixed probe before updating probe estimate
         fix_probe_aperture_iter: int, optional
             Number of iterations to run with a fixed probe Fourier amplitude before updating probe estimate
-        symmetrize_probe_iter: int, optional
-            Number of iterations to run before radially-averaging the probe
-        constrain_probe_amplitude: bool
-            If True, probe amplitude is constrained by top hat function
+        constrain_probe_amplitude_iter: int, optional
+            Number of iterations to run while constraining the real-space probe with a top-hat support.
         constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
         constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        constrain_probe_fourier_amplitude: bool
-            If True, probe fourier amplitude is constrained by top hat function
-        constrain_probe_fourier_amplitude_threshold: float
-            Threshold value for current probe fourier mask. Value should
-            be between 0 and 1, where higher values provide the most masking.
+        constrain_probe_fourier_amplitude_iter: int, optional
+            Number of iterations to run while constraining the Fourier-space probe by fitting a sigmoid for each angular frequency.
+        constrain_probe_fourier_amplitude_max_width_pixels: float
+            Maximum pixel width of fitted sigmoid functions.
+        constrain_probe_fourier_amplitude_constant_intensity: bool
+            If True, the probe aperture is additionally constrained to a constant intensity.
         fix_positions_iter: int, optional
             Number of iterations to run with fixed positions before updating positions estimate
         global_affine_transformation: bool, optional
@@ -1761,12 +1757,12 @@ def reconstruct(
             Standard deviation of gaussian kernel in A
         gaussian_filter_iter: int, optional
             Number of iterations to run using object smoothness constraint
-        probe_gaussian_filter_sigma: float, optional
-            Standard deviation of probe gaussian kernel in A^-1
-        probe_gaussian_filter_residual_aberrations_iter: int, optional
-            Number of iterations to run using probe smoothing of residual aberrations
-        probe_gaussian_filter_fix_amplitude: bool
-            If True, only the probe phase is smoothed
+        fit_probe_aberrations_iter: int, optional
+            Number of iterations to run while fitting the probe aberrations to a low-order expansion
+        fit_probe_aberrations_max_angular_order: bool
+            Max angular order of probe aberrations basis functions
+        fit_probe_aberrations_max_radial_order: bool
+            Max radial order of probe aberrations basis functions
         butterworth_filter_iter: int, optional
             Number of iterations to run using high-pass butteworth filter
         q_lowpass: float
@@ -2098,12 +2094,6 @@ def reconstruct(
                 self._probe,
                 self._positions_px,
                 fix_com=fix_com and a0 >= fix_probe_iter,
-                symmetrize_probe=a0 < symmetrize_probe_iter,
-                probe_gaussian_filter=a0
-                < probe_gaussian_filter_residual_aberrations_iter
-                and probe_gaussian_filter_sigma is not None,
-                probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
-                probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
                 constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                 and a0 >= fix_probe_iter,
                 constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
@@ -2111,7 +2101,12 @@ def reconstruct(
                 constrain_probe_fourier_amplitude=a0
                 < constrain_probe_fourier_amplitude_iter
                 and a0 >= fix_probe_iter,
-                constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_max_width_pixels=constrain_probe_fourier_amplitude_max_width_pixels,
+                constrain_probe_fourier_amplitude_constant_intensity=constrain_probe_fourier_amplitude_constant_intensity,
+                fit_probe_aberrations=a0 < fit_probe_aberrations_iter
+                and a0 >= fix_probe_iter,
+                fit_probe_aberrations_max_angular_order=fit_probe_aberrations_max_angular_order,
+                fit_probe_aberrations_max_radial_order=fit_probe_aberrations_max_radial_order,
                 fix_probe_aperture=a0 < fix_probe_aperture_iter,
                 initial_probe_aperture=self._probe_initial_aperture,
                 fix_positions=a0 < fix_positions_iter,

From ee78659e999f37c8c9791d90b96a96c98c1cfd42 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Tue, 11 Jul 2023 16:51:30 -0700
Subject: [PATCH 174/362] probe constraints for overlap tomography

---
 .../iterative_overlap_magnetic_tomography.py  | 130 +++++++++---------
 .../phase/iterative_overlap_tomography.py     | 130 +++++++++---------
 2 files changed, 124 insertions(+), 136 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 099d26bcb..4c7387763 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -1685,15 +1685,15 @@ def _constraints(
         current_probe,
         current_positions,
         fix_com,
-        symmetrize_probe,
-        probe_gaussian_filter,
-        probe_gaussian_filter_sigma,
-        probe_gaussian_filter_fix_amplitude,
+        fit_probe_aberrations,
+        fit_probe_aberrations_max_angular_order,
+        fit_probe_aberrations_max_radial_order,
         constrain_probe_amplitude,
         constrain_probe_amplitude_relative_radius,
         constrain_probe_amplitude_relative_width,
         constrain_probe_fourier_amplitude,
-        constrain_probe_fourier_amplitude_threshold,
+        constrain_probe_fourier_amplitude_max_width_pixels,
+        constrain_probe_fourier_amplitude_constant_intensity,
         fix_probe_aperture,
         initial_probe_aperture,
         fix_positions,
@@ -1725,14 +1725,12 @@ def _constraints(
             Current positions estimate
         fix_com: bool
             If True, probe CoM is fixed to the center
-        symmetrize_probe: bool
-            If True, the probe is radially-averaged
-        probe_gaussian_filter: bool
-            If True, applies reciprocal-space gaussian filtering on residual aberrations
-        probe_gaussian_filter_sigma: float
-            Standard deviation of gaussian kernel in A^-1
-        probe_gaussian_filter_fix_amplitude: bool
-            If True, only the probe phase is smoothed
+        fit_probe_aberrations: bool
+            If True, fits the probe aberrations to a low-order expansion
+        fit_probe_aberrations_max_angular_order: bool
+            Max angular order of probe aberrations basis functions
+        fit_probe_aberrations_max_radial_order: bool
+            Max radial order of probe aberrations basis functions
         constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
         constrain_probe_amplitude_relative_radius: float
@@ -1740,10 +1738,11 @@ def _constraints(
         constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
         constrain_probe_fourier_amplitude: bool
-            If True, probe fourier amplitude is constrained by top hat function
-        constrain_probe_fourier_amplitude_threshold: float
-            Threshold value for current probe fourier mask. Value should
-            be between 0 and 1, where higher values provide the most masking.
+            If True, probe aperture is constrained by fitting a sigmoid for each angular frequency.
+        constrain_probe_fourier_amplitude_max_width_pixels: float
+            Maximum pixel width of fitted sigmoid functions.
+        constrain_probe_fourier_amplitude_constant_intensity: bool
+            If True, the probe aperture is additionally constrained to a constant intensity.
         fix_probe_aperture: bool,
             If True, probe Fourier amplitude is replaced by initial probe aperture.
         initial_probe_aperture: np.ndarray,
@@ -1836,31 +1835,29 @@ def _constraints(
         if fix_com:
             current_probe = self._probe_center_of_mass_constraint(current_probe)
 
-        if probe_gaussian_filter:
-            current_probe = self._probe_residual_aberration_filtering_constraint(
-                current_probe,
-                probe_gaussian_filter_sigma,
-                probe_gaussian_filter_fix_amplitude,
-            )
-
-        if symmetrize_probe:
-            current_probe = self._probe_radial_symmetrization_constraint(current_probe)
-
         if fix_probe_aperture:
             current_probe = self._probe_aperture_constraint(
                 current_probe,
                 initial_probe_aperture,
             )
-        elif constrain_probe_amplitude:
-            current_probe = self._probe_amplitude_constraint(
-                current_probe,
-                constrain_probe_amplitude_relative_radius,
-                constrain_probe_amplitude_relative_width,
-            )
         elif constrain_probe_fourier_amplitude:
             current_probe = self._probe_fourier_amplitude_constraint(
                 current_probe,
-                constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_max_width_pixels,
+                constrain_probe_fourier_amplitude_constant_intensity,
+            )
+
+        if fit_probe_aberrations:
+            current_probe = self._probe_aberration_fitting_constraint(
+                current_probe,
+                fit_probe_aberrations_max_angular_order,
+                fit_probe_aberrations_max_radial_order,
+            )
+
+        if constrain_probe_amplitude:
+            current_probe = self._probe_amplitude_constraint(
+                current_probe,
+                constrain_probe_amplitude_relative_radius,
                 constrain_probe_amplitude_relative_width,
             )
 
@@ -1892,21 +1889,21 @@ def reconstruct(
         fix_com: bool = True,
         fix_probe_iter: int = 0,
         fix_probe_aperture_iter: int = 0,
-        symmetrize_probe_iter: int = 0,
         constrain_probe_amplitude_iter: int = 0,
         constrain_probe_amplitude_relative_radius: float = 0.5,
         constrain_probe_amplitude_relative_width: float = 0.05,
         constrain_probe_fourier_amplitude_iter: int = 0,
-        constrain_probe_fourier_amplitude_threshold: float = 0.9,
+        constrain_probe_fourier_amplitude_max_width_pixels: float = 3.0,
+        constrain_probe_fourier_amplitude_constant_intensity: bool = False,
         fix_positions_iter: int = np.inf,
         constrain_position_distance: float = None,
         global_affine_transformation: bool = True,
         gaussian_filter_sigma_e: float = None,
         gaussian_filter_sigma_m: float = None,
         gaussian_filter_iter: int = np.inf,
-        probe_gaussian_filter_sigma: float = None,
-        probe_gaussian_filter_residual_aberrations_iter: int = np.inf,
-        probe_gaussian_filter_fix_amplitude: bool = True,
+        fit_probe_aberrations_iter: int = 0,
+        fit_probe_aberrations_max_angular_order: int = 4,
+        fit_probe_aberrations_max_radial_order: int = 4,
         butterworth_filter_iter: int = np.inf,
         q_lowpass_e: float = None,
         q_lowpass_m: float = None,
@@ -1960,19 +1957,18 @@ def reconstruct(
             Number of iterations to run with a fixed probe before updating probe estimate
         fix_probe_aperture_iter: int, optional
             Number of iterations to run with a fixed probe Fourier amplitude before updating probe estimate
-        symmetrize_probe_iter: int, optional
-            Number of iterations to run before radially-averaging the probe
-        constrain_probe_amplitude: bool
-            If True, probe amplitude is constrained by top hat function
+        constrain_probe_amplitude_iter: int, optional
+            Number of iterations to run while constraining the real-space probe with a top-hat support.
         constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
         constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        constrain_probe_fourier_amplitude: bool
-            If True, probe fourier amplitude is constrained by top hat function
-        constrain_probe_fourier_amplitude_threshold: float
-            Threshold value for current probe fourier mask. Value should
-            be between 0 and 1, where higher values provide the most masking.
+        constrain_probe_fourier_amplitude_iter: int, optional
+            Number of iterations to run while constraining the Fourier-space probe by fitting a sigmoid for each angular frequency.
+        constrain_probe_fourier_amplitude_max_width_pixels: float
+            Maximum pixel width of fitted sigmoid functions.
+        constrain_probe_fourier_amplitude_constant_intensity: bool
+            If True, the probe aperture is additionally constrained to a constant intensity.
         fix_positions_iter: int, optional
             Number of iterations to run with fixed positions before updating positions estimate
         constrain_position_distance: float, optional
@@ -1986,12 +1982,12 @@ def reconstruct(
             Standard deviation of gaussian kernel for magnetic object in A
         gaussian_filter_iter: int, optional
             Number of iterations to run using object smoothness constraint
-        probe_gaussian_filter_sigma: float, optional
-            Standard deviation of probe gaussian kernel in A^-1
-        probe_gaussian_filter_residual_aberrations_iter: int, optional
-            Number of iterations to run using probe smoothing of residual aberrations
-        probe_gaussian_filter_fix_amplitude: bool
-            If True, only the probe phase is smoothed
+        fit_probe_aberrations_iter: int, optional
+            Number of iterations to run while fitting the probe aberrations to a low-order expansion
+        fit_probe_aberrations_max_angular_order: bool
+            Max angular order of probe aberrations basis functions
+        fit_probe_aberrations_max_radial_order: bool
+            Max radial order of probe aberrations basis functions
         butterworth_filter_iter: int, optional
             Number of iterations to run using high-pass butteworth filter
         q_lowpass: float
@@ -2447,12 +2443,6 @@ def reconstruct(
                         self._probe,
                         self._positions_px_all[start_tilt:end_tilt],
                         fix_com=fix_com and a0 >= fix_probe_iter,
-                        symmetrize_probe=a0 < symmetrize_probe_iter,
-                        probe_gaussian_filter=a0
-                        < probe_gaussian_filter_residual_aberrations_iter
-                        and probe_gaussian_filter_sigma is not None,
-                        probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
-                        probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
                         constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                         and a0 >= fix_probe_iter,
                         constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
@@ -2460,7 +2450,12 @@ def reconstruct(
                         constrain_probe_fourier_amplitude=a0
                         < constrain_probe_fourier_amplitude_iter
                         and a0 >= fix_probe_iter,
-                        constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                        constrain_probe_fourier_amplitude_max_width_pixels=constrain_probe_fourier_amplitude_max_width_pixels,
+                        constrain_probe_fourier_amplitude_constant_intensity=constrain_probe_fourier_amplitude_constant_intensity,
+                        fit_probe_aberrations=a0 < fit_probe_aberrations_iter
+                        and a0 >= fix_probe_iter,
+                        fit_probe_aberrations_max_angular_order=fit_probe_aberrations_max_angular_order,
+                        fit_probe_aberrations_max_radial_order=fit_probe_aberrations_max_radial_order,
                         fix_probe_aperture=a0 < fix_probe_aperture_iter,
                         initial_probe_aperture=self._probe_initial_aperture,
                         fix_positions=a0 < fix_positions_iter,
@@ -2497,12 +2492,6 @@ def reconstruct(
                     self._probe,
                     None,
                     fix_com=fix_com and a0 >= fix_probe_iter,
-                    symmetrize_probe=a0 < symmetrize_probe_iter,
-                    probe_gaussian_filter=a0
-                    < probe_gaussian_filter_residual_aberrations_iter
-                    and probe_gaussian_filter_sigma is not None,
-                    probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
-                    probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
                     constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                     and a0 >= fix_probe_iter,
                     constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
@@ -2510,7 +2499,12 @@ def reconstruct(
                     constrain_probe_fourier_amplitude=a0
                     < constrain_probe_fourier_amplitude_iter
                     and a0 >= fix_probe_iter,
-                    constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                    constrain_probe_fourier_amplitude_max_width_pixels=constrain_probe_fourier_amplitude_max_width_pixels,
+                    constrain_probe_fourier_amplitude_constant_intensity=constrain_probe_fourier_amplitude_constant_intensity,
+                    fit_probe_aberrations=a0 < fit_probe_aberrations_iter
+                    and a0 >= fix_probe_iter,
+                    fit_probe_aberrations_max_angular_order=fit_probe_aberrations_max_angular_order,
+                    fit_probe_aberrations_max_radial_order=fit_probe_aberrations_max_radial_order,
                     fix_probe_aperture=a0 < fix_probe_aperture_iter,
                     initial_probe_aperture=self._probe_initial_aperture,
                     fix_positions=True,
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index b5a3f71fa..0293fd322 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -1533,15 +1533,15 @@ def _constraints(
         current_probe,
         current_positions,
         fix_com,
-        symmetrize_probe,
-        probe_gaussian_filter,
-        probe_gaussian_filter_sigma,
-        probe_gaussian_filter_fix_amplitude,
+        fit_probe_aberrations,
+        fit_probe_aberrations_max_angular_order,
+        fit_probe_aberrations_max_radial_order,
         constrain_probe_amplitude,
         constrain_probe_amplitude_relative_radius,
         constrain_probe_amplitude_relative_width,
         constrain_probe_fourier_amplitude,
-        constrain_probe_fourier_amplitude_threshold,
+        constrain_probe_fourier_amplitude_max_width_pixels,
+        constrain_probe_fourier_amplitude_constant_intensity,
         fix_probe_aperture,
         initial_probe_aperture,
         fix_positions,
@@ -1569,14 +1569,12 @@ def _constraints(
             Current positions estimate
         fix_com: bool
             If True, probe CoM is fixed to the center
-        symmetrize_probe_iter: int, optional
-            Number of iterations to run before radially-averaging the probe
-        probe_gaussian_filter: bool
-            If True, applies reciprocal-space gaussian filtering on residual aberrations
-        probe_gaussian_filter_sigma: float
-            Standard deviation of gaussian kernel in A^-1
-        probe_gaussian_filter_fix_amplitude: bool
-            If True, only the probe phase is smoothed
+        fit_probe_aberrations: bool
+            If True, fits the probe aberrations to a low-order expansion
+        fit_probe_aberrations_max_angular_order: bool
+            Max angular order of probe aberrations basis functions
+        fit_probe_aberrations_max_radial_order: bool
+            Max radial order of probe aberrations basis functions
         constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
         constrain_probe_amplitude_relative_radius: float
@@ -1584,10 +1582,11 @@ def _constraints(
         constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
         constrain_probe_fourier_amplitude: bool
-            If True, probe fourier amplitude is constrained by top hat function
-        constrain_probe_fourier_amplitude_threshold: float
-            Threshold value for current probe fourier mask. Value should
-            be between 0 and 1, where higher values provide the most masking.
+            If True, probe aperture is constrained by fitting a sigmoid for each angular frequency.
+        constrain_probe_fourier_amplitude_max_width_pixels: float
+            Maximum pixel width of fitted sigmoid functions.
+        constrain_probe_fourier_amplitude_constant_intensity: bool
+            If True, the probe aperture is additionally constrained to a constant intensity.
         fix_probe_aperture: bool,
             If True, probe Fourier amplitude is replaced by initial probe aperture.
         initial_probe_aperture: np.ndarray,
@@ -1649,31 +1648,29 @@ def _constraints(
         if fix_com:
             current_probe = self._probe_center_of_mass_constraint(current_probe)
 
-        if probe_gaussian_filter:
-            current_probe = self._probe_residual_aberration_filtering_constraint(
-                current_probe,
-                probe_gaussian_filter_sigma,
-                probe_gaussian_filter_fix_amplitude,
-            )
-
-        if symmetrize_probe:
-            current_probe = self._probe_radial_symmetrization_constraint(current_probe)
-
         if fix_probe_aperture:
             current_probe = self._probe_aperture_constraint(
                 current_probe,
                 initial_probe_aperture,
             )
-        elif constrain_probe_amplitude:
-            current_probe = self._probe_amplitude_constraint(
-                current_probe,
-                constrain_probe_amplitude_relative_radius,
-                constrain_probe_amplitude_relative_width,
-            )
         elif constrain_probe_fourier_amplitude:
             current_probe = self._probe_fourier_amplitude_constraint(
                 current_probe,
-                constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_max_width_pixels,
+                constrain_probe_fourier_amplitude_constant_intensity,
+            )
+
+        if fit_probe_aberrations:
+            current_probe = self._probe_aberration_fitting_constraint(
+                current_probe,
+                fit_probe_aberrations_max_angular_order,
+                fit_probe_aberrations_max_radial_order,
+            )
+
+        if constrain_probe_amplitude:
+            current_probe = self._probe_amplitude_constraint(
+                current_probe,
+                constrain_probe_amplitude_relative_radius,
                 constrain_probe_amplitude_relative_width,
             )
 
@@ -1705,20 +1702,20 @@ def reconstruct(
         fix_com: bool = True,
         fix_probe_iter: int = 0,
         fix_probe_aperture_iter: int = 0,
-        symmetrize_probe_iter: int = 0,
         constrain_probe_amplitude_iter: int = 0,
         constrain_probe_amplitude_relative_radius: float = 0.5,
         constrain_probe_amplitude_relative_width: float = 0.05,
         constrain_probe_fourier_amplitude_iter: int = 0,
-        constrain_probe_fourier_amplitude_threshold: float = 0.9,
+        constrain_probe_fourier_amplitude_max_width_pixels: float = 3.0,
+        constrain_probe_fourier_amplitude_constant_intensity: bool = False,
         fix_positions_iter: int = np.inf,
         constrain_position_distance: float = None,
         global_affine_transformation: bool = True,
         gaussian_filter_sigma: float = None,
         gaussian_filter_iter: int = np.inf,
-        probe_gaussian_filter_sigma: float = None,
-        probe_gaussian_filter_residual_aberrations_iter: int = np.inf,
-        probe_gaussian_filter_fix_amplitude: bool = True,
+        fit_probe_aberrations_iter: int = 0,
+        fit_probe_aberrations_max_angular_order: int = 4,
+        fit_probe_aberrations_max_radial_order: int = 4,
         butterworth_filter_iter: int = np.inf,
         q_lowpass: float = None,
         q_highpass: float = None,
@@ -1770,19 +1767,18 @@ def reconstruct(
             Number of iterations to run with a fixed probe before updating probe estimate
         fix_probe_aperture_iter: int, optional
             Number of iterations to run with a fixed probe Fourier amplitude before updating probe estimate
-        symmetrize_probe_iter: int, optional
-            Number of iterations to run before radially-averaging the probe
-        constrain_probe_amplitude: bool
-            If True, probe amplitude is constrained by top hat function
+        constrain_probe_amplitude_iter: int, optional
+            Number of iterations to run while constraining the real-space probe with a top-hat support.
         constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
         constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        constrain_probe_fourier_amplitude: bool
-            If True, probe fourier amplitude is constrained by top hat function
-        constrain_probe_fourier_amplitude_threshold: float
-            Threshold value for current probe fourier mask. Value should
-            be between 0 and 1, where higher values provide the most masking.
+        constrain_probe_fourier_amplitude_iter: int, optional
+            Number of iterations to run while constraining the Fourier-space probe by fitting a sigmoid for each angular frequency.
+        constrain_probe_fourier_amplitude_max_width_pixels: float
+            Maximum pixel width of fitted sigmoid functions.
+        constrain_probe_fourier_amplitude_constant_intensity: bool
+            If True, the probe aperture is additionally constrained to a constant intensity.
         fix_positions_iter: int, optional
             Number of iterations to run with fixed positions before updating positions estimate
         constrain_position_distance: float, optional
@@ -1794,12 +1790,12 @@ def reconstruct(
             Standard deviation of gaussian kernel in A
         gaussian_filter_iter: int, optional
             Number of iterations to run using object smoothness constraint
-        probe_gaussian_filter_sigma: float, optional
-            Standard deviation of probe gaussian kernel in A^-1
-        probe_gaussian_filter_residual_aberrations_iter: int, optional
-            Number of iterations to run using probe smoothing of residual aberrations
-        probe_gaussian_filter_fix_amplitude: bool
-            If True, only the probe phase is smoothed
+        fit_probe_aberrations_iter: int, optional
+            Number of iterations to run while fitting the probe aberrations to a low-order expansion
+        fit_probe_aberrations_max_angular_order: bool
+            Max angular order of probe aberrations basis functions
+        fit_probe_aberrations_max_radial_order: bool
+            Max radial order of probe aberrations basis functions
         butterworth_filter_iter: int, optional
             Number of iterations to run using high-pass butteworth filter
         q_lowpass: float
@@ -2176,12 +2172,6 @@ def reconstruct(
                         self._probe,
                         self._positions_px_all[start_tilt:end_tilt],
                         fix_com=fix_com and a0 >= fix_probe_iter,
-                        symmetrize_probe=a0 < symmetrize_probe_iter,
-                        probe_gaussian_filter=a0
-                        < probe_gaussian_filter_residual_aberrations_iter
-                        and probe_gaussian_filter_sigma is not None,
-                        probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
-                        probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
                         constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                         and a0 >= fix_probe_iter,
                         constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
@@ -2189,7 +2179,12 @@ def reconstruct(
                         constrain_probe_fourier_amplitude=a0
                         < constrain_probe_fourier_amplitude_iter
                         and a0 >= fix_probe_iter,
-                        constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                        constrain_probe_fourier_amplitude_max_width_pixels=constrain_probe_fourier_amplitude_max_width_pixels,
+                        constrain_probe_fourier_amplitude_constant_intensity=constrain_probe_fourier_amplitude_constant_intensity,
+                        fit_probe_aberrations=a0 < fit_probe_aberrations_iter
+                        and a0 >= fix_probe_iter,
+                        fit_probe_aberrations_max_angular_order=fit_probe_aberrations_max_angular_order,
+                        fit_probe_aberrations_max_radial_order=fit_probe_aberrations_max_radial_order,
                         fix_probe_aperture=a0 < fix_probe_aperture_iter,
                         initial_probe_aperture=self._probe_initial_aperture,
                         fix_positions=a0 < fix_positions_iter,
@@ -2221,12 +2216,6 @@ def reconstruct(
                     self._probe,
                     None,
                     fix_com=fix_com and a0 >= fix_probe_iter,
-                    symmetrize_probe=a0 < symmetrize_probe_iter,
-                    probe_gaussian_filter=a0
-                    < probe_gaussian_filter_residual_aberrations_iter
-                    and probe_gaussian_filter_sigma is not None,
-                    probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
-                    probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
                     constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                     and a0 >= fix_probe_iter,
                     constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
@@ -2234,7 +2223,12 @@ def reconstruct(
                     constrain_probe_fourier_amplitude=a0
                     < constrain_probe_fourier_amplitude_iter
                     and a0 >= fix_probe_iter,
-                    constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                    constrain_probe_fourier_amplitude_max_width_pixels=constrain_probe_fourier_amplitude_max_width_pixels,
+                    constrain_probe_fourier_amplitude_constant_intensity=constrain_probe_fourier_amplitude_constant_intensity,
+                    fit_probe_aberrations=a0 < fit_probe_aberrations_iter
+                    and a0 >= fix_probe_iter,
+                    fit_probe_aberrations_max_angular_order=fit_probe_aberrations_max_angular_order,
+                    fit_probe_aberrations_max_radial_order=fit_probe_aberrations_max_radial_order,
                     fix_probe_aperture=a0 < fix_probe_aperture_iter,
                     initial_probe_aperture=self._probe_initial_aperture,
                     fix_positions=True,

From 03a25f1de3624d09921abe1c48ada04da7317814 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Tue, 11 Jul 2023 16:56:03 -0700
Subject: [PATCH 175/362] probe constraints for simultaneous

---
 .../iterative_simultaneous_ptychography.py    | 111 +++++++++---------
 1 file changed, 56 insertions(+), 55 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
index cf243192e..8881d021c 100644
--- a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
@@ -2210,15 +2210,15 @@ def _constraints(
         current_positions,
         pure_phase_object,
         fix_com,
-        symmetrize_probe,
-        probe_gaussian_filter,
-        probe_gaussian_filter_sigma,
-        probe_gaussian_filter_fix_amplitude,
+        fit_probe_aberrations,
+        fit_probe_aberrations_max_angular_order,
+        fit_probe_aberrations_max_radial_order,
         constrain_probe_amplitude,
         constrain_probe_amplitude_relative_radius,
         constrain_probe_amplitude_relative_width,
         constrain_probe_fourier_amplitude,
-        constrain_probe_fourier_amplitude_threshold,
+        constrain_probe_fourier_amplitude_max_width_pixels,
+        constrain_probe_fourier_amplitude_constant_intensity,
         fix_probe_aperture,
         initial_probe_aperture,
         fix_positions,
@@ -2252,8 +2252,12 @@ def _constraints(
             If True, object amplitude is set to unity
         fix_com: bool
             If True, probe CoM is fixed to the center
-        symmetrize_probe: bool
-            If True, the probe is radially-averaged
+        fit_probe_aberrations: bool
+            If True, fits the probe aberrations to a low-order expansion
+        fit_probe_aberrations_max_angular_order: bool
+            Max angular order of probe aberrations basis functions
+        fit_probe_aberrations_max_radial_order: bool
+            Max radial order of probe aberrations basis functions
         constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
         constrain_probe_amplitude_relative_radius: float
@@ -2261,10 +2265,11 @@ def _constraints(
         constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
         constrain_probe_fourier_amplitude: bool
-            If True, probe fourier amplitude is constrained by top hat function
-        constrain_probe_fourier_amplitude_threshold: float
-            Threshold value for current probe fourier mask. Value should
-            be between 0 and 1, where higher values provide the most masking.
+            If True, probe aperture is constrained by fitting a sigmoid for each angular frequency.
+        constrain_probe_fourier_amplitude_max_width_pixels: float
+            Maximum pixel width of fitted sigmoid functions.
+        constrain_probe_fourier_amplitude_constant_intensity: bool
+            If True, the probe aperture is additionally constrained to a constant intensity.
         fix_probe_aperture: bool,
             If True, probe Fourier amplitude is replaced by initial probe aperture.
         initial_probe_aperture: np.ndarray,
@@ -2364,31 +2369,29 @@ def _constraints(
         if fix_com:
             current_probe = self._probe_center_of_mass_constraint(current_probe)
 
-        if probe_gaussian_filter:
-            current_probe = self._probe_residual_aberration_filtering_constraint(
-                current_probe,
-                probe_gaussian_filter_sigma,
-                probe_gaussian_filter_fix_amplitude,
-            )
-
-        if symmetrize_probe:
-            current_probe = self._probe_radial_symmetrization_constraint(current_probe)
-
         if fix_probe_aperture:
             current_probe = self._probe_aperture_constraint(
                 current_probe,
                 initial_probe_aperture,
             )
-        elif constrain_probe_amplitude:
-            current_probe = self._probe_amplitude_constraint(
-                current_probe,
-                constrain_probe_amplitude_relative_radius,
-                constrain_probe_amplitude_relative_width,
-            )
         elif constrain_probe_fourier_amplitude:
             current_probe = self._probe_fourier_amplitude_constraint(
                 current_probe,
-                constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_max_width_pixels,
+                constrain_probe_fourier_amplitude_constant_intensity,
+            )
+
+        if fit_probe_aberrations:
+            current_probe = self._probe_aberration_fitting_constraint(
+                current_probe,
+                fit_probe_aberrations_max_angular_order,
+                fit_probe_aberrations_max_radial_order,
+            )
+
+        if constrain_probe_amplitude:
+            current_probe = self._probe_amplitude_constraint(
+                current_probe,
+                constrain_probe_amplitude_relative_radius,
                 constrain_probe_amplitude_relative_width,
             )
 
@@ -2422,21 +2425,21 @@ def reconstruct(
         fix_probe_iter: int = 0,
         warmup_iter: int = 0,
         fix_probe_aperture_iter: int = 0,
-        symmetrize_probe_iter: int = 0,
         constrain_probe_amplitude_iter: int = 0,
         constrain_probe_amplitude_relative_radius: float = 0.5,
         constrain_probe_amplitude_relative_width: float = 0.05,
         constrain_probe_fourier_amplitude_iter: int = 0,
-        constrain_probe_fourier_amplitude_threshold: float = 0.9,
+        constrain_probe_fourier_amplitude_max_width_pixels: float = 3.0,
+        constrain_probe_fourier_amplitude_constant_intensity: bool = False,
         fix_positions_iter: int = np.inf,
         constrain_position_distance: float = None,
         global_affine_transformation: bool = True,
         gaussian_filter_sigma_e: float = None,
         gaussian_filter_sigma_m: float = None,
         gaussian_filter_iter: int = np.inf,
-        probe_gaussian_filter_sigma: float = None,
-        probe_gaussian_filter_residual_aberrations_iter: int = np.inf,
-        probe_gaussian_filter_fix_amplitude: bool = True,
+        fit_probe_aberrations_iter: int = 0,
+        fit_probe_aberrations_max_angular_order: int = 4,
+        fit_probe_aberrations_max_radial_order: int = 4,
         butterworth_filter_iter: int = np.inf,
         q_lowpass_e: float = None,
         q_lowpass_m: float = None,
@@ -2492,19 +2495,18 @@ def reconstruct(
             Number of iterations to run with a fixed probe before updating probe estimate
         fix_probe_aperture_iter: int, optional
             Number of iterations to run with a fixed probe Fourier amplitude before updating probe estimate
-        symmetrize_probe_iter: int, optional
-            Number of iterations to run before radially-averaging the probe
-        constrain_probe_amplitude: bool
-            If True, probe amplitude is constrained by top hat function
+        constrain_probe_amplitude_iter: int, optional
+            Number of iterations to run while constraining the real-space probe with a top-hat support.
         constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
         constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        constrain_probe_fourier_amplitude: bool
-            If True, probe fourier amplitude is constrained by top hat function
-        constrain_probe_fourier_amplitude_threshold: float
-            Threshold value for current probe fourier mask. Value should
-            be between 0 and 1, where higher values provide the most masking.
+        constrain_probe_fourier_amplitude_iter: int, optional
+            Number of iterations to run while constraining the Fourier-space probe by fitting a sigmoid for each angular frequency.
+        constrain_probe_fourier_amplitude_max_width_pixels: float
+            Maximum pixel width of fitted sigmoid functions.
+        constrain_probe_fourier_amplitude_constant_intensity: bool
+            If True, the probe aperture is additionally constrained to a constant intensity.
         fix_positions_iter: int, optional
             Number of iterations to run with fixed positions before updating positions estimate
         constrain_position_distance: float
@@ -2518,12 +2520,12 @@ def reconstruct(
             Standard deviation of gaussian kernel for magnetic object in A
         gaussian_filter_iter: int, optional
             Number of iterations to run using object smoothness constraint
-        probe_gaussian_filter_sigma: float, optional
-            Standard deviation of probe gaussian kernel in A^-1
-        probe_gaussian_filter_residual_aberrations_iter: int, optional
-            Number of iterations to run using probe smoothing of residual aberrations
-        probe_gaussian_filter_fix_amplitude: bool
-            If True, only the probe phase is smoothed
+        fit_probe_aberrations_iter: int, optional
+            Number of iterations to run while fitting the probe aberrations to a low-order expansion
+        fit_probe_aberrations_max_angular_order: bool
+            Max angular order of probe aberrations basis functions
+        fit_probe_aberrations_max_radial_order: bool
+            Max radial order of probe aberrations basis functions
         butterworth_filter_iter: int, optional
             Number of iterations to run using high-pass butteworth filter
         q_lowpass_e: float
@@ -2868,12 +2870,6 @@ def reconstruct(
                 self._probe,
                 self._positions_px,
                 fix_com=fix_com and a0 >= fix_probe_iter,
-                symmetrize_probe=a0 < symmetrize_probe_iter,
-                probe_gaussian_filter=a0
-                < probe_gaussian_filter_residual_aberrations_iter
-                and probe_gaussian_filter_sigma is not None,
-                probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
-                probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
                 constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                 and a0 >= fix_probe_iter,
                 constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
@@ -2881,7 +2877,12 @@ def reconstruct(
                 constrain_probe_fourier_amplitude=a0
                 < constrain_probe_fourier_amplitude_iter
                 and a0 >= fix_probe_iter,
-                constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_max_width_pixels=constrain_probe_fourier_amplitude_max_width_pixels,
+                constrain_probe_fourier_amplitude_constant_intensity=constrain_probe_fourier_amplitude_constant_intensity,
+                fit_probe_aberrations=a0 < fit_probe_aberrations_iter
+                and a0 >= fix_probe_iter,
+                fit_probe_aberrations_max_angular_order=fit_probe_aberrations_max_angular_order,
+                fit_probe_aberrations_max_radial_order=fit_probe_aberrations_max_radial_order,
                 fix_probe_aperture=a0 < fix_probe_aperture_iter,
                 initial_probe_aperture=self._probe_initial_aperture,
                 fix_positions=a0 < fix_positions_iter,

From 66d3794133d59e5dfe2b45142205d3b1592c6ecc Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Tue, 11 Jul 2023 17:04:43 -0700
Subject: [PATCH 176/362] imports, formatting, linting

---
 py4DSTEM/process/phase/.gitignore             |  1 +
 py4DSTEM/process/phase/__init__.py            | 29 ++++++++++++++-----
 py4DSTEM/process/phase/iterative_dpc.py       |  2 +-
 .../iterative_overlap_magnetic_tomography.py  |  6 +++-
 .../phase/iterative_overlap_tomography.py     |  6 +++-
 .../iterative_ptychographic_constraints.py    |  2 +-
 py4DSTEM/process/phase/utils.py               |  5 ++--
 7 files changed, 37 insertions(+), 14 deletions(-)
 create mode 100644 py4DSTEM/process/phase/.gitignore

diff --git a/py4DSTEM/process/phase/.gitignore b/py4DSTEM/process/phase/.gitignore
new file mode 100644
index 000000000..c97f963b3
--- /dev/null
+++ b/py4DSTEM/process/phase/.gitignore
@@ -0,0 +1 @@
+*.sh
diff --git a/py4DSTEM/process/phase/__init__.py b/py4DSTEM/process/phase/__init__.py
index cb9176375..178079349 100644
--- a/py4DSTEM/process/phase/__init__.py
+++ b/py4DSTEM/process/phase/__init__.py
@@ -3,13 +3,28 @@
 _emd_hook = True
 
 from py4DSTEM.process.phase.iterative_dpc import DPCReconstruction
-from py4DSTEM.process.phase.iterative_mixedstate_ptychography import MixedstatePtychographicReconstruction
-from py4DSTEM.process.phase.iterative_multislice_ptychography import MultislicePtychographicReconstruction
-from py4DSTEM.process.phase.iterative_overlap_magnetic_tomography import OverlapMagneticTomographicReconstruction
-from py4DSTEM.process.phase.iterative_overlap_tomography import OverlapTomographicReconstruction
+from py4DSTEM.process.phase.iterative_mixedstate_ptychography import (
+    MixedstatePtychographicReconstruction,
+)
+from py4DSTEM.process.phase.iterative_multislice_ptychography import (
+    MultislicePtychographicReconstruction,
+)
+from py4DSTEM.process.phase.iterative_overlap_magnetic_tomography import (
+    OverlapMagneticTomographicReconstruction,
+)
+from py4DSTEM.process.phase.iterative_overlap_tomography import (
+    OverlapTomographicReconstruction,
+)
 from py4DSTEM.process.phase.iterative_parallax import ParallaxReconstruction
-from py4DSTEM.process.phase.iterative_simultaneous_ptychography import SimultaneousPtychographicReconstruction
-from py4DSTEM.process.phase.iterative_singleslice_ptychography import SingleslicePtychographicReconstruction
-from py4DSTEM.process.phase.parameter_optimize import OptimizationParameter, PtychographyOptimizer
+from py4DSTEM.process.phase.iterative_simultaneous_ptychography import (
+    SimultaneousPtychographicReconstruction,
+)
+from py4DSTEM.process.phase.iterative_singleslice_ptychography import (
+    SingleslicePtychographicReconstruction,
+)
+from py4DSTEM.process.phase.parameter_optimize import (
+    OptimizationParameter,
+    PtychographyOptimizer,
+)
 
 # fmt: on
diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index dc0df2ce6..d9dfd1514 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -4,7 +4,7 @@
 """
 
 import warnings
-from typing import Tuple, Union, Sequence
+from typing import Sequence, Tuple, Union
 
 import matplotlib.pyplot as plt
 import numpy as np
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 4c7387763..8691a121d 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -2487,7 +2487,11 @@ def reconstruct(
             if collective_tilt_updates:
                 self._object += collective_object / self._num_tilts
 
-                (self._object, self._probe, _,) = self._constraints(
+                (
+                    self._object,
+                    self._probe,
+                    _,
+                ) = self._constraints(
                     self._object,
                     self._probe,
                     None,
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index 0293fd322..d6bee12fd 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -2211,7 +2211,11 @@ def reconstruct(
             if collective_tilt_updates:
                 self._object += collective_object / self._num_tilts
 
-                (self._object, self._probe, _,) = self._constraints(
+                (
+                    self._object,
+                    self._probe,
+                    _,
+                ) = self._constraints(
                     self._object,
                     self._probe,
                     None,
diff --git a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
index 5fe1a1a35..c5aef16c6 100644
--- a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
+++ b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
@@ -3,8 +3,8 @@
     array_slice,
     estimate_global_transformation_ransac,
     fft_shift,
-    regularize_probe_amplitude,
     fit_aberration_surface,
+    regularize_probe_amplitude,
 )
 from py4DSTEM.process.utils import get_CoM
 
diff --git a/py4DSTEM/process/phase/utils.py b/py4DSTEM/process/phase/utils.py
index 2d36284ee..c2e1d3b77 100644
--- a/py4DSTEM/process/phase/utils.py
+++ b/py4DSTEM/process/phase/utils.py
@@ -1,8 +1,8 @@
+import functools
 from typing import Mapping, Tuple, Union
 
 import matplotlib.pyplot as plt
 import numpy as np
-import functools
 from scipy.optimize import curve_fit
 
 try:
@@ -12,10 +12,9 @@
     cp = None
     from scipy.fft import dstn, idstn
 
-
+from py4DSTEM.process.utils import get_CoM
 from py4DSTEM.process.utils.cross_correlate import align_and_shift_images
 from py4DSTEM.process.utils.utils import electron_wavelength_angstrom
-from py4DSTEM.process.utils import get_CoM
 from scipy.ndimage import gaussian_filter, uniform_filter1d
 from skimage.restoration import unwrap_phase
 

From b41cea746570403022c0cadf4a708fd33ab0fee2 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 11 Jul 2023 21:03:44 -0400
Subject: [PATCH 177/362] datacube.copy bugfix

---
 py4DSTEM/data/data.py |  2 +-
 test/test_misc.py     | 32 ++++++++++++++++++++++++++++++++
 2 files changed, 33 insertions(+), 1 deletion(-)
 create mode 100644 test/test_misc.py

diff --git a/py4DSTEM/data/data.py b/py4DSTEM/data/data.py
index ba82f4fec..85b3653f2 100644
--- a/py4DSTEM/data/data.py
+++ b/py4DSTEM/data/data.py
@@ -73,12 +73,12 @@ def __init__(
             self.calibration = Calibration()
         else:
             assert(isinstance(calibration,Calibration)), f"`calibration` must be a Calibration, not type {type(calibration)}"
-            self.calibration = calibration
             if calibration.root is None:
                 calibration._root = Root( name = self.name+"_root" )
                 calibration.root.tree( self )
             else:
                 calibration.root.tree( self )
+            self.calibration = calibration
 
 
     # calibration property
diff --git a/test/test_misc.py b/test/test_misc.py
new file mode 100644
index 000000000..275eb767b
--- /dev/null
+++ b/test/test_misc.py
@@ -0,0 +1,32 @@
+import py4DSTEM
+import numpy as np
+
+
+def test_attach():
+    """ tests to make sure Data.attach handles metadata merging correctly
+    """
+
+    x = py4DSTEM.DiffractionSlice(np.ones((5,5)), name='x')
+    y = py4DSTEM.DiffractionSlice(np.ones((5,5)), name='y')
+
+
+    x.calibration.set_Q_pixel_size(50)
+    y.calibration.set_Q_pixel_size(2)
+
+    x.attach(y)
+
+    assert('y' in x.treekeys)
+    assert(x.calibration.get_Q_pixel_size() == 50)
+
+
+def test_datacube_copy():
+    """ tests datacube.copy()
+    """
+    x = py4DSTEM.DataCube(data=np.zeros((3,3,4,4)))
+    y = x.copy()
+    assert(isinstance(y,py4DSTEM.DataCube))
+
+
+
+
+

From 21ec315e7d5d85893f41e554b6da7ae8e630ab1a Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 11 Jul 2023 21:38:47 -0400
Subject: [PATCH 178/362] edits

---
 py4DSTEM/braggvectors/braggvector_methods.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/py4DSTEM/braggvectors/braggvector_methods.py b/py4DSTEM/braggvectors/braggvector_methods.py
index e04a7558a..8446807cc 100644
--- a/py4DSTEM/braggvectors/braggvector_methods.py
+++ b/py4DSTEM/braggvectors/braggvector_methods.py
@@ -541,7 +541,7 @@ def fit_origin(
         try:
             self.calibration.set_origin([qx0_fit,qy0_fit])
         except AttributeError:
-            # should a warning be raised?
+            warn("No calibration found on this datacube - fit values are not being stored")
             pass
         if plot:
             from py4DSTEM.visualize import show_image_grid
@@ -573,6 +573,10 @@ def fit_origin(
                 W = 3,
                 cmap = cmap,
                 axsize = axsize,
+                title = [
+                    'measured origin, x', 'fitorigin, x', 'residuals, x',
+                    'measured origin, y', 'fitorigin, y', 'residuals, y'
+                ],
                 vmin = -1*plot_range,
                 vmax = 1*plot_range,
                 intensity_range = "absolute",

From 138673480af5481db589ab67869136808b1879d8 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 11 Jul 2023 22:11:15 -0400
Subject: [PATCH 179/362] edits

---
 py4DSTEM/visualize/vis_grid.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/visualize/vis_grid.py b/py4DSTEM/visualize/vis_grid.py
index 8ca9c477d..48b5b158a 100644
--- a/py4DSTEM/visualize/vis_grid.py
+++ b/py4DSTEM/visualize/vis_grid.py
@@ -97,7 +97,7 @@ def show_image_grid(
     H,W,
     axsize=(6,6),
     returnfig=False,
-    figax = None, 
+    figax = None,
     title = None,
     title_index = False,
     suptitle = None,

From 2721ed7f51d2c95437479c6db25fbd0f5d500a7e Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 11 Jul 2023 22:18:50 -0400
Subject: [PATCH 180/362] adds strain test file

---
 py4DSTEM/io/google_drive_downloader.py |  7 ++++
 test/gettestdata.py                    |  5 ++-
 test/test_strain.py                    | 44 +++-----------------------
 3 files changed, 15 insertions(+), 41 deletions(-)

diff --git a/py4DSTEM/io/google_drive_downloader.py b/py4DSTEM/io/google_drive_downloader.py
index c8b410d47..51e3a70d7 100644
--- a/py4DSTEM/io/google_drive_downloader.py
+++ b/py4DSTEM/io/google_drive_downloader.py
@@ -83,6 +83,10 @@
         'test_realslice_io.h5',
         '1siH80-eRJwG5R6AnU4vkoqGWByrrEz1y'
     ),
+    'test_strain' : (
+        'downsample_Si_SiGe_analysis_braggdisks_cal.h5',
+        '1bYgDdAlnWHyFmY-SwN3KVpMutWBI5MhP'
+    )
 }
 
 # collections of files
@@ -110,6 +114,9 @@
     ),
     'test_braggvectors' : (
         'Au_sim',
+    ),
+    'strain' : (
+        'test_strain',
     )
 }
 
diff --git a/test/gettestdata.py b/test/gettestdata.py
index 0b5608a7c..b3d8a0a40 100644
--- a/test/gettestdata.py
+++ b/test/gettestdata.py
@@ -19,7 +19,8 @@
 data_options = [
     'tutorials',
     'io',
-    'basic'
+    'basic',
+    'strain',
 ]
 
 # Add arguments
@@ -57,6 +58,8 @@
     data = 'test_io'
 elif args.data == 'basic':
     data = 'small_datacube'
+elif args.data == 'strain':
+    data = 'strain'
 else:
     raise Exception(f"invalid data choice, {parser.data}")
 
diff --git a/test/test_strain.py b/test/test_strain.py
index c62e51cf3..1e34c5b6c 100644
--- a/test/test_strain.py
+++ b/test/test_strain.py
@@ -7,7 +7,7 @@
 # TODO add BVs file to test suite with calibration, remove disk detection here
 
 # set filepath
-path = join(py4DSTEM._TESTPATH,"test_io/legacy_v0.9_simAuNanoplatelet_bin.h5")
+path = join(py4DSTEM._TESTPATH,"strain/downsample_Si_SiGe_analysis_braggdisks_cal.h5")
 
 
 
@@ -16,45 +16,9 @@ class TestStrainMap:
     # setup/teardown
     def setup_class(cls):
 
-        # Read sim Au datacube
-        datacube = py4DSTEM.io.read(
-            path,
-            data_id = 'polyAu_4DSTEM'
-        )
-
-        # prepare a probe
-        mask = zeros(datacube.Rshape,dtype=bool)
-        mask[28:33,14:19] = 1
-        probe = datacube.get_vacuum_probe( ROI=mask )
-        alpha_pr,qx0_pr,qy0_pr = py4DSTEM.process.calibration.get_probe_size( probe.probe )
-        probe.get_kernel(
-            mode='sigmoid',
-            origin=(qx0_pr,qy0_pr),
-            radii=(alpha_pr,2*alpha_pr)
-        )
-
-        # Set disk detection parameters
-        detect_params = {
-            'corrPower': 1.0,
-            'sigma': 0,
-            'edgeBoundary': 2,
-            'minRelativeIntensity': 0,
-            'minAbsoluteIntensity': 8,
-            'minPeakSpacing': 4,
-            'subpixel' : 'poly',
-            'maxNumPeaks': 1000,
-        #     'CUDA': True,
-        }
-
-        # find bragg peaks
-        cls.braggpeaks = datacube.find_Bragg_disks(
-            template = probe.kernel,
-            **detect_params,
-        )
-
-        # set an arbitrary origin
-        cls.braggpeaks.calibration.set_origin((0,0))
-
+        # Read braggpeaks
+        # origin is calibrated
+        cls.braggpeaks = py4DSTEM.io.read( path )
 
 
     # tests

From e71c1bc24bfa15623b4e47c7bfcc9923473edcd5 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 11 Jul 2023 22:27:11 -0400
Subject: [PATCH 181/362] hotfix, legacy 13 reader rootnode bug

---
 py4DSTEM/io/legacy/legacy13/v13_to_14.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/io/legacy/legacy13/v13_to_14.py b/py4DSTEM/io/legacy/legacy13/v13_to_14.py
index a9d188b03..18c08c777 100644
--- a/py4DSTEM/io/legacy/legacy13/v13_to_14.py
+++ b/py4DSTEM/io/legacy/legacy13/v13_to_14.py
@@ -93,7 +93,7 @@ def _populate_tree(node13,node14,root14):
         if isinstance(newnode14,Metadata):
             pass
         else:
-            node14.tree(newnode14)
+            node14.tree(newnode14,force=True)
         _populate_tree(newnode13,newnode14,root14)
 
 

From af7e87b17a6b609f4ff3d6e791e08c784b1a4152 Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Tue, 11 Jul 2023 19:51:46 -0700
Subject: [PATCH 182/362] Updating beamstop mask function, fixing bug

---
 py4DSTEM/datacube/datacube.py | 53 +++++++++++++++++++++++++++--------
 1 file changed, 42 insertions(+), 11 deletions(-)

diff --git a/py4DSTEM/datacube/datacube.py b/py4DSTEM/datacube/datacube.py
index 96ec950ba..aee760496 100644
--- a/py4DSTEM/datacube/datacube.py
+++ b/py4DSTEM/datacube/datacube.py
@@ -1016,8 +1016,11 @@ def find_Bragg_disks(
     def get_beamstop_mask(
         self,
         threshold = 0.25,
-        distance_edge = 4.0,
+        distance_edge = 2.0,
         include_edges = True,
+        sigma = 0,
+        use_max_dp = False,
+        scale_radial = None,
         name = "mask_beamstop",
         returncalc = True,
         ):
@@ -1032,6 +1035,12 @@ def get_beamstop_mask(
             distance_edge (float): How many pixels to expand the mask.
             include_edges (bool): If set to True, edge pixels will be included
                 in the mask.
+            sigma (float):
+                Gaussain blur std to apply to image before thresholding.
+            use_max_dp (bool):
+                Use the max DP instead of the mean DP.
+            scale_radial (float):
+                Scale from center of image by this factor (can help with edge)
             name (string): Name of the output array.
             returncalc (bool): Set to true to return the result.
 
@@ -1040,19 +1049,41 @@ def get_beamstop_mask(
 
         """
 
-        # Calculate dp_mean if needed
-        if not "dp_mean" in self._branch.keys():
-            self.get_dp_mean();
-
-        # normalized dp_mean
-        int_sort = np.sort(self.tree("dp_mean").data.ravel())
+        if scale_radial is not None:
+            x = np.arange(self.data.shape[2]) * 2.0 / self.data.shape[2]
+            y = np.arange(self.data.shape[3]) * 2.0 / self.data.shape[3]
+            ya, xa = np.meshgrid(y - np.mean(y), x - np.mean(x))
+            im_scale = 1.0 + np.sqrt(xa**2 + ya**2)*scale_radial
+
+        # Get image for beamstop mask
+        if use_max_dp:
+            # if not "dp_mean" in self.tree.keys():
+            #     self.get_dp_max();
+            # im = self.tree["dp_max"].data.astype('float')
+            if not "dp_max" in self._branch.keys():
+                self.get_dp_max();
+            im = self.tree("dp_max").data.astype('float')
+        else:
+            if not "dp_mean" in self._branch.keys():
+                self.get_dp_mean();
+            im = self.tree("dp_mean").data
+            # if not "dp_mean" in self.tree.keys():
+            #     self.get_dp_mean();
+            # im = self.tree["dp_mean"].data.astype('float')
+
+        # smooth and scale if needed
+        if sigma > 0.0:
+            im = gaussian_filter(im, sigma, mode='nearest')
+        if scale_radial is not None:
+            im *= im_scale
+
+        # Calculate beamstop mask
+        int_sort = np.sort(im.ravel())
         ind = np.round(np.clip(
                 int_sort.shape[0]*threshold,
                 0,int_sort.shape[0])).astype('int')
         intensity_threshold = int_sort[ind]
-
-        # Use threshold to calculate initial mask
-        mask_beamstop = self.tree("dp_mean").data >= intensity_threshold
+        mask_beamstop = im >= intensity_threshold
 
         # clean up mask
         mask_beamstop = np.logical_not(binary_fill_holes(np.logical_not(mask_beamstop)))
@@ -1089,7 +1120,7 @@ def get_beamstop_mask(
         )
 
         # Add to tree
-        self.attach( mask_beamstop )
+        self.tree(x)
 
         # return
         if returncalc:

From db78022cd0d837e33f4088b964e5b7567921e315 Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Tue, 11 Jul 2023 20:05:35 -0700
Subject: [PATCH 183/362] Removing errant print statement in get_probe_size()

---
 py4DSTEM/braggvectors/probe.py        | 1 +
 py4DSTEM/process/calibration/probe.py | 1 -
 2 files changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/braggvectors/probe.py b/py4DSTEM/braggvectors/probe.py
index 32adfe1f2..da6d32b47 100644
--- a/py4DSTEM/braggvectors/probe.py
+++ b/py4DSTEM/braggvectors/probe.py
@@ -550,6 +550,7 @@ def get_probe_kernel_edge_sigmoid(
             np.mod(np.arange(Q_Ny) + Q_Ny//2, Q_Ny) - Q_Ny//2,
             np.mod(np.arange(Q_Nx) + Q_Nx//2, Q_Nx) - Q_Nx//2)
         qr = np.sqrt(qx**2 + qy**2)
+        
         # Calculate sigmoid
         if type == 'logistic':
             r0 = 0.5*(ro+ri)
diff --git a/py4DSTEM/process/calibration/probe.py b/py4DSTEM/process/calibration/probe.py
index c239590c5..f42a353b6 100644
--- a/py4DSTEM/process/calibration/probe.py
+++ b/py4DSTEM/process/calibration/probe.py
@@ -45,7 +45,6 @@ def get_probe_size(DP, thresh_lower=0.01, thresh_upper=0.99, N=100):
 
     # Get r for each mask
     DPmax = np.max(DP)
-    print(DPmax)
     for i in range(len(thresh_vals)):
         thresh = thresh_vals[i]
         mask = DP > DPmax * thresh

From 884dcd3f9986ab1df1870890744633459ed0b064 Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Tue, 11 Jul 2023 20:23:56 -0700
Subject: [PATCH 184/362] Fix for in-place modification of dp_mean()

---
 py4DSTEM/datacube/datacube.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/datacube/datacube.py b/py4DSTEM/datacube/datacube.py
index aee760496..524b796b9 100644
--- a/py4DSTEM/datacube/datacube.py
+++ b/py4DSTEM/datacube/datacube.py
@@ -1062,11 +1062,11 @@ def get_beamstop_mask(
             # im = self.tree["dp_max"].data.astype('float')
             if not "dp_max" in self._branch.keys():
                 self.get_dp_max();
-            im = self.tree("dp_max").data.astype('float')
+            im = self.tree("dp_max").data.copy().astype('float')
         else:
             if not "dp_mean" in self._branch.keys():
                 self.get_dp_mean();
-            im = self.tree("dp_mean").data
+            im = self.tree("dp_mean").data.copy()
             # if not "dp_mean" in self.tree.keys():
             #     self.get_dp_mean();
             # im = self.tree["dp_mean"].data.astype('float')

From e446b04b3b5a790213ae887579b4b934a56760ab Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Wed, 12 Jul 2023 00:16:56 -0400
Subject: [PATCH 185/362] updates

---
 py4DSTEM/braggvectors/braggvector_methods.py |  80 ------------
 py4DSTEM/data/data.py                        |   9 +-
 py4DSTEM/process/strain.py                   | 128 +++++++++++++++++--
 test/test_strain.py                          |   3 -
 4 files changed, 122 insertions(+), 98 deletions(-)

diff --git a/py4DSTEM/braggvectors/braggvector_methods.py b/py4DSTEM/braggvectors/braggvector_methods.py
index 8446807cc..53f800ed1 100644
--- a/py4DSTEM/braggvectors/braggvector_methods.py
+++ b/py4DSTEM/braggvectors/braggvector_methods.py
@@ -637,86 +637,6 @@ def fit_p_ellipse(
 
     # Deprecated??
 
-    # Lattice vectors
-    def choose_lattice_vectors(
-        self,
-        index_g0,
-        index_g1,
-        index_g2,
-        mode = 'centered',
-        plot = True,
-        subpixel = 'multicorr',
-        upsample_factor = 16,
-        sigma=0,
-        minAbsoluteIntensity=0,
-        minRelativeIntensity=0,
-        relativeToPeak=0,
-        minSpacing=0,
-        edgeBoundary=1,
-        maxNumPeaks=10,
-        bvm_vis_params = {},
-        returncalc = False,
-        ):
-        """
-        Choose which lattice vectors to use for strain mapping.
-
-        Args:
-            index_g0 (int): origin
-            index_g1 (int): second point of vector 1
-            index_g2 (int): second point of vector 2
-            mode (str): centered or raw bragg map
-            plot (bool): plot bragg vector maps and vectors
-            subpixel (str): specifies the subpixel resolution algorithm to use.
-                must be in ('pixel','poly','multicorr'), which correspond
-                to pixel resolution, subpixel resolution by fitting a
-                parabola, and subpixel resultion by Fourier upsampling.
-            upsample_factor: the upsampling factor for the 'multicorr'
-                algorithm
-            sigma: if >0, applies a gaussian filter
-            maxNumPeaks: the maximum number of maxima to return
-            minAbsoluteIntensity, minRelativeIntensity, relativeToPeak,
-                minSpacing, edgeBoundary, maxNumPeaks: filtering applied
-                after maximum detection and before subpixel refinement
-        """
-        from py4DSTEM.process.utils import get_maxima_2D
-
-        if mode == "centered":
-            bvm = self.bvm_centered
-        else:
-            bvm = self.bvm_raw
-
-        g = get_maxima_2D(
-            bvm,
-            subpixel = subpixel,
-            upsample_factor = upsample_factor,
-            sigma = sigma,
-            minAbsoluteIntensity = minAbsoluteIntensity,
-            minRelativeIntensity = minRelativeIntensity,
-            relativeToPeak = relativeToPeak,
-            minSpacing = minSpacing,
-            edgeBoundary = edgeBoundary,
-            maxNumPeaks = maxNumPeaks,
-        )
-
-        self.g = g
-
-        from py4DSTEM.visualize import select_lattice_vectors
-        g1,g2 = select_lattice_vectors(
-            bvm,
-            gx = g['x'],
-            gy = g['y'],
-            i0 = index_g0,
-            i1 = index_g1,
-            i2 = index_g2,
-            **bvm_vis_params,
-        )
-
-        self.g1 = g1
-        self.g2 = g2
-
-        if returncalc:
-            return g1, g2
-
     def index_bragg_directions(
         self,
         x0 = None,
diff --git a/py4DSTEM/data/data.py b/py4DSTEM/data/data.py
index ba82f4fec..1a6c5adaf 100644
--- a/py4DSTEM/data/data.py
+++ b/py4DSTEM/data/data.py
@@ -68,9 +68,12 @@ def __init__(
 
         # set up calibration + EMD tree
         if calibration is None:
-            root = Root( name = self.name+"_root" )
-            root.tree( self )
-            self.calibration = Calibration()
+            if self.root is not None and 'calibration' in self.root.metadata:
+                pass
+            else:
+                root = Root( name = self.name+"_root" )
+                root.tree( self )
+                self.calibration = Calibration()
         else:
             assert(isinstance(calibration,Calibration)), f"`calibration` must be a Calibration, not type {type(calibration)}"
             self.calibration = calibration
diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index 159bc3265..e999c02d1 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -23,23 +23,17 @@ def __init__(
         """
         TODO
         """
-        # set up braggvectors
-        self.braggvectors = braggvectors
-        # TODO - how to handle changes to braggvectors
-        # TODO - ellipse cal or no?
-
-        # set up data
-        data = np.empty((
-            self.braggvectors.Rshape[0],
-            self.braggvectors.Rshape[1],
-            6
-        ))
+        assert(isinstance(braggvectors,BraggVectors)), f"braggvectors myst be BraggVectors, not type {type(braggvectors)}"
 
         # initialize as a RealSlice
         RealSlice.__init__(
             self,
             name = name,
-            data = data,
+            data = np.empty((
+                6,
+                braggvectors.Rshape[0],
+                braggvectors.Rshape[1],
+            )),
             slicelabels = [
                 'exx',
                 'eyy',
@@ -50,6 +44,21 @@ def __init__(
             ]
         )
 
+        # set up braggvectors
+        self.braggvectors = braggvectors
+        # TODO - how to handle changes to braggvectors
+        #   option: register with calibrations and add a .calibrate method
+        #   which {{does something}} when origin changes
+        # TODO - include ellipse cal or no?
+
+        assert(self.root is not None)
+
+        # initialize as Data
+        Data.__init__(
+            self,
+            calibration = self.braggvectors.calibration
+        )
+
 
     # braggvector properties
 
@@ -61,7 +70,102 @@ def braggvectors(self,x):
         assert(isinstance(x,BraggVectors)), f".braggvectors must be BraggVectors, not type {type(x)}"
         assert(x.calibration.origin is not None), f"braggvectors must have a calibrated origin"
         self._braggvectors = x
+        self._braggvectors.tree(self,force=True)
+
+
+
+    # Class methods
+
+    def choose_lattice_vectors(
+        self,
+        index_g0,
+        index_g1,
+        index_g2,
+        mode = 'centered',
+        plot = True,
+        subpixel = 'multicorr',
+        upsample_factor = 16,
+        sigma=0,
+        minAbsoluteIntensity=0,
+        minRelativeIntensity=0,
+        relativeToPeak=0,
+        minSpacing=0,
+        edgeBoundary=1,
+        maxNumPeaks=10,
+        bvm_vis_params = {},
+        returncalc = False,
+        ):
+        """
+        Choose which lattice vectors to use for strain mapping.
+
+        Args:
+            index_g0 (int): origin
+            index_g1 (int): second point of vector 1
+            index_g2 (int): second point of vector 2
+            mode (str): centered or raw bragg map
+            plot (bool): plot bragg vector maps and vectors
+            subpixel (str): specifies the subpixel resolution algorithm to use.
+                must be in ('pixel','poly','multicorr'), which correspond
+                to pixel resolution, subpixel resolution by fitting a
+                parabola, and subpixel resultion by Fourier upsampling.
+            upsample_factor: the upsampling factor for the 'multicorr'
+                algorithm
+            sigma: if >0, applies a gaussian filter
+            maxNumPeaks: the maximum number of maxima to return
+            minAbsoluteIntensity, minRelativeIntensity, relativeToPeak,
+                minSpacing, edgeBoundary, maxNumPeaks: filtering applied
+                after maximum detection and before subpixel refinement
+        """
+        from py4DSTEM.process.utils import get_maxima_2D
+
+        if mode == "centered":
+            bvm = self.bvm_centered
+        else:
+            bvm = self.bvm_raw
+
+        g = get_maxima_2D(
+            bvm,
+            subpixel = subpixel,
+            upsample_factor = upsample_factor,
+            sigma = sigma,
+            minAbsoluteIntensity = minAbsoluteIntensity,
+            minRelativeIntensity = minRelativeIntensity,
+            relativeToPeak = relativeToPeak,
+            minSpacing = minSpacing,
+            edgeBoundary = edgeBoundary,
+            maxNumPeaks = maxNumPeaks,
+        )
+
+        self.g = g
+
+        from py4DSTEM.visualize import select_lattice_vectors
+        g1,g2 = select_lattice_vectors(
+            bvm,
+            gx = g['x'],
+            gy = g['y'],
+            i0 = index_g0,
+            i1 = index_g1,
+            i2 = index_g2,
+            **bvm_vis_params,
+        )
+
+        self.g1 = g1
+        self.g2 = g2
+
+        if returncalc:
+            return g1, g2
+
+
+
+
+
+
+
+
+
+
 
+    # IO methods
 
     # TODO - copy method
 
diff --git a/test/test_strain.py b/test/test_strain.py
index 1e34c5b6c..5bfa0efd3 100644
--- a/test/test_strain.py
+++ b/test/test_strain.py
@@ -4,13 +4,10 @@
 from numpy import zeros
 
 
-# TODO add BVs file to test suite with calibration, remove disk detection here
-
 # set filepath
 path = join(py4DSTEM._TESTPATH,"strain/downsample_Si_SiGe_analysis_braggdisks_cal.h5")
 
 
-
 class TestStrainMap:
 
     # setup/teardown

From ed4ec1724dadf3c8e82144169a4256a62c569b3b Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Wed, 12 Jul 2023 09:02:37 -0700
Subject: [PATCH 186/362] fix for binning

---
 py4DSTEM/preprocess/preprocess.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/preprocess/preprocess.py b/py4DSTEM/preprocess/preprocess.py
index 8d95ccd81..1996dca1e 100644
--- a/py4DSTEM/preprocess/preprocess.py
+++ b/py4DSTEM/preprocess/preprocess.py
@@ -282,7 +282,7 @@ def bin_data_diffraction(
     datacube.calibration.set_Q_pixel_size(Qpixsize)
 
     # remake Cartesian coordinate system
-    datacube.qyy,datacube.qxx = np.meshgrid(
+    datacube._qyy,datacube._qxx = np.meshgrid(
         np.arange(0,datacube.Q_Ny),
         np.arange(0,datacube.Q_Nx)
     )

From df72ada80b28729d24e1c449dd59164306bf629a Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Wed, 12 Jul 2023 11:34:13 -0700
Subject: [PATCH 187/362] commenting out probe renormalizations
 post-constraints

---
 .../iterative_ptychographic_constraints.py    | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
index c5aef16c6..9af22ba92 100644
--- a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
+++ b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
@@ -364,7 +364,7 @@ def _probe_amplitude_constraint(
         erf = self._erf
 
         probe_intensity = xp.abs(current_probe) ** 2
-        current_probe_sum = xp.sum(probe_intensity)
+        #current_probe_sum = xp.sum(probe_intensity)
 
         X = xp.fft.fftfreq(current_probe.shape[0])[:, None]
         Y = xp.fft.fftfreq(current_probe.shape[1])[None]
@@ -374,10 +374,10 @@ def _probe_amplitude_constraint(
         tophat_mask = 0.5 * (1 - erf(sigma * r / (1 - r**2)))
 
         updated_probe = current_probe * tophat_mask
-        updated_probe_sum = xp.sum(xp.abs(updated_probe) ** 2)
-        normalization = xp.sqrt(current_probe_sum / updated_probe_sum)
+        #updated_probe_sum = xp.sum(xp.abs(updated_probe) ** 2)
+        #normalization = xp.sqrt(current_probe_sum / updated_probe_sum)
 
-        return updated_probe * normalization
+        return updated_probe #* normalization
 
     def _probe_fourier_amplitude_constraint(
         self,
@@ -406,7 +406,7 @@ def _probe_fourier_amplitude_constraint(
         xp = self._xp
         asnumpy = self._asnumpy
 
-        current_probe_sum = xp.sum(xp.abs(current_probe) ** 2)
+        #current_probe_sum = xp.sum(xp.abs(current_probe) ** 2)
         current_probe_fft = xp.fft.fft2(current_probe)
 
         updated_probe_fft, _, _, _ = regularize_probe_amplitude(
@@ -419,10 +419,10 @@ def _probe_fourier_amplitude_constraint(
 
         updated_probe_fft = xp.asarray(updated_probe_fft)
         updated_probe = xp.fft.ifft2(updated_probe_fft)
-        updated_probe_sum = xp.sum(xp.abs(updated_probe) ** 2)
-        normalization = xp.sqrt(current_probe_sum / updated_probe_sum)
+        #updated_probe_sum = xp.sum(xp.abs(updated_probe) ** 2)
+        #normalization = xp.sqrt(current_probe_sum / updated_probe_sum)
 
-        return updated_probe * normalization
+        return updated_probe #* normalization
 
     def _probe_aperture_constraint(
         self,
@@ -444,16 +444,16 @@ def _probe_aperture_constraint(
         """
         xp = self._xp
 
-        current_probe_sum = xp.sum(xp.abs(current_probe) ** 2)
+        #current_probe_sum = xp.sum(xp.abs(current_probe) ** 2)
         current_probe_fft_phase = xp.angle(xp.fft.fft2(current_probe))
 
         updated_probe = xp.fft.ifft2(
             xp.exp(1j * current_probe_fft_phase) * initial_probe_aperture
         )
-        updated_probe_sum = xp.sum(xp.abs(updated_probe) ** 2)
-        normalization = xp.sqrt(current_probe_sum / updated_probe_sum)
+        #updated_probe_sum = xp.sum(xp.abs(updated_probe) ** 2)
+        #normalization = xp.sqrt(current_probe_sum / updated_probe_sum)
 
-        return updated_probe * normalization
+        return updated_probe #* normalization
 
     def _probe_aberration_fitting_constraint(
         self,

From 40b91df818c4131f7a33433a2eec5ccb83b87541 Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Wed, 12 Jul 2023 15:45:25 -0700
Subject: [PATCH 188/362] Various changes to ACOM and BraggVectors

---
 py4DSTEM/braggvectors/braggvector_methods.py  | 57 +++++++++++----
 py4DSTEM/braggvectors/braggvectors.py         | 26 ++++++-
 py4DSTEM/process/diffraction/crystal.py       | 15 ++--
 .../process/diffraction/crystal_calibrate.py  | 33 +++++----
 py4DSTEM/process/diffraction/crystal_viz.py   | 72 +++++++++++++------
 5 files changed, 148 insertions(+), 55 deletions(-)

diff --git a/py4DSTEM/braggvectors/braggvector_methods.py b/py4DSTEM/braggvectors/braggvector_methods.py
index cf267b42d..e48834d7d 100644
--- a/py4DSTEM/braggvectors/braggvector_methods.py
+++ b/py4DSTEM/braggvectors/braggvector_methods.py
@@ -187,7 +187,11 @@ def get_virtual_image(
         mode = None,
         geometry = None,
         name = 'bragg_virtual_image',
-        returncalc = True
+        returncalc = True,
+        center = True,
+        ellipse = True,
+        pixel = True,
+        rotate = True,
         ):
         '''
         Calculates a virtual image based on the values of the Braggvectors
@@ -205,13 +209,22 @@ def get_virtual_image(
               - 'circle', 'circular': nested 2-tuple, ((qx,qy),radius)
               - 'annular' or 'annulus': nested 2-tuple,
                 ((qx,qy),(radius_i,radius_o))
-             All values are in pixels.  Note that (qx,qy) can be skipped, which
-             assumes peaks centered at (0,0)
+             Values can be in pixels or calibrated units. Note that (qx,qy) 
+             can be skipped, which assumes peaks centered at (0,0).
+        center: bool
+            Apply calibration - center coordinate.
+        ellipse: bool
+            Apply calibration - elliptical correction.
+        pixel: bool
+            Apply calibration - pixel size.
+        rotate: bool
+            Apply calibration - QR rotation.
 
         Returns
         -------
         virtual_im : VirtualImage
         '''
+
         # parse inputs
         circle_modes = ['circular','circle']
         annulus_modes = ['annular','annulus']
@@ -221,13 +234,13 @@ def get_virtual_image(
         # set geometry
         if mode is None:
             if geometry is None:
-                center = None
+                qxy_center = None
                 radial_range = np.array((0,np.inf))
             else:
                 if len(geometry[0]) == 0:
-                    center = None
+                    qxy_center = None
                 else:
-                    center = np.array(geometry[0])
+                    qxy_center = np.array(geometry[0])
                 if isinstance(geometry[1], int) or isinstance(geometry[1], float):
                     radial_range = np.array((0,geometry[1]))
                 elif len(geometry[1]) == 0:
@@ -237,30 +250,44 @@ def get_virtual_image(
         elif mode == 'circular' or mode == 'circle':
             radial_range = np.array((0,geometry[1]))
             if len(geometry[0]) == 0:
-                    center = None
+                    qxy_center = None
             else:
-                center = np.array(geometry[0])
+                qxy_center = np.array(geometry[0])
         elif mode == 'annular' or mode == 'annulus':
             radial_range = np.array(geometry[1])
             if len(geometry[0]) == 0:
-                    center = None
+                    qxy_center = None
             else:
-                center = np.array(geometry[0])
+                qxy_center = np.array(geometry[0])
 
         # allocate space
         im_virtual = np.zeros(self.shape)
 
         # generate image
-        for rx,ry in tqdmnd(self.shape[0],self.shape[1]):
-            p = self.raw[rx,ry]
+        for rx,ry in tqdmnd(
+            self.shape[0],
+            self.shape[1],
+            ):
+            # Get user-specified Bragg vectors
+            p = self.get_vectors(
+                rx,
+                ry,
+                center = center,
+                ellipse = ellipse,
+                pixel = pixel,
+                rotate = rotate,
+                )
+
             if p.data.shape[0] > 0:
                 if radial_range is None:
                     im_virtual[rx,ry] = np.sum(p.I)
                 else:
-                    if center is None:
+                    if qxy_center is None:
                         qr = np.hypot(p.qx,p.qy)
                     else:
-                        qr = np.hypot(p.qx - center[0],p.qy - center[1])
+                        qr = np.hypot(
+                            p.qx - qxy_center[0],
+                            p.qy - qxy_center[1])
                     sub = np.logical_and(
                         qr >= radial_range[0],
                         qr <  radial_range[1])
@@ -285,7 +312,7 @@ def get_virtual_image(
             }
         )
         # attach to the tree
-        self.attach( ans)
+        self.attach(ans)
 
         # return
         if returncalc:
diff --git a/py4DSTEM/braggvectors/braggvectors.py b/py4DSTEM/braggvectors/braggvectors.py
index af1078981..d3f4a42c5 100644
--- a/py4DSTEM/braggvectors/braggvectors.py
+++ b/py4DSTEM/braggvectors/braggvectors.py
@@ -250,7 +250,7 @@ def get_vectors(
         ellipse,
         pixel,
         rotate
-    ):
+        ):
         """
         Returns the bragg vectors at the specified scan position with
         the specified calibration state.
@@ -268,6 +268,7 @@ def get_vectors(
         -------
         vectors : BVects
         """
+
         ans = self._v_uncal[scan_x,scan_y].data
         ans = self.cal._transform(
             data = ans,
@@ -280,15 +281,36 @@ def get_vectors(
         )
         return BVects(ans)
 
+    def get_vectors_calibrated(
+        self,
+        scan_x,
+        scan_y,
+        ):
+        """
+        Returns the calibrated bragg vectors at the specified scan position.
+        """
+        ans = self._v_uncal[scan_x,scan_y].data
+        ans = self.cal._transform(
+            data = ans,
+            cal = self.calibration,
+            scanxy = (scan_x,scan_y),
+            center = True,
+            ellipse = True,
+            pixel = True,
+            rotate = True,
+        )
+        return BVects(ans)
+
 
     # copy
-
     def copy(self, name=None):
         name = name if name is not None else self.name+"_copy"
         braggvector_copy = BraggVectors(self.Rshape, self.Qshape, name=name)
         braggvector_copy._v_uncal = self._v_uncal.copy()
         for k in self.metadata.keys():
             braggvector_copy.metadata = self.metadata[k].copy()
+        # TODO - fix this calibration line?
+        braggvector_copy.calibration = self.calibration
         return braggvector_copy
 
 
diff --git a/py4DSTEM/process/diffraction/crystal.py b/py4DSTEM/process/diffraction/crystal.py
index 228602692..3be87eb25 100644
--- a/py4DSTEM/process/diffraction/crystal.py
+++ b/py4DSTEM/process/diffraction/crystal.py
@@ -898,12 +898,19 @@ def calculate_bragg_peak_histogram(
         k = np.arange(k_min, k_max + k_step, k_step)
         k_num = k.shape[0]
 
-        # experimental data histogram
+        # concatenate all peaks
         bigpl = np.concatenate(
             [
-                bragg_peaks.cal[i, j].data
-                for i in range(bragg_peaks.shape[0])
-                for j in range(bragg_peaks.shape[1])
+                bragg_peaks.get_vectors(
+                    rx,
+                    ry,
+                    center = True,
+                    ellipse = True,
+                    pixel = True,
+                    rotate = True,
+                ).data
+                for rx in range(bragg_peaks.shape[0])
+                for ry in range(bragg_peaks.shape[1])
             ]
         )
         qr = np.sqrt(bigpl["qx"] ** 2 + bigpl["qy"] ** 2)
diff --git a/py4DSTEM/process/diffraction/crystal_calibrate.py b/py4DSTEM/process/diffraction/crystal_calibrate.py
index 2d08cd03c..d4be6abce 100644
--- a/py4DSTEM/process/diffraction/crystal_calibrate.py
+++ b/py4DSTEM/process/diffraction/crystal_calibrate.py
@@ -24,7 +24,7 @@ def calibrate_pixel_size(
         k_step = 0.002,
         k_broadening = 0.002,
         fit_all_intensities = True,
-        set_calibration = True,
+        set_calibration_in_place = False,
         verbose = True,
         plot_result = False,
         figsize: Union[list, tuple, np.ndarray] = (12, 6),
@@ -60,8 +60,13 @@ def calibrate_pixel_size(
         figsize (list, tuple, np.ndarray): Figure size of the plot.
         returnfig (bool): Return handles figure and axis
 
-    Returns:
-        fig, ax (handles): Optional figure and axis handles, if returnfig=True.
+    Returns
+    _______
+
+    
+
+    fig, ax: handles, optional 
+        Figure and axis handles, if returnfig=True.
 
     """
 
@@ -112,17 +117,21 @@ def fit_profile(k, *coefs):
 
     # Get the answer
     pix_size_prev = bragg_peaks.calibration.get_Q_pixel_size()
-    ans = pix_size_prev / scale_pixel_size
+    pixel_size_new = pix_size_prev / scale_pixel_size
 
-    # if requested, apply calibrations
-    if set_calibration:
-        bragg_peaks.calibration.set_Q_pixel_size( ans )
+    # if requested, apply calibrations in place
+    if set_calibration_in_place:
+        bragg_peaks.calibration.set_Q_pixel_size( pixel_size_new )
         bragg_peaks.calibration.set_Q_pixel_units('A^-1')
-        bragg_peaks.setcal()
 
-    # Output
+    # Output calibrated Bragg peaks
+    bragg_peaks_cali = bragg_peaks.copy()
+    bragg_peaks_cali.calibration.set_Q_pixel_size( pixel_size_new )
+    bragg_peaks_cali.calibration.set_Q_pixel_units('A^-1')
+
+    # Output pixel size
     if verbose:
-        print(f"Calibrated pixel size = {np.round(ans, decimals=8)} A^-1")
+        print(f"Calibrated pixel size = {np.round(pixel_size_new, decimals=8)} A^-1")
 
     # Plotting
     if plot_result:
@@ -163,9 +172,9 @@ def fit_profile(k, *coefs):
 
     # return
     if returnfig and plot_result:
-        return ans, (fig,ax)
+        return bragg_peaks_cali, (fig,ax)
     else:
-        return ans
+        return bragg_peaks_cali
 
 
 
diff --git a/py4DSTEM/process/diffraction/crystal_viz.py b/py4DSTEM/process/diffraction/crystal_viz.py
index 9c1f5b667..9395682a0 100644
--- a/py4DSTEM/process/diffraction/crystal_viz.py
+++ b/py4DSTEM/process/diffraction/crystal_viz.py
@@ -296,30 +296,48 @@ def plot_scattering_intensity(
     bragg_k_power=0.0,
     bragg_intensity_power=1.0,
     bragg_k_broadening=0.005,
-    figsize: Union[list, tuple, np.ndarray] = (12, 6),
+    figsize: Union[list, tuple, np.ndarray] = (10, 4),
     returnfig: bool = False,
 ):
     """
     1D plot of the structure factors
 
-    Args:
-        k_min (float):                      min k value for profile range.
-        k_max (float):                      max k value for profile range.
-        k_step (float):                     step size of k in profile range.
-        k_broadening (float):               Broadening of simulated pattern.
-        k_power_scale (float):              Scale SF intensities by k**k_power_scale.
-        int_power_scale (float):            Scale SF intensities**int_power_scale.
-        int_scale (float):                  Scale output profile by this value.
-        remove_origin (bool):               Remove origin from plot.
-        bragg_peaks (BraggVectors):         Passed in bragg_peaks for comparison with simulated pattern.
-        bragg_k_power (float):              bragg_peaks scaled by k**bragg_k_power.
-        bragg_intensity_power (float):      bragg_peaks scaled by intensities**bragg_intensity_power.
-        bragg_k_broadening float):          Broadening applied to bragg_peaks.
-        figsize (list, tuple, np.ndarray):  Figure size for plot.
-        returnfig (bool):                   Return figure and axes handles if this is True.
-
-    Returns:
-        fig, ax                     (optional) figure and axes handles
+    Parameters
+    --------
+
+    k_min: float                      
+        min k value for profile range.
+    k_max: float                      
+        max k value for profile range.
+    k_step: float                     
+        Step size of k in profile range.
+    k_broadening: float               
+        Broadening of simulated pattern.
+    k_power_scale: float              
+        Scale SF intensities by k**k_power_scale.
+    int_power_scale: float            
+        Scale SF intensities**int_power_scale.
+    int_scale: float                  
+        Scale output profile by this value.
+    remove_origin: bool               
+        Remove origin from plot.
+    bragg_peaks: BraggVectors         
+        Passed in bragg_peaks for comparison with simulated pattern.
+    bragg_k_power: float              
+        bragg_peaks scaled by k**bragg_k_power.
+    bragg_intensity_power: float      
+        bragg_peaks scaled by intensities**bragg_intensity_power.
+    bragg_k_broadening: float  
+        Broadening applied to bragg_peaks.
+    figsize: list, tuple, np.ndarray
+        Figure size for plot.
+    returnfig (bool):                   
+        Return figure and axes handles if this is True.
+
+    Returns
+    --------
+    fig, ax (optional) 
+        figure and axes handles
     """
 
     # k coordinates
@@ -345,9 +363,16 @@ def plot_scattering_intensity(
         # concatenate all peaks
         bigpl = np.concatenate(
             [
-                bragg_peaks.cal[i, j].data
-                for i in range(bragg_peaks.shape[0])
-                for j in range(bragg_peaks.shape[1])
+                bragg_peaks.get_vectors(
+                    rx,
+                    ry,
+                    center = True,
+                    ellipse = True,
+                    pixel = True,
+                    rotate = True,
+                ).data
+                for rx in range(bragg_peaks.shape[0])
+                for ry in range(bragg_peaks.shape[1])
             ]
         )
 
@@ -903,6 +928,9 @@ def plot_diffraction_pattern(
     ax.set_ylabel("$q_x$ [Å$^{-1}$]")
 
     if plot_range_kx_ky is not None:
+        plot_range_kx_ky = np.array(plot_range_kx_ky)
+        if plot_range_kx_ky.ndim == 0:
+            plot_range_kx_ky = np.array((plot_range_kx_ky,plot_range_kx_ky))
         ax.set_xlim((-plot_range_kx_ky[0], plot_range_kx_ky[0]))
         ax.set_ylim((-plot_range_kx_ky[1], plot_range_kx_ky[1]))
     else:

From 32dd2e822e42bac0e39af8cfe3a45dcfd1f4a773 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Thu, 13 Jul 2023 13:00:19 -0400
Subject: [PATCH 189/362] partial update to Data cal handling

---
 py4DSTEM/data/data.py | 37 +++++++++++++++++++++++++++----------
 1 file changed, 27 insertions(+), 10 deletions(-)

diff --git a/py4DSTEM/data/data.py b/py4DSTEM/data/data.py
index 0b0bf4bb7..8d20cc360 100644
--- a/py4DSTEM/data/data.py
+++ b/py4DSTEM/data/data.py
@@ -64,24 +64,41 @@ def __init__(
         calibration = None
         ):
         assert(isinstance(self,Node)), "Data instances must inherit from Node"
-        pass
+        assert(calibration is None or isinstance(calibration,Calibration)), f"calibration must be None or a Calibration instance, not type {type(calibration)}"
+
 
         # set up calibration + EMD tree
         if calibration is None:
-            if self.root is not None and 'calibration' in self.root.metadata:
-                pass
-            else:
+            if self.root is None:
                 root = Root( name = self.name+"_root" )
                 root.tree( self )
                 self.calibration = Calibration()
-        else:
+            elif 'calibration' not in self.root.metadata:
+                self.calibration = Calibration()
+            else:
+                pass
+        elif calibration.root is not None:
+            if self.root is None:
+                calibration.root.tree(self)
+                self.calibration = calibration
+            elif 'calibration' not in self.root.metadata:
+                # TODO
+                self.calibration = calibration
+            else:
+                # raises a warning
+                self.calibration = calibration
+
+
             assert(isinstance(calibration,Calibration)), f"`calibration` must be a Calibration, not type {type(calibration)}"
-            if calibration.root is None:
-                calibration._root = Root( name = self.name+"_root" )
-                calibration.root.tree( self )
+            if self.root is not None and 'calibration' in self.root.metadata:
+                pass
             else:
-                calibration.root.tree( self )
-            self.calibration = calibration
+                if calibration.root is None:
+                    calibration._root = Root( name = self.name+"_root" )
+                    calibration.root.tree( self )
+                else:
+                    calibration.root.tree( self )
+                self.calibration = calibration
 
 
     # calibration property

From be5197cd58135881e23e8dfbf1527d67fc5151d2 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Thu, 13 Jul 2023 11:07:30 -0700
Subject: [PATCH 190/362] commenting out numerical instability introduced in
 commit a211a97, circa end of April

---
 py4DSTEM/process/phase/iterative_multislice_ptychography.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_multislice_ptychography.py b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
index 1e9bd2cbb..8be875b15 100644
--- a/py4DSTEM/process/phase/iterative_multislice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
@@ -974,7 +974,7 @@ def _gradient_descent_adjoint(
                 )
 
             # back-transmit
-            exit_waves *= xp.conj(obj) / xp.abs(obj) ** 2
+            exit_waves *= xp.conj(obj) #/ xp.abs(obj) ** 2
 
             if s > 0:
                 # back-propagate
@@ -1076,7 +1076,7 @@ def _projection_sets_adjoint(
                 )
 
             # back-transmit
-            exit_waves_copy *= xp.conj(obj) / xp.abs(obj) ** 2
+            exit_waves_copy *= xp.conj(obj) # / xp.abs(obj) ** 2
 
             if s > 0:
                 # back-propagate

From 60b7d2795ec2ace0cad21014d2efd433f4f4db42 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Thu, 13 Jul 2023 11:20:57 -0700
Subject: [PATCH 191/362] turn off print statements by default

---
 py4DSTEM/braggvectors/braggvectors.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/braggvectors/braggvectors.py b/py4DSTEM/braggvectors/braggvectors.py
index d3f4a42c5..1d3dee4c0 100644
--- a/py4DSTEM/braggvectors/braggvectors.py
+++ b/py4DSTEM/braggvectors/braggvectors.py
@@ -65,7 +65,7 @@ def __init__(
         Rshape,
         Qshape,
         name = 'braggvectors',
-        verbose = True,
+        verbose = False,
         calibration = None
         ):
         Custom.__init__(self,name=name)
@@ -236,7 +236,7 @@ def setcal(
             "rotate" : rotate,
         }
         if self.verbose:
-            print('current calstate: ', self.calstate)
+            print('current calibration state: ', self.calstate)
         pass
 
 

From 7a513362647895a8fe039477184eff6e382568dc Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Thu, 13 Jul 2023 14:42:49 -0400
Subject: [PATCH 192/362] refactor Data, more robust calibration handling

---
 py4DSTEM/data/data.py | 58 ++++++++++++++++++++++++++-----------------
 1 file changed, 35 insertions(+), 23 deletions(-)

diff --git a/py4DSTEM/data/data.py b/py4DSTEM/data/data.py
index 8d20cc360..3a7b415db 100644
--- a/py4DSTEM/data/data.py
+++ b/py4DSTEM/data/data.py
@@ -9,7 +9,16 @@
 
 class Data:
     """
-    Data in py4DSTEM is stored in filetree like representations, e.g.
+    The purpose of the `Data` class is to ensure calibrations are linked
+    to data containing class instances, while allowing multiple objects
+    to share a single Calibration. The calibrations of a Data instance
+    `data` is accessible as
+
+        >>> data.calibration
+
+    In py4DSTEM, Data containing objects are stored internally in filetree
+    like representations, defined by the EMD1.0 and `emdfile` specifications,
+    e.g.
 
     Root
       |--metadata
@@ -23,24 +32,30 @@ class Data:
       |     |--etc.
       :
 
-    In a Python interpreter, do
+    Calibrations are metadata which always live in the root of such a tree.
+    Running `data.calibration` returns the calibrations from the tree root,
+    and therefore the same calibration instance is referred to be all objects
+    in the same tree.  The root itself is accessible from any Data instance
+    as
+
+        >>> data.root
+
+    To examine the tree of a Data instance, in a Python interpreter do
 
         >>> data.tree(True)
 
-    to display the data tree of Data instance `data`, and
+    to display the whole data tree, and
 
         >>> data.tree()
 
     to display the tree of from the current node on, i.e. the branch
     downstream of `data`.
 
-    Every object can access the calibrations which live in the root metadata
-    of its tree with
+    Calling
 
         >>> data.calibration
 
-    which returns the calibrations, or, if none are found, raises a warning
-    and returns None.
+    will raise a warning and return None if no root calibrations are found.
 
     Some objects should be modified when the calibrations change - these
     objects must have .calibrate() method, which is called any time relevant
@@ -70,35 +85,32 @@ def __init__(
         # set up calibration + EMD tree
         if calibration is None:
             if self.root is None:
-                root = Root( name = self.name+"_root" )
+                root = Root( name=self.name+"_root" )
                 root.tree( self )
                 self.calibration = Calibration()
             elif 'calibration' not in self.root.metadata:
                 self.calibration = Calibration()
             else:
                 pass
-        elif calibration.root is not None:
+        elif calibration.root is None:
             if self.root is None:
-                calibration.root.tree(self)
+                root = Root( name=self.name+"_root" )
+                root.tree(self)
                 self.calibration = calibration
             elif 'calibration' not in self.root.metadata:
-                # TODO
                 self.calibration = calibration
             else:
-                # raises a warning
-                self.calibration = calibration
-
-
-            assert(isinstance(calibration,Calibration)), f"`calibration` must be a Calibration, not type {type(calibration)}"
-            if self.root is not None and 'calibration' in self.root.metadata:
+                warnings.warn("A calibration was passed to instantiate a new Data instance, but the instance already has a calibration. The passed calibration *WAS NOT* attached.  To attach the new calibration and overwrite the existing calibration, use `data.calibration = new_calibration`")
                 pass
-            else:
-                if calibration.root is None:
-                    calibration._root = Root( name = self.name+"_root" )
-                    calibration.root.tree( self )
-                else:
-                    calibration.root.tree( self )
+        else:
+            if self.root is None:
+                calibration.root.tree(self)
+                self.calibration = calibration
+            elif 'calibration' not in self.root.metadata:
                 self.calibration = calibration
+                warnings.warn("A calibration was passed to instantiate a new Data instance.  The Data already had a root but no calibration, and the calibration already exists in a different root.  The calibration has been added and now lives in both roots, and can therefore be modified from either place!")
+            else:
+                warnings.warn("A calibration was passed to instantiate a new Data instance, however the Data already has a root and calibration, and the calibration already has a root!! The passed calibration *WAS NOT* attached. To attach the new calibration and overwrite the existing calibration, use `data.calibration = new_calibration.")
 
 
     # calibration property

From e3d0e29835c33fb35ab3fdb1bf0059b651b365a7 Mon Sep 17 00:00:00 2001
From: SE Zeltmann <steven.zeltmann@lbl.gov>
Date: Mon, 15 May 2023 12:00:21 -0700
Subject: [PATCH 193/362] starting to add parameter class

---
 py4DSTEM/process/phase/parameter_optimize.py | 75 ++++++++++++++++++++
 1 file changed, 75 insertions(+)
 create mode 100644 py4DSTEM/process/phase/parameter_optimize.py

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
new file mode 100644
index 000000000..c3a377fb4
--- /dev/null
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -0,0 +1,75 @@
+from tqdm import tqdm
+from skopt import gp_minimize
+from skopt.space import Real, Integer, Categorical
+from skopt.plots import plot_convergence, plot_gaussian_process, plot_evaluations, plot_objective
+from skopt.utils import use_named_args
+
+from functools import partialmethod
+from typing import Union
+
+from py4DSTEM.process.phase import PtychographicReconstruction
+
+class PtychographyOptimizer:
+	"""
+	doot doot
+	"""
+
+	def __init__(
+		self,
+		reconstruction_type: type[PtychographicReconstruction],
+		):
+		"""
+		Parameter optimization for ptychographic reconstruction based on Bayesian Optimization
+		with Gaussian Process. 
+		"""
+		pass
+
+	def optimize(self,):
+		pass
+
+	def visualize(self,):
+		pass
+
+class OptimizationParameter:
+	"""
+	Wrapper for scikit-optimize Space objects used for convenient calling in the PtyhochraphyOptimizer
+	"""
+
+	def __init__(
+		self,
+		name:str,
+		lower_bound:Union[float,int,bool],
+		upper_bound:Union[float,int,bool],
+		initial_value:Union[float,int,bool],
+		scaling:str='uniform',
+		space:str="real",
+		categories:list=[],
+		):
+
+		# Check input
+		space = space.lower()
+		assert space in ("real","integer","bool","categorical"), f"Unknown Parameter type: {space}"
+
+		scaling = scaling.lower()
+		assert scaling in ("uniform", "log-uniform"), f"Unknown scaling: {scaling}"
+
+		# Get the right scikit-optimize class
+		space_map = {'real':Real, 'integer':Integer, 'bool':Categorical, 'categorical':Categorical}
+		param = space_map[space]
+
+		# If a boolean property, the categories are True/False
+		if space == 'bool':
+			categories = [True, False]
+
+		# store necessary information
+		self.name = name
+		self.initial_value = initial_value
+
+		if param is Categorical:
+			assert categories is not None, "Empty list of categories!"
+			self._skopt_param = param(name=name, categories=categories)
+		else:
+			self._skopt_param = param(name=name, low=lower_bound, high=upper_bound, prior=scaling,)
+
+
+

From 707b2fd8404f5933232907e4bbbf09e10db976bb Mon Sep 17 00:00:00 2001
From: SE Zeltmann <steven.zeltmann@lbl.gov>
Date: Tue, 16 May 2023 14:59:04 -0700
Subject: [PATCH 194/362] bayesian optimization for hyperparameter tuning in
 ptychography

---
 py4DSTEM/process/phase/parameter_optimize.py | 285 +++++++++++++++----
 1 file changed, 224 insertions(+), 61 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index c3a377fb4..c41c611ec 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -3,73 +3,236 @@
 from skopt.space import Real, Integer, Categorical
 from skopt.plots import plot_convergence, plot_gaussian_process, plot_evaluations, plot_objective
 from skopt.utils import use_named_args
+import matplotlib.pyplot as plt
 
-from functools import partialmethod
+from functools import partial
 from typing import Union
 
-from py4DSTEM.process.phase import PtychographicReconstruction
+from py4DSTEM.process.phase.iterative_base_class import PhaseReconstruction
 
 class PtychographyOptimizer:
-	"""
-	doot doot
-	"""
-
-	def __init__(
-		self,
-		reconstruction_type: type[PtychographicReconstruction],
-		):
-		"""
-		Parameter optimization for ptychographic reconstruction based on Bayesian Optimization
-		with Gaussian Process. 
-		"""
-		pass
-
-	def optimize(self,):
-		pass
-
-	def visualize(self,):
-		pass
+    """
+    doot doot
+    """
+
+    def __init__(
+        self,
+        reconstruction_type: type[PhaseReconstruction],
+        init_args:dict,
+        preprocess_args:dict,
+        reconstruction_args:dict,
+        ):
+        """
+        Parameter optimization for ptychographic reconstruction based on Bayesian Optimization
+        with Gaussian Process. 
+        """
+        
+        # loop over each argument dictionary and split into static and optimization variables
+        self._init_static_args, self._init_optimize_args = self._split_static_and_optimization_vars(init_args)
+        self._preprocess_static_args, self._preprocess_optimize_args = self._split_static_and_optimization_vars(preprocess_args)
+        self._reconstruction_static_args, self._reconstruction_optimize_args = self._split_static_and_optimization_vars(reconstruction_args)
+
+        # Save list of skopt parameter objects and inital guess
+        self._parameter_list = []
+        self._x0 = []
+        for k,v in (self._init_optimize_args|self._preprocess_optimize_args|self._reconstruction_optimize_args).items():
+            self._parameter_list.append(v._get(k))
+            self._x0.append(v._initial_value)
+
+        self._init_args = init_args
+        self._preprocess_args = preprocess_args
+        self._reconstruction_args = reconstruction_args
+
+        self._reconstruction_type = reconstruction_type
+
+        self._set_optimizer_defaults()
+
+    def optimize(
+        self,
+        n_calls:int,
+        n_initial_points:int,
+        ):
+
+        self._optimization_function = self._get_optimization_function(
+            self._reconstruction_type,
+            self._parameter_list,
+            n_calls,
+            self._init_static_args,
+            self._preprocess_static_args,
+            self._reconstruction_static_args,
+            self._init_optimize_args,
+            self._preprocess_optimize_args,
+            self._reconstruction_optimize_args
+            )
+
+        self._skopt_result = gp_minimize(
+            self._optimization_function,
+            self._parameter_list,
+            n_calls = n_calls,
+            n_initial_points=n_initial_points,
+            x0 = self._x0
+        )
+        return self
+
+    def visualize(self,):
+        if len(self._parameter_list) == 1:
+            plot_gaussian_process(self._skopt_result)
+            plt.show()
+
+        plot_convergence(self._skopt_result)
+        plt.show()
+        plot_objective(self._skopt_result)
+        plt.show()
+        plot_evaluations(self._skopt_result)
+        plt.show()
+        return self
+
+    def get_optimized_arguments(self):
+        init_opt = self._replace_optimized_parameters(self._init_args, self._parameter_list)
+        prep_opt = self._replace_optimized_parameters(self._preprocess_args, self._parameter_list)
+        reco_opt = self._replace_optimized_parameters(self._reconstruction_args, self._parameter_list)
+
+        return init_opt, prep_opt, reco_opt
+
+    def _replace_optimized_parameters(self, arg_dict, parameters):
+        opt_args = {}
+        for k,v in arg_dict.items():
+            # Check for optimization parameters
+            if isinstance(v,OptimizationParameter):
+                # Find the right parameter in the list
+                # There is probably a better way to do this inverse mapping!
+                for i,p in enumerate(parameters):
+                    if p.name == k:
+                        opt_args[k] = self._skopt_result.x[i]
+            else:
+                opt_args[k] = v
+        return opt_args
+
+
+    def _split_static_and_optimization_vars(self,argdict):
+        static_args = {}
+        optimization_args = {}
+        for k,v in argdict.items():
+            if isinstance(v,OptimizationParameter):
+                # unwrap the OptimizationParameter object into a skopt object
+                optimization_args[k] = v #._get(k)
+            else:
+                static_args[k] = v
+        return static_args, optimization_args
+
+
+    def _get_optimization_function(
+        self,
+        cls:type[PhaseReconstruction], 
+        parameter_list:list,
+        n_iterations:int,
+        init_static_args:dict, 
+        preprocess_static_args:dict, 
+        reconstruct_static_args:dict, 
+        init_optimization_param_names:dict, 
+        preprocess_optimization_param_names:dict, 
+        reconstruct_optimization_param_names:dict):
+        """
+        Wrap the ptychography pipeline into a single function that encapsulates all of the
+        non-optimization arguments and accepts a concatenated set of keyword arguments. The
+        wrapper function returns the final error value from the ptychography run.
+
+        parameter_list is a list of skopt Dimension objects
+
+        Both static and optimization args are passed in dictionaries. The values of the
+        static dictionary are the fixed parameters, and only the keys of the optimization
+        dictionary are used. 
+        """
+
+        # Construct partial methods to encapsulate the static parameters
+        obj = partial(cls,**init_static_args)
+        prep = partial(cls.preprocess, **preprocess_static_args)
+        recon = partial(cls.reconstruct, **reconstruct_static_args)
+
+        init_params = list(init_optimization_param_names.keys())
+        prep_params = list(preprocess_optimization_param_names.keys())
+        reco_params = list(reconstruct_optimization_param_names.keys())
+
+        # Make a progress bar
+        pbar = tqdm(total=n_iterations,desc="Optimizing Parameters")
+
+        # Target function for Gaussian process optimization that takes a single
+        # dict of named parameters and returns the ptycho error metric
+        @use_named_args(parameter_list)
+        def f(**kwargs):
+            init_args = {k:kwargs[k] for k in init_params}
+            prep_args = {k:kwargs[k] for k in prep_params}
+            reco_args = {k:kwargs[k] for k in reco_params}
+
+            ptycho = obj(**init_args)
+            prep(ptycho,**prep_args)
+            recon(ptycho,**reco_args)
+
+            pbar.update(1)
+
+            return ptycho.error
+                
+        return f
+
+    def _set_optimizer_defaults(self):
+        """
+        Set all of the verbose and plotting to False
+        """
+        self._init_static_args['verbose'] = False
+
+        self._preprocess_static_args['plot_center_of_mass'] = False
+        self._preprocess_static_args['plot_rotation'] = False
+        self._preprocess_static_args['plot_probe_overlaps'] = False
+
+        self._reconstruction_static_args['progress_bar'] = False
+        self._reconstruction_static_args['store_iterations'] = False
 
-class OptimizationParameter:
-	"""
-	Wrapper for scikit-optimize Space objects used for convenient calling in the PtyhochraphyOptimizer
-	"""
-
-	def __init__(
-		self,
-		name:str,
-		lower_bound:Union[float,int,bool],
-		upper_bound:Union[float,int,bool],
-		initial_value:Union[float,int,bool],
-		scaling:str='uniform',
-		space:str="real",
-		categories:list=[],
-		):
-
-		# Check input
-		space = space.lower()
-		assert space in ("real","integer","bool","categorical"), f"Unknown Parameter type: {space}"
-
-		scaling = scaling.lower()
-		assert scaling in ("uniform", "log-uniform"), f"Unknown scaling: {scaling}"
-
-		# Get the right scikit-optimize class
-		space_map = {'real':Real, 'integer':Integer, 'bool':Categorical, 'categorical':Categorical}
-		param = space_map[space]
-
-		# If a boolean property, the categories are True/False
-		if space == 'bool':
-			categories = [True, False]
-
-		# store necessary information
-		self.name = name
-		self.initial_value = initial_value
-
-		if param is Categorical:
-			assert categories is not None, "Empty list of categories!"
-			self._skopt_param = param(name=name, categories=categories)
-		else:
-			self._skopt_param = param(name=name, low=lower_bound, high=upper_bound, prior=scaling,)
 
+class OptimizationParameter:
+    """
+    Wrapper for scikit-optimize Space objects used for convenient calling in the PtyhochraphyOptimizer
+    """
+
+    def __init__(
+        self,
+        lower_bound:Union[float,int,bool],
+        upper_bound:Union[float,int,bool],
+        initial_value:Union[float,int,bool],
+        scaling:str='uniform',
+        space:str="real",
+        categories:list=[],
+        ):
+
+        # Check input
+        space = space.lower()
+        assert space in ("real","integer","bool","categorical"), f"Unknown Parameter type: {space}"
+
+        scaling = scaling.lower()
+        assert scaling in ("uniform", "log-uniform"), f"Unknown scaling: {scaling}"
+
+        # Get the right scikit-optimize class
+        space_map = {'real':Real, 'integer':Integer, 'bool':Categorical, 'categorical':Categorical}
+        param = space_map[space]
+
+        # If a boolean property, the categories are True/False
+        if space == 'bool':
+            categories = [True, False]
+
+        # store necessary information
+        self._initial_value = initial_value
+        self._categories = categories
+        self._lower_bound = lower_bound
+        self._upper_bound = upper_bound
+        self._scaling = scaling
+        self._param_type = param
+
+    def _get(self,name):
+        self._name = name
+        if self._param_type is Categorical:
+            assert categories is not None, "Empty list of categories!"
+            self._skopt_param = self._param_type(name=self._name, categories=self._categories)
+        else:
+            self._skopt_param = self._param_type(name=self._name, low=self._lower_bound, high=self._upper_bound, prior=self._scaling,)
+        return self._skopt_param
 
 

From 1f8357adbc305234f0154ab88b86a7adb41e6148 Mon Sep 17 00:00:00 2001
From: SE Zeltmann <steven.zeltmann@lbl.gov>
Date: Tue, 16 May 2023 15:23:12 -0700
Subject: [PATCH 195/362] improvements to plotting and progress bar

---
 py4DSTEM/process/phase/parameter_optimize.py | 35 ++++++++++++++------
 1 file changed, 24 insertions(+), 11 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index c41c611ec..1a5ad768b 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -53,7 +53,7 @@ def optimize(
         n_initial_points:int,
         ):
 
-        self._optimization_function = self._get_optimization_function(
+        self._optimization_function, pbar = self._get_optimization_function(
             self._reconstruction_type,
             self._parameter_list,
             n_calls,
@@ -72,19 +72,32 @@ def optimize(
             n_initial_points=n_initial_points,
             x0 = self._x0
         )
+
+        # Finish the tqdm progressbar so subsequent things behave nicely
+        pbar.close()
+
         return self
 
-    def visualize(self,):
-        if len(self._parameter_list) == 1:
+    def visualize(
+        self,
+        gp_model=True,
+        convergence=False,
+        objective=True,
+        evaluations=False,
+    ):
+        if len(self._parameter_list) == 1 and gp_model:
             plot_gaussian_process(self._skopt_result)
             plt.show()
 
-        plot_convergence(self._skopt_result)
-        plt.show()
-        plot_objective(self._skopt_result)
-        plt.show()
-        plot_evaluations(self._skopt_result)
-        plt.show()
+        if convergence:
+            plot_convergence(self._skopt_result)
+            plt.show()
+        if objective:
+            plot_objective(self._skopt_result)
+            plt.show()
+        if evaluations:
+            plot_evaluations(self._skopt_result)
+            plt.show()
         return self
 
     def get_optimized_arguments(self):
@@ -154,7 +167,7 @@ def _get_optimization_function(
         reco_params = list(reconstruct_optimization_param_names.keys())
 
         # Make a progress bar
-        pbar = tqdm(total=n_iterations,desc="Optimizing Parameters")
+        pbar = tqdm(total=n_iterations,desc="Optimizing parameters")
 
         # Target function for Gaussian process optimization that takes a single
         # dict of named parameters and returns the ptycho error metric
@@ -172,7 +185,7 @@ def f(**kwargs):
 
             return ptycho.error
                 
-        return f
+        return f, pbar
 
     def _set_optimizer_defaults(self):
         """

From 0fa9e572db4c68e50f27ce5cd3c0620e9a6c1ea5 Mon Sep 17 00:00:00 2001
From: SE Zeltmann <steven.zeltmann@lbl.gov>
Date: Tue, 16 May 2023 17:35:54 -0700
Subject: [PATCH 196/362] print optimization result

---
 py4DSTEM/process/phase/parameter_optimize.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 1a5ad768b..8d266e428 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -73,6 +73,10 @@ def optimize(
             x0 = self._x0
         )
 
+        print("Optimized parameters:")
+        for p,x in zip(self._parameter_list, self._skopt_result.x):
+            print(f"{p.name}: {x}")
+
         # Finish the tqdm progressbar so subsequent things behave nicely
         pbar.close()
 

From 86d4b8155421ed653627b5f7edcf76195e2e4880 Mon Sep 17 00:00:00 2001
From: SE Zeltmann <steven.zeltmann@lbl.gov>
Date: Tue, 16 May 2023 18:05:58 -0700
Subject: [PATCH 197/362] format

---
 py4DSTEM/process/phase/parameter_optimize.py | 181 +++++++++++--------
 1 file changed, 109 insertions(+), 72 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 8d266e428..627cb04c5 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -1,7 +1,12 @@
 from tqdm import tqdm
 from skopt import gp_minimize
 from skopt.space import Real, Integer, Categorical
-from skopt.plots import plot_convergence, plot_gaussian_process, plot_evaluations, plot_objective
+from skopt.plots import (
+    plot_convergence,
+    plot_gaussian_process,
+    plot_evaluations,
+    plot_objective,
+)
 from skopt.utils import use_named_args
 import matplotlib.pyplot as plt
 
@@ -10,6 +15,7 @@
 
 from py4DSTEM.process.phase.iterative_base_class import PhaseReconstruction
 
+
 class PtychographyOptimizer:
     """
     doot doot
@@ -18,24 +24,37 @@ class PtychographyOptimizer:
     def __init__(
         self,
         reconstruction_type: type[PhaseReconstruction],
-        init_args:dict,
-        preprocess_args:dict,
-        reconstruction_args:dict,
-        ):
+        init_args: dict,
+        preprocess_args: dict,
+        reconstruction_args: dict,
+    ):
         """
         Parameter optimization for ptychographic reconstruction based on Bayesian Optimization
-        with Gaussian Process. 
+        with Gaussian Process.
         """
-        
+
         # loop over each argument dictionary and split into static and optimization variables
-        self._init_static_args, self._init_optimize_args = self._split_static_and_optimization_vars(init_args)
-        self._preprocess_static_args, self._preprocess_optimize_args = self._split_static_and_optimization_vars(preprocess_args)
-        self._reconstruction_static_args, self._reconstruction_optimize_args = self._split_static_and_optimization_vars(reconstruction_args)
+        (
+            self._init_static_args,
+            self._init_optimize_args,
+        ) = self._split_static_and_optimization_vars(init_args)
+        (
+            self._preprocess_static_args,
+            self._preprocess_optimize_args,
+        ) = self._split_static_and_optimization_vars(preprocess_args)
+        (
+            self._reconstruction_static_args,
+            self._reconstruction_optimize_args,
+        ) = self._split_static_and_optimization_vars(reconstruction_args)
 
         # Save list of skopt parameter objects and inital guess
         self._parameter_list = []
         self._x0 = []
-        for k,v in (self._init_optimize_args|self._preprocess_optimize_args|self._reconstruction_optimize_args).items():
+        for k, v in (
+            self._init_optimize_args
+            | self._preprocess_optimize_args
+            | self._reconstruction_optimize_args
+        ).items():
             self._parameter_list.append(v._get(k))
             self._x0.append(v._initial_value)
 
@@ -49,10 +68,9 @@ def __init__(
 
     def optimize(
         self,
-        n_calls:int,
-        n_initial_points:int,
-        ):
-
+        n_calls: int,
+        n_initial_points: int,
+    ):
         self._optimization_function, pbar = self._get_optimization_function(
             self._reconstruction_type,
             self._parameter_list,
@@ -62,19 +80,19 @@ def optimize(
             self._reconstruction_static_args,
             self._init_optimize_args,
             self._preprocess_optimize_args,
-            self._reconstruction_optimize_args
-            )
+            self._reconstruction_optimize_args,
+        )
 
         self._skopt_result = gp_minimize(
             self._optimization_function,
             self._parameter_list,
-            n_calls = n_calls,
+            n_calls=n_calls,
             n_initial_points=n_initial_points,
-            x0 = self._x0
+            x0=self._x0,
         )
 
         print("Optimized parameters:")
-        for p,x in zip(self._parameter_list, self._skopt_result.x):
+        for p, x in zip(self._parameter_list, self._skopt_result.x):
             print(f"{p.name}: {x}")
 
         # Finish the tqdm progressbar so subsequent things behave nicely
@@ -105,50 +123,55 @@ def visualize(
         return self
 
     def get_optimized_arguments(self):
-        init_opt = self._replace_optimized_parameters(self._init_args, self._parameter_list)
-        prep_opt = self._replace_optimized_parameters(self._preprocess_args, self._parameter_list)
-        reco_opt = self._replace_optimized_parameters(self._reconstruction_args, self._parameter_list)
+        init_opt = self._replace_optimized_parameters(
+            self._init_args, self._parameter_list
+        )
+        prep_opt = self._replace_optimized_parameters(
+            self._preprocess_args, self._parameter_list
+        )
+        reco_opt = self._replace_optimized_parameters(
+            self._reconstruction_args, self._parameter_list
+        )
 
         return init_opt, prep_opt, reco_opt
 
     def _replace_optimized_parameters(self, arg_dict, parameters):
         opt_args = {}
-        for k,v in arg_dict.items():
+        for k, v in arg_dict.items():
             # Check for optimization parameters
-            if isinstance(v,OptimizationParameter):
+            if isinstance(v, OptimizationParameter):
                 # Find the right parameter in the list
                 # There is probably a better way to do this inverse mapping!
-                for i,p in enumerate(parameters):
+                for i, p in enumerate(parameters):
                     if p.name == k:
                         opt_args[k] = self._skopt_result.x[i]
             else:
                 opt_args[k] = v
         return opt_args
 
-
-    def _split_static_and_optimization_vars(self,argdict):
+    def _split_static_and_optimization_vars(self, argdict):
         static_args = {}
         optimization_args = {}
-        for k,v in argdict.items():
-            if isinstance(v,OptimizationParameter):
+        for k, v in argdict.items():
+            if isinstance(v, OptimizationParameter):
                 # unwrap the OptimizationParameter object into a skopt object
-                optimization_args[k] = v #._get(k)
+                optimization_args[k] = v  # ._get(k)
             else:
                 static_args[k] = v
         return static_args, optimization_args
 
-
     def _get_optimization_function(
         self,
-        cls:type[PhaseReconstruction], 
-        parameter_list:list,
-        n_iterations:int,
-        init_static_args:dict, 
-        preprocess_static_args:dict, 
-        reconstruct_static_args:dict, 
-        init_optimization_param_names:dict, 
-        preprocess_optimization_param_names:dict, 
-        reconstruct_optimization_param_names:dict):
+        cls: type[PhaseReconstruction],
+        parameter_list: list,
+        n_iterations: int,
+        init_static_args: dict,
+        preprocess_static_args: dict,
+        reconstruct_static_args: dict,
+        init_optimization_param_names: dict,
+        preprocess_optimization_param_names: dict,
+        reconstruct_optimization_param_names: dict,
+    ):
         """
         Wrap the ptychography pipeline into a single function that encapsulates all of the
         non-optimization arguments and accepts a concatenated set of keyword arguments. The
@@ -158,11 +181,11 @@ def _get_optimization_function(
 
         Both static and optimization args are passed in dictionaries. The values of the
         static dictionary are the fixed parameters, and only the keys of the optimization
-        dictionary are used. 
+        dictionary are used.
         """
 
         # Construct partial methods to encapsulate the static parameters
-        obj = partial(cls,**init_static_args)
+        obj = partial(cls, **init_static_args)
         prep = partial(cls.preprocess, **preprocess_static_args)
         recon = partial(cls.reconstruct, **reconstruct_static_args)
 
@@ -171,38 +194,38 @@ def _get_optimization_function(
         reco_params = list(reconstruct_optimization_param_names.keys())
 
         # Make a progress bar
-        pbar = tqdm(total=n_iterations,desc="Optimizing parameters")
+        pbar = tqdm(total=n_iterations, desc="Optimizing parameters")
 
         # Target function for Gaussian process optimization that takes a single
         # dict of named parameters and returns the ptycho error metric
         @use_named_args(parameter_list)
         def f(**kwargs):
-            init_args = {k:kwargs[k] for k in init_params}
-            prep_args = {k:kwargs[k] for k in prep_params}
-            reco_args = {k:kwargs[k] for k in reco_params}
+            init_args = {k: kwargs[k] for k in init_params}
+            prep_args = {k: kwargs[k] for k in prep_params}
+            reco_args = {k: kwargs[k] for k in reco_params}
 
             ptycho = obj(**init_args)
-            prep(ptycho,**prep_args)
-            recon(ptycho,**reco_args)
+            prep(ptycho, **prep_args)
+            recon(ptycho, **reco_args)
 
             pbar.update(1)
 
             return ptycho.error
-                
+
         return f, pbar
 
     def _set_optimizer_defaults(self):
         """
         Set all of the verbose and plotting to False
         """
-        self._init_static_args['verbose'] = False
+        self._init_static_args["verbose"] = False
 
-        self._preprocess_static_args['plot_center_of_mass'] = False
-        self._preprocess_static_args['plot_rotation'] = False
-        self._preprocess_static_args['plot_probe_overlaps'] = False
+        self._preprocess_static_args["plot_center_of_mass"] = False
+        self._preprocess_static_args["plot_rotation"] = False
+        self._preprocess_static_args["plot_probe_overlaps"] = False
 
-        self._reconstruction_static_args['progress_bar'] = False
-        self._reconstruction_static_args['store_iterations'] = False
+        self._reconstruction_static_args["progress_bar"] = False
+        self._reconstruction_static_args["store_iterations"] = False
 
 
 class OptimizationParameter:
@@ -212,27 +235,36 @@ class OptimizationParameter:
 
     def __init__(
         self,
-        lower_bound:Union[float,int,bool],
-        upper_bound:Union[float,int,bool],
-        initial_value:Union[float,int,bool],
-        scaling:str='uniform',
-        space:str="real",
-        categories:list=[],
-        ):
-
+        lower_bound: Union[float, int, bool],
+        upper_bound: Union[float, int, bool],
+        initial_value: Union[float, int, bool],
+        scaling: str = "uniform",
+        space: str = "real",
+        categories: list = [],
+    ):
         # Check input
         space = space.lower()
-        assert space in ("real","integer","bool","categorical"), f"Unknown Parameter type: {space}"
+        assert space in (
+            "real",
+            "integer",
+            "bool",
+            "categorical",
+        ), f"Unknown Parameter type: {space}"
 
         scaling = scaling.lower()
         assert scaling in ("uniform", "log-uniform"), f"Unknown scaling: {scaling}"
 
         # Get the right scikit-optimize class
-        space_map = {'real':Real, 'integer':Integer, 'bool':Categorical, 'categorical':Categorical}
+        space_map = {
+            "real": Real,
+            "integer": Integer,
+            "bool": Categorical,
+            "categorical": Categorical,
+        }
         param = space_map[space]
 
         # If a boolean property, the categories are True/False
-        if space == 'bool':
+        if space == "bool":
             categories = [True, False]
 
         # store necessary information
@@ -243,13 +275,18 @@ def __init__(
         self._scaling = scaling
         self._param_type = param
 
-    def _get(self,name):
+    def _get(self, name):
         self._name = name
         if self._param_type is Categorical:
             assert categories is not None, "Empty list of categories!"
-            self._skopt_param = self._param_type(name=self._name, categories=self._categories)
+            self._skopt_param = self._param_type(
+                name=self._name, categories=self._categories
+            )
         else:
-            self._skopt_param = self._param_type(name=self._name, low=self._lower_bound, high=self._upper_bound, prior=self._scaling,)
+            self._skopt_param = self._param_type(
+                name=self._name,
+                low=self._lower_bound,
+                high=self._upper_bound,
+                prior=self._scaling,
+            )
         return self._skopt_param
-
-

From b445ac3f42110f64c5677af14980e7c053298e3d Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <steven.zeltmann@berkeley.edu>
Date: Thu, 18 May 2023 15:06:19 -0700
Subject: [PATCH 198/362] add affine transform to bayesian optimize

---
 py4DSTEM/process/phase/parameter_optimize.py | 73 +++++++++++++++-----
 1 file changed, 56 insertions(+), 17 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 627cb04c5..dbecdb22c 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -9,11 +9,13 @@
 )
 from skopt.utils import use_named_args
 import matplotlib.pyplot as plt
+import numpy as np
 
 from functools import partial
 from typing import Union
 
 from py4DSTEM.process.phase.iterative_base_class import PhaseReconstruction
+from py4DSTEM.process.phase.utils import AffineTransform
 
 
 class PtychographyOptimizer:
@@ -25,6 +27,7 @@ def __init__(
         self,
         reconstruction_type: type[PhaseReconstruction],
         init_args: dict,
+        affine_args:dict,
         preprocess_args: dict,
         reconstruction_args: dict,
     ):
@@ -38,6 +41,10 @@ def __init__(
             self._init_static_args,
             self._init_optimize_args,
         ) = self._split_static_and_optimization_vars(init_args)
+        (
+            self._affine_static_args,
+            self._affine_optimize_args,
+        ) = self._split_static_and_optimization_vars(affine_args)
         (
             self._preprocess_static_args,
             self._preprocess_optimize_args,
@@ -52,6 +59,7 @@ def __init__(
         self._x0 = []
         for k, v in (
             self._init_optimize_args
+            | self._affine_optimize_args
             | self._preprocess_optimize_args
             | self._reconstruction_optimize_args
         ).items():
@@ -59,6 +67,7 @@ def __init__(
             self._x0.append(v._initial_value)
 
         self._init_args = init_args
+        self._affine_args = affine_args
         self._preprocess_args = preprocess_args
         self._reconstruction_args = reconstruction_args
 
@@ -71,24 +80,34 @@ def optimize(
         n_calls: int,
         n_initial_points: int,
     ):
-        self._optimization_function, pbar = self._get_optimization_function(
+        self._optimization_function = self._get_optimization_function(
             self._reconstruction_type,
             self._parameter_list,
             n_calls,
             self._init_static_args,
+            self._affine_static_args,
             self._preprocess_static_args,
             self._reconstruction_static_args,
             self._init_optimize_args,
+            self._affine_optimize_args,
             self._preprocess_optimize_args,
             self._reconstruction_optimize_args,
         )
 
+        # Make a progress bar
+        pbar = tqdm(total=n_calls, desc="Optimizing parameters")
+        # We need to wrap the callback because if it returns a value
+        # the optimizer breaks its loop
+        def callback(*args,**kwargs):
+            pbar.update(1)
+
         self._skopt_result = gp_minimize(
             self._optimization_function,
             self._parameter_list,
             n_calls=n_calls,
             n_initial_points=n_initial_points,
             x0=self._x0,
+            callback=callback,
         )
 
         print("Optimized parameters:")
@@ -107,10 +126,9 @@ def visualize(
         objective=True,
         evaluations=False,
     ):
-        if len(self._parameter_list) == 1 and gp_model:
+        if (len(self._parameter_list) == 1) and gp_model:
             plot_gaussian_process(self._skopt_result)
             plt.show()
-
         if convergence:
             plot_convergence(self._skopt_result)
             plt.show()
@@ -126,6 +144,13 @@ def get_optimized_arguments(self):
         init_opt = self._replace_optimized_parameters(
             self._init_args, self._parameter_list
         )
+        affine_opt = self._replace_optimized_parameters(
+            self._affine_args, self._parameter_list
+        )
+        affine_transform = partial(AffineTransform, **self._affine_static_args)(**affine_opt)
+        scan_positions = self._get_scan_positions(affine_transform, init_opt['datacube'])
+        init_opt['initial_scan_positions'] = scan_positions
+
         prep_opt = self._replace_optimized_parameters(
             self._preprocess_args, self._parameter_list
         )
@@ -154,23 +179,32 @@ def _split_static_and_optimization_vars(self, argdict):
         optimization_args = {}
         for k, v in argdict.items():
             if isinstance(v, OptimizationParameter):
-                # unwrap the OptimizationParameter object into a skopt object
-                optimization_args[k] = v  # ._get(k)
+                optimization_args[k] = v
             else:
                 static_args[k] = v
         return static_args, optimization_args
 
+    def _get_scan_positions(self, affine_transform, dataset):
+        R_pixel_size = dataset.calibration.get_R_pixel_size()
+        x,y = np.arange(dataset.R_Nx)*R_pixel_size, np.arange(dataset.R_Ny)*R_pixel_size
+        x, y = np.meshgrid(x, y, indexing="ij")
+        scan_positions = np.stack((x.ravel(),y.ravel()),axis=1)
+        scan_positions = scan_positions @ affine_transform.asarray()
+        return scan_positions
+
     def _get_optimization_function(
         self,
         cls: type[PhaseReconstruction],
         parameter_list: list,
         n_iterations: int,
         init_static_args: dict,
+        affine_static_args:dict,
         preprocess_static_args: dict,
         reconstruct_static_args: dict,
-        init_optimization_param_names: dict,
-        preprocess_optimization_param_names: dict,
-        reconstruct_optimization_param_names: dict,
+        init_optimization_params: dict,
+        affine_optimization_params: dict,
+        preprocess_optimization_params: dict,
+        reconstruct_optimization_params: dict,
     ):
         """
         Wrap the ptychography pipeline into a single function that encapsulates all of the
@@ -186,33 +220,38 @@ def _get_optimization_function(
 
         # Construct partial methods to encapsulate the static parameters
         obj = partial(cls, **init_static_args)
+        affine = partial(AffineTransform, **affine_static_args)
         prep = partial(cls.preprocess, **preprocess_static_args)
         recon = partial(cls.reconstruct, **reconstruct_static_args)
 
-        init_params = list(init_optimization_param_names.keys())
-        prep_params = list(preprocess_optimization_param_names.keys())
-        reco_params = list(reconstruct_optimization_param_names.keys())
-
-        # Make a progress bar
-        pbar = tqdm(total=n_iterations, desc="Optimizing parameters")
+        init_params = list(init_optimization_params.keys())
+        afft_params = list(affine_optimization_params.keys())
+        prep_params = list(preprocess_optimization_params.keys())
+        reco_params = list(reconstruct_optimization_params.keys())
 
         # Target function for Gaussian process optimization that takes a single
         # dict of named parameters and returns the ptycho error metric
         @use_named_args(parameter_list)
         def f(**kwargs):
             init_args = {k: kwargs[k] for k in init_params}
+            afft_args = {k: kwargs[k] for k in afft_params}
             prep_args = {k: kwargs[k] for k in prep_params}
             reco_args = {k: kwargs[k] for k in reco_params}
 
+            # Create affine transform object
+            tr = affine(**afft_args)
+            # Apply affine transform to pixel grid, using the 
+            # calibrations lifted from the dataset
+            dataset = init_static_args['datacube']
+            init_args['initial_scan_positions'] = self._get_scan_positions(tr, dataset)
+
             ptycho = obj(**init_args)
             prep(ptycho, **prep_args)
             recon(ptycho, **reco_args)
 
-            pbar.update(1)
-
             return ptycho.error
 
-        return f, pbar
+        return f
 
     def _set_optimizer_defaults(self):
         """

From 1f5051259440f39bd0c205edac9136ef2de2ac64 Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <steven.zeltmann@berkeley.edu>
Date: Thu, 18 May 2023 15:16:09 -0700
Subject: [PATCH 199/362] bugfix from linter

---
 py4DSTEM/process/phase/parameter_optimize.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index dbecdb22c..dffa991ab 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -317,7 +317,7 @@ def __init__(
     def _get(self, name):
         self._name = name
         if self._param_type is Categorical:
-            assert categories is not None, "Empty list of categories!"
+            assert self._categories is not None, "Empty list of categories!"
             self._skopt_param = self._param_type(
                 name=self._name, categories=self._categories
             )

From 1840466e43730278a136f38cf72ab9298c006c87 Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <steven.zeltmann@berkeley.edu>
Date: Fri, 19 May 2023 14:51:52 -0700
Subject: [PATCH 200/362] add documentation and format

---
 py4DSTEM/process/phase/parameter_optimize.py | 120 ++++++++++++++++---
 1 file changed, 106 insertions(+), 14 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index dffa991ab..987ffedef 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -20,20 +20,48 @@
 
 class PtychographyOptimizer:
     """
-    doot doot
+    Optimize ptychographic hyperparameters with Bayesian Optimization of a
+    Gaussian process. Any of the arguments to the ptychographic
+    init-preprocess-reconstruct pipeline can be optimized over (including
+    boolean or other flag options)
     """
 
     def __init__(
         self,
         reconstruction_type: type[PhaseReconstruction],
         init_args: dict,
-        affine_args:dict,
+        affine_args: dict,
         preprocess_args: dict,
         reconstruction_args: dict,
     ):
         """
         Parameter optimization for ptychographic reconstruction based on Bayesian Optimization
         with Gaussian Process.
+
+        Usage
+        -----
+        Dictionaries of the arguments to __init__, AffineTransform (for distorting the initial
+        scan positions), preprocess, and reconstruct are required. For parameters not optimized
+        over, the value in the dictionary is used. To optimize a parameter, instead pass an
+        OptimizationParameter object inside the dictionary to specify the bounds, initial guess,
+        and type of parameter. Calling optimize will then run the optimization simultaneously
+        over all optimization parameters. To obtain the optimized parameters, call get_optimized_arguments
+        to return a set of dictionaries where the OptimizationParameter objects have been replaced
+        with the optimal values. These can then be modified for running a full reconstruction.
+
+        Parameters
+        ----------
+        reconstruction_type: class
+            Type of ptychographic reconstruction to perform
+        init_args: dict
+            Keyword arguments passed to the __init__ method of the reconstruction class
+        affine_args: dict
+            Keyword arguments passed to AffineTransform. The transform is applied to the initial
+            scan positions.
+        preprocess_args: dict
+            Keyword arguments passed to the preprocess method the reconstruction object
+        reconstruction_args: dict
+            Keyword arguments passed to the reconstruct method the the reconstruction object
         """
 
         # loop over each argument dictionary and split into static and optimization variables
@@ -79,7 +107,22 @@ def optimize(
         self,
         n_calls: int,
         n_initial_points: int,
+        **skopt_kwargs: dict,
     ):
+        """
+        Run optimizer
+
+        Parameters
+        ----------
+        n_calls: int
+            Number of times to run ptychographic reconstruction
+        n_initial_points: int
+            Number of uniformly spaced trial points to test before
+            beginning Bayesian optimization (must be less than n_calls)
+        skopt_kwargs: dict
+            Additional arguments to be passed to skopt.gp_minimize
+
+        """
         self._optimization_function = self._get_optimization_function(
             self._reconstruction_type,
             self._parameter_list,
@@ -96,9 +139,10 @@ def optimize(
 
         # Make a progress bar
         pbar = tqdm(total=n_calls, desc="Optimizing parameters")
+
         # We need to wrap the callback because if it returns a value
         # the optimizer breaks its loop
-        def callback(*args,**kwargs):
+        def callback(*args, **kwargs):
             pbar.update(1)
 
         self._skopt_result = gp_minimize(
@@ -108,6 +152,7 @@ def callback(*args,**kwargs):
             n_initial_points=n_initial_points,
             x0=self._x0,
             callback=callback,
+            **skopt_kwargs,
         )
 
         print("Optimized parameters:")
@@ -126,6 +171,20 @@ def visualize(
         objective=True,
         evaluations=False,
     ):
+        """
+        Visualize optimization results
+
+        Parameters
+        ----------
+        gp_model: bool
+            Display fitted Gaussian process model (only available for 1-dimensional problem)
+        convergence: bool
+            Display convergence history
+        objective: bool
+            Display GP objective function and partial dependence plots
+        evaluations: bool
+            Display histograms of sampled points
+        """
         if (len(self._parameter_list) == 1) and gp_model:
             plot_gaussian_process(self._skopt_result)
             plt.show()
@@ -141,15 +200,29 @@ def visualize(
         return self
 
     def get_optimized_arguments(self):
+        """
+        Get argument dictionaries containing optimized hyperparameters
+
+        Returns
+        -------
+        init_opt, prep_opt, reco_opt: dicts
+            Dictionaries of arguments to __init__, preprocess, and reconstruct
+            where the OptimizationParameter items have been replaced with the optimal
+            values obtained from the optimizer
+        """
         init_opt = self._replace_optimized_parameters(
             self._init_args, self._parameter_list
         )
         affine_opt = self._replace_optimized_parameters(
             self._affine_args, self._parameter_list
         )
-        affine_transform = partial(AffineTransform, **self._affine_static_args)(**affine_opt)
-        scan_positions = self._get_scan_positions(affine_transform, init_opt['datacube'])
-        init_opt['initial_scan_positions'] = scan_positions
+        affine_transform = partial(AffineTransform, **self._affine_static_args)(
+            **affine_opt
+        )
+        scan_positions = self._get_scan_positions(
+            affine_transform, init_opt["datacube"]
+        )
+        init_opt["initial_scan_positions"] = scan_positions
 
         prep_opt = self._replace_optimized_parameters(
             self._preprocess_args, self._parameter_list
@@ -186,9 +259,12 @@ def _split_static_and_optimization_vars(self, argdict):
 
     def _get_scan_positions(self, affine_transform, dataset):
         R_pixel_size = dataset.calibration.get_R_pixel_size()
-        x,y = np.arange(dataset.R_Nx)*R_pixel_size, np.arange(dataset.R_Ny)*R_pixel_size
+        x, y = (
+            np.arange(dataset.R_Nx) * R_pixel_size,
+            np.arange(dataset.R_Ny) * R_pixel_size,
+        )
         x, y = np.meshgrid(x, y, indexing="ij")
-        scan_positions = np.stack((x.ravel(),y.ravel()),axis=1)
+        scan_positions = np.stack((x.ravel(), y.ravel()), axis=1)
         scan_positions = scan_positions @ affine_transform.asarray()
         return scan_positions
 
@@ -198,7 +274,7 @@ def _get_optimization_function(
         parameter_list: list,
         n_iterations: int,
         init_static_args: dict,
-        affine_static_args:dict,
+        affine_static_args: dict,
         preprocess_static_args: dict,
         reconstruct_static_args: dict,
         init_optimization_params: dict,
@@ -240,10 +316,10 @@ def f(**kwargs):
 
             # Create affine transform object
             tr = affine(**afft_args)
-            # Apply affine transform to pixel grid, using the 
+            # Apply affine transform to pixel grid, using the
             # calibrations lifted from the dataset
-            dataset = init_static_args['datacube']
-            init_args['initial_scan_positions'] = self._get_scan_positions(tr, dataset)
+            dataset = init_static_args["datacube"]
+            init_args["initial_scan_positions"] = self._get_scan_positions(tr, dataset)
 
             ptycho = obj(**init_args)
             prep(ptycho, **prep_args)
@@ -274,13 +350,29 @@ class OptimizationParameter:
 
     def __init__(
         self,
-        lower_bound: Union[float, int, bool],
-        upper_bound: Union[float, int, bool],
         initial_value: Union[float, int, bool],
+        lower_bound: Union[float, int, bool] = None,
+        upper_bound: Union[float, int, bool] = None,
         scaling: str = "uniform",
         space: str = "real",
         categories: list = [],
     ):
+        """
+        Wrapper for scikit-optimize Space objects used as inputs to PtychographyOptimizer
+
+        Parameters
+        ----------
+        initial_value:
+            Initial value, used for first evaluation in optimizer
+        lower_bound, upper_bound:
+            Bounds on real or integer variables (not needed for bool or categorical)
+        scaling: str
+            Prior knowledge on sensitivity of the variable. Can be 'uniform' or 'log-uniform'
+        space: str
+            Type of variable. Can be 'real', 'integer', 'bool', or 'categorical'
+        categories: list
+            List of options for Categorical parameter
+        """
         # Check input
         space = space.lower()
         assert space in (

From 6ae97a3ebc9a7accc0f62f27d5cc0bb1a4f0669e Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <steven.zeltmann@berkeley.edu>
Date: Fri, 19 May 2023 14:57:52 -0700
Subject: [PATCH 201/362] add isotropic expansion option to AffineTransform

---
 py4DSTEM/process/phase/utils.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/process/phase/utils.py b/py4DSTEM/process/phase/utils.py
index bb11db7d4..5bc44d95a 100644
--- a/py4DSTEM/process/phase/utils.py
+++ b/py4DSTEM/process/phase/utils.py
@@ -644,6 +644,8 @@ class AffineTransform:
         x-translation
     t1: float
         y-translation
+    dilation: float
+        Isotropic expansion (multiplies scale0 and scale1)
     """
 
     def __init__(
@@ -654,9 +656,10 @@ def __init__(
         angle: float = 0.0,
         t0: float = 0.0,
         t1: float = 0.0,
+        dilation: float = 1.0,
     ):
-        self.scale0 = scale0
-        self.scale1 = scale1
+        self.scale0 = scale0 * dilation
+        self.scale1 = scale1 * dilation
         self.shear1 = shear1
         self.angle = angle
         self.t0 = t0

From f78342ec6ae2715e495d88af28df23dc16bf0dc5 Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Wed, 17 May 2023 11:32:12 -0400
Subject: [PATCH 202/362] fix calibration move

---
 py4DSTEM/preprocess/preprocess.py              | 3 +++
 py4DSTEM/process/phase/iterative_base_class.py | 3 +--
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/preprocess/preprocess.py b/py4DSTEM/preprocess/preprocess.py
index 343c20895..16dd64555 100644
--- a/py4DSTEM/preprocess/preprocess.py
+++ b/py4DSTEM/preprocess/preprocess.py
@@ -643,6 +643,7 @@ def resample_data_diffraction(
         datacube.data = fourier_resample(
             datacube.data, scale=resampling_factor, output_size=output_size
         )
+        datacube.calibration.set_Q_pixel_size(datacube.calibration.get_Q_pixel_size() / resampling_factor)
 
     elif method == "bilinear":
         from scipy.ndimage import zoom
@@ -674,6 +675,8 @@ def resample_data_diffraction(
 
         resampling_factor = np.concatenate(((1, 1), resampling_factor))
         datacube.data = zoom(datacube.data, resampling_factor, order=1)
+        datacube.calibration.set_Q_pixel_size(datacube.calibration.get_Q_pixel_size() / resampling_factor[2])
+
     else:
         raise ValueError(
             f"'method' needs to be one of 'bilinear' or 'fourier', not {method}."
diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index e3dfa1cd7..bf9c6b2f9 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -194,8 +194,7 @@ def _preprocess_datacube_and_vacuum_probe(
                         output_size=diffraction_intensities_shape,
                         force_nonnegative=True,
                     )
-            datacube.calibration.set_Q_pixel_size(Q_pixel_size / resampling_factor_x)
-
+        
         if probe_roi_shape is not None:
             Qx, Qy = datacube.shape[-2:]
             Sx, Sy = probe_roi_shape

From 0461c3f5c39fc14194aef407526da8679f4f7c86 Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Sun, 4 Jun 2023 11:07:46 -0400
Subject: [PATCH 203/362] add calibration overrides to ptycho base class

---
 .../process/phase/iterative_base_class.py     | 164 +++++++++++-------
 1 file changed, 104 insertions(+), 60 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index bf9c6b2f9..4acb85cd5 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -221,6 +221,9 @@ def _extract_intensities_and_calibrations_from_datacube(
         self,
         datacube: DataCube,
         require_calibrations: bool = False,
+        force_scan_sampling: Optional[float] = None,
+        force_angular_sampling: Optional[float] = None,
+        force_reciprocal_sampling: Optional[float] = None,
     ):
         """
         Method to extract intensities and calibrations from datacube.
@@ -231,6 +234,12 @@ def _extract_intensities_and_calibrations_from_datacube(
             Input 4D diffraction pattern intensities
         require_calibrations: bool
             If False, warning is issued instead of raising an error
+        force_scan_sampling: float, optional
+            Override DataCube real space scan pixel size calibrations, in Angstrom
+        force_angular_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in mrad
+        force_reciprocal_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in A^-1
 
         Assigns
         --------
@@ -276,80 +285,115 @@ def _extract_intensities_and_calibrations_from_datacube(
         reciprocal_space_units = calibration.get_Q_pixel_units()
 
         # Real-space
-        if real_space_units == "pixels":
-            if require_calibrations:
-                raise ValueError("Real-space calibrations must be given in 'A'")
-
-            warnings.warn(
-                (
-                    "Iterative reconstruction will not be quantitative unless you specify "
-                    "real-space calibrations in 'A'"
-                ),
-                UserWarning,
-            )
+        if force_scan_sampling is not None:
+            self._scan_sampling = (force_scan_sampling, force_scan_sampling)
+            self._scan_units = "A"
+        else:
+            if real_space_units == "pixels":
+                if require_calibrations:
+                    raise ValueError("Real-space calibrations must be given in 'A'")
 
-            self._scan_sampling = (1.0, 1.0)
-            self._scan_units = ("pixels",) * 2
+                warnings.warn(
+                    (
+                        "Iterative reconstruction will not be quantitative unless you specify "
+                        "real-space calibrations in 'A'"
+                    ),
+                    UserWarning,
+                )
 
-        elif real_space_units == "A":
-            self._scan_sampling = (calibration.get_R_pixel_size(),) * 2
-            self._scan_units = ("A",) * 2
-        elif real_space_units == "nm":
-            self._scan_sampling = (calibration.get_R_pixel_size() * 10,) * 2
-            self._scan_units = ("A",) * 2
-        else:
-            raise ValueError(
-                f"Real-space calibrations must be given in 'A', not {real_space_units}"
-            )
+                self._scan_sampling = (1.0, 1.0)
+                self._scan_units = ("pixels",) * 2
 
-        # Reciprocal-space
-        if reciprocal_space_units == "pixels":
-            if require_calibrations:
+            elif real_space_units == "A":
+                self._scan_sampling = (calibration.get_R_pixel_size(),) * 2
+                self._scan_units = ("A",) * 2
+            elif real_space_units == "nm":
+                self._scan_sampling = (calibration.get_R_pixel_size() * 10,) * 2
+                self._scan_units = ("A",) * 2
+            else:
                 raise ValueError(
-                    "Reciprocal-space calibrations must be given in in 'A^-1' or 'mrad'"
+                    f"Real-space calibrations must be given in 'A', not {real_space_units}"
                 )
 
-            warnings.warn(
-                (
-                    "Iterative reconstruction will not be quantitative unless you specify "
-                    "appropriate reciprocal-space calibrations"
-                ),
-                UserWarning,
+        # Reciprocal-space
+        if force_angular_sampling is not None or force_reciprocal_sampling is not None:
+            # there is no xor keyword in Python!
+            angular = force_angular_sampling is not None
+            reciprocal = force_reciprocal_sampling is not None
+            assert (angular and not reciprocal) or (not angular and reciprocal), (
+                "Only one of angular or reciprocal calibration can be forced!"
             )
 
-            self._angular_sampling = (1.0, 1.0)
-            self._angular_units = ("pixels",) * 2
-            self._reciprocal_sampling = (1.0, 1.0)
-            self._reciprocal_units = ("pixels",) * 2
-
-        elif reciprocal_space_units == "A^-1":
-            reciprocal_size = calibration.get_Q_pixel_size()
-            self._reciprocal_sampling = (reciprocal_size,) * 2
-            self._reciprocal_units = ("A^-1",) * 2
-
-            if self._energy is not None:
-                self._angular_sampling = (
-                    reciprocal_size * electron_wavelength_angstrom(self._energy) * 1e3,
-                ) * 2
+            # angular calibration specified
+            if angular:
+                self._angular_sampling = (force_angular_sampling,) * 2
                 self._angular_units = ("mrad",) * 2
 
-        elif reciprocal_space_units == "mrad":
-            angular_size = calibration.get_Q_pixel_size()
-            self._angular_sampling = (angular_size,) * 2
-            self._angular_units = ("mrad",) * 2
+                if self._energy is not None:
+                    self._reciprocal_sampling = (
+                        force_angular_sampling / electron_wavelength_angstrom(self._energy) / 1e3,
+                    ) * 2
+                    self._reciprocal_units = ("A^-1",) * 2
 
-            if self._energy is not None:
-                self._reciprocal_sampling = (
-                    angular_size / electron_wavelength_angstrom(self._energy) / 1e3,
-                ) * 2
+            # reciprocal calibration specified
+            if reciprocal:
+                self._reciprocal_sampling = (force_reciprocal_sampling,) * 2
                 self._reciprocal_units = ("A^-1",) * 2
+
+                if self._energy is not None:
+                    self._angular_sampling = (
+                        force_reciprocal_sampling * electron_wavelength_angstrom(self._energy) * 1e3,
+                    ) * 2
+                    self._angular_units = ("mrad",) * 2
+
         else:
-            raise ValueError(
-                (
-                    "Reciprocal-space calibrations must be given in 'A^-1' or 'mrad', "
-                    f"not {reciprocal_space_units}"
+            if reciprocal_space_units == "pixels":
+                if require_calibrations:
+                    raise ValueError(
+                        "Reciprocal-space calibrations must be given in in 'A^-1' or 'mrad'"
+                    )
+
+                warnings.warn(
+                    (
+                        "Iterative reconstruction will not be quantitative unless you specify "
+                        "appropriate reciprocal-space calibrations"
+                    ),
+                    UserWarning,
+                )
+
+                self._angular_sampling = (1.0, 1.0)
+                self._angular_units = ("pixels",) * 2
+                self._reciprocal_sampling = (1.0, 1.0)
+                self._reciprocal_units = ("pixels",) * 2
+
+            elif reciprocal_space_units == "A^-1":
+                reciprocal_size = calibration.get_Q_pixel_size()
+                self._reciprocal_sampling = (reciprocal_size,) * 2
+                self._reciprocal_units = ("A^-1",) * 2
+
+                if self._energy is not None:
+                    self._angular_sampling = (
+                        reciprocal_size * electron_wavelength_angstrom(self._energy) * 1e3,
+                    ) * 2
+                    self._angular_units = ("mrad",) * 2
+
+            elif reciprocal_space_units == "mrad":
+                angular_size = calibration.get_Q_pixel_size()
+                self._angular_sampling = (angular_size,) * 2
+                self._angular_units = ("mrad",) * 2
+
+                if self._energy is not None:
+                    self._reciprocal_sampling = (
+                        angular_size / electron_wavelength_angstrom(self._energy) / 1e3,
+                    ) * 2
+                    self._reciprocal_units = ("A^-1",) * 2
+            else:
+                raise ValueError(
+                    (
+                        "Reciprocal-space calibrations must be given in 'A^-1' or 'mrad', "
+                        f"not {reciprocal_space_units}"
+                    )
                 )
-            )
 
         return intensities
 

From fb3383e153b52d992b348ce961b102e9bfcc976e Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Mon, 5 Jun 2023 15:04:52 -0400
Subject: [PATCH 204/362] bugfix and document previous commit

---
 py4DSTEM/preprocess/preprocess.py             |  8 +++++++-
 .../process/phase/iterative_base_class.py     |  6 +++---
 .../iterative_singleslice_ptychography.py     | 19 +++++++++++++++++++
 3 files changed, 29 insertions(+), 4 deletions(-)

diff --git a/py4DSTEM/preprocess/preprocess.py b/py4DSTEM/preprocess/preprocess.py
index 16dd64555..9bb52cd46 100644
--- a/py4DSTEM/preprocess/preprocess.py
+++ b/py4DSTEM/preprocess/preprocess.py
@@ -640,10 +640,16 @@ def resample_data_diffraction(
             )
             resampling_factor = resampling_factor[0]
 
+        old_size = datacube.data.shape
+
         datacube.data = fourier_resample(
             datacube.data, scale=resampling_factor, output_size=output_size
         )
-        datacube.calibration.set_Q_pixel_size(datacube.calibration.get_Q_pixel_size() / resampling_factor)
+
+        if not resampling_factor:
+            resampling_factor = old_size[2] / output_size[0]
+        if datacube.calibration.get_Q_pixel_size() is not None:
+            datacube.calibration.set_Q_pixel_size(datacube.calibration.get_Q_pixel_size() / resampling_factor)
 
     elif method == "bilinear":
         from scipy.ndimage import zoom
diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index 4acb85cd5..c383598b2 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -221,9 +221,9 @@ def _extract_intensities_and_calibrations_from_datacube(
         self,
         datacube: DataCube,
         require_calibrations: bool = False,
-        force_scan_sampling: Optional[float] = None,
-        force_angular_sampling: Optional[float] = None,
-        force_reciprocal_sampling: Optional[float] = None,
+        force_scan_sampling: float = None,
+        force_angular_sampling: float = None,
+        force_reciprocal_sampling: float = None,
     ):
         """
         Method to extract intensities and calibrations from datacube.
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index 3efe50810..cfac995fb 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -91,6 +91,7 @@ def __init__(
         energy: float,
         datacube: DataCube = None,
         semiangle_cutoff: float = None,
+        semiangle_cutoff_pixels: float = None,
         rolloff: float = 2.0,
         vacuum_probe_intensity: np.ndarray = None,
         polar_parameters: Mapping[str, float] = None,
@@ -156,6 +157,7 @@ def __init__(
         self._scan_positions = initial_scan_positions
         self._energy = energy
         self._semiangle_cutoff = semiangle_cutoff
+        self._semiangle_cutoff_pixels = semiangle_cutoff_pixels
         self._rolloff = rolloff
         self._object_type = object_type
         self._object_padding_px = object_padding_px
@@ -180,6 +182,9 @@ def preprocess(
         force_com_rotation: float = None,
         force_com_transpose: float = None,
         force_com_shifts: float = None,
+        force_scan_sampling: float = None,
+        force_angular_sampling: float = None,
+        force_reciprocal_sampling: float = None,
         object_fov_mask: np.ndarray = None,
         **kwargs,
     ):
@@ -229,6 +234,12 @@ def preprocess(
             Amplitudes come from diffraction patterns shifted with
             the CoM in the upper left corner for each probe unless
             shift is overwritten.
+        force_scan_sampling: float, optional
+            Override DataCube real space scan pixel size calibrations, in Angstrom
+        force_angular_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in mrad
+        force_reciprocal_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in A^-1
         object_fov_mask: np.ndarray (boolean)
             Boolean mask of FOV. Used to calculate additional shrinkage of object
             If None, probe_overlap intensity is thresholded
@@ -273,8 +284,16 @@ def preprocess(
         self._intensities = self._extract_intensities_and_calibrations_from_datacube(
             self._datacube,
             require_calibrations=True,
+            force_scan_sampling=force_scan_sampling,
+            force_angular_sampling=force_angular_sampling,
+            force_reciprocal_sampling=force_reciprocal_sampling,
         )
 
+        # handle semiangle specified in pixels
+        if self._semiangle_cutoff_pixels:
+            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
+
+
         (
             self._com_measured_x,
             self._com_measured_y,

From dfde3e5cc202c74be963bae67b8af1a9d47e8db0 Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Sat, 3 Jun 2023 12:13:26 -0400
Subject: [PATCH 205/362] backtracking in DPC

---
 py4DSTEM/process/phase/iterative_dpc.py | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index ca0cdf10d..334856a2f 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -603,6 +603,7 @@ def reconstruct(
         max_iter: int = 64,
         step_size: float = None,
         stopping_criterion: float = 1e-6,
+        backtrack: bool = True,
         progress_bar: bool = True,
         gaussian_filter_sigma: float = None,
         gaussian_filter_iter: int = np.inf,
@@ -667,6 +668,8 @@ def reconstruct(
             self._step_size = step_size if step_size is not None else 0.5
             self._padded_phase_object = self._padded_phase_object_initial.copy()
 
+        previous_iteration = self._padded_phase_object.copy()
+
         self.error = getattr(self, "error", np.inf)
 
         if step_size is None:
@@ -689,10 +692,19 @@ def reconstruct(
                 break
 
             # forward operator
-            com_dx, com_dy, self.error, self._step_size = self._forward(
+            com_dx, com_dy, new_error, self._step_size = self._forward(
                 self._padded_phase_object, mask, mask_inv, self.error, self._step_size
             )
 
+            # if the error went up after the previous step, go back to the step
+            # before the error rose and continue with the halved step size
+            if (new_error > self.error) and backtrack:
+                self._padded_phase_object = previous_iteration
+                print(f"Iteration {a0}, step reduced to {self._step_size}")
+                continue
+            self.error = new_error
+            previous_iteration = self._padded_phase_object.copy()
+
             # adjoint operator
             phase_update = self._adjoint(com_dx, com_dy, self._kx_op, self._ky_op)
 

From fc33b47f1138aa00effafa5cec16f465ea956657 Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Sat, 3 Jun 2023 12:16:40 -0400
Subject: [PATCH 206/362] DPC backtrack docs

---
 py4DSTEM/process/phase/iterative_dpc.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index 334856a2f..f511f4cd7 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -625,6 +625,10 @@ def reconstruct(
             Reconstruction update step size
         stopping_criterion: float, optional
             step_size below which reconstruction exits
+        backtrack: bool, optional
+            If True, steps that increase the error metric are rejected
+            and iteration continues with a reduced step size from the
+            previous iteration
         progress_bar: bool, optional
             If True, reconstruction progress bar will be printed
         gaussian_filter_sigma: float, optional

From feef290d7fa6d8796948a2c2ec2db03d0bc7659d Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <55254539+smribet@users.noreply.github.com>
Date: Wed, 7 Jun 2023 13:58:36 -0700
Subject: [PATCH 207/362] step size reorg

---
 py4DSTEM/process/phase/iterative_dpc.py | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index f511f4cd7..113a7ea4e 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -421,9 +421,6 @@ def _forward(
             xp.mean(self._com_x.ravel() ** 2 + self._com_y.ravel() ** 2)
         )
 
-        if new_error > error:
-            step_size /= 2
-
         return obj_dx, obj_dy, new_error, step_size
 
     def _adjoint(
@@ -671,9 +668,7 @@ def reconstruct(
             self.error = np.inf
             self._step_size = step_size if step_size is not None else 0.5
             self._padded_phase_object = self._padded_phase_object_initial.copy()
-
-        previous_iteration = self._padded_phase_object.copy()
-
+            
         self.error = getattr(self, "error", np.inf)
 
         if step_size is None:
@@ -694,7 +689,9 @@ def reconstruct(
         ):
             if self._step_size < stopping_criterion:
                 break
-
+                
+            previous_iteration = self._padded_phase_object.copy()
+            
             # forward operator
             com_dx, com_dy, new_error, self._step_size = self._forward(
                 self._padded_phase_object, mask, mask_inv, self.error, self._step_size
@@ -704,10 +701,10 @@ def reconstruct(
             # before the error rose and continue with the halved step size
             if (new_error > self.error) and backtrack:
                 self._padded_phase_object = previous_iteration
+                self._step_size /= 2
                 print(f"Iteration {a0}, step reduced to {self._step_size}")
                 continue
             self.error = new_error
-            previous_iteration = self._padded_phase_object.copy()
 
             # adjoint operator
             phase_update = self._adjoint(com_dx, com_dy, self._kx_op, self._ky_op)

From a099124ecfa3ce710e00176413cf2735e364ac4e Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Thu, 8 Jun 2023 10:04:25 -0700
Subject: [PATCH 208/362] anti gridding filter

---
 py4DSTEM/process/phase/iterative_dpc.py | 81 +++++++++++++++++++------
 1 file changed, 63 insertions(+), 18 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index 113a7ea4e..949ae0d45 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -338,13 +338,13 @@ def preprocess(
         padded_object_shape = np.round(
             np.array(self._grid_scan_shape) * padding_factor
         ).astype("int")
-        self._padded_phase_object = xp.zeros(padded_object_shape, dtype=xp.float32)
+        self._padded_object_phase = xp.zeros(padded_object_shape, dtype=xp.float32)
         if self._object_phase is not None:
-            self._padded_phase_object[
+            self._padded_object_phase[
                 : self._grid_scan_shape[0], : self._grid_scan_shape[1]
             ] = xp.asarray(self._object_phase, dtype=xp.float32)
 
-        self._padded_phase_object_initial = self._padded_phase_object.copy()
+        self._padded_object_phase_initial = self._padded_object_phase.copy()
 
         # Fourier coordinates and operators
         kx = xp.fft.fftfreq(padded_object_shape[0], d=self._scan_sampling[0])
@@ -479,7 +479,7 @@ def _update(
 
         Returns
         --------
-        updated_padded_phase_object: np.ndarray
+        updated_padded_object_phase: np.ndarray
             Updated padded phase object estimate
         """
 
@@ -548,6 +548,37 @@ def _object_butterworth_constraint(self, current_object, q_lowpass, q_highpass):
 
         return xp.real(current_object)
 
+    def _object_anti_gridding_contraint(self, current_object):
+        """
+        Zero outer pixels of object fft to remove gridding artifacts
+
+        Parameters
+        --------
+        current_object: np.ndarray
+            Current object estimate
+
+        Returns
+        --------
+        constrained_object: np.ndarray
+            Constrained object estimate
+        """
+        xp = self._xp
+
+        #find indices to zero accounting for object padding 
+        width_x = self._grid_scan_shape[0]
+        width_y = self._grid_scan_shape[1]
+        ind_min_x = int(xp.floor(width_x / 2) - 1)
+        ind_max_x = int(xp.ceil(width_x / 2) + 1)
+        ind_min_y = int(xp.floor(width_y / 2) - 1)
+        ind_max_y = int(xp.ceil(width_y / 2) + 1)
+
+        #zero pixels
+        object_fft = xp.fft.fft2(current_object)
+        object_fft[ind_min_x:-ind_max_x] = 0
+        object_fft[:, ind_min_y:-ind_max_y] = 0
+
+        return xp.real(xp.fft.ifft2(object_fft))
+
     def _constraints(
         self,
         current_object,
@@ -556,6 +587,7 @@ def _constraints(
         butterworth_filter,
         q_lowpass,
         q_highpass,
+        anti_gridding,
     ):
         """
         DPC constraints operator.
@@ -574,6 +606,9 @@ def _constraints(
             Cut-off frequency in A^-1 for low-pass butterworth filter
         q_highpass: float
             Cut-off frequency in A^-1 for high-pass butterworth filter
+        anti_gridding: bool
+            If true, zero outer pixels of object fft to remove
+            gridding artifacts
 
         Returns
         --------
@@ -592,6 +627,11 @@ def _constraints(
                 q_highpass,
             )
 
+        if anti_gridding:
+            current_object = self._object_anti_gridding_contraint(
+                current_object,
+            )
+
         return current_object
 
     def reconstruct(
@@ -607,6 +647,7 @@ def reconstruct(
         butterworth_filter_iter: int = np.inf,
         q_lowpass: float = None,
         q_highpass: float = None,
+        anti_gridding: float = True,
         store_iterations: bool = False,
     ):
         """
@@ -638,6 +679,9 @@ def reconstruct(
             Cut-off frequency in A^-1 for low-pass butterworth filter
         q_highpass: float
             Cut-off frequency in A^-1 for high-pass butterworth filter
+        anti_gridding: bool
+            If true, zero outer pixels of object fft to remove
+            gridding artifacts
         store_iterations: bool, optional
             If True, all reconstruction iterations will be stored
 
@@ -667,8 +711,8 @@ def reconstruct(
         if reset:
             self.error = np.inf
             self._step_size = step_size if step_size is not None else 0.5
-            self._padded_phase_object = self._padded_phase_object_initial.copy()
-            
+            self._padded_object_phase = self._padded_object_phase_initial.copy()
+
         self.error = getattr(self, "error", np.inf)
 
         if step_size is None:
@@ -676,7 +720,7 @@ def reconstruct(
         else:
             self._step_size = step_size
 
-        mask = xp.zeros(self._padded_phase_object.shape, dtype="bool")
+        mask = xp.zeros(self._padded_object_phase.shape, dtype="bool")
         mask[: self._grid_scan_shape[0], : self._grid_scan_shape[1]] = True
         mask_inv = xp.logical_not(mask)
 
@@ -689,18 +733,18 @@ def reconstruct(
         ):
             if self._step_size < stopping_criterion:
                 break
-                
-            previous_iteration = self._padded_phase_object.copy()
-            
+
+            previous_iteration = self._padded_object_phase.copy()
+
             # forward operator
             com_dx, com_dy, new_error, self._step_size = self._forward(
-                self._padded_phase_object, mask, mask_inv, self.error, self._step_size
+                self._padded_object_phase, mask, mask_inv, self.error, self._step_size
             )
 
             # if the error went up after the previous step, go back to the step
             # before the error rose and continue with the halved step size
             if (new_error > self.error) and backtrack:
-                self._padded_phase_object = previous_iteration
+                self._padded_object_phase = previous_iteration
                 self._step_size /= 2
                 print(f"Iteration {a0}, step reduced to {self._step_size}")
                 continue
@@ -710,13 +754,13 @@ def reconstruct(
             phase_update = self._adjoint(com_dx, com_dy, self._kx_op, self._ky_op)
 
             # update
-            self._padded_phase_object = self._update(
-                self._padded_phase_object, phase_update, self._step_size
+            self._padded_object_phase = self._update(
+                self._padded_object_phase, phase_update, self._step_size
             )
 
             # constraints
-            self._padded_phase_object = self._constraints(
-                self._padded_phase_object,
+            self._padded_object_phase = self._constraints(
+                self._padded_object_phase,
                 gaussian_filter=a0 < gaussian_filter_iter
                 and gaussian_filter_sigma is not None,
                 gaussian_filter_sigma=gaussian_filter_sigma,
@@ -724,12 +768,13 @@ def reconstruct(
                 and (q_lowpass is not None or q_highpass is not None),
                 q_lowpass=q_lowpass,
                 q_highpass=q_highpass,
+                anti_gridding=anti_gridding,
             )
 
             if store_iterations:
                 self.object_phase_iterations.append(
                     asnumpy(
-                        self._padded_phase_object[
+                        self._padded_object_phase[
                             : self._grid_scan_shape[0], : self._grid_scan_shape[1]
                         ].copy()
                     )
@@ -743,7 +788,7 @@ def reconstruct(
             )
 
         # crop result
-        self._object_phase = self._padded_phase_object[
+        self._object_phase = self._padded_object_phase[
             : self._grid_scan_shape[0], : self._grid_scan_shape[1]
         ]
         self.object_phase = asnumpy(self._object_phase)

From 395bb0c305d61b8ffde6c22935393fd0ca17a96e Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Thu, 8 Jun 2023 20:02:09 -0700
Subject: [PATCH 209/362] fix for anti gridding

---
 py4DSTEM/process/phase/iterative_dpc.py | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index 949ae0d45..dc29d9c6a 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -564,18 +564,18 @@ def _object_anti_gridding_contraint(self, current_object):
         """
         xp = self._xp
 
-        #find indices to zero accounting for object padding 
-        width_x = self._grid_scan_shape[0]
-        width_y = self._grid_scan_shape[1]
-        ind_min_x = int(xp.floor(width_x / 2) - 1)
-        ind_max_x = int(xp.ceil(width_x / 2) + 1)
-        ind_min_y = int(xp.floor(width_y / 2) - 1)
-        ind_max_y = int(xp.ceil(width_y / 2) + 1)
+        #find indices to zero 
+        width_x = current_object.shape[0]
+        width_y = current_object.shape[1]
+        ind_min_x = int(xp.floor(width_x / 2) - 2)
+        ind_max_x = int(xp.ceil(width_x / 2) + 2)
+        ind_min_y = int(xp.floor(width_y / 2) - 2)
+        ind_max_y = int(xp.ceil(width_y / 2) + 2)
 
         #zero pixels
         object_fft = xp.fft.fft2(current_object)
-        object_fft[ind_min_x:-ind_max_x] = 0
-        object_fft[:, ind_min_y:-ind_max_y] = 0
+        object_fft[ind_min_x:ind_max_x] = 0
+        object_fft[:, ind_min_y:ind_max_y] = 0
 
         return xp.real(xp.fft.ifft2(object_fft))
 

From 6ad9aa7912c57ea5e84603f2b953f9466aa095e5 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Sat, 10 Jun 2023 15:46:18 -0700
Subject: [PATCH 210/362] butterworth order

---
 .../process/phase/iterative_base_class.py     |  2 +-
 py4DSTEM/process/phase/iterative_dpc.py       | 22 ++++++++++++++-----
 .../iterative_multislice_ptychography.py      |  2 ++
 .../iterative_overlap_magnetic_tomography.py  | 22 ++++++++++++++++---
 .../phase/iterative_overlap_tomography.py     | 22 ++++++++++++++-----
 5 files changed, 56 insertions(+), 14 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index c383598b2..57049a83e 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -2225,6 +2225,6 @@ def positions(self):
 
     @property
     def _object_cropped(self):
-        """ cropped and rotated object """
+        """cropped and rotated object"""
 
         return self._crop_rotate_object_fov(self._object)
diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index dc29d9c6a..0c5fbb7a9 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -510,7 +510,9 @@ def _object_gaussian_constraint(self, current_object, gaussian_filter_sigma):
 
         return current_object
 
-    def _object_butterworth_constraint(self, current_object, q_lowpass, q_highpass):
+    def _object_butterworth_constraint(
+        self, current_object, q_lowpass, q_highpass, butterworth_order
+    ):
         """
         Butterworth filter used for low/high-pass filtering.
 
@@ -522,6 +524,8 @@ def _object_butterworth_constraint(self, current_object, q_lowpass, q_highpass):
             Cut-off frequency in A^-1 for low-pass butterworth filter
         q_highpass: float
             Cut-off frequency in A^-1 for high-pass butterworth filter
+        butterworth_order: float
+            Butterworth filter order. Smaller gives a smoother filter
 
         Returns
         --------
@@ -537,9 +541,9 @@ def _object_butterworth_constraint(self, current_object, q_lowpass, q_highpass):
 
         env = xp.ones_like(qra)
         if q_highpass:
-            env *= 1 - 1 / (1 + (qra / q_highpass) ** 4)
+            env *= 1 - 1 / (1 + (qra / q_highpass) ** butterworth_order)
         if q_lowpass:
-            env *= 1 / (1 + (qra / q_lowpass) ** 4)
+            env *= 1 / (1 + (qra / q_lowpass) ** butterworth_order)
 
         current_object_mean = xp.mean(current_object)
         current_object -= current_object_mean
@@ -564,7 +568,7 @@ def _object_anti_gridding_contraint(self, current_object):
         """
         xp = self._xp
 
-        #find indices to zero 
+        # find indices to zero
         width_x = current_object.shape[0]
         width_y = current_object.shape[1]
         ind_min_x = int(xp.floor(width_x / 2) - 2)
@@ -572,7 +576,7 @@ def _object_anti_gridding_contraint(self, current_object):
         ind_min_y = int(xp.floor(width_y / 2) - 2)
         ind_max_y = int(xp.ceil(width_y / 2) + 2)
 
-        #zero pixels
+        # zero pixels
         object_fft = xp.fft.fft2(current_object)
         object_fft[ind_min_x:ind_max_x] = 0
         object_fft[:, ind_min_y:ind_max_y] = 0
@@ -587,6 +591,7 @@ def _constraints(
         butterworth_filter,
         q_lowpass,
         q_highpass,
+        butterworth_order,
         anti_gridding,
     ):
         """
@@ -606,6 +611,8 @@ def _constraints(
             Cut-off frequency in A^-1 for low-pass butterworth filter
         q_highpass: float
             Cut-off frequency in A^-1 for high-pass butterworth filter
+        butterworth_order: float
+            Butterworth filter order. Smaller gives a smoother filter
         anti_gridding: bool
             If true, zero outer pixels of object fft to remove
             gridding artifacts
@@ -625,6 +632,7 @@ def _constraints(
                 current_object,
                 q_lowpass,
                 q_highpass,
+                butterworth_order,
             )
 
         if anti_gridding:
@@ -647,6 +655,7 @@ def reconstruct(
         butterworth_filter_iter: int = np.inf,
         q_lowpass: float = None,
         q_highpass: float = None,
+        butterworth_order: float = 2,
         anti_gridding: float = True,
         store_iterations: bool = False,
     ):
@@ -679,6 +688,8 @@ def reconstruct(
             Cut-off frequency in A^-1 for low-pass butterworth filter
         q_highpass: float
             Cut-off frequency in A^-1 for high-pass butterworth filter
+        butterworth_order: float
+            Butterworth filter order. Smaller gives a smoother filter
         anti_gridding: bool
             If true, zero outer pixels of object fft to remove
             gridding artifacts
@@ -768,6 +779,7 @@ def reconstruct(
                 and (q_lowpass is not None or q_highpass is not None),
                 q_lowpass=q_lowpass,
                 q_highpass=q_highpass,
+                butterworth_order=butterworth_order,
                 anti_gridding=anti_gridding,
             )
 
diff --git a/py4DSTEM/process/phase/iterative_multislice_ptychography.py b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
index a7fe53589..58f7152c4 100644
--- a/py4DSTEM/process/phase/iterative_multislice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
@@ -1331,6 +1331,8 @@ def _object_butterworth_constraint(
             Cut-off frequency in A^-1 for low-pass butterworth filter
         q_highpass: float
             Cut-off frequency in A^-1 for high-pass butterworth filter
+        butterworth_order: float
+            Butterworth filter order. Smaller gives a smoother filter
 
         Returns
         --------
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 2c413c5d2..b74000b14 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -1591,7 +1591,9 @@ def _object_gaussian_constraint(self, current_object, gaussian_filter_sigma):
 
         return current_object
 
-    def _object_butterworth_constraint(self, current_object, q_lowpass, q_highpass):
+    def _object_butterworth_constraint(
+        self, current_object, q_lowpass, q_highpass, butterworth_order
+    ):
         """
         Butterworth filter
 
@@ -1603,6 +1605,8 @@ def _object_butterworth_constraint(self, current_object, q_lowpass, q_highpass):
             Cut-off frequency in A^-1 for low-pass butterworth filter
         q_highpass: float
             Cut-off frequency in A^-1 for high-pass butterworth filter
+        butterworth_order: float
+            Butterworth filter order. Smaller gives a smoother filter
 
         Returns
         --------
@@ -1618,9 +1622,9 @@ def _object_butterworth_constraint(self, current_object, q_lowpass, q_highpass):
 
         env = xp.ones_like(qra)
         if q_highpass:
-            env *= 1 - 1 / (1 + (qra / q_highpass) ** 4)
+            env *= 1 - 1 / (1 + (qra / q_highpass) ** butterworth_order)
         if q_lowpass:
-            env *= 1 / (1 + (qra / q_lowpass) ** 4)
+            env *= 1 / (1 + (qra / q_lowpass) ** butterworth_order)
 
         current_object_mean = xp.mean(current_object)
         current_object -= current_object_mean
@@ -1677,6 +1681,7 @@ def _constraints(
         q_lowpass_m,
         q_highpass_e,
         q_highpass_m,
+        butterworth_order,
         object_positivity,
         shrinkage_rad,
         object_mask,
@@ -1732,6 +1737,8 @@ def _constraints(
             Cut-off frequency in A^-1 for high-pass filtering electrostatic object
         q_highpass_m: float
             Cut-off frequency in A^-1 for high-pass filtering magnetic object
+        butterworth_order: float
+            Butterworth filter order. Smaller gives a smoother filter
         object_positivity: bool
             If True, forces object to be positive
         shrinkage_rad: float
@@ -1766,21 +1773,25 @@ def _constraints(
                 current_object[0],
                 q_lowpass_e,
                 q_highpass_e,
+                butterworth_order,
             )
             current_object[1] = self._object_butterworth_constraint(
                 current_object[1],
                 q_lowpass_m,
                 q_highpass_m,
+                butterworth_order,
             )
             current_object[2] = self._object_butterworth_constraint(
                 current_object[2],
                 q_lowpass_m,
                 q_highpass_m,
+                butterworth_order,
             )
             current_object[3] = self._object_butterworth_constraint(
                 current_object[3],
                 q_lowpass_m,
                 q_highpass_m,
+                butterworth_order,
             )
 
         if shrinkage_rad > 0.0 or object_mask is not None:
@@ -1863,6 +1874,7 @@ def reconstruct(
         q_lowpass_m: float = None,
         q_highpass_e: float = None,
         q_highpass_m: float = None,
+        butterworth_order: float = 2,
         object_positivity: bool = True,
         shrinkage_rad: float = 0.0,
         fix_potential_baseline: bool = True,
@@ -1942,6 +1954,8 @@ def reconstruct(
             Cut-off frequency in A^-1 for low-pass butterworth filter
         q_highpass: float
             Cut-off frequency in A^-1 for high-pass butterworth filter
+        butterworth_order: float
+            Butterworth filter order. Smaller gives a smoother filter
         object_positivity: bool, optional
             If True, forces object to be positive
         shrinkage_rad: float
@@ -2408,6 +2422,7 @@ def reconstruct(
                         q_lowpass_m=q_lowpass_m,
                         q_highpass_e=q_highpass_e,
                         q_highpass_m=q_highpass_m,
+                        butterworth_order=butterworth_order,
                         object_positivity=object_positivity,
                         shrinkage_rad=shrinkage_rad,
                         object_mask=self._object_fov_mask_inverse
@@ -2454,6 +2469,7 @@ def reconstruct(
                     q_lowpass_m=q_lowpass_m,
                     q_highpass_e=q_highpass_e,
                     q_highpass_m=q_highpass_m,
+                    butterworth_order=butterworth_order,
                     object_positivity=object_positivity,
                     shrinkage_rad=shrinkage_rad,
                     object_mask=self._object_fov_mask_inverse
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index 3337d02cc..c005081b2 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -1492,13 +1492,15 @@ def _object_gaussian_constraint(self, current_object, gaussian_filter_sigma):
         """
         gaussian_filter = self._gaussian_filter
         xp = self._xp
-        gaussian_filter_sigma /= xp.sqrt(self.sampling[0] ** 2 + self.sampling[1] ** 2)
 
+        gaussian_filter_sigma /= xp.sqrt(self.sampling[0] ** 2 + self.sampling[1] ** 2)
         current_object = gaussian_filter(current_object, gaussian_filter_sigma)
 
         return current_object
 
-    def _object_butterworth_constraint(self, current_object, q_lowpass, q_highpass):
+    def _object_butterworth_constraint(
+        self, current_object, q_lowpass, q_highpass, butterworth_order
+    ):
         """
         Butterworth filter
 
@@ -1510,7 +1512,8 @@ def _object_butterworth_constraint(self, current_object, q_lowpass, q_highpass):
             Cut-off frequency in A^-1 for low-pass butterworth filter
         q_highpass: float
             Cut-off frequency in A^-1 for high-pass butterworth filter
-
+        butterworth_order: float
+            Butterworth filter order. Smaller gives a smoother filter
         Returns
         --------
         constrained_object: np.ndarray
@@ -1525,9 +1528,9 @@ def _object_butterworth_constraint(self, current_object, q_lowpass, q_highpass):
 
         env = xp.ones_like(qra)
         if q_highpass:
-            env *= 1 - 1 / (1 + (qra / q_highpass) ** 4)
+            env *= 1 - 1 / (1 + (qra / q_highpass) ** butterworth_order)
         if q_lowpass:
-            env *= 1 / (1 + (qra / q_lowpass) ** 4)
+            env *= 1 / (1 + (qra / q_lowpass) ** butterworth_order)
 
         current_object_mean = xp.mean(current_object)
         current_object -= current_object_mean
@@ -1557,6 +1560,7 @@ def _constraints(
         butterworth_filter,
         q_lowpass,
         q_highpass,
+        butterworth_order,
         object_positivity,
         shrinkage_rad,
         object_mask,
@@ -1605,6 +1609,8 @@ def _constraints(
             Cut-off frequency in A^-1 for low-pass butterworth filter
         q_highpass: float
             Cut-off frequency in A^-1 for high-pass butterworth filter
+        butterworth_order: float
+            Butterworth filter order. Smaller gives a smoother filter
         object_positivity: bool
             If True, forces object to be positive
         shrinkage_rad: float
@@ -1632,6 +1638,7 @@ def _constraints(
                 current_object,
                 q_lowpass,
                 q_highpass,
+                butterworth_order,
             )
 
         if shrinkage_rad > 0.0 or object_mask is not None:
@@ -1711,6 +1718,7 @@ def reconstruct(
         butterworth_filter_iter: int = np.inf,
         q_lowpass: float = None,
         q_highpass: float = None,
+        butterworth_order: float = 2,
         object_positivity: bool = True,
         shrinkage_rad: float = 0.0,
         fix_potential_baseline: bool = True,
@@ -1788,6 +1796,8 @@ def reconstruct(
             Cut-off frequency in A^-1 for low-pass butterworth filter
         q_highpass: float
             Cut-off frequency in A^-1 for high-pass butterworth filter
+        butterworth_order: float
+            Butterworth filter order. Smaller gives a smoother filter
         object_positivity: bool, optional
             If True, forces object to be positive
         shrinkage_rad: float
@@ -2172,6 +2182,7 @@ def reconstruct(
                         and (q_lowpass is not None or q_highpass is not None),
                         q_lowpass=q_lowpass,
                         q_highpass=q_highpass,
+                        butterworth_order=butterworth_order,
                         object_positivity=object_positivity,
                         shrinkage_rad=shrinkage_rad,
                         object_mask=self._object_fov_mask_inverse
@@ -2213,6 +2224,7 @@ def reconstruct(
                     and (q_lowpass is not None or q_highpass is not None),
                     q_lowpass=q_lowpass,
                     q_highpass=q_highpass,
+                    butterworth_order=butterworth_order,
                     object_positivity=object_positivity,
                     shrinkage_rad=shrinkage_rad,
                     object_mask=self._object_fov_mask_inverse

From 95b9c21391b4bca1b33541d6dab873570b3915e8 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Sun, 11 Jun 2023 11:29:28 -0700
Subject: [PATCH 211/362] fixing small butterworth order bug

---
 py4DSTEM/process/phase/iterative_dpc.py                |  4 ++--
 .../phase/iterative_overlap_magnetic_tomography.py     | 10 +++++++---
 py4DSTEM/process/phase/iterative_overlap_tomography.py | 10 +++++++---
 3 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index 0c5fbb7a9..494f661aa 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -541,9 +541,9 @@ def _object_butterworth_constraint(
 
         env = xp.ones_like(qra)
         if q_highpass:
-            env *= 1 - 1 / (1 + (qra / q_highpass) ** butterworth_order)
+            env *= 1 - 1 / (1 + (qra / q_highpass) ** (2 * butterworth_order))
         if q_lowpass:
-            env *= 1 / (1 + (qra / q_lowpass) ** butterworth_order)
+            env *= 1 / (1 + (qra / q_lowpass) ** (2 * butterworth_order))
 
         current_object_mean = xp.mean(current_object)
         current_object -= current_object_mean
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index b74000b14..0eb7fb924 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -1622,9 +1622,9 @@ def _object_butterworth_constraint(
 
         env = xp.ones_like(qra)
         if q_highpass:
-            env *= 1 - 1 / (1 + (qra / q_highpass) ** butterworth_order)
+            env *= 1 - 1 / (1 + (qra / q_highpass) ** (2 * butterworth_order))
         if q_lowpass:
-            env *= 1 / (1 + (qra / q_lowpass) ** butterworth_order)
+            env *= 1 / (1 + (qra / q_lowpass) ** (2 * butterworth_order))
 
         current_object_mean = xp.mean(current_object)
         current_object -= current_object_mean
@@ -2439,7 +2439,11 @@ def reconstruct(
             if collective_tilt_updates:
                 self._object += collective_object / self._num_tilts
 
-                (self._object, self._probe, _,) = self._constraints(
+                (
+                    self._object,
+                    self._probe,
+                    _,
+                ) = self._constraints(
                     self._object,
                     self._probe,
                     None,
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index c005081b2..6c773b269 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -1528,9 +1528,9 @@ def _object_butterworth_constraint(
 
         env = xp.ones_like(qra)
         if q_highpass:
-            env *= 1 - 1 / (1 + (qra / q_highpass) ** butterworth_order)
+            env *= 1 - 1 / (1 + (qra / q_highpass) ** (2 * butterworth_order))
         if q_lowpass:
-            env *= 1 / (1 + (qra / q_lowpass) ** butterworth_order)
+            env *= 1 / (1 + (qra / q_lowpass) ** (2 * butterworth_order))
 
         current_object_mean = xp.mean(current_object)
         current_object -= current_object_mean
@@ -2197,7 +2197,11 @@ def reconstruct(
             if collective_tilt_updates:
                 self._object += collective_object / self._num_tilts
 
-                (self._object, self._probe, _,) = self._constraints(
+                (
+                    self._object,
+                    self._probe,
+                    _,
+                ) = self._constraints(
                     self._object,
                     self._probe,
                     None,

From e1fe3d36316bbf8e202399ec647b0a841d128613 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Sun, 11 Jun 2023 14:13:09 -0700
Subject: [PATCH 212/362] nesterov acceleration prefactors for reference.
 currently unused - see comment on PR #443

---
 py4DSTEM/process/phase/utils.py | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/py4DSTEM/process/phase/utils.py b/py4DSTEM/process/phase/utils.py
index 5bc44d95a..50d8a792a 100644
--- a/py4DSTEM/process/phase/utils.py
+++ b/py4DSTEM/process/phase/utils.py
@@ -2,6 +2,7 @@
 
 import matplotlib.pyplot as plt
 import numpy as np
+import functools
 
 try:
     import cupy as cp
@@ -1287,3 +1288,16 @@ def project_vector_field_divergence(vector_field, spacings=(1, 1, 1), xp=np):
     p = preconditioned_poisson_solver(div_v, spacings[0], xp=xp)
     grad_p = compute_gradient(p, spacings, xp=xp)
     return vector_field - grad_p
+
+# Nesterov acceleration functions
+# https://blogs.princeton.edu/imabandit/2013/04/01/acceleratedgradientdescent/
+
+@functools.cache
+def nesterov_lambda(one_indexed_iter_num):
+    if one_indexed_iter_num == 0:
+        return 0
+    return (1+np.sqrt(1+4*nesterov_lambda(one_indexed_iter_num-1)**2))/2
+
+def nesterov_gamma(zero_indexed_iter_num):
+    one_indexed_iter_num = zero_indexed_iter_num + 1
+    return (1-nesterov_lambda(one_indexed_iter_num))/nesterov_lambda(one_indexed_iter_num+1)

From 9fb8900d7472902294654c29295dce7183db86aa Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Wed, 14 Jun 2023 08:42:58 -0700
Subject: [PATCH 213/362] step size default update

---
 py4DSTEM/process/phase/iterative_mixedstate_ptychography.py     | 2 +-
 py4DSTEM/process/phase/iterative_multislice_ptychography.py     | 2 +-
 py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py | 2 +-
 py4DSTEM/process/phase/iterative_overlap_tomography.py          | 2 +-
 py4DSTEM/process/phase/iterative_simultaneous_ptychography.py   | 2 +-
 py4DSTEM/process/phase/iterative_singleslice_ptychography.py    | 2 +-
 6 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
index d09b5a339..ff32f5b49 100644
--- a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
@@ -1226,7 +1226,7 @@ def reconstruct(
         reconstruction_parameter: float = 1.0,
         max_batch_size: int = None,
         seed_random: int = None,
-        step_size: float = 0.9,
+        step_size: float = 0.5,
         normalization_min: float = 1,
         positions_step_size: float = 0.9,
         pure_phase_object_iter: int = 0,
diff --git a/py4DSTEM/process/phase/iterative_multislice_ptychography.py b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
index 58f7152c4..c0e73e13b 100644
--- a/py4DSTEM/process/phase/iterative_multislice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
@@ -1623,7 +1623,7 @@ def reconstruct(
         reconstruction_parameter: float = 1.0,
         max_batch_size: int = None,
         seed_random: int = None,
-        step_size: float = 0.9,
+        step_size: float = 0.5,
         normalization_min: float = 1,
         positions_step_size: float = 0.9,
         fix_com: bool = True,
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 0eb7fb924..67deaaa4f 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -1849,7 +1849,7 @@ def reconstruct(
         reconstruction_parameter: float = 1.0,
         max_batch_size: int = None,
         seed_random: int = None,
-        step_size: float = 0.9,
+        step_size: float = 0.5,
         normalization_min: float = 1,
         positions_step_size: float = 0.9,
         fix_com: bool = True,
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index 6c773b269..36d32fba7 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -1696,7 +1696,7 @@ def reconstruct(
         reconstruction_parameter: float = 1.0,
         max_batch_size: int = None,
         seed_random: int = None,
-        step_size: float = 0.9,
+        step_size: float = 0.5,
         normalization_min: float = 1,
         positions_step_size: float = 0.9,
         fix_com: bool = True,
diff --git a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
index c655b82a1..c2a6f047f 100644
--- a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
@@ -2398,7 +2398,7 @@ def reconstruct(
         reconstruction_parameter: float = 1.0,
         max_batch_size: int = None,
         seed_random: int = None,
-        step_size: float = 0.9,
+        step_size: float = 0.5,
         normalization_min: float = 1,
         positions_step_size: float = 0.9,
         pure_phase_object_iter: int = 0,
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index cfac995fb..02ad967c9 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -1157,7 +1157,7 @@ def reconstruct(
         reconstruction_parameter: float = 1.0,
         max_batch_size: int = None,
         seed_random: int = None,
-        step_size: float = 0.9,
+        step_size: float = 0.5,
         normalization_min: float = 1,
         positions_step_size: float = 0.9,
         pure_phase_object_iter: int = 0,

From e14a547a35e47daaa67f10a23e48657712dae139 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Wed, 14 Jun 2023 09:59:34 -0700
Subject: [PATCH 214/362] changing gaussian sigma normalization

---
 py4DSTEM/process/phase/iterative_dpc.py                     | 2 +-
 .../process/phase/iterative_overlap_magnetic_tomography.py  | 2 +-
 py4DSTEM/process/phase/iterative_overlap_tomography.py      | 2 +-
 .../process/phase/iterative_ptychographic_constraints.py    | 6 ++----
 4 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index 494f661aa..e6f7659bd 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -505,7 +505,7 @@ def _object_gaussian_constraint(self, current_object, gaussian_filter_sigma):
         xp = self._xp
         gaussian_filter = self._gaussian_filter
 
-        gaussian_filter_sigma /= xp.sqrt(self.sampling[0] ** 2 + self.sampling[1] ** 2)
+        gaussian_filter_sigma /= self.sampling[0]
         current_object = gaussian_filter(current_object, gaussian_filter_sigma)
 
         return current_object
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 67deaaa4f..478e3fe60 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -1586,7 +1586,7 @@ def _object_gaussian_constraint(self, current_object, gaussian_filter_sigma):
         gaussian_filter = self._gaussian_filter
         xp = self._xp
 
-        gaussian_filter_sigma /= xp.sqrt(self.sampling[0] ** 2 + self.sampling[1] ** 2)
+        gaussian_filter_sigma /= self.sampling[0]
         current_object = gaussian_filter(current_object, gaussian_filter_sigma)
 
         return current_object
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index 36d32fba7..ac98738dc 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -1493,7 +1493,7 @@ def _object_gaussian_constraint(self, current_object, gaussian_filter_sigma):
         gaussian_filter = self._gaussian_filter
         xp = self._xp
 
-        gaussian_filter_sigma /= xp.sqrt(self.sampling[0] ** 2 + self.sampling[1] ** 2)
+        gaussian_filter_sigma /= self.sampling[0]
         current_object = gaussian_filter(current_object, gaussian_filter_sigma)
 
         return current_object
diff --git a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
index d0a637204..2abad3d45 100644
--- a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
+++ b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
@@ -120,7 +120,7 @@ def _object_gaussian_constraint(
         """
         xp = self._xp
         gaussian_filter = self._gaussian_filter
-        gaussian_filter_sigma /= xp.sqrt(self.sampling[0] ** 2 + self.sampling[1] ** 2)
+        gaussian_filter_sigma /= self.sampling[0]
 
         if pure_phase_object:
             phase = xp.angle(current_object)
@@ -518,9 +518,7 @@ def _probe_residual_aberration_filtering_constraint(
         xp = self._xp
         gaussian_filter = self._gaussian_filter
         known_aberrations_array = self._known_aberrations_array
-        gaussian_filter_sigma /= xp.sqrt(
-            self._reciprocal_sampling[0] ** 2 + self._reciprocal_sampling[1] ** 2
-        )
+        gaussian_filter_sigma /= self._reciprocal_sampling[0]
 
         fourier_probe = self._return_fourier_probe(current_probe)
         if fix_amplitude:

From 5b1fdb2b7ec7640d46e2fab8707fe333c79d5304 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Wed, 14 Jun 2023 10:06:49 -0700
Subject: [PATCH 215/362] small device specification cleanup

---
 py4DSTEM/process/phase/iterative_parallax.py                  | 3 ++-
 py4DSTEM/process/phase/iterative_ptychographic_constraints.py | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_parallax.py b/py4DSTEM/process/phase/iterative_parallax.py
index 94f32ad12..5ab4c6cdd 100644
--- a/py4DSTEM/process/phase/iterative_parallax.py
+++ b/py4DSTEM/process/phase/iterative_parallax.py
@@ -79,6 +79,7 @@ def __init__(
         # Metadata
         self._energy = energy
         self._verbose = verbose
+        self._device = device
         self._object_padding_px = object_padding_px
         self._preprocessed = False
 
@@ -725,7 +726,7 @@ def reconstruct(
                     G_ref,
                     G,
                     upsample_factor=upsample_factor,
-                    device="cpu" if xp is np else "gpu",
+                    device=self._device,
                 )
 
                 dx = (
diff --git a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
index 2abad3d45..790edaa69 100644
--- a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
+++ b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
@@ -333,7 +333,7 @@ def _probe_center_of_mass_constraint(self, current_probe):
         probe_intensity = xp.abs(current_probe) ** 2
 
         probe_x0, probe_y0 = get_CoM(
-            probe_intensity, device="cpu" if xp is np else "gpu"
+            probe_intensity, device=self._device
         )
         shifted_probe = fft_shift(
             current_probe, probe_center - xp.array([probe_x0, probe_y0]), xp

From 3b0c6a459a6094496d466fdb5306f6fa62991529 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Fri, 16 Jun 2023 14:45:14 -0700
Subject: [PATCH 216/362] switching to corner-centered probes

---
 py4DSTEM/process/phase/__init__.py            |  28 +--
 .../process/phase/iterative_base_class.py     | 181 ++++++++----------
 .../iterative_ptychographic_constraints.py    |  36 ++--
 .../iterative_singleslice_ptychography.py     |  88 +++++----
 py4DSTEM/process/phase/utils.py               |  63 +++---
 py4DSTEM/process/utils/utils.py               |  15 +-
 6 files changed, 197 insertions(+), 214 deletions(-)

diff --git a/py4DSTEM/process/phase/__init__.py b/py4DSTEM/process/phase/__init__.py
index c2e141399..207e44b56 100644
--- a/py4DSTEM/process/phase/__init__.py
+++ b/py4DSTEM/process/phase/__init__.py
@@ -1,22 +1,14 @@
+# fmt: off
+
 _emd_hook = True
 
 from py4DSTEM.process.phase.iterative_dpc import DPCReconstruction
-from py4DSTEM.process.phase.iterative_mixedstate_ptychography import (
-    MixedstatePtychographicReconstruction,
-)
-from py4DSTEM.process.phase.iterative_multislice_ptychography import (
-    MultislicePtychographicReconstruction,
-)
-from py4DSTEM.process.phase.iterative_overlap_magnetic_tomography import (
-    OverlapMagneticTomographicReconstruction,
-)
-from py4DSTEM.process.phase.iterative_overlap_tomography import (
-    OverlapTomographicReconstruction,
-)
+from py4DSTEM.process.phase.iterative_mixedstate_ptychography import MixedstatePtychographicReconstruction
+from py4DSTEM.process.phase.iterative_multislice_ptychography import MultislicePtychographicReconstruction
+from py4DSTEM.process.phase.iterative_overlap_magnetic_tomography import OverlapMagneticTomographicReconstruction
+from py4DSTEM.process.phase.iterative_overlap_tomography import OverlapTomographicReconstruction
 from py4DSTEM.process.phase.iterative_parallax import ParallaxReconstruction
-from py4DSTEM.process.phase.iterative_simultaneous_ptychography import (
-    SimultaneousPtychographicReconstruction,
-)
-from py4DSTEM.process.phase.iterative_singleslice_ptychography import (
-    SingleslicePtychographicReconstruction,
-)
+from py4DSTEM.process.phase.iterative_simultaneous_ptychography import SimultaneousPtychographicReconstruction
+from py4DSTEM.process.phase.iterative_singleslice_ptychography import SingleslicePtychographicReconstruction
+
+# fmt: on
diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index 57049a83e..6bb429a64 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -144,6 +144,13 @@ def _preprocess_datacube_and_vacuum_probe(
             Resampled and Padded datacube
         """
 
+        if com_shifts is not None:
+            if np.isscalar(com_shifts[0]):
+                com_shifts = (
+                    np.ones(self._datacube.Rshape) * com_shifts[0],
+                    np.ones(self._datacube.Rshape) * com_shifts[1],
+                )
+
         if diffraction_intensities_shape is not None:
             Qx, Qy = datacube.shape[-2:]
             Sx, Sy = diffraction_intensities_shape
@@ -571,7 +578,7 @@ def _solve_for_center_of_mass_relative_rotation(
                 warnings.warn(
                     (
                         "Best fit rotation forced to "
-                        f"{str(np.round(force_com_rotation))} degrees."
+                        f"{force_com_rotation:.0f} degrees."
                     ),
                     UserWarning,
                 )
@@ -741,12 +748,7 @@ def _solve_for_center_of_mass_relative_rotation(
                         _rotation_best_rad = rotation_angles_rad[ind_min]
 
                 if self._verbose:
-                    print(
-                        (
-                            "Best fit rotation = "
-                            f"{str(np.round(rotation_best_deg))} degrees."
-                        )
-                    )
+                    print(("Best fit rotation = " f"{rotation_best_deg:.0f} degrees."))
 
                 if plot_rotation:
                     figsize = kwargs.get("figsize", (8, 2))
@@ -901,12 +903,7 @@ def _solve_for_center_of_mass_relative_rotation(
                 self._rotation_angles_deg = rotation_angles_deg
                 # Print summary
                 if self._verbose:
-                    print(
-                        (
-                            "Best fit rotation = "
-                            f"{str(np.round(rotation_best_deg))} degrees."
-                        )
-                    )
+                    print(("Best fit rotation = " f"{rotation_best_deg:.0f} degrees."))
                     if _rotation_best_transpose:
                         print("Diffraction intensities should be transposed.")
                     else:
@@ -1373,11 +1370,6 @@ def _set_polar_parameters(self, parameters: dict):
         ----------
         parameters: dict
             Mapping from aberration symbols to their corresponding values.
-
-        Mutates
-        -------
-        self._polar_parameters: dict
-            Updated polar aberrations dictionary
         """
 
         for symbol, value in parameters.items():
@@ -1403,11 +1395,6 @@ def _calculate_scan_positions_in_pixels(self, positions: np.ndarray):
             Input probe positions in Å.
             If None, a raster scan using experimental parameters is constructed.
 
-        Mutates
-        -------
-        self._object_padding_px: np.ndarray
-            Object array padding in pixels
-
         Returns
         -------
         positions_in_px: (J,2) np.ndarray
@@ -1456,74 +1443,17 @@ def _calculate_scan_positions_in_pixels(self, positions: np.ndarray):
         positions -= np.min(positions, axis=0)
 
         if self._object_padding_px is None:
-            self._object_padding_px = self._region_of_interest_shape / 2
-        positions += self._object_padding_px
+            float_padding = self._region_of_interest_shape / 2
+            self._object_padding_px = (float_padding, float_padding)
+        positions[:, 0] += self._object_padding_px[0][0]
+        positions[:, 1] += self._object_padding_px[1][0]
 
         return positions
 
-    def _wrapped_indices_2D_window(
-        self,
-        center_position: np.ndarray,
-        window_shape: Sequence[int],
-        array_shape: Sequence[int],
-    ):
-        """
-        Computes periodic indices for a window_shape probe centered at center_position,
-        in object of size array_shape.
-
-        Parameters
-        ----------
-        center_position: (2,) np.ndarray
-            The window center positions in pixels
-        window_shape: (2,) Sequence[int]
-            The pixel dimensions of the window
-        array_shape: (2,) Sequence[int]
-            The pixel dimensions of the array the window will be embedded in
-
-        Returns
-        -------
-        window_indices: length-2 tuple of
-            The 2D indices of the window
-        """
-
-        asnumpy = self._asnumpy
-        sx, sy = array_shape
-        nx, ny = window_shape
-
-        cx, cy = np.round(asnumpy(center_position)).astype(int)
-        ox, oy = (cx - nx // 2, cy - ny // 2)
-
-        return np.ix_(np.arange(ox, ox + nx) % sx, np.arange(oy, oy + ny) % sy)
-
-    def _sum_overlapping_patches(self, patches: np.ndarray):
-        """
-        Sum overlapping patches defined into object shaped array
-
-        Parameters
-        ----------
-        patches: (Rx*Ry,Sx,Sy) np.ndarray
-            Patches to sum
-
-        Returns
-        -------
-        out_array: (Px,Py) np.ndarray
-            Summed array
-        """
-        xp = self._xp
-        positions = self._positions_px
-        patch_shape = self._region_of_interest_shape
-        array_shape = self._object_shape
-
-        out_array = xp.zeros(array_shape, patches.dtype)
-        for ind, pos in enumerate(positions):
-            indices = self._wrapped_indices_2D_window(pos, patch_shape, array_shape)
-            out_array[indices] += patches[ind]
-
-        return out_array
-
     def _sum_overlapping_patches_bincounts_base(self, patches: np.ndarray):
         """
         Base bincouts overlapping patches sum function, operating on real-valued arrays.
+        Note this assumes the probe is corner-centered.
 
         Parameters
         ----------
@@ -1540,8 +1470,8 @@ def _sum_overlapping_patches_bincounts_base(self, patches: np.ndarray):
         y0 = xp.round(self._positions_px[:, 1]).astype("int")
 
         roi_shape = self._region_of_interest_shape
-        x_ind = xp.round(xp.arange(roi_shape[0]) - roi_shape[0] / 2).astype("int")
-        y_ind = xp.round(xp.arange(roi_shape[1]) - roi_shape[1] / 2).astype("int")
+        x_ind = xp.fft.fftfreq(roi_shape[0], d=1 / roi_shape[0]).astype("int")
+        y_ind = xp.fft.fftfreq(roi_shape[1], d=1 / roi_shape[1]).astype("int")
 
         flat_weights = patches.ravel()
         indices = (
@@ -1583,6 +1513,7 @@ def _sum_overlapping_patches_bincounts(self, patches: np.ndarray):
     def _extract_vectorized_patch_indices(self):
         """
         Sets the vectorized row/col indices used for the overlap projection
+        Note this assumes the probe is corner-centered.
 
         Returns
         -------
@@ -1596,8 +1527,8 @@ def _extract_vectorized_patch_indices(self):
         y0 = xp.round(self._positions_px[:, 1]).astype("int")
 
         roi_shape = self._region_of_interest_shape
-        x_ind = xp.round(xp.arange(roi_shape[0]) - roi_shape[0] / 2).astype("int")
-        y_ind = xp.round(xp.arange(roi_shape[1]) - roi_shape[1] / 2).astype("int")
+        x_ind = xp.fft.fftfreq(roi_shape[0], d=1 / roi_shape[0]).astype("int")
+        y_ind = xp.fft.fftfreq(roi_shape[1], d=1 / roi_shape[1]).astype("int")
 
         obj_shape = self._object_shape
         vectorized_patch_indices_row = (
@@ -1769,8 +1700,7 @@ def tune_angle_and_defocus(
 
             fig = plt.figure(figsize=figsize)
 
-        progress_bar = kwargs.get("progress_bar", False)
-        kwargs.pop("progress_bar", None)
+        progress_bar = kwargs.pop("progress_bar", False)
         # run loop and plot along the way
         self._verbose = False
         for flat_index, (angle, defocus) in enumerate(
@@ -2038,7 +1968,7 @@ def _return_fourier_probe(
     ):
         """
         Returns complex fourier probe shifted to center of array from
-        complex real space probe in center
+        corner-centered complex real space probe
 
         Parameters
         ----------
@@ -2057,16 +1987,61 @@ def _return_fourier_probe(
         else:
             probe = xp.asarray(probe, dtype=xp.complex64)
 
-        return xp.fft.fftshift(
-            xp.fft.fft2(xp.fft.ifftshift(probe, axes=(-2, -1))), axes=(-2, -1)
-        )
+        return xp.fft.fftshift(xp.fft.fft2(probe), axes=(-2, -1))
+
+    def _return_fourier_probe_from_centered_probe(
+        self,
+        probe=None,
+    ):
+        """
+        Returns complex fourier probe shifted to center of array from
+        centered complex real space probe
+
+        Parameters
+        ----------
+        probe: complex array, optional
+            if None is specified, uses self._probe
+
+        Returns
+        -------
+        fourier_probe: np.ndarray
+            Fourier-transformed and center-shifted probe.
+        """
+        xp = self._xp
+        return self._return_fourier_probe(xp.fft.ifftshift(probe, axes=(-2, -1)))
+
+    def _return_centered_probe(
+        self,
+        probe=None,
+    ):
+        """
+        Returns complex probe centered in middle of the array.
+
+        Parameters
+        ----------
+        probe: complex array, optional
+            if None is specified, uses self._probe
+
+        Returns
+        -------
+        centered_probe: np.ndarray
+            Center-shifted probe.
+        """
+        xp = self._xp
+
+        if probe is None:
+            probe = self._probe
+        else:
+            probe = xp.asarray(probe, dtype=xp.complex64)
+
+        return xp.fft.fftshift(probe, axes=(-2, -1))
 
     def _return_object_fft(
         self,
         obj=None,
     ):
         """
-        Returns obj fft shifted to center of array
+        Returns absolute value of obj fft shifted to center of array
 
         Parameters
         ----------
@@ -2084,7 +2059,7 @@ def _return_object_fft(
             obj = self._object
 
         obj = self._crop_rotate_object_fov(asnumpy(obj))
-        return np.abs(np.fft.fftshift(np.fft.fft2(obj)))
+        return np.abs(np.fft.fftshift(np.fft.fft2(np.fft.ifftshift(obj))))
 
     def show_fourier_probe(
         self,
@@ -2175,13 +2150,21 @@ def show_object_fft(self, obj=None, **kwargs):
     @property
     def probe_fourier(self):
         """Current probe estimate in Fourier space"""
-
         if not hasattr(self, "_probe"):
             return None
 
         asnumpy = self._asnumpy
         return asnumpy(self._return_fourier_probe(self._probe))
 
+    @property
+    def probe_centered(self):
+        """Current probe estimate shifted to the center"""
+        if not hasattr(self, "_probe"):
+            return None
+
+        asnumpy = self._asnumpy
+        return asnumpy(self._return_centered_probe(self._probe))
+
     @property
     def object_fft(self):
         """Fourier transform of current object estimate"""
@@ -2224,7 +2207,7 @@ def positions(self):
         return asnumpy(positions)
 
     @property
-    def _object_cropped(self):
+    def object_cropped(self):
         """cropped and rotated object"""
 
         return self._crop_rotate_object_fov(self._object)
diff --git a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
index 790edaa69..10b24eb78 100644
--- a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
+++ b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
@@ -315,7 +315,7 @@ def _object_denoise_tv_chambolle(
     def _probe_center_of_mass_constraint(self, current_probe):
         """
         Ptychographic center of mass constraint.
-        Used for centering probe intensity.
+        Used for centering corner-centered probe intensity.
 
         Parameters
         --------
@@ -329,15 +329,12 @@ def _probe_center_of_mass_constraint(self, current_probe):
         """
         xp = self._xp
 
-        probe_center = xp.array(self._region_of_interest_shape) / 2
         probe_intensity = xp.abs(current_probe) ** 2
 
         probe_x0, probe_y0 = get_CoM(
-            probe_intensity, device=self._device
-        )
-        shifted_probe = fft_shift(
-            current_probe, probe_center - xp.array([probe_x0, probe_y0]), xp
+            probe_intensity, device=self._device, corner_centered=True
         )
+        shifted_probe = fft_shift(current_probe, -xp.array([probe_x0, probe_y0]), xp)
 
         return shifted_probe
 
@@ -352,13 +349,14 @@ def _probe_radial_symmetrization_constraint_base(
         sx, sy = current_probe.shape
 
         if center is None:
-            center = (sx // 2, sy // 2)
+            center = (0, 0)
 
         if num_bins is None:
             num_bins = np.maximum(sx, sy) * 2 + 1
 
         cx, cy = center
-        X, Y = xp.ogrid[0:sx, 0:sy]
+        X = xp.fft.fftfreq(sx, d=1 / sx)[:, None]
+        Y = xp.fft.fftfreq(sy, d=1 / sy)[None]
         r = xp.hypot(X - cx, Y - cy)
 
         rbin = (num_bins * r / r.max()).astype("int")
@@ -383,7 +381,7 @@ def _probe_radial_symmetrization_constraint(
         xp = self._xp
 
         current_probe_sum = xp.sum(xp.abs(current_probe) ** 2)
-        fourier_probe = self._return_fourier_probe(current_probe)
+        fourier_probe = xp.fft.fft2(current_probe)
 
         fourier_probe_real = fourier_probe.real.copy()
         fourier_probe_imag = fourier_probe.imag.copy()
@@ -396,7 +394,7 @@ def _probe_radial_symmetrization_constraint(
         )
 
         fourier_probe = fourier_probe_real + 1.0j * fourier_probe_imag
-        current_probe = xp.fft.ifftshift(xp.fft.ifft2(xp.fft.fftshift(fourier_probe)))
+        current_probe = xp.fft.ifft2(fourier_probe)
         current_probe *= xp.sqrt(current_probe_sum / np.sum(np.abs(current_probe) ** 2))
 
         return current_probe
@@ -427,13 +425,12 @@ def _probe_amplitude_constraint(
         probe_intensity = xp.abs(current_probe) ** 2
         current_probe_sum = xp.sum(probe_intensity)
 
-        x = xp.linspace(-1 / 2, 1 / 2, current_probe.shape[0])
-        y = xp.linspace(-1 / 2, 1 / 2, current_probe.shape[1])
-        xa, ya = xp.meshgrid(x, y, indexing="ij")
-        ra = xp.sqrt(xa**2 + ya**2) - relative_radius
+        X = xp.fft.fftfreq(current_probe.shape[0])[:, None]
+        Y = xp.fft.fftfreq(current_probe.shape[1])[None]
+        r = xp.hypot(X, Y) - relative_radius
 
         sigma = np.sqrt(np.pi) / relative_width
-        tophat_mask = 0.5 * (1 - erf(sigma * ra / (1 - ra**2)))
+        tophat_mask = 0.5 * (1 - erf(sigma * r / (1 - r**2)))
 
         updated_probe = current_probe * tophat_mask
         updated_probe_sum = xp.sum(xp.abs(updated_probe) ** 2)
@@ -483,7 +480,6 @@ def _probe_fourier_amplitude_constraint(
 
         sigma = np.sqrt(np.pi) / relative_width
         tophat_mask = 0.5 * (1 - erf(sigma * qra / (1 - qra**2)))
-
         updated_probe = xp.fft.ifft2(current_probe_fft * tophat_mask)
         updated_probe_sum = xp.sum(xp.abs(updated_probe) ** 2)
         normalization = xp.sqrt(current_probe_sum / updated_probe_sum)
@@ -520,19 +516,21 @@ def _probe_residual_aberration_filtering_constraint(
         known_aberrations_array = self._known_aberrations_array
         gaussian_filter_sigma /= self._reciprocal_sampling[0]
 
-        fourier_probe = self._return_fourier_probe(current_probe)
+        fourier_probe = xp.fft.fft2(current_probe)
         if fix_amplitude:
             fourier_probe_abs = xp.abs(fourier_probe)
 
         fourier_probe *= xp.conjugate(known_aberrations_array)
-        fourier_probe = gaussian_filter(fourier_probe, gaussian_filter_sigma)
+        fourier_probe = gaussian_filter(
+            fourier_probe, gaussian_filter_sigma, mode="wrap"
+        )
         fourier_probe *= known_aberrations_array
 
         if fix_amplitude:
             fourier_probe_angle = xp.angle(fourier_probe)
             fourier_probe = fourier_probe_abs * xp.exp(1.0j * fourier_probe_angle)
 
-        current_probe = xp.fft.ifftshift(xp.fft.ifft2(xp.fft.fftshift(fourier_probe)))
+        current_probe = xp.fft.ifft2(fourier_probe)
 
         return current_probe
 
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index 02ad967c9..5ef8985c6 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -346,16 +346,16 @@ def preprocess(
         self._positions_px = self._calculate_scan_positions_in_pixels(
             self._scan_positions
         )
-
         # Object Initialization
         if self._object is None:
-            pad_x, pad_y = self._object_padding_px
-            p, q = np.max(self._positions_px, axis=0)
+            pad_x = self._object_padding_px[0][1]
+            pad_y = self._object_padding_px[1][1]
+            p, q = np.round(np.max(self._positions_px, axis=0))
             p = np.max([np.round(p + pad_x), self._region_of_interest_shape[0]]).astype(
-                int
+                "int"
             )
             q = np.max([np.round(q + pad_y), self._region_of_interest_shape[1]]).astype(
-                int
+                "int"
             )
             if self._object_type == "potential":
                 self._object = xp.zeros((p, q), dtype=xp.float32)
@@ -398,18 +398,16 @@ def preprocess(
                     self._vacuum_probe_intensity, dtype=xp.float32
                 )
                 probe_x0, probe_y0 = get_CoM(
-                    self._vacuum_probe_intensity, device=self._device
+                    self._vacuum_probe_intensity,
+                    device=self._device,
                 )
-                shift_x = self._region_of_interest_shape[0] // 2 - probe_x0
-                shift_y = self._region_of_interest_shape[1] // 2 - probe_y0
                 self._vacuum_probe_intensity = get_shifted_ar(
                     self._vacuum_probe_intensity,
-                    shift_x,
-                    shift_y,
+                    -probe_x0,
+                    -probe_y0,
                     bilinear=True,
                     device=self._device,
                 )
-
             self._probe = (
                 ComplexProbe(
                     gpts=self._region_of_interest_shape,
@@ -457,8 +455,6 @@ def preprocess(
             device=self._device,
         )._evaluate_ctf()
 
-        self._known_aberrations_array = xp.fft.ifftshift(self._known_aberrations_array)
-
         # overlaps
         shifted_probes = fft_shift(self._probe, self._positions_px_fractional, xp)
         probe_intensities = xp.abs(shifted_probes) ** 2
@@ -481,7 +477,7 @@ def preprocess(
 
             # initial probe
             complex_probe_rgb = Complex2RGB(
-                asnumpy(self._probe),
+                self.probe_centered,
                 vmin=vmin,
                 vmax=vmax,
                 hue_start=hue_start,
@@ -1597,11 +1593,11 @@ def reconstruct(
             self.error_iterations.append(error.item())
             if store_iterations:
                 self.object_iterations.append(asnumpy(self._object.copy()))
-                self.probe_iterations.append(asnumpy(self._probe.copy()))
+                self.probe_iterations.append(self.probe_centered)
 
         # store result
         self.object = asnumpy(self._object)
-        self.probe = asnumpy(self._probe)
+        self.probe = self.probe_centered
         self.error = error.item()
 
         return self
@@ -1715,12 +1711,20 @@ def _visualize_last_iteration(
             0,
         ]
 
-        probe_extent = [
-            0,
-            self.sampling[1] * self._region_of_interest_shape[1],
-            self.sampling[0] * self._region_of_interest_shape[0],
-            0,
-        ]
+        if plot_fourier_probe:
+            probe_extent = [
+                0,
+                self.angular_sampling[1] * self._region_of_interest_shape[1],
+                self.angular_sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
+        elif plot_probe:
+            probe_extent = [
+                0,
+                self.sampling[1] * self._region_of_interest_shape[1],
+                self.sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
 
         if plot_convergence:
             if plot_probe or plot_fourier_probe:
@@ -1786,19 +1790,21 @@ def _visualize_last_iteration(
                     self.probe_fourier, hue_start=hue_start, invert=invert
                 )
                 ax.set_title("Reconstructed Fourier probe")
+                ax.set_ylabel("kx [mrad]")
+                ax.set_xlabel("ky [mrad]")
             else:
                 probe_array = Complex2RGB(
                     self.probe, hue_start=hue_start, invert=invert
                 )
                 ax.set_title("Reconstructed probe")
+                ax.set_ylabel("x [A]")
+                ax.set_xlabel("y [A]")
 
             im = ax.imshow(
                 probe_array,
                 extent=probe_extent,
                 **kwargs,
             )
-            ax.set_ylabel("x [A]")
-            ax.set_xlabel("y [A]")
 
             if cbar:
                 divider = make_axes_locatable(ax)
@@ -1942,12 +1948,20 @@ def _visualize_all_iterations(
             0,
         ]
 
-        probe_extent = [
-            0,
-            self.sampling[1] * self._region_of_interest_shape[1],
-            self.sampling[0] * self._region_of_interest_shape[0],
-            0,
-        ]
+        if plot_fourier_probe:
+            probe_extent = [
+                0,
+                self.angular_sampling[1] * self._region_of_interest_shape[1],
+                self.angular_sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
+        elif plot_probe:
+            probe_extent = [
+                0,
+                self.sampling[1] * self._region_of_interest_shape[1],
+                self.sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
 
         if plot_convergence:
             if plot_probe or plot_fourier_probe:
@@ -2003,16 +2017,25 @@ def _visualize_all_iterations(
             for n, ax in enumerate(grid):
                 if plot_fourier_probe:
                     probe_array = Complex2RGB(
-                        asnumpy(self._return_fourier_probe(probes[grid_range[n]])),
+                        asnumpy(
+                            self._return_fourier_probe_from_centered_probe(
+                                probes[grid_range[n]]
+                            )
+                        ),
                         hue_start=hue_start,
                         invert=invert,
                     )
                     ax.set_title(f"Iter: {grid_range[n]} Fourier probe")
+                    ax.set_ylabel("kx [mrad]")
+                    ax.set_xlabel("ky [mrad]")
+
                 else:
                     probe_array = Complex2RGB(
                         probes[grid_range[n]], hue_start=hue_start, invert=invert
                     )
                     ax.set_title(f"Iter: {grid_range[n]} probe")
+                    ax.set_ylabel("x [A]")
+                    ax.set_xlabel("y [A]")
 
                 im = ax.imshow(
                     probe_array,
@@ -2020,9 +2043,6 @@ def _visualize_all_iterations(
                     **kwargs,
                 )
 
-                ax.set_ylabel("x [A]")
-                ax.set_xlabel("y [A]")
-
                 if cbar:
                     add_colorbar_arg(
                         grid.cbar_axes[n], hue_start=hue_start, invert=invert
diff --git a/py4DSTEM/process/phase/utils.py b/py4DSTEM/process/phase/utils.py
index 50d8a792a..6a14bc508 100644
--- a/py4DSTEM/process/phase/utils.py
+++ b/py4DSTEM/process/phase/utils.py
@@ -15,46 +15,26 @@
 from py4DSTEM.process.utils.utils import electron_wavelength_angstrom
 from scipy.ndimage import gaussian_filter
 
+# fmt: off
+
 #: Symbols for the polar representation of all optical aberrations up to the fifth order.
 polar_symbols = (
-    "C10",
-    "C12",
-    "phi12",
-    "C21",
-    "phi21",
-    "C23",
-    "phi23",
-    "C30",
-    "C32",
-    "phi32",
-    "C34",
-    "phi34",
-    "C41",
-    "phi41",
-    "C43",
-    "phi43",
-    "C45",
-    "phi45",
-    "C50",
-    "C52",
-    "phi52",
-    "C54",
-    "phi54",
-    "C56",
-    "phi56",
+        "C10", "C12", "phi12",
+        "C21", "phi21", "C23", "phi23",
+        "C30", "C32", "phi32", "C34", "phi34",
+        "C41", "phi41", "C43", "phi43", "C45", "phi45",
+        "C50", "C52", "phi52", "C54", "phi54", "C56", "phi56",
 )
 
 #: Aliases for the most commonly used optical aberrations.
 polar_aliases = {
-    "defocus": "C10",
-    "astigmatism": "C12",
-    "astigmatism_angle": "phi12",
-    "coma": "C21",
-    "coma_angle": "phi21",
-    "Cs": "C30",
-    "C5": "C50",
+        "defocus": "C10", "astigmatism": "C12", "astigmatism_angle": "phi12",
+        "coma": "C21", "coma_angle": "phi21",
+        "Cs": "C30",
+        "C5": "C50",
 }
 
+# fmt: on
 
 ### Probe functions
 
@@ -81,6 +61,8 @@ class ComplexProbe:
         Device to perform calculations on. Must be either 'cpu' or 'gpu'
     rolloff: float, optional
         Tapers the cutoff edge over the given angular range [mrad].
+    vacuum_probe_intensity: np.ndarray, optional
+        Squared of corner-centered aperture amplitude to use, instead of semiangle_cutoff + rolloff
     focal_spread: float, optional
         The 1/e width of the focal spread due to chromatic aberration and lens current instability [Å].
     angular_spread: float, optional
@@ -180,7 +162,7 @@ def evaluate_aperture(
                 self._vacuum_probe_intensity, dtype=xp.float32
             )
             vacuum_probe_amplitude = xp.sqrt(xp.maximum(vacuum_probe_intensity, 0))
-            return xp.fft.ifftshift(vacuum_probe_amplitude)
+            return vacuum_probe_amplitude
 
         if self._semiangle_cutoff == xp.inf:
             return xp.ones_like(alpha)
@@ -432,9 +414,9 @@ def polar_coordinates(self, x, y):
         return alpha, phi
 
     def build(self):
-        """Builds complex probe in the center of the region of interest."""
+        """Builds corner-centered complex probe in the center of the region of interest."""
         xp = self._xp
-        array = xp.fft.fftshift(xp.fft.ifft2(self._evaluate_ctf()))
+        array = xp.fft.ifft2(self._evaluate_ctf())
         array = array / xp.sqrt((xp.abs(array) ** 2).sum())
         self._array = array
         return self
@@ -448,7 +430,7 @@ def visualize(self, **kwargs):
         kwargs.pop("cmap", None)
 
         plt.imshow(
-            asnumpy(xp.abs(self._array) ** 2),
+            asnumpy(xp.abs(xp.fft.ifftshift(self._array)) ** 2),
             cmap=cmap,
             **kwargs,
         )
@@ -1289,15 +1271,20 @@ def project_vector_field_divergence(vector_field, spacings=(1, 1, 1), xp=np):
     grad_p = compute_gradient(p, spacings, xp=xp)
     return vector_field - grad_p
 
+
 # Nesterov acceleration functions
 # https://blogs.princeton.edu/imabandit/2013/04/01/acceleratedgradientdescent/
 
+
 @functools.cache
 def nesterov_lambda(one_indexed_iter_num):
     if one_indexed_iter_num == 0:
         return 0
-    return (1+np.sqrt(1+4*nesterov_lambda(one_indexed_iter_num-1)**2))/2
+    return (1 + np.sqrt(1 + 4 * nesterov_lambda(one_indexed_iter_num - 1) ** 2)) / 2
+
 
 def nesterov_gamma(zero_indexed_iter_num):
     one_indexed_iter_num = zero_indexed_iter_num + 1
-    return (1-nesterov_lambda(one_indexed_iter_num))/nesterov_lambda(one_indexed_iter_num+1)
+    return (1 - nesterov_lambda(one_indexed_iter_num)) / nesterov_lambda(
+        one_indexed_iter_num + 1
+    )
diff --git a/py4DSTEM/process/utils/utils.py b/py4DSTEM/process/utils/utils.py
index 29badd389..1df4e78c5 100644
--- a/py4DSTEM/process/utils/utils.py
+++ b/py4DSTEM/process/utils/utils.py
@@ -174,21 +174,24 @@ def make_Fourier_coords2D(Nx, Ny, pixelSize=1):
     qy, qx = np.meshgrid(qy, qx)
     return qx, qy
 
-
-def get_CoM(ar, device = "cpu"):
+def get_CoM(ar, device="cpu", corner_centered=False):
     """
     Finds and returns the center of mass of array ar.
+    If corner_centered is True, uses fftfreq for indices.
     """
     if device == "cpu":
         xp = np
-
     elif device == "gpu":
         xp = cp
 
-    ar = xp.asarray(ar)
-
+    ar = xp.asarray(ar) 
     nx, ny = ar.shape
-    ry, rx = xp.meshgrid(xp.arange(ny), xp.arange(nx))
+
+    if corner_centered:
+        ry, rx = xp.meshgrid(xp.fft.fftfreq(ny, 1 / ny), xp.fft.fftfreq(nx, 1 / nx))
+    else:
+        ry, rx = xp.meshgrid(xp.arange(ny), xp.arange(nx))
+    
     tot_intens = xp.sum(ar)
     xCoM = xp.sum(rx * ar) / tot_intens
     yCoM = xp.sum(ry * ar) / tot_intens

From e5bb0ced76ba00511f38715e19a77a502c693bb4 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 16 Jun 2023 09:25:04 -0700
Subject: [PATCH 217/362] handing of single value for com shifts

---
 py4DSTEM/process/phase/iterative_base_class.py | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index 6bb429a64..def3f8799 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -143,6 +143,12 @@ def _preprocess_datacube_and_vacuum_probe(
         datacube: Datacube
             Resampled and Padded datacube
         """
+        if com_shifts is not None:
+            if np.isscalar(com_shifts[0]):
+                com_shifts = (
+                    np.ones(self._datacube.Rshape) * com_shifts[0],
+                    np.ones(self._datacube.Rshape) * com_shifts[1],
+                )
 
         if com_shifts is not None:
             if np.isscalar(com_shifts[0]):

From 196d9971d3d81d6f60b5218397d3a3ed7faeeaa7 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Fri, 16 Jun 2023 14:46:17 -0700
Subject: [PATCH 218/362] removing merge conflict duplicate lines

---
 py4DSTEM/process/phase/iterative_base_class.py | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index def3f8799..288c573cd 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -150,13 +150,6 @@ def _preprocess_datacube_and_vacuum_probe(
                     np.ones(self._datacube.Rshape) * com_shifts[1],
                 )
 
-        if com_shifts is not None:
-            if np.isscalar(com_shifts[0]):
-                com_shifts = (
-                    np.ones(self._datacube.Rshape) * com_shifts[0],
-                    np.ones(self._datacube.Rshape) * com_shifts[1],
-                )
-
         if diffraction_intensities_shape is not None:
             Qx, Qy = datacube.shape[-2:]
             Sx, Sy = diffraction_intensities_shape

From 9fa6d0af5133bab24be74949610e4e6d017740d5 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Fri, 16 Jun 2023 15:21:29 -0700
Subject: [PATCH 219/362] corner-centered probe multislice

---
 .../iterative_multislice_ptychography.py      | 95 ++++++++++++-------
 1 file changed, 59 insertions(+), 36 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_multislice_ptychography.py b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
index c0e73e13b..ce8d13325 100644
--- a/py4DSTEM/process/phase/iterative_multislice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
@@ -421,13 +421,14 @@ def preprocess(
 
         # Object Initialization
         if self._object is None:
-            pad_x, pad_y = self._object_padding_px
-            p, q = np.max(self._positions_px, axis=0)
+            pad_x = self._object_padding_px[0][1]
+            pad_y = self._object_padding_px[1][1]
+            p, q = np.round(np.max(self._positions_px, axis=0))
             p = np.max([np.round(p + pad_x), self._region_of_interest_shape[0]]).astype(
-                int
+                "int"
             )
             q = np.max([np.round(q + pad_y), self._region_of_interest_shape[1]]).astype(
-                int
+                "int"
             )
             if self._object_type == "potential":
                 self._object = xp.zeros((self._num_slices, p, q), dtype=xp.float32)
@@ -470,14 +471,13 @@ def preprocess(
                     self._vacuum_probe_intensity, dtype=xp.float32
                 )
                 probe_x0, probe_y0 = get_CoM(
-                    self._vacuum_probe_intensity, device=self._device
+                    self._vacuum_probe_intensity,
+                    device=self._device,
                 )
-                shift_x = self._region_of_interest_shape[0] // 2 - probe_x0
-                shift_y = self._region_of_interest_shape[1] // 2 - probe_y0
                 self._vacuum_probe_intensity = get_shifted_ar(
                     self._vacuum_probe_intensity,
-                    shift_x,
-                    shift_y,
+                    -probe_x0,
+                    -probe_y0,
                     bilinear=True,
                     device=self._device,
                 )
@@ -530,8 +530,6 @@ def preprocess(
             device=self._device,
         )._evaluate_ctf()
 
-        self._known_aberrations_array = xp.fft.ifftshift(self._known_aberrations_array)
-
         # Precomputed propagator arrays
         self._propagator_arrays = self._precompute_propagator_arrays(
             self._region_of_interest_shape,
@@ -562,7 +560,7 @@ def preprocess(
 
             # initial probe
             complex_probe_rgb = Complex2RGB(
-                asnumpy(self._probe),
+                self.probe_centered,
                 vmin=vmin,
                 vmax=vmax,
                 hue_start=hue_start,
@@ -577,7 +575,7 @@ def preprocess(
                     propagated_probe, self._propagator_arrays[s]
                 )
             complex_propagated_rgb = Complex2RGB(
-                asnumpy(propagated_probe),
+                asnumpy(self._return_centered_probe(propagated_probe)),
                 vmin=vmin,
                 vmax=vmax,
                 hue_start=hue_start,
@@ -2090,11 +2088,11 @@ def reconstruct(
             self.error_iterations.append(error.item())
             if store_iterations:
                 self.object_iterations.append(asnumpy(self._object.copy()))
-                self.probe_iterations.append(asnumpy(self._probe.copy()))
+                self.probe_iterations.append(self.probe_centered)
 
         # store result
         self.object = asnumpy(self._object)
-        self.probe = asnumpy(self._probe)
+        self.probe = self.probe_centered
         self.error = error.item()
 
         return self
@@ -2215,12 +2213,21 @@ def _visualize_last_iteration(
             0,
         ]
 
-        probe_extent = [
-            0,
-            self.sampling[1] * self._region_of_interest_shape[1],
-            self.sampling[0] * self._region_of_interest_shape[0],
-            0,
-        ]
+        if plot_fourier_probe:
+            probe_extent = [
+                0,
+                self.angular_sampling[1] * self._region_of_interest_shape[1],
+                self.angular_sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
+
+        elif plot_probe:
+            probe_extent = [
+                0,
+                self.sampling[1] * self._region_of_interest_shape[1],
+                self.sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
 
         if plot_convergence:
             if plot_probe or plot_fourier_probe:
@@ -2287,19 +2294,21 @@ def _visualize_last_iteration(
                     self.probe_fourier, hue_start=hue_start, invert=invert
                 )
                 ax.set_title("Reconstructed Fourier probe")
+                ax.set_ylabel("kx [mrad]")
+                ax.set_xlabel("ky [mrad]")
             else:
                 probe_array = Complex2RGB(
                     self.probe, hue_start=hue_start, invert=invert
                 )
                 ax.set_title("Reconstructed probe")
+                ax.set_ylabel("x [A]")
+                ax.set_xlabel("y [A]")
 
             im = ax.imshow(
                 probe_array,
                 extent=probe_extent,
                 **kwargs,
             )
-            ax.set_ylabel("x [A]")
-            ax.set_xlabel("y [A]")
 
             if cbar:
                 divider = make_axes_locatable(ax)
@@ -2445,12 +2454,20 @@ def _visualize_all_iterations(
             0,
         ]
 
-        probe_extent = [
-            0,
-            self.sampling[1] * self._region_of_interest_shape[1],
-            self.sampling[0] * self._region_of_interest_shape[0],
-            0,
-        ]
+        if plot_fourier_probe:
+            probe_extent = [
+                0,
+                self.angular_sampling[1] * self._region_of_interest_shape[1],
+                self.angular_sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
+        elif plot_probe:
+            probe_extent = [
+                0,
+                self.sampling[1] * self._region_of_interest_shape[1],
+                self.sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
 
         if plot_convergence:
             if plot_probe or plot_fourier_probe:
@@ -2505,16 +2522,24 @@ def _visualize_all_iterations(
             for n, ax in enumerate(grid):
                 if plot_fourier_probe:
                     probe_array = Complex2RGB(
-                        asnumpy(self._return_fourier_probe(probes[grid_range[n]])),
+                        asnumpy(
+                            self._return_fourier_probe_from_centered_probe(
+                                probes[grid_range[n]]
+                            )
+                        ),
                         hue_start=hue_start,
                         invert=invert,
                     )
                     ax.set_title(f"Iter: {grid_range[n]} Fourier probe")
+                    ax.set_ylabel("kx [mrad]")
+                    ax.set_xlabel("ky [mrad]")
                 else:
                     probe_array = Complex2RGB(
                         probes[grid_range[n]], hue_start=hue_start, invert=invert
                     )
                     ax.set_title(f"Iter: {grid_range[n]} probe")
+                    ax.set_ylabel("x [A]")
+                    ax.set_xlabel("y [A]")
 
                 im = ax.imshow(
                     probe_array,
@@ -2522,9 +2547,6 @@ def _visualize_all_iterations(
                     **kwargs,
                 )
 
-                ax.set_ylabel("x [A]")
-                ax.set_xlabel("y [A]")
-
                 if cbar:
                     add_colorbar_arg(
                         grid.cbar_axes[n], hue_start=hue_start, invert=invert
@@ -2621,6 +2643,7 @@ def show_transmitted_probe(
         """
 
         xp = self._xp
+        asnumpy = self._asnumpy
 
         transmitted_probe_intensities = xp.sum(
             xp.abs(self._transmitted_probes) ** 2, axis=(-2, -1)
@@ -2633,7 +2656,7 @@ def show_transmitted_probe(
         ]
         mean_transmitted = self._transmitted_probes.mean(0)
         probes = [
-            self._asnumpy(probe)
+            asnumpy(self._return_centered_probe(probe))
             for probe in [
                 mean_transmitted,
                 min_intensity_transmitted,
@@ -2648,7 +2671,7 @@ def show_transmitted_probe(
 
         if plot_fourier_probe:
             bottom_row = [
-                self._asnumpy(self._return_fourier_probe(probe))
+                asnumpy(self._return_fourier_probe(probe))
                 for probe in [
                     mean_transmitted,
                     min_intensity_transmitted,
@@ -2988,4 +3011,4 @@ def _return_object_fft(
             obj = np.angle(obj)
 
         obj = self._crop_rotate_object_fov(np.sum(obj, axis=0))
-        return np.abs(np.fft.fftshift(np.fft.fft2(obj)))
+        return np.abs(np.fft.fftshift(np.fft.fft2(np.fft.ifftshift(obj))))

From 3b6fdc709e38857f1a7909832bdb38de14fb9106 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Fri, 16 Jun 2023 16:22:27 -0700
Subject: [PATCH 220/362] corner-centered probe mixedstate

---
 .../iterative_mixedstate_ptychography.py      | 112 ++++++++++--------
 1 file changed, 64 insertions(+), 48 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
index ff32f5b49..2d595fab1 100644
--- a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
@@ -347,13 +347,14 @@ def preprocess(
 
         # Object Initialization
         if self._object is None:
-            pad_x, pad_y = self._object_padding_px
-            p, q = np.max(self._positions_px, axis=0)
+            pad_x = self._object_padding_px[0][1]
+            pad_y = self._object_padding_px[1][1]
+            p, q = np.round(np.max(self._positions_px, axis=0))
             p = np.max([np.round(p + pad_x), self._region_of_interest_shape[0]]).astype(
-                int
+                "int"
             )
             q = np.max([np.round(q + pad_y), self._region_of_interest_shape[1]]).astype(
-                int
+                "int"
             )
             if self._object_type == "potential":
                 self._object = xp.zeros((p, q), dtype=xp.float32)
@@ -400,12 +401,10 @@ def preprocess(
                         self._vacuum_probe_intensity,
                         device=self._device,
                     )
-                    shift_x = self._region_of_interest_shape[0] // 2 - probe_x0
-                    shift_y = self._region_of_interest_shape[1] // 2 - probe_y0
                     self._vacuum_probe_intensity = get_shifted_ar(
                         self._vacuum_probe_intensity,
-                        shift_x,
-                        shift_y,
+                        -probe_x0,
+                        -probe_y0,
                         bilinear=True,
                         device=self._device,
                     )
@@ -476,8 +475,6 @@ def preprocess(
             device=self._device,
         )._evaluate_ctf()
 
-        self._known_aberrations_array = xp.fft.ifftshift(self._known_aberrations_array)
-
         # overlaps
         shifted_probes = fft_shift(self._probe[0], self._positions_px_fractional, xp)
         probe_intensities = xp.abs(shifted_probes) ** 2
@@ -500,7 +497,7 @@ def preprocess(
 
             # initial probe
             complex_probe_rgb = Complex2RGB(
-                asnumpy(self._probe[0]),
+                self.probe_centered[0],
                 vmin=vmin,
                 vmax=vmax,
                 hue_start=hue_start,
@@ -536,7 +533,7 @@ def preprocess(
             )
             ax1.set_ylabel("x [A]")
             ax1.set_xlabel("y [A]")
-            ax1.set_title("Initial Probe")
+            ax1.set_title("Initial Probe[0]")
 
             ax2.imshow(
                 asnumpy(probe_overlap),
@@ -1021,8 +1018,8 @@ def _adjoint(
 
     def _probe_center_of_mass_constraint(self, current_probe):
         """
-        Ptychographic threshold constraint.
-        Used for avoiding the scaling ambiguity between probe and object.
+        Ptychographic center of mass constraint.
+        Used for centering corner-centered probe intensity.
 
         Parameters
         --------
@@ -1035,15 +1032,12 @@ def _probe_center_of_mass_constraint(self, current_probe):
             Constrained probe estimate
         """
         xp = self._xp
-        asnumpy = self._asnumpy
-
-        probe_center = xp.array(self._region_of_interest_shape) / 2
-        probe_intensity = asnumpy(xp.abs(current_probe[0]) ** 2)
+        probe_intensity = xp.abs(current_probe[0]) ** 2
 
-        probe_x0, probe_y0 = get_CoM(probe_intensity)
-        shifted_probe = fft_shift(
-            current_probe, probe_center - xp.array([probe_x0, probe_y0]), xp
+        probe_x0, probe_y0 = get_CoM(
+            probe_intensity, device=self._device, corner_centered=True
         )
+        shifted_probe = fft_shift(current_probe, -xp.array([probe_x0, probe_y0]), xp)
 
         return shifted_probe
 
@@ -1063,10 +1057,9 @@ def _probe_orthogonalization_constraint(self, current_probe):
             Orthogonalized probe estimate
         """
         xp = self._xp
+        shape = current_probe.shape
 
-        return orthogonalize(current_probe.reshape((self._num_probes, -1)), xp).reshape(
-            current_probe.shape
-        )
+        return orthogonalize(current_probe.reshape((shape[0], -1)), xp).reshape(shape)
 
     def _constraints(
         self,
@@ -1663,11 +1656,11 @@ def reconstruct(
             self.error_iterations.append(error.item())
             if store_iterations:
                 self.object_iterations.append(asnumpy(self._object.copy()))
-                self.probe_iterations.append(asnumpy(self._probe.copy()))
+                self.probe_iterations.append(self.probe_centered)
 
         # store result
         self.object = asnumpy(self._object)
-        self.probe = asnumpy(self._probe)
+        self.probe = self.probe_centered
         self.error = error.item()
 
         return self
@@ -1779,12 +1772,20 @@ def _visualize_last_iteration(
             0,
         ]
 
-        probe_extent = [
-            0,
-            self.sampling[1] * self._region_of_interest_shape[1],
-            self.sampling[0] * self._region_of_interest_shape[0],
-            0,
-        ]
+        if plot_fourier_probe:
+            probe_extent = [
+                0,
+                self.angular_sampling[1] * self._region_of_interest_shape[1],
+                self.angular_sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
+        elif plot_probe:
+            probe_extent = [
+                0,
+                self.sampling[1] * self._region_of_interest_shape[1],
+                self.sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
 
         if plot_convergence:
             if plot_probe or plot_fourier_probe:
@@ -1849,20 +1850,22 @@ def _visualize_last_iteration(
                 probe_array = Complex2RGB(
                     self.probe_fourier[0], hue_start=hue_start, invert=invert
                 )
-                ax.set_title("Reconstructed Fourier probe")
+                ax.set_title("Reconstructed Fourier probe[0]")
+                ax.set_ylabel("kx [mrad]")
+                ax.set_xlabel("ky [mrad]")
             else:
                 probe_array = Complex2RGB(
                     self.probe[0], hue_start=hue_start, invert=invert
                 )
-                ax.set_title("Reconstructed probe")
+                ax.set_title("Reconstructed probe[0]")
+                ax.set_ylabel("x [A]")
+                ax.set_xlabel("y [A]")
 
             im = ax.imshow(
                 probe_array,
                 extent=probe_extent,
                 **kwargs,
             )
-            ax.set_ylabel("x [A]")
-            ax.set_xlabel("y [A]")
 
             if cbar:
                 divider = make_axes_locatable(ax)
@@ -2006,12 +2009,20 @@ def _visualize_all_iterations(
             0,
         ]
 
-        probe_extent = [
-            0,
-            self.sampling[1] * self._region_of_interest_shape[1],
-            self.sampling[0] * self._region_of_interest_shape[0],
-            0,
-        ]
+        if plot_fourier_probe:
+            probe_extent = [
+                0,
+                self.angular_sampling[1] * self._region_of_interest_shape[1],
+                self.angular_sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
+        elif plot_probe:
+            probe_extent = [
+                0,
+                self.sampling[1] * self._region_of_interest_shape[1],
+                self.sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
 
         if plot_convergence:
             if plot_probe or plot_fourier_probe:
@@ -2066,16 +2077,24 @@ def _visualize_all_iterations(
             for n, ax in enumerate(grid):
                 if plot_fourier_probe:
                     probe_array = Complex2RGB(
-                        asnumpy(self._return_fourier_probe(probes[grid_range[n]][0])),
+                        asnumpy(
+                            self._return_fourier_probe_from_centered_probe(
+                                probes[grid_range[n]][0]
+                            )
+                        ),
                         hue_start=hue_start,
                         invert=invert,
                     )
-                    ax.set_title(f"Iter: {grid_range[n]} Fourier probe")
+                    ax.set_title(f"Iter: {grid_range[n]} Fourier probe[0]")
+                    ax.set_ylabel("kx [mrad]")
+                    ax.set_xlabel("ky [mrad]")
                 else:
                     probe_array = Complex2RGB(
                         probes[grid_range[n]][0], hue_start=hue_start, invert=invert
                     )
-                    ax.set_title(f"Iter: {grid_range[n]} probe")
+                    ax.set_title(f"Iter: {grid_range[n]} probe[0]")
+                    ax.set_ylabel("x [A]")
+                    ax.set_xlabel("y [A]")
 
                 im = ax.imshow(
                     probe_array,
@@ -2083,9 +2102,6 @@ def _visualize_all_iterations(
                     **kwargs,
                 )
 
-                ax.set_ylabel("x [A]")
-                ax.set_xlabel("y [A]")
-
                 if cbar:
                     add_colorbar_arg(
                         grid.cbar_axes[n], hue_start=hue_start, invert=invert

From 44ee041a839f33cac73a903fa9a53f1dd960a6e5 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Fri, 16 Jun 2023 16:41:35 -0700
Subject: [PATCH 221/362] corner-centered probe simultaneous

---
 .../iterative_simultaneous_ptychography.py    | 77 +++++++------------
 1 file changed, 28 insertions(+), 49 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
index c2a6f047f..e872bc42e 100644
--- a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
@@ -593,13 +593,14 @@ def preprocess(
 
         # Object Initialization
         if self._object is None:
-            pad_x, pad_y = self._object_padding_px
-            p, q = np.max(self._positions_px, axis=0)
+            pad_x = self._object_padding_px[0][1]
+            pad_y = self._object_padding_px[1][1]
+            p, q = np.round(np.max(self._positions_px, axis=0))
             p = np.max([np.round(p + pad_x), self._region_of_interest_shape[0]]).astype(
-                int
+                "int"
             )
             q = np.max([np.round(q + pad_y), self._region_of_interest_shape[1]]).astype(
-                int
+                "int"
             )
             if self._object_type == "potential":
                 object_e = xp.zeros((p, q), dtype=xp.float32)
@@ -647,12 +648,10 @@ def preprocess(
                 probe_x0, probe_y0 = get_CoM(
                     self._vacuum_probe_intensity, device=self._device
                 )
-                shift_x = self._region_of_interest_shape[0] // 2 - probe_x0
-                shift_y = self._region_of_interest_shape[1] // 2 - probe_y0
                 self._vacuum_probe_intensity = get_shifted_ar(
                     self._vacuum_probe_intensity,
-                    shift_x,
-                    shift_y,
+                    -probe_x0,
+                    -probe_y0,
                     bilinear=True,
                     device=self._device,
                 )
@@ -704,8 +703,6 @@ def preprocess(
             device=self._device,
         )._evaluate_ctf()
 
-        self._known_aberrations_array = xp.fft.ifftshift(self._known_aberrations_array)
-
         # overlaps
         shifted_probes = fft_shift(self._probe, self._positions_px_fractional, xp)
         probe_intensities = xp.abs(shifted_probes) ** 2
@@ -728,7 +725,7 @@ def preprocess(
 
             # initial probe
             complex_probe_rgb = Complex2RGB(
-                asnumpy(self._probe),
+                self.probe_centered,
                 vmin=vmin,
                 vmax=vmax,
                 hue_start=hue_start,
@@ -2173,34 +2170,6 @@ def _adjoint(
 
         return current_object, current_probe
 
-    def _probe_center_of_mass_constraint(self, current_probe):
-        """
-        Ptychographic threshold constraint.
-        Used for avoiding the scaling ambiguity between probe and object.
-
-        Parameters
-        --------
-        current_probe: np.ndarray
-            Current probe estimate
-
-        Returns
-        --------
-        constrained_probe: np.ndarray
-            Constrained probe estimate
-        """
-        xp = self._xp
-        asnumpy = self._asnumpy
-
-        probe_center = xp.array(self._region_of_interest_shape) / 2
-        probe_intensity = asnumpy(xp.abs(current_probe) ** 2)
-
-        probe_x0, probe_y0 = get_CoM(probe_intensity)
-        shifted_probe = fft_shift(
-            current_probe, probe_center - xp.array([probe_x0, probe_y0]), xp
-        )
-
-        return shifted_probe
-
     def _constraints(
         self,
         current_object,
@@ -2885,14 +2854,14 @@ def reconstruct(
                             asnumpy(self._object[1].copy()),
                         )
                     )
-                self.probe_iterations.append(asnumpy(self._probe.copy()))
+                self.probe_iterations.append(self.probe_centered)
 
         # store result
         if a0 < warmup_iter:
             self.object = (asnumpy(self._object[0]), None)
         else:
             self.object = (asnumpy(self._object[0]), asnumpy(self._object[1]))
-        self.probe = asnumpy(self._probe)
+        self.probe = self.probe_centered
         self.error = error.item()
 
         return self
@@ -3019,12 +2988,20 @@ def _visualize_last_iteration(
             0,
         ]
 
-        probe_extent = [
-            0,
-            self.sampling[1] * self._region_of_interest_shape[1],
-            self.sampling[0] * self._region_of_interest_shape[0],
-            0,
-        ]
+        if plot_fourier_probe:
+            probe_extent = [
+                0,
+                self.angular_sampling[1] * self._region_of_interest_shape[1],
+                self.angular_sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
+        elif plot_probe:
+            probe_extent = [
+                0,
+                self.sampling[1] * self._region_of_interest_shape[1],
+                self.sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
 
         if plot_convergence:
             if plot_probe or plot_fourier_probe:
@@ -3111,19 +3088,21 @@ def _visualize_last_iteration(
                     self.probe_fourier, hue_start=hue_start, invert=invert
                 )
                 ax.set_title("Reconstructed Fourier probe")
+                ax.set_ylabel("kx [mrad]")
+                ax.set_xlabel("ky [mrad]")
             else:
                 probe_array = Complex2RGB(
                     self.probe, hue_start=hue_start, invert=invert
                 )
                 ax.set_title("Reconstructed probe")
+                ax.set_ylabel("x [A]")
+                ax.set_xlabel("y [A]")
 
             im = ax.imshow(
                 probe_array,
                 extent=probe_extent,
                 **kwargs,
             )
-            ax.set_ylabel("x [A]")
-            ax.set_xlabel("y [A]")
 
             if cbar:
                 divider = make_axes_locatable(ax)

From 5e54e9b519ce0d8362dedf086789bb9df82b98ec Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Fri, 16 Jun 2023 17:02:43 -0700
Subject: [PATCH 222/362] corner-centered probe overlap tomography

---
 .../iterative_overlap_magnetic_tomography.py  |  23 ++--
 .../phase/iterative_overlap_tomography.py     | 115 ++++++++----------
 2 files changed, 62 insertions(+), 76 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 478e3fe60..67d5f2bd5 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -602,8 +602,9 @@ def preprocess(
 
         # Object Initialization
         if self._object is None:
-            pad_x, pad_y = self._object_padding_px
-            p, q = np.max(self._positions_px_all, axis=0)
+            pad_x = self._object_padding_px[0][1]
+            pad_y = self._object_padding_px[1][1]
+            p, q = np.round(np.max(self._positions_px_all, axis=0))
             p = np.max([np.round(p + pad_x), self._region_of_interest_shape[0]]).astype(
                 "int"
             )
@@ -654,12 +655,10 @@ def preprocess(
                 probe_x0, probe_y0 = get_CoM(
                     self._vacuum_probe_intensity, device=self._device
                 )
-                shift_x = self._region_of_interest_shape[0] // 2 - probe_x0
-                shift_y = self._region_of_interest_shape[1] // 2 - probe_y0
                 self._vacuum_probe_intensity = get_shifted_ar(
                     self._vacuum_probe_intensity,
-                    shift_x,
-                    shift_y,
+                    -probe_x0,
+                    -probe_y0,
                     bilinear=True,
                     device=self._device,
                 )
@@ -717,8 +716,6 @@ def preprocess(
             device=self._device,
         )._evaluate_ctf()
 
-        self._known_aberrations_array = xp.fft.ifftshift(self._known_aberrations_array)
-
         # Precomputed propagator arrays
         self._slice_thicknesses = np.tile(
             self._object_shape[1] * self.sampling[1] / self._num_slices,
@@ -795,7 +792,7 @@ def preprocess(
 
             # initial probe
             complex_probe_rgb = Complex2RGB(
-                asnumpy(self._probe),
+                self.probe_centered,
                 vmin=vmin,
                 vmax=vmax,
                 hue_start=hue_start,
@@ -810,7 +807,7 @@ def preprocess(
                     propagated_probe, self._propagator_arrays[s]
                 )
             complex_propagated_rgb = Complex2RGB(
-                asnumpy(propagated_probe),
+                asnumpy(self._return_centered_probe(propagated_probe)),
                 vmin=vmin,
                 vmax=vmax,
                 hue_start=hue_start,
@@ -2485,11 +2482,11 @@ def reconstruct(
             self.error_iterations.append(error.item())
             if store_iterations:
                 self.object_iterations.append(asnumpy(self._object.copy()))
-                self.probe_iterations.append(asnumpy(self._probe.copy()))
+                self.probe_iterations.append(self.probe_centered)
 
         # store result
         self.object = asnumpy(self._object)
-        self.probe = asnumpy(self._probe)
+        self.probe = self.probe_centered
         self.error = error.item()
 
         return self
@@ -3030,7 +3027,7 @@ def _return_object_fft(
             rotated_3d_obj.sum(0), angle=None, x_lims=x_lims, y_lims=y_lims
         )
 
-        return np.abs(np.fft.fftshift(np.fft.fft2(rotated_object)))
+        return np.abs(np.fft.fftshift(np.fft.fft2(np.fft.ifftshift(rotated_object))))
 
     def show_object_fft(
         self,
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index ac98738dc..dd5eb2be8 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -254,40 +254,6 @@ def _propagate_array(self, array: np.ndarray, propagator_array: np.ndarray):
 
         return xp.fft.ifft2(xp.fft.fft2(array) * propagator_array)
 
-    def _expand_or_project_sliced_object(self, array: np.ndarray, output_z):
-        """
-        OLD Version
-
-        Expands supersliced object or projects voxel-sliced object.
-
-        Parameters
-        ----------
-        array: np.ndarray
-            3D array to expand/project
-        output_z: int
-            Output_dimension to expand/project array to.
-            If output_z > array.shape[0] array is expanded, else it's projected
-
-        Returns
-        -------
-        expanded_or_projected_array: np.ndarray
-            expanded or projected array
-        """
-        zoom = self._zoom
-        input_z = array.shape[0]
-
-        return (
-            zoom(
-                array,
-                (output_z / input_z, 1, 1),
-                order=0,
-                mode="nearest",
-                grid_mode=True,
-            )
-            * input_z
-            / output_z
-        )
-
     def _project_sliced_object(self, array: np.ndarray, output_z):
         """
         Expands supersliced object or projects voxel-sliced object.
@@ -545,8 +511,9 @@ def preprocess(
 
         # Object Initialization
         if self._object is None:
-            pad_x, pad_y = self._object_padding_px
-            p, q = np.max(self._positions_px_all, axis=0)
+            pad_x = self._object_padding_px[0][1]
+            pad_y = self._object_padding_px[1][1]
+            p, q = np.round(np.max(self._positions_px_all, axis=0))
             p = np.max([np.round(p + pad_x), self._region_of_interest_shape[0]]).astype(
                 "int"
             )
@@ -601,8 +568,8 @@ def preprocess(
                 shift_y = self._region_of_interest_shape[1] // 2 - probe_y0
                 self._vacuum_probe_intensity = get_shifted_ar(
                     self._vacuum_probe_intensity,
-                    shift_x,
-                    shift_y,
+                    -probe_x0,
+                    -probe_y0,
                     bilinear=True,
                     device=self._device,
                 )
@@ -660,8 +627,6 @@ def preprocess(
             device=self._device,
         )._evaluate_ctf()
 
-        self._known_aberrations_array = xp.fft.ifftshift(self._known_aberrations_array)
-
         # Precomputed propagator arrays
         self._slice_thicknesses = np.tile(
             self._object_shape[1] * self.sampling[1] / self._num_slices,
@@ -741,7 +706,7 @@ def preprocess(
 
             # initial probe
             complex_probe_rgb = Complex2RGB(
-                asnumpy(self._probe),
+                self.probe_centered,
                 vmin=vmin,
                 vmax=vmax,
                 hue_start=hue_start,
@@ -756,7 +721,7 @@ def preprocess(
                     propagated_probe, self._propagator_arrays[s]
                 )
             complex_propagated_rgb = Complex2RGB(
-                asnumpy(propagated_probe),
+                asnumpy(self._return_centered_probe(propagated_probe)),
                 vmin=vmin,
                 vmax=vmax,
                 hue_start=hue_start,
@@ -2240,11 +2205,11 @@ def reconstruct(
             self.error_iterations.append(error.item())
             if store_iterations:
                 self.object_iterations.append(asnumpy(self._object.copy()))
-                self.probe_iterations.append(asnumpy(self._probe.copy()))
+                self.probe_iterations.append(self.probe_centered)
 
         # store result
         self.object = asnumpy(self._object)
-        self.probe = asnumpy(self._probe)
+        self.probe = self.probe_centered
         self.error = error.item()
 
         return self
@@ -2440,12 +2405,21 @@ def _visualize_last_iteration(
             0,
         ]
 
-        probe_extent = [
-            0,
-            self.sampling[1] * self._region_of_interest_shape[1],
-            self.sampling[0] * self._region_of_interest_shape[0],
-            0,
-        ]
+        if plot_fourier_probe:
+            probe_extent = [
+                0,
+                self.angular_sampling[1] * self._region_of_interest_shape[1],
+                self.angular_sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
+
+        elif plot_probe:
+            probe_extent = [
+                0,
+                self.sampling[1] * self._region_of_interest_shape[1],
+                self.sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
 
         if plot_convergence:
             if plot_probe or plot_fourier_probe:
@@ -2509,19 +2483,21 @@ def _visualize_last_iteration(
                     self.probe_fourier, hue_start=hue_start, invert=invert
                 )
                 ax.set_title("Reconstructed Fourier probe")
+                ax.set_ylabel("kx [mrad]")
+                ax.set_xlabel("ky [mrad]")
             else:
                 probe_array = Complex2RGB(
                     self.probe, hue_start=hue_start, invert=invert
                 )
                 ax.set_title("Reconstructed probe")
+                ax.set_ylabel("x [A]")
+                ax.set_xlabel("y [A]")
 
             im = ax.imshow(
                 probe_array,
                 extent=probe_extent,
                 **kwargs,
             )
-            ax.set_ylabel("x [A]")
-            ax.set_xlabel("y [A]")
 
             if cbar:
                 divider = make_axes_locatable(ax)
@@ -2686,12 +2662,20 @@ def _visualize_all_iterations(
             0,
         ]
 
-        probe_extent = [
-            0,
-            self.sampling[1] * self._region_of_interest_shape[1],
-            self.sampling[0] * self._region_of_interest_shape[0],
-            0,
-        ]
+        if plot_fourier_probe:
+            probe_extent = [
+                0,
+                self.angular_sampling[1] * self._region_of_interest_shape[1],
+                self.angular_sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
+        elif plot_probe:
+            probe_extent = [
+                0,
+                self.sampling[1] * self._region_of_interest_shape[1],
+                self.sampling[0] * self._region_of_interest_shape[0],
+                0,
+            ]
 
         if plot_convergence:
             if plot_probe or plot_fourier_probe:
@@ -2745,16 +2729,24 @@ def _visualize_all_iterations(
             for n, ax in enumerate(grid):
                 if plot_fourier_probe:
                     probe_array = Complex2RGB(
-                        asnumpy(self._return_fourier_probe(probes[grid_range[n]])),
+                        asnumpy(
+                            self._return_fourier_probe_from_centered_probe(
+                                probes[grid_range[n]]
+                            )
+                        ),
                         hue_start=hue_start,
                         invert=invert,
                     )
                     ax.set_title(f"Iter: {grid_range[n]} Fourier probe")
+                    ax.set_ylabel("kx [mrad]")
+                    ax.set_xlabel("ky [mrad]")
                 else:
                     probe_array = Complex2RGB(
                         probes[grid_range[n]], hue_start=hue_start, invert=invert
                     )
                     ax.set_title(f"Iter: {grid_range[n]} probe")
+                    ax.set_ylabel("x [A]")
+                    ax.set_xlabel("y [A]")
 
                 im = ax.imshow(
                     probe_array,
@@ -2762,9 +2754,6 @@ def _visualize_all_iterations(
                     **kwargs,
                 )
 
-                ax.set_ylabel("x [A]")
-                ax.set_xlabel("y [A]")
-
                 if cbar:
                     add_colorbar_arg(
                         grid.cbar_axes[n], hue_start=hue_start, invert=invert
@@ -2909,7 +2898,7 @@ def _return_object_fft(
             rotated_3d_obj.sum(0), angle=None, x_lims=x_lims, y_lims=y_lims
         )
 
-        return np.abs(np.fft.fftshift(np.fft.fft2(rotated_object)))
+        return np.abs(np.fft.fftshift(np.fft.fft2(np.fft.ifftshift(rotated_object))))
 
     def show_object_fft(
         self,

From 38d3bcec3db03dc5b4b2119617445b378dd9699b Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Fri, 16 Jun 2023 17:05:55 -0700
Subject: [PATCH 223/362] some flake8 gotchas

---
 py4DSTEM/process/phase/iterative_base_class.py                 | 1 -
 .../process/phase/iterative_overlap_magnetic_tomography.py     | 1 -
 py4DSTEM/process/phase/iterative_overlap_tomography.py         | 3 ---
 3 files changed, 5 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index 288c573cd..3e55b6d5a 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -3,7 +3,6 @@
 """
 
 import warnings
-from typing import Sequence
 
 import matplotlib.pyplot as plt
 import numpy as np
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 67d5f2bd5..0ef7725a1 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -1581,7 +1581,6 @@ def _object_gaussian_constraint(self, current_object, gaussian_filter_sigma):
             Constrained object estimate
         """
         gaussian_filter = self._gaussian_filter
-        xp = self._xp
 
         gaussian_filter_sigma /= self.sampling[0]
         current_object = gaussian_filter(current_object, gaussian_filter_sigma)
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index dd5eb2be8..4a64f17af 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -564,8 +564,6 @@ def preprocess(
                 probe_x0, probe_y0 = get_CoM(
                     self._vacuum_probe_intensity, device=self._device
                 )
-                shift_x = self._region_of_interest_shape[0] // 2 - probe_x0
-                shift_y = self._region_of_interest_shape[1] // 2 - probe_y0
                 self._vacuum_probe_intensity = get_shifted_ar(
                     self._vacuum_probe_intensity,
                     -probe_x0,
@@ -1456,7 +1454,6 @@ def _object_gaussian_constraint(self, current_object, gaussian_filter_sigma):
             Constrained object estimate
         """
         gaussian_filter = self._gaussian_filter
-        xp = self._xp
 
         gaussian_filter_sigma /= self.sampling[0]
         current_object = gaussian_filter(current_object, gaussian_filter_sigma)

From 0abdc555855a9a7093e6afd23e8a44abfc347538 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Fri, 16 Jun 2023 17:09:41 -0700
Subject: [PATCH 224/362] supporting old padding format

---
 py4DSTEM/process/phase/iterative_base_class.py | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index 3e55b6d5a..2ad0a0927 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -1443,6 +1443,12 @@ def _calculate_scan_positions_in_pixels(self, positions: np.ndarray):
         if self._object_padding_px is None:
             float_padding = self._region_of_interest_shape / 2
             self._object_padding_px = (float_padding, float_padding)
+        elif np.isscalar(self._object_padding_px[0]):
+            self._object_padding_px = (
+                    (self._object_padding_px[0],)*2,
+                    (self._object_padding_px[1],)*2
+                    )
+
         positions[:, 0] += self._object_padding_px[0][0]
         positions[:, 1] += self._object_padding_px[1][0]
 

From 4a1c13925e8044c7f340cd588b2ff8f4f76bf7fd Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Fri, 16 Jun 2023 17:25:37 -0700
Subject: [PATCH 225/362] adding show_complex to top-level imports

---
 py4DSTEM/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/__init__.py b/py4DSTEM/__init__.py
index 21409c101..dc8306990 100644
--- a/py4DSTEM/__init__.py
+++ b/py4DSTEM/__init__.py
@@ -46,7 +46,7 @@
 ### visualization
 
 from py4DSTEM import visualize
-from py4DSTEM.visualize import show
+from py4DSTEM.visualize import show,show_complex
 
 
 

From 97d6103d3ff8954bd3cf0e8d90c4b83e0465b337 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Sat, 17 Jun 2023 09:10:07 -0700
Subject: [PATCH 226/362] switched to svd-like orthogonalization (minor
 differences)

---
 .../iterative_mixedstate_ptychography.py      | 22 ++++++++++++++++---
 py4DSTEM/process/phase/utils.py               | 14 ------------
 2 files changed, 19 insertions(+), 17 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
index 2d595fab1..067f2aa8a 100644
--- a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
@@ -24,7 +24,6 @@
     ComplexProbe,
     fft_shift,
     generate_batches,
-    orthogonalize,
     polar_aliases,
     polar_symbols,
 )
@@ -1045,6 +1044,7 @@ def _probe_orthogonalization_constraint(self, current_probe):
         """
         Ptychographic probe-orthogonalization constraint.
         Used to ensure mixed states are orthogonal to each other.
+        Adapted from https://github.com/AdvancedPhotonSource/tike/blob/main/src/tike/ptycho/probe.py#L690
 
         Parameters
         --------
@@ -1057,9 +1057,25 @@ def _probe_orthogonalization_constraint(self, current_probe):
             Orthogonalized probe estimate
         """
         xp = self._xp
-        shape = current_probe.shape
+        n_probes = self._num_probes
 
-        return orthogonalize(current_probe.reshape((shape[0], -1)), xp).reshape(shape)
+        # compute upper half of P* @ P
+        pairwise_dot_product = xp.empty((n_probes, n_probes), dtype=current_probe.dtype)
+
+        for i in range(n_probes):
+            for j in range(i, n_probes):
+                pairwise_dot_product[i, j] = xp.sum(
+                    current_probe[i].conj() * current_probe[j]
+                )
+
+        # compute eigenvectors (effectively cheaper way of computing V* from SVD)
+        _, evecs = xp.linalg.eigh(pairwise_dot_product, UPLO="U")
+        current_probe = xp.tensordot(evecs.T, current_probe, axes=1)
+
+        # sort by real-space intensity
+        intensities = xp.sum(xp.abs(current_probe) ** 2, axis=(-2, -1))
+        intensities_order = xp.argsort(intensities, axis=None)[::-1]
+        return current_probe[intensities_order]
 
     def _constraints(
         self,
diff --git a/py4DSTEM/process/phase/utils.py b/py4DSTEM/process/phase/utils.py
index 6a14bc508..d57ad820a 100644
--- a/py4DSTEM/process/phase/utils.py
+++ b/py4DSTEM/process/phase/utils.py
@@ -458,20 +458,6 @@ def spatial_frequencies(gpts: Tuple[int, int], sampling: Tuple[float, float]):
     )
 
 
-def projection(u: np.ndarray, v: np.ndarray, xp):
-    """Projection of vector u onto vector v."""
-    return u * xp.vdot(u, v) / xp.vdot(u, u)
-
-
-def orthogonalize(V: np.ndarray, xp):
-    """Non-normalized QR decomposition using repeated projections."""
-    U = V.copy()
-    for i in range(1, V.shape[0]):
-        for j in range(i):
-            U[i, :] -= projection(U[j, :], V[i, :], xp)
-    return U
-
-
 ### FFT-shift functions
 
 

From e419d67c109c2c79b672ec20c3a65b7e2660e520 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Sat, 17 Jun 2023 09:10:41 -0700
Subject: [PATCH 227/362] fixed mixed-state probe initialization bug, expanded
 preprocess viz to help debug

---
 .../iterative_mixedstate_ptychography.py      | 59 +++++++++----------
 1 file changed, 27 insertions(+), 32 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
index 067f2aa8a..4b2187a15 100644
--- a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
@@ -442,16 +442,10 @@ def preprocess(
             # Randomly shift phase of other probes
             for i_probe in range(1, self._num_probes):
                 shift_x = xp.exp(
-                    -2j
-                    * np.pi
-                    * (xp.random.rand() - 0.5)
-                    * ((xp.arange(sx) + 0.5) / sx - 0.5)
+                    -2j * np.pi * (xp.random.rand() - 0.5) * xp.fft.fftfreq(sx)
                 )
                 shift_y = xp.exp(
-                    -2j
-                    * np.pi
-                    * (xp.random.rand() - 0.5)
-                    * ((xp.arange(sy) + 0.5) / sy - 0.5)
+                    -2j * np.pi * (xp.random.rand() - 0.5) * xp.fft.fftfreq(sy)
                 )
                 self._probe[i_probe] = (
                     self._probe[i_probe - 1] * shift_x[:, None] * shift_y[None]
@@ -487,7 +481,7 @@ def preprocess(
         self._object_fov_mask_inverse = np.invert(self._object_fov_mask)
 
         if plot_probe_overlaps:
-            figsize = kwargs.pop("figsize", (9, 4))
+            figsize = kwargs.pop("figsize", (4.5 * self._num_probes + 4, 4))
             cmap = kwargs.pop("cmap", "Greys_r")
             vmin = kwargs.pop("vmin", None)
             vmax = kwargs.pop("vmax", None)
@@ -496,7 +490,7 @@ def preprocess(
 
             # initial probe
             complex_probe_rgb = Complex2RGB(
-                self.probe_centered[0],
+                self.probe_centered,
                 vmin=vmin,
                 vmax=vmax,
                 hue_start=hue_start,
@@ -517,40 +511,41 @@ def preprocess(
                 0,
             ]
 
-            fig, (ax1, ax2) = plt.subplots(1, 2, figsize=figsize)
+            fig, axs = plt.subplots(1, self._num_probes + 1, figsize=figsize)
 
-            ax1.imshow(
-                complex_probe_rgb,
-                extent=probe_extent,
-                **kwargs,
-            )
-
-            divider = make_axes_locatable(ax1)
-            cax1 = divider.append_axes("right", size="5%", pad="2.5%")
-            add_colorbar_arg(
-                cax1, vmin=vmin, vmax=vmax, hue_start=hue_start, invert=invert
-            )
-            ax1.set_ylabel("x [A]")
-            ax1.set_xlabel("y [A]")
-            ax1.set_title("Initial Probe[0]")
+            for i in range(self._num_probes):
+                axs[i].imshow(
+                    complex_probe_rgb[i],
+                    extent=probe_extent,
+                    **kwargs,
+                )
+                axs[i].set_ylabel("x [A]")
+                axs[i].set_xlabel("y [A]")
+                axs[i].set_title(f"Initial Probe[{i}]")
+
+                divider = make_axes_locatable(axs[i])
+                cax = divider.append_axes("right", size="5%", pad="2.5%")
+                add_colorbar_arg(
+                    cax, vmin=vmin, vmax=vmax, hue_start=hue_start, invert=invert
+                )
 
-            ax2.imshow(
+            axs[-1].imshow(
                 asnumpy(probe_overlap),
                 extent=extent,
                 cmap=cmap,
                 **kwargs,
             )
-            ax2.scatter(
+            axs[-1].scatter(
                 self.positions[:, 1],
                 self.positions[:, 0],
                 s=2.5,
                 color=(1, 0, 0, 1),
             )
-            ax2.set_ylabel("x [A]")
-            ax2.set_xlabel("y [A]")
-            ax2.set_xlim((extent[0], extent[1]))
-            ax2.set_ylim((extent[2], extent[3]))
-            ax2.set_title("Object Field of View")
+            axs[-1].set_ylabel("x [A]")
+            axs[-1].set_xlabel("y [A]")
+            axs[-1].set_xlim((extent[0], extent[1]))
+            axs[-1].set_ylim((extent[2], extent[3]))
+            axs[-1].set_title("Object Field of View")
 
             fig.tight_layout()
 

From b3bb16d5c639a849010a3754ae37b08dfb484b32 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Sat, 17 Jun 2023 10:16:28 -0700
Subject: [PATCH 228/362] fixed read-write of corner-centered probes

---
 .../process/phase/iterative_base_class.py     | 50 ++++++++-----------
 1 file changed, 21 insertions(+), 29 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index 2ad0a0927..04462c389 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -1210,6 +1210,15 @@ def to_h5(self, group):
             data=self._polar_parameters,
         )
 
+        # object
+        self._object_emd = Array(
+            name="reconstruction_object",
+            data=asnumpy(self._xp.asarray(self._object)),
+        )
+
+        # probe
+        self._probe_emd = Array(name="reconstruction_probe", data=asnumpy(self._probe))
+
         if is_stack:
             iterations_labels = [f"iteration_{i:03}" for i in iterations]
 
@@ -1217,32 +1226,20 @@ def to_h5(self, group):
             object_iterations = [
                 np.asarray(self.object_iterations[i]) for i in iterations
             ]
-            self._object_emd = Array(
-                name="reconstruction_object",
+            self._object_iterations_emd = Array(
+                name="reconstruction_object_iterations",
                 data=np.stack(object_iterations, axis=0),
                 slicelabels=iterations_labels,
             )
 
             # probe
             probe_iterations = [self.probe_iterations[i] for i in iterations]
-            self._probe_emd = Array(
-                name="reconstruction_probe",
+            self._probe_iterations_emd = Array(
+                name="reconstruction_probe_iterations",
                 data=np.stack(probe_iterations, axis=0),
                 slicelabels=iterations_labels,
             )
 
-        else:
-            # object
-            self._object_emd = Array(
-                name="reconstruction_object",
-                data=asnumpy(self._xp.asarray(self._object)),
-            )
-
-            # probe
-            self._probe_emd = Array(
-                name="reconstruction_probe", data=asnumpy(self._probe)
-            )
-
         # exit_waves
         if self._save_exit_waves:
             self._exit_waves_emd = Array(
@@ -1283,13 +1280,8 @@ def _get_constructor_args(cls, group):
         else:
             dc = None
 
-        # Check if stack
-        if dict_data["_object_emd"].is_stack:
-            obj = dict_data["_object_emd"][-1].data
-            probe = dict_data["_probe_emd"][-1].data
-        else:
-            obj = dict_data["_object_emd"].data
-            probe = dict_data["_probe_emd"].data
+        obj = dict_data["_object_emd"].data
+        probe = dict_data["_probe_emd"].data
 
         # Populate args and return
         kwargs = {
@@ -1347,8 +1339,8 @@ def _populate_instance(self, group):
 
         # Check if stack
         if hasattr(error, "__len__"):
-            self.object_iterations = list(dict_data["_object_emd"].data)
-            self.probe_iterations = list(dict_data["_probe_emd"].data)
+            self.object_iterations = list(dict_data["_object_iterations_emd"].data)
+            self.probe_iterations = list(dict_data["_probe_iterations_emd"].data)
             self.error_iterations = error
             self.error = error[-1]
         else:
@@ -1357,7 +1349,7 @@ def _populate_instance(self, group):
         # Slim preprocessing to enable visualize
         self._positions_px_com = xp.mean(self._positions_px, axis=0)
         self.object = asnumpy(self._object)
-        self.probe = asnumpy(self._probe)
+        self.probe = self.probe_centered
         self._preprocessed = True
 
     def _set_polar_parameters(self, parameters: dict):
@@ -1445,9 +1437,9 @@ def _calculate_scan_positions_in_pixels(self, positions: np.ndarray):
             self._object_padding_px = (float_padding, float_padding)
         elif np.isscalar(self._object_padding_px[0]):
             self._object_padding_px = (
-                    (self._object_padding_px[0],)*2,
-                    (self._object_padding_px[1],)*2
-                    )
+                (self._object_padding_px[0],) * 2,
+                (self._object_padding_px[1],) * 2,
+            )
 
         positions[:, 0] += self._object_padding_px[0][0]
         positions[:, 1] += self._object_padding_px[1][0]

From 0b56a40cf383349666f2d3ea5bd6b64409e83f5b Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Tue, 20 Jun 2023 16:08:48 -0700
Subject: [PATCH 229/362] re-introducing Fourier probe amplitude fixing

---
 .../iterative_ptychographic_constraints.py    | 31 +++++++
 .../iterative_singleslice_ptychography.py     | 80 ++++++++++++-------
 2 files changed, 80 insertions(+), 31 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
index 10b24eb78..274e86f39 100644
--- a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
+++ b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
@@ -486,6 +486,37 @@ def _probe_fourier_amplitude_constraint(
 
         return updated_probe * normalization
 
+    def _probe_aperture_constraint(
+        self,
+        current_probe,
+        initial_probe_aperture,
+    ):
+        """
+        Ptychographic constraint to fix Fourier amplitude to initial aperture.
+
+        Parameters
+        ----------
+        current_probe: np.ndarray
+            Current positions estimate
+
+        Returns
+        --------
+        constrained_probe: np.ndarray
+            Constrained probe estimate
+        """
+        xp = self._xp
+
+        current_probe_sum = xp.sum(xp.abs(current_probe) ** 2)
+        current_probe_fft_phase = xp.angle(xp.fft.fft2(current_probe))
+
+        updated_probe = xp.fft.ifft2(
+            xp.exp(1j * current_probe_fft_phase) * initial_probe_aperture
+        )
+        updated_probe_sum = xp.sum(xp.abs(updated_probe) ** 2)
+        normalization = xp.sqrt(current_probe_sum / updated_probe_sum)
+
+        return updated_probe * normalization
+
     def _probe_residual_aberration_filtering_constraint(
         self,
         current_probe,
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index 5ef8985c6..269a61180 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -446,6 +446,7 @@ def preprocess(
                 self._probe = xp.asarray(self._probe, dtype=xp.complex64)
 
         self._probe_initial = self._probe.copy()
+        self._probe_initial_aperture = xp.abs(xp.fft.fft2(self._probe))
 
         self._known_aberrations_array = ComplexProbe(
             energy=self._energy,
@@ -999,11 +1000,13 @@ def _constraints(
         probe_gaussian_filter,
         probe_gaussian_filter_sigma,
         probe_gaussian_filter_fix_amplitude,
-        fix_probe_amplitude,
-        fix_probe_amplitude_relative_radius,
-        fix_probe_amplitude_relative_width,
-        fix_probe_fourier_amplitude,
-        fix_probe_fourier_amplitude_threshold,
+        constrain_probe_amplitude,
+        constrain_probe_amplitude_relative_radius,
+        constrain_probe_amplitude_relative_width,
+        constrain_probe_fourier_amplitude,
+        constrain_probe_fourier_amplitude_threshold,
+        fix_probe_aperture,
+        initial_probe_aperture,
         fix_positions,
         global_affine_transformation,
         gaussian_filter,
@@ -1039,17 +1042,21 @@ def _constraints(
             Standard deviation of gaussian kernel in A^-1
         probe_gaussian_filter_fix_amplitude: bool
             If True, only the probe phase is smoothed
-        fix_probe_amplitude: bool
+        constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
-        fix_probe_amplitude_relative_radius: float
+        constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
-        fix_probe_amplitude_relative_width: float
+        constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        fix_probe_fourier_amplitude: bool
+        constrain_probe_fourier_amplitude: bool
             If True, probe fourier amplitude is constrained by top hat function
-        fix_probe_fourier_amplitude_threshold: float
+        constrain_probe_fourier_amplitude_threshold: float
             Threshold value for current probe fourier mask. Value should
             be between 0 and 1, where higher values provide the most masking.
+        fix_probe_aperture: bool,
+            If True, probe Fourier amplitude is replaced by initial probe aperture.
+        initial_probe_aperture: np.ndarray,
+            Initial probe aperture to use in replacing probe Fourier amplitude.
         fix_positions: bool
             If True, positions are not updated
         gaussian_filter: bool
@@ -1121,17 +1128,22 @@ def _constraints(
         if symmetrize_probe:
             current_probe = self._probe_radial_symmetrization_constraint(current_probe)
 
-        if fix_probe_amplitude:
+        if fix_probe_aperture:
+            current_probe = self._probe_aperture_constraint(
+                current_probe,
+                initial_probe_aperture,
+            )
+        elif constrain_probe_amplitude:
             current_probe = self._probe_amplitude_constraint(
                 current_probe,
-                fix_probe_amplitude_relative_radius,
-                fix_probe_amplitude_relative_width,
+                constrain_probe_amplitude_relative_radius,
+                constrain_probe_amplitude_relative_width,
             )
-        elif fix_probe_fourier_amplitude:
+        elif constrain_probe_fourier_amplitude:
             current_probe = self._probe_fourier_amplitude_constraint(
                 current_probe,
-                fix_probe_fourier_amplitude_threshold,
-                fix_probe_amplitude_relative_width,
+                constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_amplitude_relative_width,
             )
 
         if not fix_positions:
@@ -1159,12 +1171,13 @@ def reconstruct(
         pure_phase_object_iter: int = 0,
         fix_com: bool = True,
         fix_probe_iter: int = 0,
+        fix_probe_aperture_iter: int = 0,
         symmetrize_probe_iter: int = 0,
-        fix_probe_amplitude_iter: int = 0,
-        fix_probe_amplitude_relative_radius: float = 0.5,
-        fix_probe_amplitude_relative_width: float = 0.05,
-        fix_probe_fourier_amplitude_iter: int = 0,
-        fix_probe_fourier_amplitude_threshold: float = 0.9,
+        constrain_probe_amplitude_iter: int = 0,
+        constrain_probe_amplitude_relative_radius: float = 0.5,
+        constrain_probe_amplitude_relative_width: float = 0.05,
+        constrain_probe_fourier_amplitude_iter: int = 0,
+        constrain_probe_fourier_amplitude_threshold: float = 0.9,
         fix_positions_iter: int = np.inf,
         constrain_position_distance: float = None,
         global_affine_transformation: bool = True,
@@ -1218,17 +1231,19 @@ def reconstruct(
             If True, fixes center of mass of probe
         fix_probe_iter: int, optional
             Number of iterations to run with a fixed probe before updating probe estimate
+        fix_probe_aperture_iter: int, optional
+            Number of iterations to run with a fixed probe Fourier amplitude before updating probe estimate
         symmetrize_probe_iter: int, optional
             Number of iterations to run before radially-averaging the probe
-        fix_probe_amplitude: bool
+        constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
-        fix_probe_amplitude_relative_radius: float
+        constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
-        fix_probe_amplitude_relative_width: float
+        constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        fix_probe_fourier_amplitude: bool
+        constrain_probe_fourier_amplitude: bool
             If True, probe fourier amplitude is constrained by top hat function
-        fix_probe_fourier_amplitude_threshold: float
+        constrain_probe_fourier_amplitude_threshold: float
             Threshold value for current probe fourier mask. Value should
             be between 0 and 1, where higher values provide the most masking.
         fix_positions_iter: int, optional
@@ -1564,13 +1579,16 @@ def reconstruct(
                 and probe_gaussian_filter_sigma is not None,
                 probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
                 probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
-                fix_probe_amplitude=a0 < fix_probe_amplitude_iter
+                constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                 and a0 >= fix_probe_iter,
-                fix_probe_amplitude_relative_radius=fix_probe_amplitude_relative_radius,
-                fix_probe_amplitude_relative_width=fix_probe_amplitude_relative_width,
-                fix_probe_fourier_amplitude=a0 < fix_probe_fourier_amplitude_iter
+                constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
+                constrain_probe_amplitude_relative_width=constrain_probe_amplitude_relative_width,
+                constrain_probe_fourier_amplitude=a0
+                < constrain_probe_fourier_amplitude_iter
                 and a0 >= fix_probe_iter,
-                fix_probe_fourier_amplitude_threshold=fix_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                fix_probe_aperture=a0 < fix_probe_aperture_iter,
+                initial_probe_aperture=self._probe_initial_aperture,
                 fix_positions=a0 < fix_positions_iter,
                 global_affine_transformation=global_affine_transformation,
                 gaussian_filter=a0 < gaussian_filter_iter

From a0cfa8b8ab93ae5dea164d578e94843b054e0b96 Mon Sep 17 00:00:00 2001
From: gvarnavi <gvarnavi@mit.edu>
Date: Wed, 21 Jun 2023 09:40:28 -0700
Subject: [PATCH 230/362] Fourier probe amplitude fixing in rest of classes

---
 .../iterative_mixedstate_ptychography.py      | 69 +++++++------
 .../iterative_multislice_ptychography.py      | 80 ++++++++++------
 .../iterative_overlap_magnetic_tomography.py  | 94 +++++++++++-------
 .../phase/iterative_overlap_tomography.py     | 96 +++++++++++--------
 .../iterative_simultaneous_ptychography.py    | 80 ++++++++++------
 5 files changed, 255 insertions(+), 164 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
index 4b2187a15..afa565871 100644
--- a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
@@ -459,6 +459,7 @@ def preprocess(
             self._probe = xp.asarray(self._probe, dtype=xp.complex64)
 
         self._probe_initial = self._probe.copy()
+        self._probe_initial_aperture = None  # Doesn't really make sense for mixed-state
 
         self._known_aberrations_array = ComplexProbe(
             energy=self._energy,
@@ -1083,11 +1084,13 @@ def _constraints(
         probe_gaussian_filter,
         probe_gaussian_filter_sigma,
         probe_gaussian_filter_fix_amplitude,
-        fix_probe_amplitude,
-        fix_probe_amplitude_relative_radius,
-        fix_probe_amplitude_relative_width,
-        fix_probe_fourier_amplitude,
-        fix_probe_fourier_amplitude_threshold,
+        constrain_probe_amplitude,
+        constrain_probe_amplitude_relative_radius,
+        constrain_probe_amplitude_relative_width,
+        constrain_probe_fourier_amplitude,
+        constrain_probe_fourier_amplitude_threshold,
+        fix_probe_aperture,
+        initial_probe_aperture,
         fix_positions,
         global_affine_transformation,
         gaussian_filter,
@@ -1124,17 +1127,21 @@ def _constraints(
             If True, only the probe phase is smoothed
         symmetrize_probe: bool
             If True, the probe is radially-averaged
-        fix_probe_amplitude: bool
+        constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
-        fix_probe_amplitude_relative_radius: float
+        constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
-        fix_probe_amplitude_relative_width: float
+        constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        fix_probe_fourier_amplitude: bool
+        constrain_probe_fourier_amplitude: bool
             If True, probe fourier amplitude is constrained by top hat function
-        fix_probe_fourier_amplitude_threshold: float
+        constrain_probe_fourier_amplitude_threshold: float
             Threshold value for current probe fourier mask. Value should
             be between 0 and 1, where higher values provide the most masking.
+        fix_probe_aperture: bool,
+            If True, probe fourier amplitude is replaced by initial probe aperture.
+        initial_probe_aperture: np.ndarray
+            initial probe aperture to use in replacing probe fourier amplitude
         fix_positions: bool
             If True, positions are not updated
         gaussian_filter: bool
@@ -1203,9 +1210,11 @@ def _constraints(
             raise NotImplementedError()
         if symmetrize_probe:
             raise NotImplementedError()
-        if fix_probe_amplitude:
+        if fix_probe_aperture:
             raise NotImplementedError()
-        elif fix_probe_fourier_amplitude:
+        elif constrain_probe_amplitude:
+            raise NotImplementedError()
+        elif constrain_probe_fourier_amplitude:
             raise NotImplementedError()
 
         if orthogonalize_probe:
@@ -1237,12 +1246,13 @@ def reconstruct(
         fix_com: bool = True,
         orthogonalize_probe: bool = True,
         fix_probe_iter: int = 0,
+        fix_probe_aperture_iter: int = 0,
         symmetrize_probe_iter: int = 0,
-        fix_probe_amplitude_iter: int = 0,
-        fix_probe_amplitude_relative_radius: float = 0.5,
-        fix_probe_amplitude_relative_width: float = 0.05,
-        fix_probe_fourier_amplitude_iter: int = 0,
-        fix_probe_fourier_amplitude_threshold: float = 0.9,
+        constrain_probe_amplitude_iter: int = 0,
+        constrain_probe_amplitude_relative_radius: float = 0.5,
+        constrain_probe_amplitude_relative_width: float = 0.05,
+        constrain_probe_fourier_amplitude_iter: int = 0,
+        constrain_probe_fourier_amplitude_threshold: float = 0.9,
         fix_positions_iter: int = np.inf,
         global_affine_transformation: bool = True,
         gaussian_filter_sigma: float = None,
@@ -1295,17 +1305,19 @@ def reconstruct(
             If True, fixes center of mass of probe
         fix_probe_iter: int, optional
             Number of iterations to run with a fixed probe before updating probe estimate
+        fix_probe_aperture_iter: int, optional
+            Number of iterations to run with a fixed probe fourier amplitude before updating probe estimate
         symmetrize_probe_iter: int, optional
             Number of iterations to run before radially-averaging the probe
-        fix_probe_amplitude: bool
+        constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
-        fix_probe_amplitude_relative_radius: float
+        constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
-        fix_probe_amplitude_relative_width: float
+        constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        fix_probe_fourier_amplitude: bool
+        constrain_probe_fourier_amplitude: bool
             If True, probe fourier amplitude is constrained by top hat function
-        fix_probe_fourier_amplitude_threshold: float
+        constrain_probe_fourier_amplitude_threshold: float
             Threshold value for current probe fourier mask. Value should
             be between 0 and 1, where higher values provide the most masking.
         fix_positions_iter: int, optional
@@ -1637,13 +1649,16 @@ def reconstruct(
                 and probe_gaussian_filter_sigma is not None,
                 probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
                 probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
-                fix_probe_amplitude=a0 < fix_probe_amplitude_iter
+                constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                 and a0 >= fix_probe_iter,
-                fix_probe_amplitude_relative_radius=fix_probe_amplitude_relative_radius,
-                fix_probe_amplitude_relative_width=fix_probe_amplitude_relative_width,
-                fix_probe_fourier_amplitude=a0 < fix_probe_fourier_amplitude_iter
+                constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
+                constrain_probe_amplitude_relative_width=constrain_probe_amplitude_relative_width,
+                constrain_probe_fourier_amplitude=a0
+                < constrain_probe_fourier_amplitude_iter
                 and a0 >= fix_probe_iter,
-                fix_probe_fourier_amplitude_threshold=fix_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                fix_probe_aperture=a0 < fix_probe_aperture_iter,
+                initial_probe_aperture=self._probe_initial_aperture,
                 fix_positions=a0 < fix_positions_iter,
                 global_affine_transformation=global_affine_transformation,
                 gaussian_filter=a0 < gaussian_filter_iter
diff --git a/py4DSTEM/process/phase/iterative_multislice_ptychography.py b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
index ce8d13325..a67bd93e9 100644
--- a/py4DSTEM/process/phase/iterative_multislice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
@@ -521,6 +521,7 @@ def preprocess(
                 self._probe = xp.asarray(self._probe, dtype=xp.complex64)
 
         self._probe_initial = self._probe.copy()
+        self._probe_initial_aperture = xp.abs(xp.fft.fft2(self._probe))
 
         self._known_aberrations_array = ComplexProbe(
             energy=self._energy,
@@ -1432,11 +1433,13 @@ def _constraints(
         probe_gaussian_filter,
         probe_gaussian_filter_sigma,
         probe_gaussian_filter_fix_amplitude,
-        fix_probe_amplitude,
-        fix_probe_amplitude_relative_radius,
-        fix_probe_amplitude_relative_width,
-        fix_probe_fourier_amplitude,
-        fix_probe_fourier_amplitude_threshold,
+        constrain_probe_amplitude,
+        constrain_probe_amplitude_relative_radius,
+        constrain_probe_amplitude_relative_width,
+        constrain_probe_fourier_amplitude,
+        constrain_probe_fourier_amplitude_threshold,
+        fix_probe_aperture,
+        initial_probe_aperture,
         fix_positions,
         global_affine_transformation,
         gaussian_filter,
@@ -1477,17 +1480,21 @@ def _constraints(
             Standard deviation of gaussian kernel in A^-1
         probe_gaussian_filter_fix_amplitude: bool
             If True, only the probe phase is smoothed
-        fix_probe_amplitude: bool
+        constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
-        fix_probe_amplitude_relative_radius: float
+        constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
-        fix_probe_amplitude_relative_width: float
+        constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        fix_probe_fourier_amplitude: bool
+        constrain_probe_fourier_amplitude: bool
             If True, probe fourier amplitude is constrained by top hat function
-        fix_probe_fourier_amplitude_threshold: float
+        constrain_probe_fourier_amplitude_threshold: float
             Threshold value for current probe fourier mask. Value should
             be between 0 and 1, where higher values provide the most masking.
+        fix_probe_aperture: bool
+            If True, probe Fourier amplitude is replaced by initial_probe_aperture
+        initial_probe_aperture: np.ndarray
+            Initial probe aperture to use in replacing probe Fourier amplitude
         fix_positions: bool
             If True, positions are not updated
         gaussian_filter: bool
@@ -1589,17 +1596,22 @@ def _constraints(
         if symmetrize_probe:
             current_probe = self._probe_radial_symmetrization_constraint(current_probe)
 
-        if fix_probe_amplitude:
+        if fix_probe_aperture:
+            current_probe = self._probe_aperture_constraint(
+                current_probe,
+                initial_probe_aperture,
+            )
+        elif constrain_probe_amplitude:
             current_probe = self._probe_amplitude_constraint(
                 current_probe,
-                fix_probe_amplitude_relative_radius,
-                fix_probe_amplitude_relative_width,
+                constrain_probe_amplitude_relative_radius,
+                constrain_probe_amplitude_relative_width,
             )
-        elif fix_probe_fourier_amplitude:
+        elif constrain_probe_fourier_amplitude:
             current_probe = self._probe_fourier_amplitude_constraint(
                 current_probe,
-                fix_probe_fourier_amplitude_threshold,
-                fix_probe_amplitude_relative_width,
+                constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_amplitude_relative_width,
             )
 
         if not fix_positions:
@@ -1626,12 +1638,13 @@ def reconstruct(
         positions_step_size: float = 0.9,
         fix_com: bool = True,
         fix_probe_iter: int = 0,
+        fix_probe_aperture_iter: int = 0,
         symmetrize_probe_iter: int = 0,
-        fix_probe_amplitude_iter: int = 0,
-        fix_probe_amplitude_relative_radius: float = 0.5,
-        fix_probe_amplitude_relative_width: float = 0.05,
-        fix_probe_fourier_amplitude_iter: int = 0,
-        fix_probe_fourier_amplitude_threshold: float = 0.9,
+        constrain_probe_amplitude_iter: int = 0,
+        constrain_probe_amplitude_relative_radius: float = 0.5,
+        constrain_probe_amplitude_relative_width: float = 0.05,
+        constrain_probe_fourier_amplitude_iter: int = 0,
+        constrain_probe_fourier_amplitude_threshold: float = 0.9,
         fix_positions_iter: int = np.inf,
         constrain_position_distance: float = None,
         global_affine_transformation: bool = True,
@@ -1692,17 +1705,19 @@ def reconstruct(
             If True, fixes center of mass of probe
         fix_probe_iter: int, optional
             Number of iterations to run with a fixed probe before updating probe estimate
+        fix_probe_aperture_iter: int, optional
+            Number of iterations to run with a fixed probe Fourier amplitude before updating probe estimate
         symmetrize_probe_iter: int, optional
             Number of iterations to run before radially-averaging the probe
-        fix_probe_amplitude: bool
+        constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
-        fix_probe_amplitude_relative_radius: float
+        constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
-        fix_probe_amplitude_relative_width: float
+        constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        fix_probe_fourier_amplitude: bool
+        constrain_probe_fourier_amplitude: bool
             If True, probe fourier amplitude is constrained by top hat function
-        fix_probe_fourier_amplitude_threshold: float
+        constrain_probe_fourier_amplitude_threshold: float
             Threshold value for current probe fourier mask. Value should
             be between 0 and 1, where higher values provide the most masking.
         fix_positions_iter: int, optional
@@ -2049,13 +2064,16 @@ def reconstruct(
                 and probe_gaussian_filter_sigma is not None,
                 probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
                 probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
-                fix_probe_amplitude=a0 < fix_probe_amplitude_iter
+                constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                 and a0 >= fix_probe_iter,
-                fix_probe_amplitude_relative_radius=fix_probe_amplitude_relative_radius,
-                fix_probe_amplitude_relative_width=fix_probe_amplitude_relative_width,
-                fix_probe_fourier_amplitude=a0 < fix_probe_fourier_amplitude_iter
+                constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
+                constrain_probe_amplitude_relative_width=constrain_probe_amplitude_relative_width,
+                constrain_probe_fourier_amplitude=a0
+                < constrain_probe_fourier_amplitude_iter
                 and a0 >= fix_probe_iter,
-                fix_probe_fourier_amplitude_threshold=fix_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                fix_probe_aperture=a0 < fix_probe_aperture_iter,
+                initial_probe_aperture=self._probe_initial_aperture,
                 fix_positions=a0 < fix_positions_iter,
                 global_affine_transformation=global_affine_transformation,
                 gaussian_filter=a0 < gaussian_filter_iter
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 0ef7725a1..8e8484827 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -707,6 +707,7 @@ def preprocess(
                 self._probe = xp.asarray(self._probe, dtype=xp.complex64)
 
         self._probe_initial = self._probe.copy()
+        self._probe_initial_aperture = xp.abs(xp.fft.fft2(self._probe))
 
         self._known_aberrations_array = ComplexProbe(
             energy=self._energy,
@@ -1662,11 +1663,13 @@ def _constraints(
         probe_gaussian_filter,
         probe_gaussian_filter_sigma,
         probe_gaussian_filter_fix_amplitude,
-        fix_probe_amplitude,
-        fix_probe_amplitude_relative_radius,
-        fix_probe_amplitude_relative_width,
-        fix_probe_fourier_amplitude,
-        fix_probe_fourier_amplitude_threshold,
+        constrain_probe_amplitude,
+        constrain_probe_amplitude_relative_radius,
+        constrain_probe_amplitude_relative_width,
+        constrain_probe_fourier_amplitude,
+        constrain_probe_fourier_amplitude_threshold,
+        fix_probe_aperture,
+        initial_probe_aperture,
         fix_positions,
         global_affine_transformation,
         gaussian_filter,
@@ -1704,17 +1707,21 @@ def _constraints(
             Standard deviation of gaussian kernel in A^-1
         probe_gaussian_filter_fix_amplitude: bool
             If True, only the probe phase is smoothed
-        fix_probe_amplitude: bool
+        constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
-        fix_probe_amplitude_relative_radius: float
+        constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
-        fix_probe_amplitude_relative_width: float
+        constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        fix_probe_fourier_amplitude: bool
+        constrain_probe_fourier_amplitude: bool
             If True, probe fourier amplitude is constrained by top hat function
-        fix_probe_fourier_amplitude_threshold: float
+        constrain_probe_fourier_amplitude_threshold: float
             Threshold value for current probe fourier mask. Value should
             be between 0 and 1, where higher values provide the most masking.
+        fix_probe_aperture: bool,
+            If True, probe Fourier amplitude is replaced by initial probe aperture.
+        initial_probe_aperture: np.ndarray,
+            Initial probe aperture to use in replacing probe Fourier amplitude.
         fix_positions: bool
             If True, positions are not updated
         gaussian_filter: bool
@@ -1813,17 +1820,22 @@ def _constraints(
         if symmetrize_probe:
             current_probe = self._probe_radial_symmetrization_constraint(current_probe)
 
-        if fix_probe_amplitude:
+        if fix_probe_aperture:
+            current_probe = self._probe_aperture_constraint(
+                current_probe,
+                initial_probe_aperture,
+            )
+        elif constrain_probe_amplitude:
             current_probe = self._probe_amplitude_constraint(
                 current_probe,
-                fix_probe_amplitude_relative_radius,
-                fix_probe_amplitude_relative_width,
+                constrain_probe_amplitude_relative_radius,
+                constrain_probe_amplitude_relative_width,
             )
-        elif fix_probe_fourier_amplitude:
+        elif constrain_probe_fourier_amplitude:
             current_probe = self._probe_fourier_amplitude_constraint(
                 current_probe,
-                fix_probe_fourier_amplitude_threshold,
-                fix_probe_amplitude_relative_width,
+                constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_amplitude_relative_width,
             )
 
         if not fix_positions:
@@ -1850,12 +1862,13 @@ def reconstruct(
         positions_step_size: float = 0.9,
         fix_com: bool = True,
         fix_probe_iter: int = 0,
+        fix_probe_aperture_iter: int = 0,
         symmetrize_probe_iter: int = 0,
-        fix_probe_amplitude_iter: int = 0,
-        fix_probe_amplitude_relative_radius: float = 0.5,
-        fix_probe_amplitude_relative_width: float = 0.05,
-        fix_probe_fourier_amplitude_iter: int = 0,
-        fix_probe_fourier_amplitude_threshold: float = 0.9,
+        constrain_probe_amplitude_iter: int = 0,
+        constrain_probe_amplitude_relative_radius: float = 0.5,
+        constrain_probe_amplitude_relative_width: float = 0.05,
+        constrain_probe_fourier_amplitude_iter: int = 0,
+        constrain_probe_fourier_amplitude_threshold: float = 0.9,
         fix_positions_iter: int = np.inf,
         constrain_position_distance: float = None,
         global_affine_transformation: bool = True,
@@ -1912,17 +1925,19 @@ def reconstruct(
             If True, fixes center of mass of probe
         fix_probe_iter: int, optional
             Number of iterations to run with a fixed probe before updating probe estimate
+        fix_probe_aperture_iter: int, optional
+            Number of iterations to run with a fixed probe Fourier amplitude before updating probe estimate
         symmetrize_probe_iter: int, optional
             Number of iterations to run before radially-averaging the probe
-        fix_probe_amplitude: bool
+        constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
-        fix_probe_amplitude_relative_radius: float
+        constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
-        fix_probe_amplitude_relative_width: float
+        constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        fix_probe_fourier_amplitude: bool
+        constrain_probe_fourier_amplitude: bool
             If True, probe fourier amplitude is constrained by top hat function
-        fix_probe_fourier_amplitude_threshold: float
+        constrain_probe_fourier_amplitude_threshold: float
             Threshold value for current probe fourier mask. Value should
             be between 0 and 1, where higher values provide the most masking.
         fix_positions_iter: int, optional
@@ -2398,14 +2413,16 @@ def reconstruct(
                         and probe_gaussian_filter_sigma is not None,
                         probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
                         probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
-                        fix_probe_amplitude=a0 < fix_probe_amplitude_iter
+                        constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                         and a0 >= fix_probe_iter,
-                        fix_probe_amplitude_relative_radius=fix_probe_amplitude_relative_radius,
-                        fix_probe_amplitude_relative_width=fix_probe_amplitude_relative_width,
-                        fix_probe_fourier_amplitude=a0
-                        < fix_probe_fourier_amplitude_iter
+                        constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
+                        constrain_probe_amplitude_relative_width=constrain_probe_amplitude_relative_width,
+                        constrain_probe_fourier_amplitude=a0
+                        < constrain_probe_fourier_amplitude_iter
                         and a0 >= fix_probe_iter,
-                        fix_probe_fourier_amplitude_threshold=fix_probe_fourier_amplitude_threshold,
+                        constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                        fix_probe_aperture=a0 < fix_probe_aperture_iter,
+                        initial_probe_aperture=self._probe_initial_aperture,
                         fix_positions=a0 < fix_positions_iter,
                         global_affine_transformation=global_affine_transformation,
                         gaussian_filter=a0 < gaussian_filter_iter
@@ -2450,13 +2467,16 @@ def reconstruct(
                     and probe_gaussian_filter_sigma is not None,
                     probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
                     probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
-                    fix_probe_amplitude=a0 < fix_probe_amplitude_iter
+                    constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                     and a0 >= fix_probe_iter,
-                    fix_probe_amplitude_relative_radius=fix_probe_amplitude_relative_radius,
-                    fix_probe_amplitude_relative_width=fix_probe_amplitude_relative_width,
-                    fix_probe_fourier_amplitude=a0 < fix_probe_fourier_amplitude_iter
+                    constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
+                    constrain_probe_amplitude_relative_width=constrain_probe_amplitude_relative_width,
+                    constrain_probe_fourier_amplitude=a0
+                    < constrain_probe_fourier_amplitude_iter
                     and a0 >= fix_probe_iter,
-                    fix_probe_fourier_amplitude_threshold=fix_probe_fourier_amplitude_threshold,
+                    constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                    fix_probe_aperture=a0 < fix_probe_aperture_iter,
+                    initial_probe_aperture=self._probe_initial_aperture,
                     fix_positions=True,
                     global_affine_transformation=global_affine_transformation,
                     gaussian_filter=a0 < gaussian_filter_iter
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index 4a64f17af..6166640f4 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -616,6 +616,7 @@ def preprocess(
                 self._probe = xp.asarray(self._probe, dtype=xp.complex64)
 
         self._probe_initial = self._probe.copy()
+        self._probe_initial_aperture = xp.abs(xp.fft.fft2(self._probe))
 
         self._known_aberrations_array = ComplexProbe(
             energy=self._energy,
@@ -1510,11 +1511,13 @@ def _constraints(
         probe_gaussian_filter,
         probe_gaussian_filter_sigma,
         probe_gaussian_filter_fix_amplitude,
-        fix_probe_amplitude,
-        fix_probe_amplitude_relative_radius,
-        fix_probe_amplitude_relative_width,
-        fix_probe_fourier_amplitude,
-        fix_probe_fourier_amplitude_threshold,
+        constrain_probe_amplitude,
+        constrain_probe_amplitude_relative_radius,
+        constrain_probe_amplitude_relative_width,
+        constrain_probe_fourier_amplitude,
+        constrain_probe_fourier_amplitude_threshold,
+        fix_probe_aperture,
+        initial_probe_aperture,
         fix_positions,
         global_affine_transformation,
         gaussian_filter,
@@ -1548,17 +1551,21 @@ def _constraints(
             Standard deviation of gaussian kernel in A^-1
         probe_gaussian_filter_fix_amplitude: bool
             If True, only the probe phase is smoothed
-        fix_probe_amplitude: bool
+        constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
-        fix_probe_amplitude_relative_radius: float
+        constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
-        fix_probe_amplitude_relative_width: float
+        constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        fix_probe_fourier_amplitude: bool
+        constrain_probe_fourier_amplitude: bool
             If True, probe fourier amplitude is constrained by top hat function
-        fix_probe_fourier_amplitude_threshold: float
+        constrain_probe_fourier_amplitude_threshold: float
             Threshold value for current probe fourier mask. Value should
             be between 0 and 1, where higher values provide the most masking.
+        fix_probe_aperture: bool,
+            If True, probe Fourier amplitude is replaced by initial probe aperture.
+        initial_probe_aperture: np.ndarray,
+            Initial probe aperture to use in replacing probe Fourier amplitude.
         fix_positions: bool
             If True, positions are not updated
         gaussian_filter: bool
@@ -1626,17 +1633,22 @@ def _constraints(
         if symmetrize_probe:
             current_probe = self._probe_radial_symmetrization_constraint(current_probe)
 
-        if fix_probe_amplitude:
+        if fix_probe_aperture:
+            current_probe = self._probe_aperture_constraint(
+                current_probe,
+                initial_probe_aperture,
+            )
+        elif constrain_probe_amplitude:
             current_probe = self._probe_amplitude_constraint(
                 current_probe,
-                fix_probe_amplitude_relative_radius,
-                fix_probe_amplitude_relative_width,
+                constrain_probe_amplitude_relative_radius,
+                constrain_probe_amplitude_relative_width,
             )
-        elif fix_probe_fourier_amplitude:
+        elif constrain_probe_fourier_amplitude:
             current_probe = self._probe_fourier_amplitude_constraint(
                 current_probe,
-                fix_probe_fourier_amplitude_threshold,
-                fix_probe_amplitude_relative_width,
+                constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_amplitude_relative_width,
             )
 
         if not fix_positions:
@@ -1663,12 +1675,13 @@ def reconstruct(
         positions_step_size: float = 0.9,
         fix_com: bool = True,
         fix_probe_iter: int = 0,
+        fix_probe_aperture_iter: int = 0,
         symmetrize_probe_iter: int = 0,
-        fix_probe_amplitude_iter: int = 0,
-        fix_probe_amplitude_relative_radius: float = 0.5,
-        fix_probe_amplitude_relative_width: float = 0.05,
-        fix_probe_fourier_amplitude_iter: int = 0,
-        fix_probe_fourier_amplitude_threshold: float = 0.9,
+        constrain_probe_amplitude_iter: int = 0,
+        constrain_probe_amplitude_relative_radius: float = 0.5,
+        constrain_probe_amplitude_relative_width: float = 0.05,
+        constrain_probe_fourier_amplitude_iter: int = 0,
+        constrain_probe_fourier_amplitude_threshold: float = 0.9,
         fix_positions_iter: int = np.inf,
         constrain_position_distance: float = None,
         global_affine_transformation: bool = True,
@@ -1722,17 +1735,19 @@ def reconstruct(
             If True, fixes center of mass of probe
         fix_probe_iter: int, optional
             Number of iterations to run with a fixed probe before updating probe estimate
+        fix_probe_aperture_iter: int, optional
+            Number of iterations to run with a fixed probe Fourier amplitude before updating probe estimate
         symmetrize_probe_iter: int, optional
-            Number of iterations to run with a fixed probe before updating probe estimate
-        fix_probe_amplitude: bool
+            Number of iterations to run before radially-averaging the probe
+        constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
-        fix_probe_amplitude_relative_radius: float
+        constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
-        fix_probe_amplitude_relative_width: float
+        constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        fix_probe_fourier_amplitude: bool
+        constrain_probe_fourier_amplitude: bool
             If True, probe fourier amplitude is constrained by top hat function
-        fix_probe_fourier_amplitude_threshold: float
+        constrain_probe_fourier_amplitude_threshold: float
             Threshold value for current probe fourier mask. Value should
             be between 0 and 1, where higher values provide the most masking.
         fix_positions_iter: int, optional
@@ -2127,14 +2142,16 @@ def reconstruct(
                         and probe_gaussian_filter_sigma is not None,
                         probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
                         probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
-                        fix_probe_amplitude=a0 < fix_probe_amplitude_iter
+                        constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                         and a0 >= fix_probe_iter,
-                        fix_probe_amplitude_relative_radius=fix_probe_amplitude_relative_radius,
-                        fix_probe_amplitude_relative_width=fix_probe_amplitude_relative_width,
-                        fix_probe_fourier_amplitude=a0
-                        < fix_probe_fourier_amplitude_iter
+                        constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
+                        constrain_probe_amplitude_relative_width=constrain_probe_amplitude_relative_width,
+                        constrain_probe_fourier_amplitude=a0
+                        < constrain_probe_fourier_amplitude_iter
                         and a0 >= fix_probe_iter,
-                        fix_probe_fourier_amplitude_threshold=fix_probe_fourier_amplitude_threshold,
+                        constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                        fix_probe_aperture=a0 < fix_probe_aperture_iter,
+                        initial_probe_aperture=self._probe_initial_aperture,
                         fix_positions=a0 < fix_positions_iter,
                         global_affine_transformation=global_affine_transformation,
                         gaussian_filter=a0 < gaussian_filter_iter
@@ -2174,13 +2191,16 @@ def reconstruct(
                     and probe_gaussian_filter_sigma is not None,
                     probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
                     probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
-                    fix_probe_amplitude=a0 < fix_probe_amplitude_iter
+                    constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                     and a0 >= fix_probe_iter,
-                    fix_probe_amplitude_relative_radius=fix_probe_amplitude_relative_radius,
-                    fix_probe_amplitude_relative_width=fix_probe_amplitude_relative_width,
-                    fix_probe_fourier_amplitude=a0 < fix_probe_fourier_amplitude_iter
+                    constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
+                    constrain_probe_amplitude_relative_width=constrain_probe_amplitude_relative_width,
+                    constrain_probe_fourier_amplitude=a0
+                    < constrain_probe_fourier_amplitude_iter
                     and a0 >= fix_probe_iter,
-                    fix_probe_fourier_amplitude_threshold=fix_probe_fourier_amplitude_threshold,
+                    constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                    fix_probe_aperture=a0 < fix_probe_aperture_iter,
+                    initial_probe_aperture=self._probe_initial_aperture,
                     fix_positions=True,
                     global_affine_transformation=global_affine_transformation,
                     gaussian_filter=a0 < gaussian_filter_iter
diff --git a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
index e872bc42e..da358e089 100644
--- a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
@@ -694,6 +694,7 @@ def preprocess(
                 self._probe = xp.asarray(self._probe, dtype=xp.complex64)
 
         self._probe_initial = self._probe.copy()
+        self._probe_initial_aperture = xp.abs(xp.fft.fft2(self._probe))
 
         self._known_aberrations_array = ComplexProbe(
             energy=self._energy,
@@ -2181,11 +2182,13 @@ def _constraints(
         probe_gaussian_filter,
         probe_gaussian_filter_sigma,
         probe_gaussian_filter_fix_amplitude,
-        fix_probe_amplitude,
-        fix_probe_amplitude_relative_radius,
-        fix_probe_amplitude_relative_width,
-        fix_probe_fourier_amplitude,
-        fix_probe_fourier_amplitude_threshold,
+        constrain_probe_amplitude,
+        constrain_probe_amplitude_relative_radius,
+        constrain_probe_amplitude_relative_width,
+        constrain_probe_fourier_amplitude,
+        constrain_probe_fourier_amplitude_threshold,
+        fix_probe_aperture,
+        initial_probe_aperture,
         fix_positions,
         global_affine_transformation,
         gaussian_filter,
@@ -2219,17 +2222,21 @@ def _constraints(
             If True, probe CoM is fixed to the center
         symmetrize_probe: bool
             If True, the probe is radially-averaged
-        fix_probe_amplitude: bool
+        constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
-        fix_probe_amplitude_relative_radius: float
+        constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
-        fix_probe_amplitude_relative_width: float
+        constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        fix_probe_fourier_amplitude: bool
+        constrain_probe_fourier_amplitude: bool
             If True, probe fourier amplitude is constrained by top hat function
-        fix_probe_fourier_amplitude_threshold: float
+        constrain_probe_fourier_amplitude_threshold: float
             Threshold value for current probe fourier mask. Value should
             be between 0 and 1, where higher values provide the most masking.
+        fix_probe_aperture: bool,
+            If True, probe Fourier amplitude is replaced by initial probe aperture.
+        initial_probe_aperture: np.ndarray,
+            Initial probe aperture to use in replacing probe Fourier amplitude.
         fix_positions: bool
             If True, positions are not updated
         gaussian_filter: bool
@@ -2335,17 +2342,22 @@ def _constraints(
         if symmetrize_probe:
             current_probe = self._probe_radial_symmetrization_constraint(current_probe)
 
-        if fix_probe_amplitude:
+        if fix_probe_aperture:
+            current_probe = self._probe_aperture_constraint(
+                current_probe,
+                initial_probe_aperture,
+            )
+        elif constrain_probe_amplitude:
             current_probe = self._probe_amplitude_constraint(
                 current_probe,
-                fix_probe_amplitude_relative_radius,
-                fix_probe_amplitude_relative_width,
+                constrain_probe_amplitude_relative_radius,
+                constrain_probe_amplitude_relative_width,
             )
-        elif fix_probe_fourier_amplitude:
+        elif constrain_probe_fourier_amplitude:
             current_probe = self._probe_fourier_amplitude_constraint(
                 current_probe,
-                fix_probe_fourier_amplitude_threshold,
-                fix_probe_amplitude_relative_width,
+                constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_amplitude_relative_width,
             )
 
         if not fix_positions:
@@ -2374,12 +2386,13 @@ def reconstruct(
         fix_com: bool = True,
         fix_probe_iter: int = 0,
         warmup_iter: int = 0,
+        fix_probe_aperture_iter: int = 0,
         symmetrize_probe_iter: int = 0,
-        fix_probe_amplitude_iter: int = 0,
-        fix_probe_amplitude_relative_radius: float = 0.5,
-        fix_probe_amplitude_relative_width: float = 0.05,
-        fix_probe_fourier_amplitude_iter: int = 0,
-        fix_probe_fourier_amplitude_threshold: float = 0.9,
+        constrain_probe_amplitude_iter: int = 0,
+        constrain_probe_amplitude_relative_radius: float = 0.5,
+        constrain_probe_amplitude_relative_width: float = 0.05,
+        constrain_probe_fourier_amplitude_iter: int = 0,
+        constrain_probe_fourier_amplitude_threshold: float = 0.9,
         fix_positions_iter: int = np.inf,
         constrain_position_distance: float = None,
         global_affine_transformation: bool = True,
@@ -2436,17 +2449,19 @@ def reconstruct(
             If True, fixes center of mass of probe
         fix_probe_iter: int, optional
             Number of iterations to run with a fixed probe before updating probe estimate
+        fix_probe_aperture_iter: int, optional
+            Number of iterations to run with a fixed probe Fourier amplitude before updating probe estimate
         symmetrize_probe_iter: int, optional
             Number of iterations to run before radially-averaging the probe
-        fix_probe_amplitude: bool
+        constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
-        fix_probe_amplitude_relative_radius: float
+        constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
-        fix_probe_amplitude_relative_width: float
+        constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        fix_probe_fourier_amplitude: bool
+        constrain_probe_fourier_amplitude: bool
             If True, probe fourier amplitude is constrained by top hat function
-        fix_probe_fourier_amplitude_threshold: float
+        constrain_probe_fourier_amplitude_threshold: float
             Threshold value for current probe fourier mask. Value should
             be between 0 and 1, where higher values provide the most masking.
         fix_positions_iter: int, optional
@@ -2811,13 +2826,16 @@ def reconstruct(
                 and probe_gaussian_filter_sigma is not None,
                 probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
                 probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
-                fix_probe_amplitude=a0 < fix_probe_amplitude_iter
+                constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                 and a0 >= fix_probe_iter,
-                fix_probe_amplitude_relative_radius=fix_probe_amplitude_relative_radius,
-                fix_probe_amplitude_relative_width=fix_probe_amplitude_relative_width,
-                fix_probe_fourier_amplitude=a0 < fix_probe_fourier_amplitude_iter
+                constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
+                constrain_probe_amplitude_relative_width=constrain_probe_amplitude_relative_width,
+                constrain_probe_fourier_amplitude=a0
+                < constrain_probe_fourier_amplitude_iter
                 and a0 >= fix_probe_iter,
-                fix_probe_fourier_amplitude_threshold=fix_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                fix_probe_aperture=a0 < fix_probe_aperture_iter,
+                initial_probe_aperture=self._probe_initial_aperture,
                 fix_positions=a0 < fix_positions_iter,
                 global_affine_transformation=global_affine_transformation,
                 warmup_iteration=a0 < warmup_iter,

From c5ef1c39e290107742a4d89b5baea119b69af72b Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Sat, 24 Jun 2023 13:18:58 -0400
Subject: [PATCH 231/362] propagate sampling overrides

---
 .../iterative_mixedstate_ptychography.py      | 22 +++++++++++++-
 .../iterative_multislice_ptychography.py      | 22 +++++++++++++-
 .../iterative_overlap_magnetic_tomography.py  | 23 ++++++++++++++-
 .../phase/iterative_overlap_tomography.py     | 23 ++++++++++++++-
 .../iterative_simultaneous_ptychography.py    | 29 ++++++++++++++++++-
 .../iterative_singleslice_ptychography.py     | 14 +++++----
 6 files changed, 122 insertions(+), 11 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
index afa565871..4dea8172f 100644
--- a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
@@ -52,7 +52,9 @@ class MixedstatePtychographicReconstruction(PtychographicReconstruction):
     num_probes: int, optional
         Number of mixed-state probes
     semiangle_cutoff: float, optional
-        Semiangle cutoff for the initial probe guess
+        Semiangle cutoff for the initial probe guess in mrad
+    semiangle_cutoff_pixels: float, optional
+        Semiangle cutoff for the initial probe guess in pixels
     rolloff: float, optional
         Semiangle rolloff for the initial probe guess
     vacuum_probe_intensity: np.ndarray, optional
@@ -91,6 +93,7 @@ def __init__(
         datacube: DataCube = None,
         num_probes: int = None,
         semiangle_cutoff: float = None,
+        semiangle_cutoff_pixels: float = None,
         rolloff: float = 2.0,
         vacuum_probe_intensity: np.ndarray = None,
         polar_parameters: Mapping[str, float] = None,
@@ -171,6 +174,7 @@ def __init__(
         self._scan_positions = initial_scan_positions
         self._energy = energy
         self._semiangle_cutoff = semiangle_cutoff
+        self._semiangle_cutoff_pixels = semiangle_cutoff_pixels
         self._rolloff = rolloff
         self._object_type = object_type
         self._object_padding_px = object_padding_px
@@ -196,6 +200,9 @@ def preprocess(
         force_com_rotation: float = None,
         force_com_transpose: float = None,
         force_com_shifts: float = None,
+        force_scan_sampling: float = None,
+        force_angular_sampling: float = None,
+        force_reciprocal_sampling: float = None,
         object_fov_mask: np.ndarray = None,
         **kwargs,
     ):
@@ -245,6 +252,12 @@ def preprocess(
             Amplitudes come from diffraction patterns shifted with
             the CoM in the upper left corner for each probe unless
             shift is overwritten.
+        force_scan_sampling: float, optional
+            Override DataCube real space scan pixel size calibrations, in Angstrom
+        force_angular_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in mrad
+        force_reciprocal_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in A^-1
         object_fov_mask: np.ndarray (boolean)
             Boolean mask of FOV. Used to calculate additional shrinkage of object
             If None, probe_overlap intensity is thresholded
@@ -289,6 +302,9 @@ def preprocess(
         self._intensities = self._extract_intensities_and_calibrations_from_datacube(
             self._datacube,
             require_calibrations=True,
+            force_scan_sampling=force_scan_sampling,
+            force_angular_sampling=force_angular_sampling,
+            force_reciprocal_sampling=force_reciprocal_sampling,
         )
 
         (
@@ -344,6 +360,10 @@ def preprocess(
             self._scan_positions
         )
 
+        # handle semiangle specified in pixels
+        if self._semiangle_cutoff_pixels:
+            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
+
         # Object Initialization
         if self._object is None:
             pad_x = self._object_padding_px[0][1]
diff --git a/py4DSTEM/process/phase/iterative_multislice_ptychography.py b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
index a67bd93e9..a9dcf2d41 100644
--- a/py4DSTEM/process/phase/iterative_multislice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
@@ -56,7 +56,9 @@ class MultislicePtychographicReconstruction(PtychographicReconstruction):
     datacube: DataCube, optional
         Input 4D diffraction pattern intensities
     semiangle_cutoff: float, optional
-        Semiangle cutoff for the initial probe guess
+        Semiangle cutoff for the initial probe guess in mrad
+    semiangle_cutoff_pixels: float, optional
+        Semiangle cutoff for the initial probe guess in pixels
     rolloff: float, optional
         Semiangle rolloff for the initial probe guess
     vacuum_probe_intensity: np.ndarray, optional
@@ -99,6 +101,7 @@ def __init__(
         slice_thicknesses: Union[float, Sequence[float]],
         datacube: DataCube = None,
         semiangle_cutoff: float = None,
+        semiangle_cutoff_pixels: float = None,
         rolloff: float = 2.0,
         vacuum_probe_intensity: np.ndarray = None,
         polar_parameters: Mapping[str, float] = None,
@@ -175,6 +178,7 @@ def __init__(
         self._scan_positions = initial_scan_positions
         self._energy = energy
         self._semiangle_cutoff = semiangle_cutoff
+        self._semiangle_cutoff_pixels = semiangle_cutoff_pixels
         self._rolloff = rolloff
         self._object_type = object_type
         self._object_padding_px = object_padding_px
@@ -271,6 +275,9 @@ def preprocess(
         force_com_rotation: float = None,
         force_com_transpose: float = None,
         force_com_shifts: float = None,
+        force_scan_sampling: float = None,
+        force_angular_sampling: float = None,
+        force_reciprocal_sampling: float = None,
         object_fov_mask: np.ndarray = None,
         **kwargs,
     ):
@@ -320,6 +327,12 @@ def preprocess(
             Amplitudes come from diffraction patterns shifted with
             the CoM in the upper left corner for each probe unless
             shift is overwritten.
+        force_scan_sampling: float, optional
+            Override DataCube real space scan pixel size calibrations, in Angstrom
+        force_angular_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in mrad
+        force_reciprocal_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in A^-1
         object_fov_mask: np.ndarray (boolean)
             Boolean mask of FOV. Used to calculate additional shrinkage of object
             If None, probe_overlap intensity is thresholded
@@ -364,6 +377,9 @@ def preprocess(
         self._intensities = self._extract_intensities_and_calibrations_from_datacube(
             self._datacube,
             require_calibrations=True,
+            force_scan_sampling=force_scan_sampling,
+            force_angular_sampling=force_angular_sampling,
+            force_reciprocal_sampling=force_reciprocal_sampling,
         )
 
         (
@@ -419,6 +435,10 @@ def preprocess(
             self._scan_positions
         )
 
+        # handle semiangle specified in pixels
+        if self._semiangle_cutoff_pixels:
+            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
+
         # Object Initialization
         if self._object is None:
             pad_x = self._object_padding_px[0][1]
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 8e8484827..7831bd12a 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -63,7 +63,9 @@ class OverlapMagneticTomographicReconstruction(PtychographicReconstruction):
           - \beta tilt around x-axis
           - -\alpha tilt around z-axis
     semiangle_cutoff: float, optional
-        Semiangle cutoff for the initial probe guess
+        Semiangle cutoff for the initial probe guess in mrad
+    semiangle_cutoff_pixels: float, optional
+        Semiangle cutoff for the initial probe guess in pixels
     rolloff: float, optional
         Semiangle rolloff for the initial probe guess
     vacuum_probe_intensity: np.ndarray, optional
@@ -106,6 +108,7 @@ def __init__(
         tilt_angles_deg: Sequence[Tuple[float, float]],
         datacube: Sequence[DataCube] = None,
         semiangle_cutoff: float = None,
+        semiangle_cutoff_pixels: float = None,
         rolloff: float = 2.0,
         vacuum_probe_intensity: np.ndarray = None,
         polar_parameters: Mapping[str, float] = None,
@@ -171,6 +174,7 @@ def __init__(
         self._scan_positions = initial_scan_positions
         self._energy = energy
         self._semiangle_cutoff = semiangle_cutoff
+        self._semiangle_cutoff_pixels = semiangle_cutoff_pixels
         self._rolloff = rolloff
         self._object_type = object_type
         self._object_padding_px = object_padding_px
@@ -422,6 +426,9 @@ def preprocess(
         diffraction_patterns_transpose: bool = None,
         force_com_shifts: Sequence[float] = None,
         progress_bar: bool = True,
+        force_scan_sampling: float = None,
+        force_angular_sampling: float = None,
+        force_reciprocal_sampling: float = None,
         object_fov_mask: np.ndarray = None,
         **kwargs,
     ):
@@ -458,6 +465,12 @@ def preprocess(
             Amplitudes come from diffraction patterns shifted with
             the CoM in the upper left corner for each probe unless
             shift is overwritten. One tuple per tilt.
+        force_scan_sampling: float, optional
+            Override DataCube real space scan pixel size calibrations, in Angstrom
+        force_angular_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in mrad
+        force_reciprocal_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in A^-1
         object_fov_mask: np.ndarray (boolean)
             Boolean mask of FOV. Used to calculate additional shrinkage of object
             If None, probe_overlap intensity is thresholded
@@ -551,6 +564,9 @@ def preprocess(
             intensities = self._extract_intensities_and_calibrations_from_datacube(
                 self._datacube[tilt_index],
                 require_calibrations=True,
+                force_scan_sampling=force_scan_sampling,
+                force_angular_sampling=force_angular_sampling,
+                force_reciprocal_sampling=force_reciprocal_sampling,
             )
 
             (
@@ -600,6 +616,11 @@ def preprocess(
                 self._scan_positions[tilt_index]
             )
 
+        # handle semiangle specified in pixels
+        if self._semiangle_cutoff_pixels:
+            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
+
+
         # Object Initialization
         if self._object is None:
             pad_x = self._object_padding_px[0][1]
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index 6166640f4..a55a08697 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -58,7 +58,9 @@ class OverlapTomographicReconstruction(PtychographicReconstruction):
     tilt_angles_deg: Sequence[float]
         List of tilt angles in degrees,
     semiangle_cutoff: float, optional
-        Semiangle cutoff for the initial probe guess
+        Semiangle cutoff for the initial probe guess in mrad
+    semiangle_cutoff_pixels: float, optional
+        Semiangle cutoff for the initial probe guess in pixels
     rolloff: float, optional
         Semiangle rolloff for the initial probe guess
     vacuum_probe_intensity: np.ndarray, optional
@@ -101,6 +103,7 @@ def __init__(
         tilt_angles_deg: Sequence[float],
         datacube: Sequence[DataCube] = None,
         semiangle_cutoff: float = None,
+        semiangle_cutoff_pixels: float = None,
         rolloff: float = 2.0,
         vacuum_probe_intensity: np.ndarray = None,
         polar_parameters: Mapping[str, float] = None,
@@ -172,6 +175,7 @@ def __init__(
         self._scan_positions = initial_scan_positions
         self._energy = energy
         self._semiangle_cutoff = semiangle_cutoff
+        self._semiangle_cutoff_pixels = semiangle_cutoff_pixels
         self._rolloff = rolloff
         self._object_type = object_type
         self._object_padding_px = object_padding_px
@@ -331,6 +335,9 @@ def preprocess(
         diffraction_patterns_rotate_degrees: float = None,
         diffraction_patterns_transpose: bool = None,
         force_com_shifts: Sequence[float] = None,
+        force_scan_sampling: float = None,
+        force_angular_sampling: float = None,
+        force_reciprocal_sampling: float = None,
         progress_bar: bool = True,
         object_fov_mask: np.ndarray = None,
         **kwargs,
@@ -368,6 +375,12 @@ def preprocess(
             Amplitudes come from diffraction patterns shifted with
             the CoM in the upper left corner for each probe unless
             shift is overwritten. One tuple per tilt.
+        force_scan_sampling: float, optional
+            Override DataCube real space scan pixel size calibrations, in Angstrom
+        force_angular_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in mrad
+        force_reciprocal_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in A^-1
         object_fov_mask: np.ndarray (boolean)
             Boolean mask of FOV. Used to calculate additional shrinkage of object
             If None, probe_overlap intensity is thresholded
@@ -460,6 +473,9 @@ def preprocess(
             intensities = self._extract_intensities_and_calibrations_from_datacube(
                 self._datacube[tilt_index],
                 require_calibrations=True,
+                force_scan_sampling=force_scan_sampling,
+                force_angular_sampling=force_angular_sampling,
+                force_reciprocal_sampling=force_reciprocal_sampling,
             )
 
             (
@@ -509,6 +525,11 @@ def preprocess(
                 self._scan_positions[tilt_index]
             )
 
+        # handle semiangle specified in pixels
+        if self._semiangle_cutoff_pixels:
+            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
+
+
         # Object Initialization
         if self._object is None:
             pad_x = self._object_padding_px[0][1]
diff --git a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
index da358e089..ae302f660 100644
--- a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
@@ -53,7 +53,9 @@ class SimultaneousPtychographicReconstruction(PtychographicReconstruction):
     simultaneous_measurements_mode: str, optional
         One of '-+', '-0+', '0+', where -/0/+ refer to the sign of the magnetic potential
     semiangle_cutoff: float, optional
-        Semiangle cutoff for the initial probe guess
+        Semiangle cutoff for the initial probe guess in mrad
+    semiangle_cutoff_pixels: float, optional
+        Semiangle cutoff for the initial probe guess in pixels
     rolloff: float, optional
         Semiangle rolloff for the initial probe guess
     vacuum_probe_intensity: np.ndarray, optional
@@ -95,6 +97,7 @@ def __init__(
         datacube: Sequence[DataCube] = None,
         simultaneous_measurements_mode: str = "-+",
         semiangle_cutoff: float = None,
+        semiangle_cutoff_pixels: float = None,
         rolloff: float = 2.0,
         vacuum_probe_intensity: np.ndarray = None,
         polar_parameters: Mapping[str, float] = None,
@@ -160,6 +163,7 @@ def __init__(
         self._scan_positions = initial_scan_positions
         self._energy = energy
         self._semiangle_cutoff = semiangle_cutoff
+        self._semiangle_cutoff_pixels = semiangle_cutoff_pixels
         self._rolloff = rolloff
         self._object_type = object_type
         self._object_padding_px = object_padding_px
@@ -184,6 +188,9 @@ def preprocess(
         force_com_rotation: float = None,
         force_com_transpose: float = None,
         force_com_shifts: float = None,
+        force_scan_sampling: float = None,
+        force_angular_sampling: float = None,
+        force_reciprocal_sampling: float = None,
         object_fov_mask: np.ndarray = None,
         **kwargs,
     ):
@@ -230,6 +237,12 @@ def preprocess(
             Amplitudes come from diffraction patterns shifted with
             the CoM in the upper left corner for each probe unless
             shift is overwritten.
+        force_scan_sampling: float, optional
+            Override DataCube real space scan pixel size calibrations, in Angstrom
+        force_angular_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in mrad
+        force_reciprocal_sampling: float, optional
+            Override DataCube reciprocal pixel size calibration, in A^-1
         object_fov_mask: np.ndarray (boolean)
             Boolean mask of FOV. Used to calculate additional shrinkage of object
             If None, probe_overlap intensity is thresholded
@@ -344,6 +357,9 @@ def preprocess(
         intensities_0 = self._extract_intensities_and_calibrations_from_datacube(
             measurement_0,
             require_calibrations=True,
+            force_scan_sampling=force_scan_sampling,
+            force_angular_sampling=force_angular_sampling,
+            force_reciprocal_sampling=force_reciprocal_sampling,
         )
 
         (
@@ -424,6 +440,9 @@ def preprocess(
         intensities_1 = self._extract_intensities_and_calibrations_from_datacube(
             measurement_1,
             require_calibrations=True,
+            force_scan_sampling=force_scan_sampling,
+            force_angular_sampling=force_angular_sampling,
+            force_reciprocal_sampling=force_reciprocal_sampling,
         )
 
         (
@@ -505,6 +524,9 @@ def preprocess(
             intensities_2 = self._extract_intensities_and_calibrations_from_datacube(
                 measurement_2,
                 require_calibrations=True,
+                force_scan_sampling=force_scan_sampling,
+                force_angular_sampling=force_angular_sampling,
+                force_reciprocal_sampling=force_reciprocal_sampling,
             )
 
             (
@@ -591,6 +613,11 @@ def preprocess(
             self._scan_positions
         )
 
+        # handle semiangle specified in pixels
+        if self._semiangle_cutoff_pixels:
+            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
+
+
         # Object Initialization
         if self._object is None:
             pad_x = self._object_padding_px[0][1]
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index 269a61180..494d97119 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -50,7 +50,9 @@ class SingleslicePtychographicReconstruction(PtychographicReconstruction):
     datacube: DataCube
         Input 4D diffraction pattern intensities
     semiangle_cutoff: float, optional
-        Semiangle cutoff for the initial probe guess
+        Semiangle cutoff for the initial probe guess in mrad
+    semiangle_cutoff_pixels: float, optional
+        Semiangle cutoff for the initial probe guess in pixels
     rolloff: float, optional
         Semiangle rolloff for the initial probe guess
     vacuum_probe_intensity: np.ndarray, optional
@@ -289,11 +291,6 @@ def preprocess(
             force_reciprocal_sampling=force_reciprocal_sampling,
         )
 
-        # handle semiangle specified in pixels
-        if self._semiangle_cutoff_pixels:
-            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
-
-
         (
             self._com_measured_x,
             self._com_measured_y,
@@ -346,6 +343,11 @@ def preprocess(
         self._positions_px = self._calculate_scan_positions_in_pixels(
             self._scan_positions
         )
+
+        # handle semiangle specified in pixels
+        if self._semiangle_cutoff_pixels:
+            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
+
         # Object Initialization
         if self._object is None:
             pad_x = self._object_padding_px[0][1]

From df86a73da87ca484b2dcf7dd7e7cc22f10f6811b Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Sat, 24 Jun 2023 13:21:25 -0400
Subject: [PATCH 232/362] format with black

---
 .../process/phase/iterative_base_class.py     | 20 ++++++++++++-------
 .../iterative_mixedstate_ptychography.py      |  4 +++-
 .../iterative_multislice_ptychography.py      |  4 +++-
 .../iterative_overlap_magnetic_tomography.py  |  5 +++--
 .../phase/iterative_overlap_tomography.py     |  5 +++--
 .../iterative_simultaneous_ptychography.py    |  5 +++--
 .../iterative_singleslice_ptychography.py     |  4 +++-
 7 files changed, 31 insertions(+), 16 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index 04462c389..766d03c6a 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -199,7 +199,7 @@ def _preprocess_datacube_and_vacuum_probe(
                         output_size=diffraction_intensities_shape,
                         force_nonnegative=True,
                     )
-        
+
         if probe_roi_shape is not None:
             Qx, Qy = datacube.shape[-2:]
             Sx, Sy = probe_roi_shape
@@ -325,9 +325,9 @@ def _extract_intensities_and_calibrations_from_datacube(
             # there is no xor keyword in Python!
             angular = force_angular_sampling is not None
             reciprocal = force_reciprocal_sampling is not None
-            assert (angular and not reciprocal) or (not angular and reciprocal), (
-                "Only one of angular or reciprocal calibration can be forced!"
-            )
+            assert (angular and not reciprocal) or (
+                not angular and reciprocal
+            ), "Only one of angular or reciprocal calibration can be forced!"
 
             # angular calibration specified
             if angular:
@@ -336,7 +336,9 @@ def _extract_intensities_and_calibrations_from_datacube(
 
                 if self._energy is not None:
                     self._reciprocal_sampling = (
-                        force_angular_sampling / electron_wavelength_angstrom(self._energy) / 1e3,
+                        force_angular_sampling
+                        / electron_wavelength_angstrom(self._energy)
+                        / 1e3,
                     ) * 2
                     self._reciprocal_units = ("A^-1",) * 2
 
@@ -347,7 +349,9 @@ def _extract_intensities_and_calibrations_from_datacube(
 
                 if self._energy is not None:
                     self._angular_sampling = (
-                        force_reciprocal_sampling * electron_wavelength_angstrom(self._energy) * 1e3,
+                        force_reciprocal_sampling
+                        * electron_wavelength_angstrom(self._energy)
+                        * 1e3,
                     ) * 2
                     self._angular_units = ("mrad",) * 2
 
@@ -378,7 +382,9 @@ def _extract_intensities_and_calibrations_from_datacube(
 
                 if self._energy is not None:
                     self._angular_sampling = (
-                        reciprocal_size * electron_wavelength_angstrom(self._energy) * 1e3,
+                        reciprocal_size
+                        * electron_wavelength_angstrom(self._energy)
+                        * 1e3,
                     ) * 2
                     self._angular_units = ("mrad",) * 2
 
diff --git a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
index 4dea8172f..8d4574aa4 100644
--- a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
@@ -362,7 +362,9 @@ def preprocess(
 
         # handle semiangle specified in pixels
         if self._semiangle_cutoff_pixels:
-            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
+            self._semiangle_cutoff = (
+                self._semiangle_cutoff_pixels * self._angular_sampling[0]
+            )
 
         # Object Initialization
         if self._object is None:
diff --git a/py4DSTEM/process/phase/iterative_multislice_ptychography.py b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
index a9dcf2d41..36b44b77e 100644
--- a/py4DSTEM/process/phase/iterative_multislice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
@@ -437,7 +437,9 @@ def preprocess(
 
         # handle semiangle specified in pixels
         if self._semiangle_cutoff_pixels:
-            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
+            self._semiangle_cutoff = (
+                self._semiangle_cutoff_pixels * self._angular_sampling[0]
+            )
 
         # Object Initialization
         if self._object is None:
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 7831bd12a..9d4acfc4c 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -618,8 +618,9 @@ def preprocess(
 
         # handle semiangle specified in pixels
         if self._semiangle_cutoff_pixels:
-            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
-
+            self._semiangle_cutoff = (
+                self._semiangle_cutoff_pixels * self._angular_sampling[0]
+            )
 
         # Object Initialization
         if self._object is None:
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index a55a08697..82d1caac3 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -527,8 +527,9 @@ def preprocess(
 
         # handle semiangle specified in pixels
         if self._semiangle_cutoff_pixels:
-            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
-
+            self._semiangle_cutoff = (
+                self._semiangle_cutoff_pixels * self._angular_sampling[0]
+            )
 
         # Object Initialization
         if self._object is None:
diff --git a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
index ae302f660..9e4b39cf5 100644
--- a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
@@ -615,8 +615,9 @@ def preprocess(
 
         # handle semiangle specified in pixels
         if self._semiangle_cutoff_pixels:
-            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
-
+            self._semiangle_cutoff = (
+                self._semiangle_cutoff_pixels * self._angular_sampling[0]
+            )
 
         # Object Initialization
         if self._object is None:
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index 494d97119..52aa2f816 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -346,7 +346,9 @@ def preprocess(
 
         # handle semiangle specified in pixels
         if self._semiangle_cutoff_pixels:
-            self._semiangle_cutoff = self._semiangle_cutoff_pixels * self._angular_sampling[0]
+            self._semiangle_cutoff = (
+                self._semiangle_cutoff_pixels * self._angular_sampling[0]
+            )
 
         # Object Initialization
         if self._object is None:

From f0be6cbfa0779e6b84b2286fd4a2d20c537bbc89 Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Sat, 24 Jun 2023 13:45:10 -0400
Subject: [PATCH 233/362] first attempt at caching preprocessed object if not
 optimized

---
 py4DSTEM/process/phase/parameter_optimize.py | 30 ++++++++++++++++----
 1 file changed, 24 insertions(+), 6 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 987ffedef..ee8473be1 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -294,17 +294,35 @@ def _get_optimization_function(
         dictionary are used.
         """
 
-        # Construct partial methods to encapsulate the static parameters
-        obj = partial(cls, **init_static_args)
-        affine = partial(AffineTransform, **affine_static_args)
-        prep = partial(cls.preprocess, **preprocess_static_args)
-        recon = partial(cls.reconstruct, **reconstruct_static_args)
-
+        # Get lists of optimization parameters for each step
         init_params = list(init_optimization_params.keys())
         afft_params = list(affine_optimization_params.keys())
         prep_params = list(preprocess_optimization_params.keys())
         reco_params = list(reconstruct_optimization_params.keys())
 
+        # Construct partial methods to encapsulate the static parameters.
+        # If only ``reconstruct`` has optimization variables, perform
+        # preprocessing now, store the ptycho object, and use dummy
+        # functions instead of the partials
+        if (len(init_params),len(afft_params),len(prep_params)) == (0,0,0):
+            affine_preprocessed = AffineTransform(**affine_static_args)
+            init_args = init_static_args.copy()
+            init_args["initial_scan_positions"] = self._get_scan_positions(affine_preprocessed, init_static_args["datacube"])
+
+            ptycho_preprocessed = cls.__init__(**init_args).preprocess(**preprocess_static_args)
+
+            def obj(**kwargs):
+                return ptycho_preprocessed
+            def prep(ptycho,**kwargs):
+                return ptycho
+
+        else:
+            obj = partial(cls, **init_static_args)
+            affine = partial(AffineTransform, **affine_static_args)
+            prep = partial(cls.preprocess, **preprocess_static_args)
+
+        recon = partial(cls.reconstruct, **reconstruct_static_args)
+
         # Target function for Gaussian process optimization that takes a single
         # dict of named parameters and returns the ptycho error metric
         @use_named_args(parameter_list)

From 9f3686d1b288d6f0ade767802048b019a75b4ec7 Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Sat, 24 Jun 2023 13:45:32 -0400
Subject: [PATCH 234/362] format with black

---
 py4DSTEM/process/phase/parameter_optimize.py | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index ee8473be1..292df27b6 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -304,16 +304,21 @@ def _get_optimization_function(
         # If only ``reconstruct`` has optimization variables, perform
         # preprocessing now, store the ptycho object, and use dummy
         # functions instead of the partials
-        if (len(init_params),len(afft_params),len(prep_params)) == (0,0,0):
+        if (len(init_params), len(afft_params), len(prep_params)) == (0, 0, 0):
             affine_preprocessed = AffineTransform(**affine_static_args)
             init_args = init_static_args.copy()
-            init_args["initial_scan_positions"] = self._get_scan_positions(affine_preprocessed, init_static_args["datacube"])
+            init_args["initial_scan_positions"] = self._get_scan_positions(
+                affine_preprocessed, init_static_args["datacube"]
+            )
 
-            ptycho_preprocessed = cls.__init__(**init_args).preprocess(**preprocess_static_args)
+            ptycho_preprocessed = cls.__init__(**init_args).preprocess(
+                **preprocess_static_args
+            )
 
             def obj(**kwargs):
                 return ptycho_preprocessed
-            def prep(ptycho,**kwargs):
+
+            def prep(ptycho, **kwargs):
                 return ptycho
 
         else:

From 2ced4e5e4ea7dc9fc06e237c58ecf4d87c967b4b Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Sat, 24 Jun 2023 15:04:18 -0400
Subject: [PATCH 235/362] preprocess caching bug fixed

---
 py4DSTEM/process/phase/parameter_optimize.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 292df27b6..2e52a677a 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -311,7 +311,7 @@ def _get_optimization_function(
                 affine_preprocessed, init_static_args["datacube"]
             )
 
-            ptycho_preprocessed = cls.__init__(**init_args).preprocess(
+            ptycho_preprocessed = cls(**init_args).preprocess(
                 **preprocess_static_args
             )
 
@@ -323,9 +323,9 @@ def prep(ptycho, **kwargs):
 
         else:
             obj = partial(cls, **init_static_args)
-            affine = partial(AffineTransform, **affine_static_args)
             prep = partial(cls.preprocess, **preprocess_static_args)
 
+        affine = partial(AffineTransform, **affine_static_args)
         recon = partial(cls.reconstruct, **reconstruct_static_args)
 
         # Target function for Gaussian process optimization that takes a single
@@ -364,6 +364,7 @@ def _set_optimizer_defaults(self):
 
         self._reconstruction_static_args["progress_bar"] = False
         self._reconstruction_static_args["store_iterations"] = False
+        self._reconstruction_static_args["reset"] = True
 
 
 class OptimizationParameter:

From 258c9cddaa4f3735d53b89afd3dea933344e5810 Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Sun, 25 Jun 2023 13:05:14 -0400
Subject: [PATCH 236/362] use log error for optimizer

---
 py4DSTEM/process/phase/parameter_optimize.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 2e52a677a..3676616a4 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -348,7 +348,7 @@ def f(**kwargs):
             prep(ptycho, **prep_args)
             recon(ptycho, **reco_args)
 
-            return ptycho.error
+            return np.log(ptycho.error)
 
         return f
 

From a67305a38dcaa0fb10416099c385ad35e7537a51 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Thu, 1 Jun 2023 13:56:32 -0700
Subject: [PATCH 237/362] doc strings modification

---
 py4DSTEM/process/phase/parameter_optimize.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 3676616a4..33f566fe6 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -43,9 +43,11 @@ def __init__(
         Dictionaries of the arguments to __init__, AffineTransform (for distorting the initial
         scan positions), preprocess, and reconstruct are required. For parameters not optimized
         over, the value in the dictionary is used. To optimize a parameter, instead pass an
-        OptimizationParameter object inside the dictionary to specify the bounds, initial guess,
-        and type of parameter. Calling optimize will then run the optimization simultaneously
-        over all optimization parameters. To obtain the optimized parameters, call get_optimized_arguments
+        OptimizationParameter object inside the dictionary to specify the initial guess, bounds, 
+        and type of parameter, for example: 
+            >>> 'param':OptimizationParameter(initial guess, lower bound, upper bound)
+        Calling optimize will then run the optimization simultaneously over all 
+        optimization parameters. To obtain the optimized parameters, call get_optimized_arguments
         to return a set of dictionaries where the OptimizationParameter objects have been replaced
         with the optimal values. These can then be modified for running a full reconstruction.
 

From 18b583c797c3d6a49d4ed1f6d7d292dcea33acd3 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Mon, 5 Jun 2023 11:31:39 -0700
Subject: [PATCH 238/362] no empty dictionaries required!

---
 py4DSTEM/process/phase/parameter_optimize.py | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 33f566fe6..f0631694d 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -30,9 +30,9 @@ def __init__(
         self,
         reconstruction_type: type[PhaseReconstruction],
         init_args: dict,
-        affine_args: dict,
         preprocess_args: dict,
         reconstruction_args: dict,
+        affine_args: dict = None,
     ):
         """
         Parameter optimization for ptychographic reconstruction based on Bayesian Optimization
@@ -43,10 +43,10 @@ def __init__(
         Dictionaries of the arguments to __init__, AffineTransform (for distorting the initial
         scan positions), preprocess, and reconstruct are required. For parameters not optimized
         over, the value in the dictionary is used. To optimize a parameter, instead pass an
-        OptimizationParameter object inside the dictionary to specify the initial guess, bounds, 
-        and type of parameter, for example: 
+        OptimizationParameter object inside the dictionary to specify the initial guess, bounds,
+        and type of parameter, for example:
             >>> 'param':OptimizationParameter(initial guess, lower bound, upper bound)
-        Calling optimize will then run the optimization simultaneously over all 
+        Calling optimize will then run the optimization simultaneously over all
         optimization parameters. To obtain the optimized parameters, call get_optimized_arguments
         to return a set of dictionaries where the OptimizationParameter objects have been replaced
         with the optimal values. These can then be modified for running a full reconstruction.
@@ -57,14 +57,16 @@ def __init__(
             Type of ptychographic reconstruction to perform
         init_args: dict
             Keyword arguments passed to the __init__ method of the reconstruction class
-        affine_args: dict
-            Keyword arguments passed to AffineTransform. The transform is applied to the initial
-            scan positions.
         preprocess_args: dict
             Keyword arguments passed to the preprocess method the reconstruction object
         reconstruction_args: dict
             Keyword arguments passed to the reconstruct method the the reconstruction object
+        affine_args: dict
+            Keyword arguments passed to AffineTransform. The transform is applied to the initial
+            scan positions.
         """
+        if affine_args is None:
+            affine_args = {}
 
         # loop over each argument dictionary and split into static and optimization variables
         (

From 559d79ec7dc7bd57cc1cafa70f666413f3e9b00c Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Thu, 29 Jun 2023 17:35:17 -0400
Subject: [PATCH 239/362] add skopt to dependencies

---
 setup.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/setup.py b/setup.py
index b97e84882..cb9da8169 100644
--- a/setup.py
+++ b/setup.py
@@ -30,6 +30,7 @@
         'matplotlib >= 3.2.2',
         'scikit-image >= 0.17.2',
         'scikit-learn >= 0.23.2',
+        'scikit-optimize >= 0.9.0',
         'tqdm >= 4.46.1',
         'dill >= 0.3.3',
         'gdown >= 4.4.0',

From 62f8d3f49210c6abfb654022973e2a7e06e9d946 Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Sat, 1 Jul 2023 15:44:55 -0400
Subject: [PATCH 240/362] add custom error metrics for ptycho optimizer

---
 py4DSTEM/process/phase/parameter_optimize.py | 102 +++++++++++++++++--
 1 file changed, 95 insertions(+), 7 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index f0631694d..ddc51f57b 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -12,7 +12,7 @@
 import numpy as np
 
 from functools import partial
-from typing import Union
+from typing import Union, Callable
 
 from py4DSTEM.process.phase.iterative_base_class import PhaseReconstruction
 from py4DSTEM.process.phase.utils import AffineTransform
@@ -109,8 +109,9 @@ def __init__(
 
     def optimize(
         self,
-        n_calls: int,
-        n_initial_points: int,
+        n_calls: int = 50,
+        n_initial_points: int = 20,
+        error_metric: Union[Callable, str] = "log",
         **skopt_kwargs: dict,
     ):
         """
@@ -123,10 +124,29 @@ def optimize(
         n_initial_points: int
             Number of uniformly spaced trial points to test before
             beginning Bayesian optimization (must be less than n_calls)
+        error_metric: Callable or str
+            Function used to compute the reconstruction error.
+            When passed as a string, may be one of:
+                'log': log(NMSE) of final object
+                'linear': NMSE of final object
+                'log-converged': log(NMSE) of final object if
+                    NMSE is decreasing, 0 if NMSE increasing
+                'linear-converged': NMSE of final object if
+                    NMSE is decreasing, 1 if NMSE increasing
+                'TV': sum( abs( grad( object ) ) ) / sum( abs( object ) )
+                'std': negative standard deviation of cropped object
+                'std-phase': negative standard deviation of
+                    phase of the cropped object
+            When passed as a Callable, a function that takes the
+                PhaseReconstruction object as its only argument
+                and returns the error metric as a single float
         skopt_kwargs: dict
             Additional arguments to be passed to skopt.gp_minimize
 
         """
+
+        error_metric = self._get_error_metric(error_metric)
+
         self._optimization_function = self._get_optimization_function(
             self._reconstruction_type,
             self._parameter_list,
@@ -139,6 +159,7 @@ def optimize(
             self._affine_optimize_args,
             self._preprocess_optimize_args,
             self._reconstruction_optimize_args,
+            error_metric,
         )
 
         # Make a progress bar
@@ -272,6 +293,74 @@ def _get_scan_positions(self, affine_transform, dataset):
         scan_positions = scan_positions @ affine_transform.asarray()
         return scan_positions
 
+    def _get_error_metric(self, error_metric: Union[Callable, str]) -> Callable:
+        """
+        Get error metric as a function, converting builtin method names
+        to functions
+        """
+
+        if callable(error_metric):
+            return error_metric
+
+        assert error_metric in (
+            "log",
+            "linear",
+            "log-converged",
+            "linear-converged",
+            "TV",
+            "std",
+            "std-phase",
+        ), f"Error metric {error_metric} not recognized."
+
+        if error_metric == "log":
+
+            def f(ptycho):
+                return np.log(ptycho.error)
+
+        elif error_metric == "linear":
+
+            def f(ptycho):
+                return ptycho.error
+
+        elif error_metric == "log-converged":
+
+            def f(ptycho):
+                converged = ptycho.error_iterations[-1] <= np.min(
+                    ptycho.error_iterations
+                )
+                return np.log(ptycho.error) if converged else 0.0
+
+        elif error_metric == "log-linear":
+
+            def f(ptycho):
+                converged = ptycho.error_iterations[-1] <= np.min(
+                    ptycho.error_iterations
+                )
+                return ptycho.error if converged else 1.0
+
+        elif error_metric == "TV":
+
+            def f(ptycho):
+                gx, gy = np.gradient(ptycho.object_cropped, axis=(-2, -1))
+                obj_mag = np.sum(np.abs(ptycho.object_cropped))
+                tv = np.sum(np.abs(gx)) + np.sum(np.abs(gy))
+                return tv / obj_mag
+
+        elif error_metric == "std":
+
+            def f(ptycho):
+                return -np.std(ptycho.object_cropped)
+
+        elif error_metric == "std-phase":
+
+            def f(ptycho):
+                return -np.std(np.angle(ptycho.object_cropped))
+
+        else:
+            raise ValueError(f"Error metric {error_metric} not recognized.")
+
+        return f
+
     def _get_optimization_function(
         self,
         cls: type[PhaseReconstruction],
@@ -285,6 +374,7 @@ def _get_optimization_function(
         affine_optimization_params: dict,
         preprocess_optimization_params: dict,
         reconstruct_optimization_params: dict,
+        error_metric: Callable,
     ):
         """
         Wrap the ptychography pipeline into a single function that encapsulates all of the
@@ -315,9 +405,7 @@ def _get_optimization_function(
                 affine_preprocessed, init_static_args["datacube"]
             )
 
-            ptycho_preprocessed = cls(**init_args).preprocess(
-                **preprocess_static_args
-            )
+            ptycho_preprocessed = cls(**init_args).preprocess(**preprocess_static_args)
 
             def obj(**kwargs):
                 return ptycho_preprocessed
@@ -352,7 +440,7 @@ def f(**kwargs):
             prep(ptycho, **prep_args)
             recon(ptycho, **reco_args)
 
-            return np.log(ptycho.error)
+            return error_metric(ptycho)
 
         return f
 

From 1b968dbb3a2ec9cb6447bae3f4c98c7a3e8e1999 Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <37132012+sezelt@users.noreply.github.com>
Date: Sun, 2 Jul 2023 15:27:41 -0400
Subject: [PATCH 241/362] docstring clarification

Co-authored-by: Georgios Varnavides <gvarnavides@berkeley.edu>
---
 py4DSTEM/process/phase/parameter_optimize.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index ddc51f57b..998400843 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -21,9 +21,8 @@
 class PtychographyOptimizer:
     """
     Optimize ptychographic hyperparameters with Bayesian Optimization of a
-    Gaussian process. Any of the arguments to the ptychographic
-    init-preprocess-reconstruct pipeline can be optimized over (including
-    boolean or other flag options)
+    Gaussian process. Any of the scalar-valued real or integer,  boolean, or categorical 
+    arguments to the ptychographic init-preprocess-reconstruct pipeline can be optimized over.
     """
 
     def __init__(

From 1ad12120ac13b5b6acd3e722125c2227a5a85675 Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <37132012+sezelt@users.noreply.github.com>
Date: Sun, 2 Jul 2023 15:33:22 -0400
Subject: [PATCH 242/362] remove unused argument

Co-authored-by: Georgios Varnavides <gvarnavides@berkeley.edu>
---
 py4DSTEM/process/phase/parameter_optimize.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 998400843..f3530491c 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -364,7 +364,6 @@ def _get_optimization_function(
         self,
         cls: type[PhaseReconstruction],
         parameter_list: list,
-        n_iterations: int,
         init_static_args: dict,
         affine_static_args: dict,
         preprocess_static_args: dict,

From 887aa80208fc5e65b319574b2d13da2b9717aea0 Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <37132012+sezelt@users.noreply.github.com>
Date: Sun, 2 Jul 2023 15:34:43 -0400
Subject: [PATCH 243/362] remove another unused argument

Co-authored-by: Georgios Varnavides <gvarnavides@berkeley.edu>
---
 py4DSTEM/process/phase/parameter_optimize.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index f3530491c..ccc700ec9 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -149,7 +149,6 @@ def optimize(
         self._optimization_function = self._get_optimization_function(
             self._reconstruction_type,
             self._parameter_list,
-            n_calls,
             self._init_static_args,
             self._affine_static_args,
             self._preprocess_static_args,

From bc28d5f3294a81ae65d20bf23342aa84efb2d86d Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <37132012+sezelt@users.noreply.github.com>
Date: Sun, 2 Jul 2023 15:37:14 -0400
Subject: [PATCH 244/362] update plot function

Co-authored-by: Georgios Varnavides <gvarnavides@berkeley.edu>
---
 py4DSTEM/process/phase/parameter_optimize.py | 81 +++++++++++++++-----
 1 file changed, 61 insertions(+), 20 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index ccc700ec9..d5aa580a9 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -189,37 +189,78 @@ def callback(*args, **kwargs):
 
     def visualize(
         self,
-        gp_model=True,
-        convergence=False,
-        objective=True,
-        evaluations=False,
+        plot_gp_model=True,
+        plot_convergence=False,
+        plot_objective=True,
+        plot_evaluations=False,
+        **kwargs,
     ):
         """
         Visualize optimization results
 
         Parameters
         ----------
-        gp_model: bool
+        plot_gp_model: bool
             Display fitted Gaussian process model (only available for 1-dimensional problem)
-        convergence: bool
+        plot_convergence: bool
             Display convergence history
-        objective: bool
+        plot_objective: bool
             Display GP objective function and partial dependence plots
-        evaluations: bool
+        plot_evaluations: bool
             Display histograms of sampled points
+        kwargs:
+            Passed directly to the skopt plot_gassian_process/plot_objective
         """
-        if (len(self._parameter_list) == 1) and gp_model:
-            plot_gaussian_process(self._skopt_result)
-            plt.show()
-        if convergence:
-            plot_convergence(self._skopt_result)
-            plt.show()
-        if objective:
-            plot_objective(self._skopt_result)
-            plt.show()
-        if evaluations:
-            plot_evaluations(self._skopt_result)
-            plt.show()
+        ndims = len(self._parameter_list)
+        if ndims == 1:
+            if plot_convergence:
+                figsize = kwargs.pop("figsize", (9, 9))
+                spec = GridSpec(nrows=2,ncols=1,height_ratios=[2,1], hspace=0.15)
+            else:
+                figsize = kwargs.pop("figsize", (9, 6))
+                spec = GridSpec(nrows=1,ncols=1)
+
+            fig = plt.figure(figsize = figsize)
+            ax = fig.add_subplot(spec[0])
+            skopt_plot_gaussian_process(self._skopt_result,ax=ax, **kwargs)
+
+            if plot_convergence:
+                ax = fig.add_subplot(spec[1])
+                skopt_plot_convergence(self._skopt_result,ax=ax)
+
+        else:
+            if plot_convergence:
+                figsize = kwargs.pop("figsize", (4*ndims, 4*(ndims+0.5)))
+                spec = GridSpec(nrows=ndims+1,ncols=ndims,height_ratios=[2]*ndims+[1], hspace=0.15)
+            else:
+                figsize = kwargs.pop("figsize", (4*ndims, 4*ndims))
+                spec = GridSpec(nrows=ndims,ncols=ndims, hspace=0.15)
+
+            if plot_evaluations:
+                axs = skopt_plot_evaluations(self._skopt_result)
+            elif plot_objective:
+                cmap = kwargs.pop("cmap", 'magma')
+                axs = skopt_plot_objective(self._skopt_result, cmap=cmap,**kwargs)
+            elif plot_convergence:
+                skopt_plot_convergence(self._skopt_result)
+                return self
+
+            fig = axs[0,0].figure
+            fig.set_size_inches(figsize)
+            for i in range(ndims):
+                for j in range(ndims):
+                    ax = axs[i,j]
+                    ax.remove()
+                    ax.figure = fig
+                    fig.add_axes(ax)
+                    ax.set_subplotspec(spec[i,j])
+
+            if plot_convergence:
+                ax = fig.add_subplot(spec[ndims,:])
+                skopt_plot_convergence(self._skopt_result,ax=ax)
+
+        spec.tight_layout(fig)
+
         return self
 
     def get_optimized_arguments(self):

From 43a580e947b3ad4a4673fdd8b7ec0b3fd329e286 Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <37132012+sezelt@users.noreply.github.com>
Date: Sun, 2 Jul 2023 15:37:35 -0400
Subject: [PATCH 245/362] update plot imports

Co-authored-by: Georgios Varnavides <gvarnavides@berkeley.edu>
---
 py4DSTEM/process/phase/parameter_optimize.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index d5aa580a9..1485b5edf 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -2,10 +2,10 @@
 from skopt import gp_minimize
 from skopt.space import Real, Integer, Categorical
 from skopt.plots import (
-    plot_convergence,
-    plot_gaussian_process,
-    plot_evaluations,
-    plot_objective,
+    plot_convergence as skopt_plot_convergence,
+    plot_gaussian_process as skopt_plot_gaussian_process,
+    plot_evaluations as skopt_plot_evaluations,
+    plot_objective as skopt_plot_objective,
 )
 from skopt.utils import use_named_args
 import matplotlib.pyplot as plt

From 7ccb46ce3e54aa0bb70af82efa2243b3ed07ef59 Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <37132012+sezelt@users.noreply.github.com>
Date: Sun, 2 Jul 2023 15:38:59 -0400
Subject: [PATCH 246/362] aesthetic preferences regarding asserts

Co-authored-by: Georgios Varnavides <gvarnavides@berkeley.edu>
---
 py4DSTEM/process/phase/parameter_optimize.py | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 1485b5edf..e46361a86 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -529,12 +529,9 @@ def __init__(
         """
         # Check input
         space = space.lower()
-        assert space in (
-            "real",
-            "integer",
-            "bool",
-            "categorical",
-        ), f"Unknown Parameter type: {space}"
+        if space not in ("real", "integer", "bool", "categorical"):
+            raise ValueError(f"Unknown Parameter type: {space}")
+
 
         scaling = scaling.lower()
         assert scaling in ("uniform", "log-uniform"), f"Unknown scaling: {scaling}"

From 0155fd05a342f51f08787dc3d94d2de2197ad009 Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <37132012+sezelt@users.noreply.github.com>
Date: Sun, 2 Jul 2023 15:39:21 -0400
Subject: [PATCH 247/362] being less assertive

Co-authored-by: Georgios Varnavides <gvarnavides@berkeley.edu>
---
 py4DSTEM/process/phase/parameter_optimize.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index e46361a86..3ca9f53bd 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -534,7 +534,8 @@ def __init__(
 
 
         scaling = scaling.lower()
-        assert scaling in ("uniform", "log-uniform"), f"Unknown scaling: {scaling}"
+        if scaling not in ("uniform", "log-uniform"):
+            raise ValueError(f"Unknown scaling: {scaling}")
 
         # Get the right scikit-optimize class
         space_map = {

From af6f2dcf375a4b7e75ca5952eb480e420d33b9a6 Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <37132012+sezelt@users.noreply.github.com>
Date: Sun, 2 Jul 2023 15:39:51 -0400
Subject: [PATCH 248/362] you wouldn't raise an AssertionError

Co-authored-by: Georgios Varnavides <gvarnavides@berkeley.edu>
---
 py4DSTEM/process/phase/parameter_optimize.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 3ca9f53bd..db9477d2b 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -550,6 +550,8 @@ def __init__(
         if space == "bool":
             categories = [True, False]
 
+        if not categories:
+            raise ValueError("Empty list of categories!")
         # store necessary information
         self._initial_value = initial_value
         self._categories = categories

From 506e129704a21020c1a67e00efcb72370d80d39f Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <37132012+sezelt@users.noreply.github.com>
Date: Sun, 2 Jul 2023 15:40:23 -0400
Subject: [PATCH 249/362] remove another assert

Co-authored-by: Georgios Varnavides <gvarnavides@berkeley.edu>
---
 py4DSTEM/process/phase/parameter_optimize.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index db9477d2b..74be59373 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -563,7 +563,6 @@ def __init__(
     def _get(self, name):
         self._name = name
         if self._param_type is Categorical:
-            assert self._categories is not None, "Empty list of categories!"
             self._skopt_param = self._param_type(
                 name=self._name, categories=self._categories
             )

From 1b9c5c372ca8ac9123051e9595c9e477d3ea661d Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Mon, 3 Jul 2023 08:50:26 -0400
Subject: [PATCH 250/362] fix for george's suggestion

---
 py4DSTEM/process/phase/parameter_optimize.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 74be59373..b298b0017 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -550,8 +550,9 @@ def __init__(
         if space == "bool":
             categories = [True, False]
 
-        if not categories:
+        if categories == [] and space in ("categorical", "bool"):
             raise ValueError("Empty list of categories!")
+
         # store necessary information
         self._initial_value = initial_value
         self._categories = categories

From 14d8f2d3bbcaf28c3529c8b00013b29ef48a1ca4 Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Mon, 3 Jul 2023 17:04:29 -0400
Subject: [PATCH 251/362] add entropy metric, not sure if correct

---
 py4DSTEM/process/phase/parameter_optimize.py | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index b298b0017..0badf4ccd 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -9,6 +9,7 @@
 )
 from skopt.utils import use_named_args
 import matplotlib.pyplot as plt
+from matplotlib.gridspec import GridSpec
 import numpy as np
 
 from functools import partial
@@ -349,6 +350,7 @@ def _get_error_metric(self, error_metric: Union[Callable, str]) -> Callable:
             "TV",
             "std",
             "std-phase",
+            "entropy-phase",
         ), f"Error metric {error_metric} not recognized."
 
         if error_metric == "log":
@@ -395,6 +397,15 @@ def f(ptycho):
             def f(ptycho):
                 return -np.std(np.angle(ptycho.object_cropped))
 
+        elif error_metric == "entropy-phase":
+            def f(ptycho):
+                obj = np.angle(ptycho.object_cropped)
+                gx,gy = np.gradient(obj)
+                ghist,_,_ = np.histogram2d(gx.ravel(),gy.ravel(),bins=obj.shape,density=True)
+                nz = ghist > 0
+                S = np.sum(ghist[nz] * np.log2(ghist[nz]))
+                return S
+
         else:
             raise ValueError(f"Error metric {error_metric} not recognized.")
 

From 9b4fd0b12d999c73e71bbc873b91afde3b18eb74 Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Mon, 3 Jul 2023 17:05:10 -0400
Subject: [PATCH 252/362] docstring

---
 py4DSTEM/process/phase/parameter_optimize.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 0badf4ccd..96ef07f15 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -137,6 +137,8 @@ def optimize(
                 'std': negative standard deviation of cropped object
                 'std-phase': negative standard deviation of
                     phase of the cropped object
+                'entropy-phase': entropy of the phase of the 
+                    cropped object
             When passed as a Callable, a function that takes the
                 PhaseReconstruction object as its only argument
                 and returns the error metric as a single float

From 4a4dea9a0a9eb999acc1969e58628910722cc2e4 Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <37132012+sezelt@users.noreply.github.com>
Date: Thu, 6 Jul 2023 14:24:52 -0400
Subject: [PATCH 253/362] change how optimized dict is assembled

Co-authored-by: Georgios Varnavides <gvarnavides@berkeley.edu>
---
 py4DSTEM/process/phase/parameter_optimize.py | 43 +++++++-------------
 1 file changed, 15 insertions(+), 28 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 96ef07f15..5785fe792 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -277,12 +277,14 @@ def get_optimized_arguments(self):
             where the OptimizationParameter items have been replaced with the optimal
             values obtained from the optimizer
         """
-        init_opt = self._replace_optimized_parameters(
-            self._init_args, self._parameter_list
-        )
-        affine_opt = self._replace_optimized_parameters(
-            self._affine_args, self._parameter_list
-        )
+        optimized_dict = {p.name: v for p,v in zip(self._parameter_list,self._skopt_result.x)}
+        
+        filtered_dict = { k: v for k,v in optimized_dict.items() if k in self._init_args }
+        init_opt = self._init_args | filtered_dict
+        
+        filtered_dict = { k: v for k,v in optimized_dict.items() if k in self._affine_args }
+        affine_opt = self._affine_args | filtered_dict
+        
         affine_transform = partial(AffineTransform, **self._affine_static_args)(
             **affine_opt
         )
@@ -290,30 +292,15 @@ def get_optimized_arguments(self):
             affine_transform, init_opt["datacube"]
         )
         init_opt["initial_scan_positions"] = scan_positions
-
-        prep_opt = self._replace_optimized_parameters(
-            self._preprocess_args, self._parameter_list
-        )
-        reco_opt = self._replace_optimized_parameters(
-            self._reconstruction_args, self._parameter_list
-        )
-
+        
+        filtered_dict = { k: v for k,v in optimized_dict.items() if k in self._preprocess_args }
+        prep_opt = self._preprocess_args | filtered_dict
+        
+        filtered_dict = { k: v for k,v in optimized_dict.items() if k in self._reconstruction_args }
+        reco_opt = self._reconstruction_args | filtered_dict
+        
         return init_opt, prep_opt, reco_opt
 
-    def _replace_optimized_parameters(self, arg_dict, parameters):
-        opt_args = {}
-        for k, v in arg_dict.items():
-            # Check for optimization parameters
-            if isinstance(v, OptimizationParameter):
-                # Find the right parameter in the list
-                # There is probably a better way to do this inverse mapping!
-                for i, p in enumerate(parameters):
-                    if p.name == k:
-                        opt_args[k] = self._skopt_result.x[i]
-            else:
-                opt_args[k] = v
-        return opt_args
-
     def _split_static_and_optimization_vars(self, argdict):
         static_args = {}
         optimization_args = {}

From e82a8299459114c5aed4c0b4adeb88730546d3a9 Mon Sep 17 00:00:00 2001
From: Steve Zeltmann <37132012+sezelt@users.noreply.github.com>
Date: Thu, 6 Jul 2023 18:44:09 -0400
Subject: [PATCH 254/362] add option to override default arguments to ptycho

Co-authored-by: Georgios Varnavides <gvarnavides@berkeley.edu>
---
 py4DSTEM/process/phase/parameter_optimize.py | 26 +++++++++++++-------
 1 file changed, 17 insertions(+), 9 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 5785fe792..09296126f 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -482,19 +482,27 @@ def f(**kwargs):
 
         return f
 
-    def _set_optimizer_defaults(self):
+    def _set_optimizer_defaults(
+        verbose = False,
+        plot_center_of_mass = False,
+        plot_rotation = False,
+        plot_probe_overlaps = False,
+        progress_bar = False,
+        store_iterations = False,
+        reset = True,
+        ):
         """
-        Set all of the verbose and plotting to False
+        Set all of the verbose and plotting to False, allowing for user-overwrite.
         """
-        self._init_static_args["verbose"] = False
+        self._init_static_args["verbose"] = verbose
 
-        self._preprocess_static_args["plot_center_of_mass"] = False
-        self._preprocess_static_args["plot_rotation"] = False
-        self._preprocess_static_args["plot_probe_overlaps"] = False
+        self._preprocess_static_args["plot_center_of_mass"] = plot_center_of_mass
+        self._preprocess_static_args["plot_rotation"] = plot_rotation
+        self._preprocess_static_args["plot_probe_overlaps"] = plot_probe_overlaps
 
-        self._reconstruction_static_args["progress_bar"] = False
-        self._reconstruction_static_args["store_iterations"] = False
-        self._reconstruction_static_args["reset"] = True
+        self._reconstruction_static_args["progress_bar"] = progress_bar
+        self._reconstruction_static_args["store_iterations"] = store_iterations
+        self._reconstruction_static_args["reset"] = reset
 
 
 class OptimizationParameter:

From a0964ca97c83e3128eb3323a1e3c7e1b7018829f Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Thu, 6 Jul 2023 18:47:24 -0400
Subject: [PATCH 255/362] bugfix in optimizer defaults

---
 py4DSTEM/process/phase/parameter_optimize.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 09296126f..53e2222d3 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -483,6 +483,7 @@ def f(**kwargs):
         return f
 
     def _set_optimizer_defaults(
+        self,
         verbose = False,
         plot_center_of_mass = False,
         plot_rotation = False,

From d70a22a72326ec491198ef7e04f24f8e951a3b4b Mon Sep 17 00:00:00 2001
From: gvarnavi <gvarnavi@mit.edu>
Date: Fri, 7 Jul 2023 08:59:18 -0700
Subject: [PATCH 256/362] ptychoptimize formatting

---
 py4DSTEM/process/phase/__init__.py           |  1 +
 py4DSTEM/process/phase/parameter_optimize.py | 97 ++++++++++++--------
 2 files changed, 58 insertions(+), 40 deletions(-)

diff --git a/py4DSTEM/process/phase/__init__.py b/py4DSTEM/process/phase/__init__.py
index 207e44b56..ee542524f 100644
--- a/py4DSTEM/process/phase/__init__.py
+++ b/py4DSTEM/process/phase/__init__.py
@@ -10,5 +10,6 @@
 from py4DSTEM.process.phase.iterative_parallax import ParallaxReconstruction
 from py4DSTEM.process.phase.iterative_simultaneous_ptychography import SimultaneousPtychographicReconstruction
 from py4DSTEM.process.phase.iterative_singleslice_ptychography import SingleslicePtychographicReconstruction
+from py4DSTEM.process.phase.utils import OptimizationParameter, PtychographyOptimizer
 
 # fmt: on
diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index 53e2222d3..c8a51171d 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -22,7 +22,7 @@
 class PtychographyOptimizer:
     """
     Optimize ptychographic hyperparameters with Bayesian Optimization of a
-    Gaussian process. Any of the scalar-valued real or integer,  boolean, or categorical 
+    Gaussian process. Any of the scalar-valued real or integer,  boolean, or categorical
     arguments to the ptychographic init-preprocess-reconstruct pipeline can be optimized over.
     """
 
@@ -137,7 +137,7 @@ def optimize(
                 'std': negative standard deviation of cropped object
                 'std-phase': negative standard deviation of
                     phase of the cropped object
-                'entropy-phase': entropy of the phase of the 
+                'entropy-phase': entropy of the phase of the
                     cropped object
             When passed as a Callable, a function that takes the
                 PhaseReconstruction object as its only argument
@@ -218,49 +218,54 @@ def visualize(
         if ndims == 1:
             if plot_convergence:
                 figsize = kwargs.pop("figsize", (9, 9))
-                spec = GridSpec(nrows=2,ncols=1,height_ratios=[2,1], hspace=0.15)
+                spec = GridSpec(nrows=2, ncols=1, height_ratios=[2, 1], hspace=0.15)
             else:
                 figsize = kwargs.pop("figsize", (9, 6))
-                spec = GridSpec(nrows=1,ncols=1)
+                spec = GridSpec(nrows=1, ncols=1)
 
-            fig = plt.figure(figsize = figsize)
+            fig = plt.figure(figsize=figsize)
             ax = fig.add_subplot(spec[0])
-            skopt_plot_gaussian_process(self._skopt_result,ax=ax, **kwargs)
+            skopt_plot_gaussian_process(self._skopt_result, ax=ax, **kwargs)
 
             if plot_convergence:
                 ax = fig.add_subplot(spec[1])
-                skopt_plot_convergence(self._skopt_result,ax=ax)
+                skopt_plot_convergence(self._skopt_result, ax=ax)
 
         else:
             if plot_convergence:
-                figsize = kwargs.pop("figsize", (4*ndims, 4*(ndims+0.5)))
-                spec = GridSpec(nrows=ndims+1,ncols=ndims,height_ratios=[2]*ndims+[1], hspace=0.15)
+                figsize = kwargs.pop("figsize", (4 * ndims, 4 * (ndims + 0.5)))
+                spec = GridSpec(
+                    nrows=ndims + 1,
+                    ncols=ndims,
+                    height_ratios=[2] * ndims + [1],
+                    hspace=0.15,
+                )
             else:
-                figsize = kwargs.pop("figsize", (4*ndims, 4*ndims))
-                spec = GridSpec(nrows=ndims,ncols=ndims, hspace=0.15)
+                figsize = kwargs.pop("figsize", (4 * ndims, 4 * ndims))
+                spec = GridSpec(nrows=ndims, ncols=ndims, hspace=0.15)
 
             if plot_evaluations:
                 axs = skopt_plot_evaluations(self._skopt_result)
             elif plot_objective:
-                cmap = kwargs.pop("cmap", 'magma')
-                axs = skopt_plot_objective(self._skopt_result, cmap=cmap,**kwargs)
+                cmap = kwargs.pop("cmap", "magma")
+                axs = skopt_plot_objective(self._skopt_result, cmap=cmap, **kwargs)
             elif plot_convergence:
                 skopt_plot_convergence(self._skopt_result)
                 return self
 
-            fig = axs[0,0].figure
+            fig = axs[0, 0].figure
             fig.set_size_inches(figsize)
             for i in range(ndims):
                 for j in range(ndims):
-                    ax = axs[i,j]
+                    ax = axs[i, j]
                     ax.remove()
                     ax.figure = fig
                     fig.add_axes(ax)
-                    ax.set_subplotspec(spec[i,j])
+                    ax.set_subplotspec(spec[i, j])
 
             if plot_convergence:
-                ax = fig.add_subplot(spec[ndims,:])
-                skopt_plot_convergence(self._skopt_result,ax=ax)
+                ax = fig.add_subplot(spec[ndims, :])
+                skopt_plot_convergence(self._skopt_result, ax=ax)
 
         spec.tight_layout(fig)
 
@@ -277,14 +282,20 @@ def get_optimized_arguments(self):
             where the OptimizationParameter items have been replaced with the optimal
             values obtained from the optimizer
         """
-        optimized_dict = {p.name: v for p,v in zip(self._parameter_list,self._skopt_result.x)}
-        
-        filtered_dict = { k: v for k,v in optimized_dict.items() if k in self._init_args }
+        optimized_dict = {
+            p.name: v for p, v in zip(self._parameter_list, self._skopt_result.x)
+        }
+
+        filtered_dict = {
+            k: v for k, v in optimized_dict.items() if k in self._init_args
+        }
         init_opt = self._init_args | filtered_dict
-        
-        filtered_dict = { k: v for k,v in optimized_dict.items() if k in self._affine_args }
+
+        filtered_dict = {
+            k: v for k, v in optimized_dict.items() if k in self._affine_args
+        }
         affine_opt = self._affine_args | filtered_dict
-        
+
         affine_transform = partial(AffineTransform, **self._affine_static_args)(
             **affine_opt
         )
@@ -292,13 +303,17 @@ def get_optimized_arguments(self):
             affine_transform, init_opt["datacube"]
         )
         init_opt["initial_scan_positions"] = scan_positions
-        
-        filtered_dict = { k: v for k,v in optimized_dict.items() if k in self._preprocess_args }
+
+        filtered_dict = {
+            k: v for k, v in optimized_dict.items() if k in self._preprocess_args
+        }
         prep_opt = self._preprocess_args | filtered_dict
-        
-        filtered_dict = { k: v for k,v in optimized_dict.items() if k in self._reconstruction_args }
+
+        filtered_dict = {
+            k: v for k, v in optimized_dict.items() if k in self._reconstruction_args
+        }
         reco_opt = self._reconstruction_args | filtered_dict
-        
+
         return init_opt, prep_opt, reco_opt
 
     def _split_static_and_optimization_vars(self, argdict):
@@ -387,10 +402,13 @@ def f(ptycho):
                 return -np.std(np.angle(ptycho.object_cropped))
 
         elif error_metric == "entropy-phase":
+
             def f(ptycho):
                 obj = np.angle(ptycho.object_cropped)
-                gx,gy = np.gradient(obj)
-                ghist,_,_ = np.histogram2d(gx.ravel(),gy.ravel(),bins=obj.shape,density=True)
+                gx, gy = np.gradient(obj)
+                ghist, _, _ = np.histogram2d(
+                    gx.ravel(), gy.ravel(), bins=obj.shape, density=True
+                )
                 nz = ghist > 0
                 S = np.sum(ghist[nz] * np.log2(ghist[nz]))
                 return S
@@ -484,14 +502,14 @@ def f(**kwargs):
 
     def _set_optimizer_defaults(
         self,
-        verbose = False,
-        plot_center_of_mass = False,
-        plot_rotation = False,
-        plot_probe_overlaps = False,
-        progress_bar = False,
-        store_iterations = False,
-        reset = True,
-        ):
+        verbose=False,
+        plot_center_of_mass=False,
+        plot_rotation=False,
+        plot_probe_overlaps=False,
+        progress_bar=False,
+        store_iterations=False,
+        reset=True,
+    ):
         """
         Set all of the verbose and plotting to False, allowing for user-overwrite.
         """
@@ -541,7 +559,6 @@ def __init__(
         if space not in ("real", "integer", "bool", "categorical"):
             raise ValueError(f"Unknown Parameter type: {space}")
 
-
         scaling = scaling.lower()
         if scaling not in ("uniform", "log-uniform"):
             raise ValueError(f"Unknown scaling: {scaling}")

From 455c19cdb549acc9f91f26465240dd60d6cffa6f Mon Sep 17 00:00:00 2001
From: gvarnavi <gvarnavi@mit.edu>
Date: Fri, 7 Jul 2023 09:00:23 -0700
Subject: [PATCH 257/362] ptychoptimize imports ordering

---
 py4DSTEM/process/phase/parameter_optimize.py | 27 +++++++++-----------
 1 file changed, 12 insertions(+), 15 deletions(-)

diff --git a/py4DSTEM/process/phase/parameter_optimize.py b/py4DSTEM/process/phase/parameter_optimize.py
index c8a51171d..125b72c71 100644
--- a/py4DSTEM/process/phase/parameter_optimize.py
+++ b/py4DSTEM/process/phase/parameter_optimize.py
@@ -1,22 +1,19 @@
-from tqdm import tqdm
-from skopt import gp_minimize
-from skopt.space import Real, Integer, Categorical
-from skopt.plots import (
-    plot_convergence as skopt_plot_convergence,
-    plot_gaussian_process as skopt_plot_gaussian_process,
-    plot_evaluations as skopt_plot_evaluations,
-    plot_objective as skopt_plot_objective,
-)
-from skopt.utils import use_named_args
-import matplotlib.pyplot as plt
-from matplotlib.gridspec import GridSpec
-import numpy as np
-
 from functools import partial
-from typing import Union, Callable
+from typing import Callable, Union
 
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.gridspec import GridSpec
 from py4DSTEM.process.phase.iterative_base_class import PhaseReconstruction
 from py4DSTEM.process.phase.utils import AffineTransform
+from skopt import gp_minimize
+from skopt.plots import plot_convergence as skopt_plot_convergence
+from skopt.plots import plot_evaluations as skopt_plot_evaluations
+from skopt.plots import plot_gaussian_process as skopt_plot_gaussian_process
+from skopt.plots import plot_objective as skopt_plot_objective
+from skopt.space import Categorical, Integer, Real
+from skopt.utils import use_named_args
+from tqdm import tqdm
 
 
 class PtychographyOptimizer:

From a78b67dbf2a43c52c247a6521ef7f8cc102ee990 Mon Sep 17 00:00:00 2001
From: gvarnavi <gvarnavi@mit.edu>
Date: Fri, 7 Jul 2023 09:03:57 -0700
Subject: [PATCH 258/362] init bugfix

---
 py4DSTEM/process/phase/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/process/phase/__init__.py b/py4DSTEM/process/phase/__init__.py
index ee542524f..cb9176375 100644
--- a/py4DSTEM/process/phase/__init__.py
+++ b/py4DSTEM/process/phase/__init__.py
@@ -10,6 +10,6 @@
 from py4DSTEM.process.phase.iterative_parallax import ParallaxReconstruction
 from py4DSTEM.process.phase.iterative_simultaneous_ptychography import SimultaneousPtychographicReconstruction
 from py4DSTEM.process.phase.iterative_singleslice_ptychography import SingleslicePtychographicReconstruction
-from py4DSTEM.process.phase.utils import OptimizationParameter, PtychographyOptimizer
+from py4DSTEM.process.phase.parameter_optimize import OptimizationParameter, PtychographyOptimizer
 
 # fmt: on

From 47200eb0096cb4aa5486a40660321b02c1704da4 Mon Sep 17 00:00:00 2001
From: gvarnavi <gvarnavi@mit.edu>
Date: Fri, 7 Jul 2023 09:36:17 -0700
Subject: [PATCH 259/362] making generalized-projections
 ptychoptimize-compatible

---
 .../iterative_mixedstate_ptychography.py      | 30 +++++++++++++----
 .../iterative_multislice_ptychography.py      | 32 +++++++++++++------
 .../iterative_overlap_magnetic_tomography.py  | 32 +++++++++++++------
 .../phase/iterative_overlap_tomography.py     | 32 +++++++++++++------
 .../iterative_simultaneous_ptychography.py    | 30 +++++++++++++----
 .../iterative_singleslice_ptychography.py     | 30 +++++++++++++----
 6 files changed, 138 insertions(+), 48 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
index 8d4574aa4..3450d1b13 100644
--- a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
@@ -1259,6 +1259,9 @@ def reconstruct(
         max_iter: int = 64,
         reconstruction_method: str = "gradient-descent",
         reconstruction_parameter: float = 1.0,
+        reconstruction_parameter_a: float = None,
+        reconstruction_parameter_b: float = None,
+        reconstruction_parameter_c: float = None,
         max_batch_size: int = None,
         seed_random: int = None,
         step_size: float = 0.5,
@@ -1303,7 +1306,7 @@ def reconstruct(
             Maximum number of iterations to run
         reconstruction_method: str, optional
             Specifies which reconstruction algorithm to use, one of:
-            "generalized-projection",
+            "generalized-projections",
             "DM_AP" (or "difference-map_alternating-projections"),
             "RAAR" (or "relaxed-averaged-alternating-reflections"),
             "RRR" (or "relax-reflect-reflect"),
@@ -1311,6 +1314,12 @@ def reconstruct(
             "GD" (or "gradient_descent")
         reconstruction_parameter: float, optional
             Reconstruction parameter for various reconstruction methods above.
+        reconstruction_parameter_a: float, optional
+            Reconstruction parameter a for reconstruction_method='generalized-projections'.
+        reconstruction_parameter_b: float, optional
+            Reconstruction parameter b for reconstruction_method='generalized-projections'.
+        reconstruction_parameter_c: float, optional
+            Reconstruction parameter c for reconstruction_method='generalized-projections'.
         max_batch_size: int, optional
             Max number of probes to update at once
         seed_random: int, optional
@@ -1390,17 +1399,23 @@ def reconstruct(
 
         # Reconstruction method
 
-        if reconstruction_method == "generalized-projection":
-            if np.array(reconstruction_parameter).shape != (3,):
+        if reconstruction_method == "generalized-projections":
+            if (
+                reconstruction_parameter_a is None
+                or reconstruction_parameter_b is None
+                or reconstruction_parameter_c is None
+            ):
                 raise ValueError(
                     (
-                        "reconstruction_parameter must be a list of three numbers "
-                        "when using `reconstriction_method`=generalized-projection."
+                        "reconstruction_parameter_a/b/c must all be specified "
+                        "when using reconstruction_method='generalized-projections'."
                     )
                 )
 
             use_projection_scheme = True
-            projection_a, projection_b, projection_c = reconstruction_parameter
+            projection_a = reconstruction_parameter_a
+            projection_b = reconstruction_parameter_b
+            projection_c = reconstruction_parameter_c
             step_size = None
         elif (
             reconstruction_method == "DM_AP"
@@ -1459,7 +1474,8 @@ def reconstruct(
         else:
             raise ValueError(
                 (
-                    "reconstruction_method must be one of 'DM_AP' (or 'difference-map_alternating-projections'), "
+                    "reconstruction_method must be one of 'generalized-projections', "
+                    "'DM_AP' (or 'difference-map_alternating-projections'), "
                     "'RAAR' (or 'relaxed-averaged-alternating-reflections'), "
                     "'RRR' (or 'relax-reflect-reflect'), "
                     "'SUPERFLIP' (or 'charge-flipping'), "
diff --git a/py4DSTEM/process/phase/iterative_multislice_ptychography.py b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
index 36b44b77e..f9f8c2d29 100644
--- a/py4DSTEM/process/phase/iterative_multislice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
@@ -1653,6 +1653,9 @@ def reconstruct(
         max_iter: int = 64,
         reconstruction_method: str = "gradient-descent",
         reconstruction_parameter: float = 1.0,
+        reconstruction_parameter_a: float = None,
+        reconstruction_parameter_b: float = None,
+        reconstruction_parameter_c: float = None,
         max_batch_size: int = None,
         seed_random: int = None,
         step_size: float = 0.5,
@@ -1703,7 +1706,7 @@ def reconstruct(
             Maximum number of iterations to run
         reconstruction_method: str, optional
             Specifies which reconstruction algorithm to use, one of:
-            "generalized-projection",
+            "generalized-projections",
             "DM_AP" (or "difference-map_alternating-projections"),
             "RAAR" (or "relaxed-averaged-alternating-reflections"),
             "RRR" (or "relax-reflect-reflect"),
@@ -1711,8 +1714,12 @@ def reconstruct(
             "GD" (or "gradient_descent")
         reconstruction_parameter: float, optional
             Reconstruction parameter for various reconstruction methods above.
-        reconstruction_parameter: float, optional
-            Tuning parameter to interpolate b/w DM-AP and DM-RAAR
+        reconstruction_parameter_a: float, optional
+            Reconstruction parameter a for reconstruction_method='generalized-projections'.
+        reconstruction_parameter_b: float, optional
+            Reconstruction parameter b for reconstruction_method='generalized-projections'.
+        reconstruction_parameter_c: float, optional
+            Reconstruction parameter c for reconstruction_method='generalized-projections'.
         max_batch_size: int, optional
             Max number of probes to update at once
         seed_random: int, optional
@@ -1804,17 +1811,23 @@ def reconstruct(
 
         # Reconstruction method
 
-        if reconstruction_method == "generalized-projection":
-            if np.array(reconstruction_parameter).shape != (3,):
+        if reconstruction_method == "generalized-projections":
+            if (
+                reconstruction_parameter_a is None
+                or reconstruction_parameter_b is None
+                or reconstruction_parameter_c is None
+            ):
                 raise ValueError(
                     (
-                        "reconstruction_parameter must be a list of three numbers "
-                        "when using `reconstriction_method`=generalized-projection."
+                        "reconstruction_parameter_a/b/c must all be specified "
+                        "when using reconstruction_method='generalized-projections'."
                     )
                 )
 
             use_projection_scheme = True
-            projection_a, projection_b, projection_c = reconstruction_parameter
+            projection_a = reconstruction_parameter_a
+            projection_b = reconstruction_parameter_b
+            projection_c = reconstruction_parameter_c
             step_size = None
         elif (
             reconstruction_method == "DM_AP"
@@ -1873,7 +1886,8 @@ def reconstruct(
         else:
             raise ValueError(
                 (
-                    "reconstruction_method must be one of 'DM_AP' (or 'difference-map_alternating-projections'), "
+                    "reconstruction_method must be one of 'generalized-projections', "
+                    "'DM_AP' (or 'difference-map_alternating-projections'), "
                     "'RAAR' (or 'relaxed-averaged-alternating-reflections'), "
                     "'RRR' (or 'relax-reflect-reflect'), "
                     "'SUPERFLIP' (or 'charge-flipping'), "
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 9d4acfc4c..5d70b99ce 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -1877,6 +1877,9 @@ def reconstruct(
         max_iter: int = 64,
         reconstruction_method: str = "gradient-descent",
         reconstruction_parameter: float = 1.0,
+        reconstruction_parameter_a: float = None,
+        reconstruction_parameter_b: float = None,
+        reconstruction_parameter_c: float = None,
         max_batch_size: int = None,
         seed_random: int = None,
         step_size: float = 0.5,
@@ -1923,7 +1926,7 @@ def reconstruct(
             Maximum number of iterations to run
         reconstruction_method: str, optional
             Specifies which reconstruction algorithm to use, one of:
-            "generalized-projection",
+            "generalized-projections",
             "DM_AP" (or "difference-map_alternating-projections"),
             "RAAR" (or "relaxed-averaged-alternating-reflections"),
             "RRR" (or "relax-reflect-reflect"),
@@ -1931,8 +1934,12 @@ def reconstruct(
             "GD" (or "gradient_descent")
         reconstruction_parameter: float, optional
             Reconstruction parameter for various reconstruction methods above.
-        reconstruction_parameter: float, optional
-            Tuning parameter to interpolate b/w DM-AP and DM-RAAR
+        reconstruction_parameter_a: float, optional
+            Reconstruction parameter a for reconstruction_method='generalized-projections'.
+        reconstruction_parameter_b: float, optional
+            Reconstruction parameter b for reconstruction_method='generalized-projections'.
+        reconstruction_parameter_c: float, optional
+            Reconstruction parameter c for reconstruction_method='generalized-projections'.
         max_batch_size: int, optional
             Max number of probes to update at once
         seed_random: int, optional
@@ -2010,17 +2017,23 @@ def reconstruct(
 
         # Reconstruction method
 
-        if reconstruction_method == "generalized-projection":
-            if np.array(reconstruction_parameter).shape != (3,):
+        if reconstruction_method == "generalized-projections":
+            if (
+                reconstruction_parameter_a is None
+                or reconstruction_parameter_b is None
+                or reconstruction_parameter_c is None
+            ):
                 raise ValueError(
                     (
-                        "reconstruction_parameter must be a list of three numbers "
-                        "when using `reconstriction_method`=generalized-projection."
+                        "reconstruction_parameter_a/b/c must all be specified "
+                        "when using reconstruction_method='generalized-projections'."
                     )
                 )
 
             use_projection_scheme = True
-            projection_a, projection_b, projection_c = reconstruction_parameter
+            projection_a = reconstruction_parameter_a
+            projection_b = reconstruction_parameter_b
+            projection_c = reconstruction_parameter_c
             step_size = None
         elif (
             reconstruction_method == "DM_AP"
@@ -2079,7 +2092,8 @@ def reconstruct(
         else:
             raise ValueError(
                 (
-                    "reconstruction_method must be one of 'DM_AP' (or 'difference-map_alternating-projections'), "
+                    "reconstruction_method must be one of 'generalized-projections', "
+                    "'DM_AP' (or 'difference-map_alternating-projections'), "
                     "'RAAR' (or 'relaxed-averaged-alternating-reflections'), "
                     "'RRR' (or 'relax-reflect-reflect'), "
                     "'SUPERFLIP' (or 'charge-flipping'), "
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index 82d1caac3..037a3c805 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -1690,6 +1690,9 @@ def reconstruct(
         max_iter: int = 64,
         reconstruction_method: str = "gradient-descent",
         reconstruction_parameter: float = 1.0,
+        reconstruction_parameter_a: float = None,
+        reconstruction_parameter_b: float = None,
+        reconstruction_parameter_c: float = None,
         max_batch_size: int = None,
         seed_random: int = None,
         step_size: float = 0.5,
@@ -1733,7 +1736,7 @@ def reconstruct(
             Maximum number of iterations to run
         reconstruction_method: str, optional
             Specifies which reconstruction algorithm to use, one of:
-            "generalized-projection",
+            "generalized-projections",
             "DM_AP" (or "difference-map_alternating-projections"),
             "RAAR" (or "relaxed-averaged-alternating-reflections"),
             "RRR" (or "relax-reflect-reflect"),
@@ -1741,8 +1744,12 @@ def reconstruct(
             "GD" (or "gradient_descent")
         reconstruction_parameter: float, optional
             Reconstruction parameter for various reconstruction methods above.
-        reconstruction_parameter: float, optional
-            Tuning parameter to interpolate b/w DM-AP and DM-RAAR
+        reconstruction_parameter_a: float, optional
+            Reconstruction parameter a for reconstruction_method='generalized-projections'.
+        reconstruction_parameter_b: float, optional
+            Reconstruction parameter b for reconstruction_method='generalized-projections'.
+        reconstruction_parameter_c: float, optional
+            Reconstruction parameter c for reconstruction_method='generalized-projections'.
         max_batch_size: int, optional
             Max number of probes to update at once
         seed_random: int, optional
@@ -1818,17 +1825,23 @@ def reconstruct(
 
         # Reconstruction method
 
-        if reconstruction_method == "generalized-projection":
-            if np.array(reconstruction_parameter).shape != (3,):
+        if reconstruction_method == "generalized-projections":
+            if (
+                reconstruction_parameter_a is None
+                or reconstruction_parameter_b is None
+                or reconstruction_parameter_c is None
+            ):
                 raise ValueError(
                     (
-                        "reconstruction_parameter must be a list of three numbers "
-                        "when using `reconstriction_method`=generalized-projection."
+                        "reconstruction_parameter_a/b/c must all be specified "
+                        "when using reconstruction_method='generalized-projections'."
                     )
                 )
 
             use_projection_scheme = True
-            projection_a, projection_b, projection_c = reconstruction_parameter
+            projection_a = reconstruction_parameter_a
+            projection_b = reconstruction_parameter_b
+            projection_c = reconstruction_parameter_c
             step_size = None
         elif (
             reconstruction_method == "DM_AP"
@@ -1887,7 +1900,8 @@ def reconstruct(
         else:
             raise ValueError(
                 (
-                    "reconstruction_method must be one of 'DM_AP' (or 'difference-map_alternating-projections'), "
+                    "reconstruction_method must be one of 'generalized-projections', "
+                    "'DM_AP' (or 'difference-map_alternating-projections'), "
                     "'RAAR' (or 'relaxed-averaged-alternating-reflections'), "
                     "'RRR' (or 'relax-reflect-reflect'), "
                     "'SUPERFLIP' (or 'charge-flipping'), "
diff --git a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
index 9e4b39cf5..629108b54 100644
--- a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
@@ -2405,6 +2405,9 @@ def reconstruct(
         max_iter: int = 64,
         reconstruction_method: str = "gradient-descent",
         reconstruction_parameter: float = 1.0,
+        reconstruction_parameter_a: float = None,
+        reconstruction_parameter_b: float = None,
+        reconstruction_parameter_c: float = None,
         max_batch_size: int = None,
         seed_random: int = None,
         step_size: float = 0.5,
@@ -2453,7 +2456,7 @@ def reconstruct(
             Maximum number of iterations to run
         reconstruction_method: str, optional
             Specifies which reconstruction algorithm to use, one of:
-            "generalized-projection",
+            "generalized-projections",
             "DM_AP" (or "difference-map_alternating-projections"),
             "RAAR" (or "relaxed-averaged-alternating-reflections"),
             "RRR" (or "relax-reflect-reflect"),
@@ -2461,6 +2464,12 @@ def reconstruct(
             "GD" (or "gradient_descent")
         reconstruction_parameter: float, optional
             Reconstruction parameter for various reconstruction methods above.
+        reconstruction_parameter_a: float, optional
+            Reconstruction parameter a for reconstruction_method='generalized-projections'.
+        reconstruction_parameter_b: float, optional
+            Reconstruction parameter b for reconstruction_method='generalized-projections'.
+        reconstruction_parameter_c: float, optional
+            Reconstruction parameter c for reconstruction_method='generalized-projections'.
         max_batch_size: int, optional
             Max number of probes to update at once
         seed_random: int, optional
@@ -2549,17 +2558,23 @@ def reconstruct(
 
         # Reconstruction method
 
-        if reconstruction_method == "generalized-projection":
-            if np.array(reconstruction_parameter).shape != (3,):
+        if reconstruction_method == "generalized-projections":
+            if (
+                reconstruction_parameter_a is None
+                or reconstruction_parameter_b is None
+                or reconstruction_parameter_c is None
+            ):
                 raise ValueError(
                     (
-                        "reconstruction_parameter must be a list of three numbers "
-                        "when using `reconstriction_method`=generalized-projection."
+                        "reconstruction_parameter_a/b/c must all be specified "
+                        "when using reconstruction_method='generalized-projections'."
                     )
                 )
 
             use_projection_scheme = True
-            projection_a, projection_b, projection_c = reconstruction_parameter
+            projection_a = reconstruction_parameter_a
+            projection_b = reconstruction_parameter_b
+            projection_c = reconstruction_parameter_c
             step_size = None
         elif (
             reconstruction_method == "DM_AP"
@@ -2618,7 +2633,8 @@ def reconstruct(
         else:
             raise ValueError(
                 (
-                    "reconstruction_method must be one of 'DM_AP' (or 'difference-map_alternating-projections'), "
+                    "reconstruction_method must be one of 'generalized-projections', "
+                    "'DM_AP' (or 'difference-map_alternating-projections'), "
                     "'RAAR' (or 'relaxed-averaged-alternating-reflections'), "
                     "'RRR' (or 'relax-reflect-reflect'), "
                     "'SUPERFLIP' (or 'charge-flipping'), "
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index 52aa2f816..d977dc916 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -1167,6 +1167,9 @@ def reconstruct(
         max_iter: int = 64,
         reconstruction_method: str = "gradient-descent",
         reconstruction_parameter: float = 1.0,
+        reconstruction_parameter_a: float = None,
+        reconstruction_parameter_b: float = None,
+        reconstruction_parameter_c: float = None,
         max_batch_size: int = None,
         seed_random: int = None,
         step_size: float = 0.5,
@@ -1211,7 +1214,7 @@ def reconstruct(
             Maximum number of iterations to run
         reconstruction_method: str, optional
             Specifies which reconstruction algorithm to use, one of:
-            "generalized-projection",
+            "generalized-projections",
             "DM_AP" (or "difference-map_alternating-projections"),
             "RAAR" (or "relaxed-averaged-alternating-reflections"),
             "RRR" (or "relax-reflect-reflect"),
@@ -1219,6 +1222,12 @@ def reconstruct(
             "GD" (or "gradient_descent")
         reconstruction_parameter: float, optional
             Reconstruction parameter for various reconstruction methods above.
+        reconstruction_parameter_a: float, optional
+            Reconstruction parameter a for reconstruction_method='generalized-projections'.
+        reconstruction_parameter_b: float, optional
+            Reconstruction parameter b for reconstruction_method='generalized-projections'.
+        reconstruction_parameter_c: float, optional
+            Reconstruction parameter c for reconstruction_method='generalized-projections'.
         max_batch_size: int, optional
             Max number of probes to update at once
         seed_random: int, optional
@@ -1301,17 +1310,23 @@ def reconstruct(
 
         # Reconstruction method
 
-        if reconstruction_method == "generalized-projection":
-            if np.array(reconstruction_parameter).shape != (3,):
+        if reconstruction_method == "generalized-projections":
+            if (
+                reconstruction_parameter_a is None
+                or reconstruction_parameter_b is None
+                or reconstruction_parameter_c is None
+            ):
                 raise ValueError(
                     (
-                        "reconstruction_parameter must be a list of three numbers "
-                        "when using `reconstriction_method`=generalized-projection."
+                        "reconstruction_parameter_a/b/c must all be specified "
+                        "when using reconstruction_method='generalized-projections'."
                     )
                 )
 
             use_projection_scheme = True
-            projection_a, projection_b, projection_c = reconstruction_parameter
+            projection_a = reconstruction_parameter_a
+            projection_b = reconstruction_parameter_b
+            projection_c = reconstruction_parameter_c
             step_size = None
         elif (
             reconstruction_method == "DM_AP"
@@ -1370,7 +1385,8 @@ def reconstruct(
         else:
             raise ValueError(
                 (
-                    "reconstruction_method must be one of 'DM_AP' (or 'difference-map_alternating-projections'), "
+                    "reconstruction_method must be one of 'generalized-projections', "
+                    "'DM_AP' (or 'difference-map_alternating-projections'), "
                     "'RAAR' (or 'relaxed-averaged-alternating-reflections'), "
                     "'RRR' (or 'relax-reflect-reflect'), "
                     "'SUPERFLIP' (or 'charge-flipping'), "

From e4c0c325a2742d5e26359d06bfc7fec614006b74 Mon Sep 17 00:00:00 2001
From: gvarnavi <gvarnavi@mit.edu>
Date: Fri, 7 Jul 2023 09:43:38 -0700
Subject: [PATCH 260/362] centered Fourier-probe extent

---
 .../phase/iterative_mixedstate_ptychography.py  | 16 ++++++++--------
 .../phase/iterative_multislice_ptychography.py  | 17 ++++++++---------
 .../phase/iterative_overlap_tomography.py       | 17 ++++++++---------
 .../iterative_simultaneous_ptychography.py      |  8 ++++----
 .../phase/iterative_singleslice_ptychography.py | 16 ++++++++--------
 5 files changed, 36 insertions(+), 38 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
index 3450d1b13..d4e2e5346 100644
--- a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
@@ -1838,10 +1838,10 @@ def _visualize_last_iteration(
 
         if plot_fourier_probe:
             probe_extent = [
-                0,
-                self.angular_sampling[1] * self._region_of_interest_shape[1],
-                self.angular_sampling[0] * self._region_of_interest_shape[0],
-                0,
+                -self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
+                -self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
             ]
         elif plot_probe:
             probe_extent = [
@@ -2075,10 +2075,10 @@ def _visualize_all_iterations(
 
         if plot_fourier_probe:
             probe_extent = [
-                0,
-                self.angular_sampling[1] * self._region_of_interest_shape[1],
-                self.angular_sampling[0] * self._region_of_interest_shape[0],
-                0,
+                -self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
+                -self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
             ]
         elif plot_probe:
             probe_extent = [
diff --git a/py4DSTEM/process/phase/iterative_multislice_ptychography.py b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
index f9f8c2d29..d477da8ce 100644
--- a/py4DSTEM/process/phase/iterative_multislice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
@@ -2269,12 +2269,11 @@ def _visualize_last_iteration(
 
         if plot_fourier_probe:
             probe_extent = [
-                0,
-                self.angular_sampling[1] * self._region_of_interest_shape[1],
-                self.angular_sampling[0] * self._region_of_interest_shape[0],
-                0,
+                -self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
+                -self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
             ]
-
         elif plot_probe:
             probe_extent = [
                 0,
@@ -2510,10 +2509,10 @@ def _visualize_all_iterations(
 
         if plot_fourier_probe:
             probe_extent = [
-                0,
-                self.angular_sampling[1] * self._region_of_interest_shape[1],
-                self.angular_sampling[0] * self._region_of_interest_shape[0],
-                0,
+                -self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
+                -self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
             ]
         elif plot_probe:
             probe_extent = [
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index 037a3c805..61d40473d 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -2460,12 +2460,11 @@ def _visualize_last_iteration(
 
         if plot_fourier_probe:
             probe_extent = [
-                0,
-                self.angular_sampling[1] * self._region_of_interest_shape[1],
-                self.angular_sampling[0] * self._region_of_interest_shape[0],
-                0,
+                -self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
+                -self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
             ]
-
         elif plot_probe:
             probe_extent = [
                 0,
@@ -2717,10 +2716,10 @@ def _visualize_all_iterations(
 
         if plot_fourier_probe:
             probe_extent = [
-                0,
-                self.angular_sampling[1] * self._region_of_interest_shape[1],
-                self.angular_sampling[0] * self._region_of_interest_shape[0],
-                0,
+                -self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
+                -self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
             ]
         elif plot_probe:
             probe_extent = [
diff --git a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
index 629108b54..545900634 100644
--- a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
@@ -3052,10 +3052,10 @@ def _visualize_last_iteration(
 
         if plot_fourier_probe:
             probe_extent = [
-                0,
-                self.angular_sampling[1] * self._region_of_interest_shape[1],
-                self.angular_sampling[0] * self._region_of_interest_shape[0],
-                0,
+                -self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
+                -self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
             ]
         elif plot_probe:
             probe_extent = [
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index d977dc916..791e3ffb5 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -1751,10 +1751,10 @@ def _visualize_last_iteration(
 
         if plot_fourier_probe:
             probe_extent = [
-                0,
-                self.angular_sampling[1] * self._region_of_interest_shape[1],
-                self.angular_sampling[0] * self._region_of_interest_shape[0],
-                0,
+                -self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
+                -self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
             ]
         elif plot_probe:
             probe_extent = [
@@ -1988,10 +1988,10 @@ def _visualize_all_iterations(
 
         if plot_fourier_probe:
             probe_extent = [
-                0,
-                self.angular_sampling[1] * self._region_of_interest_shape[1],
-                self.angular_sampling[0] * self._region_of_interest_shape[0],
-                0,
+                -self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[1] * self._region_of_interest_shape[1] / 2,
+                self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
+                -self.angular_sampling[0] * self._region_of_interest_shape[0] / 2,
             ]
         elif plot_probe:
             probe_extent = [

From 4344eef22a9fcf8c7310a1b012888b329cffd0dd Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 7 Jul 2023 17:21:08 -0700
Subject: [PATCH 261/362] Force COM measured for DPC

---
 .../process/phase/iterative_base_class.py     | 71 +++++++++++--------
 py4DSTEM/process/phase/iterative_dpc.py       | 24 +++++--
 .../iterative_overlap_magnetic_tomography.py  |  6 +-
 .../phase/iterative_overlap_tomography.py     |  6 +-
 4 files changed, 60 insertions(+), 47 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index 766d03c6a..76583815e 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -281,7 +281,7 @@ def _extract_intensities_and_calibrations_from_datacube(
 
         # Copies intensities to device casting to float32
         xp = self._xp
-        intensities = xp.asarray(datacube.data, dtype=xp.float32)
+        intensities = datacube.data
         self._grid_scan_shape = intensities.shape[:2]
 
         # Extracts calibrations
@@ -414,6 +414,7 @@ def _calculate_intensities_center_of_mass(
         dp_mask: np.ndarray = None,
         fit_function: str = "plane",
         com_shifts: np.ndarray = None,
+        com_measured: np.ndarray = None,
     ):
         """
         Common preprocessing function to compute and fit diffraction intensities CoM
@@ -426,9 +427,10 @@ def _calculate_intensities_center_of_mass(
             If not None, apply mask to datacube amplitude
         fit_function: str, optional
             2D fitting function for CoM fitting. One of 'plane','parabola','bezier_two'
-        com_shifts, np.ndarray, optional
+        com_shifts, tuple of ndarrays (CoMx measured, CoMy measured)
             If not None, com_shifts are fitted on the measured CoM values.
-
+        com_measured: tuple of ndarrays (CoMx measured, CoMy measured)
+            If not None, com_measured are passed as com_measured_x, com_measured_y
         Returns
         -------
 
@@ -449,39 +451,48 @@ def _calculate_intensities_center_of_mass(
         xp = self._xp
         asnumpy = self._asnumpy
 
-        # Coordinates
-        kx = xp.arange(intensities.shape[-2], dtype=xp.float32)
-        ky = xp.arange(intensities.shape[-1], dtype=xp.float32)
-        kya, kxa = xp.meshgrid(ky, kx)
+        intensities = xp.asarray(intensities, dtype=xp.float32)
+
+        # for ptycho
+        if com_measured:
+            com_measured_x, com_measured_y = com_measured
 
-        # calculate CoM
-        if dp_mask is not None:
-            if dp_mask.shape != intensities.shape[-2:]:
-                raise ValueError(
-                    (
-                        f"Mask shape should be (Qx,Qy):{intensities.shape[-2:]}, "
-                        f"not {dp_mask.shape}"
-                    )
-                )
-            intensities_mask = intensities * xp.asarray(dp_mask, dtype=xp.float32)
         else:
-            intensities_mask = intensities
+            # Coordinates
+            kx = xp.arange(intensities.shape[-2], dtype=xp.float32)
+            ky = xp.arange(intensities.shape[-1], dtype=xp.float32)
+            kya, kxa = xp.meshgrid(ky, kx)
 
-        intensities_sum = xp.sum(intensities_mask, axis=(-2, -1))
-        com_measured_x = (
-            xp.sum(intensities_mask * kxa[None, None], axis=(-2, -1)) / intensities_sum
-        )
-        com_measured_y = (
-            xp.sum(intensities_mask * kya[None, None], axis=(-2, -1)) / intensities_sum
-        )
+            # calculate CoM
+            if dp_mask is not None:
+                if dp_mask.shape != intensities.shape[-2:]:
+                    raise ValueError(
+                        (
+                            f"Mask shape should be (Qx,Qy):{intensities.shape[-2:]}, "
+                            f"not {dp_mask.shape}"
+                        )
+                    )
+                intensities_mask = intensities * xp.asarray(dp_mask, dtype=xp.float32)
+            else:
+                intensities_mask = intensities
+
+            intensities_sum = xp.sum(intensities_mask, axis=(-2, -1))
+            com_measured_x = (
+                xp.sum(intensities_mask * kxa[None, None], axis=(-2, -1))
+                / intensities_sum
+            )
+            com_measured_y = (
+                xp.sum(intensities_mask * kya[None, None], axis=(-2, -1))
+                / intensities_sum
+            )
 
-        # Fit function to center of mass
         if com_shifts is None:
             com_shifts = fit_origin(
                 (asnumpy(com_measured_x), asnumpy(com_measured_y)),
                 fitfunction=fit_function,
             )
 
+        # Fit function to center of mass
         com_fitted_x = xp.asarray(com_shifts[0], dtype=xp.float32)
         com_fitted_y = xp.asarray(com_shifts[1], dtype=xp.float32)
 
@@ -993,8 +1004,8 @@ def _solve_for_center_of_mass_relative_rotation(
             cmap = kwargs.pop("cmap", "RdBu_r")
             extent = [
                 0,
-                self._scan_sampling[1] * self._intensities.shape[1],
-                self._scan_sampling[0] * self._intensities.shape[0],
+                self._scan_sampling[1] * _com_measured_x.shape[1],
+                self._scan_sampling[0] * _com_measured_x.shape[0],
                 0,
             ]
 
@@ -1031,8 +1042,8 @@ def _solve_for_center_of_mass_relative_rotation(
 
             extent = [
                 0,
-                self._scan_sampling[1] * self._intensities.shape[1],
-                self._scan_sampling[0] * self._intensities.shape[0],
+                self._scan_sampling[1] * com_x.shape[1],
+                self._scan_sampling[0] * com_x.shape[0],
                 0,
             ]
 
diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index e6f7659bd..4e890db79 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -4,7 +4,7 @@
 """
 
 import warnings
-from typing import Tuple
+from typing import Tuple, Union, Sequence
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -239,7 +239,8 @@ def preprocess(
         fit_function: str = "plane",
         force_com_rotation: float = None,
         force_com_transpose: bool = None,
-        force_com_shifts: float = None,
+        force_com_shifts: Union[Sequence[np.ndarray], Sequence[float]] = None,
+        force_com_measured: Sequence[np.ndarray] = None,
         plot_center_of_mass: str = "default",
         plot_rotation: bool = True,
         **kwargs,
@@ -270,6 +271,8 @@ def preprocess(
             Force whether diffraction intensities need to be transposed.
         force_com_shifts: tuple of ndarrays (CoMx, CoMy)
             Force CoM fitted shifts
+        force_com_measured: tuple of ndarrays (CoMx measured, CoMy measured)
+            Force CoM measured shifts
         plot_center_of_mass: str, optional
             If 'default', the corrected CoM arrays will be displayed
             If 'all', the computed and fitted CoM arrays will be displayed
@@ -287,12 +290,18 @@ def preprocess(
         self._dp_mask = dp_mask
 
         if self._datacube is None:
-            raise ValueError(
-                (
-                    "The preprocess() method requires a DataCube. "
-                    "Please run dpc.attach_datacube(DataCube) first."
+            if force_com_measured is None:
+                raise ValueError(
+                    (
+                        "The preprocess() method requires either a DataCube "
+                        "or `force_com_measured`. "
+                        "Please run dpc.attach_datacube(DataCube) to attach DataCube."
+                    )
+                )
+            else:
+                self._datacube = DataCube(
+                    data=np.empty(force_com_measured[0].shape + (1, 1))
                 )
-            )
 
         self._intensities = self._extract_intensities_and_calibrations_from_datacube(
             self._datacube,
@@ -311,6 +320,7 @@ def preprocess(
             dp_mask=self._dp_mask,
             fit_function=fit_function,
             com_shifts=force_com_shifts,
+            com_measured=force_com_measured,
         )
 
         (
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 5d70b99ce..939f42dec 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -2488,11 +2488,7 @@ def reconstruct(
             if collective_tilt_updates:
                 self._object += collective_object / self._num_tilts
 
-                (
-                    self._object,
-                    self._probe,
-                    _,
-                ) = self._constraints(
+                (self._object, self._probe, _,) = self._constraints(
                     self._object,
                     self._probe,
                     None,
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index 61d40473d..6b0a16e2e 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -2212,11 +2212,7 @@ def reconstruct(
             if collective_tilt_updates:
                 self._object += collective_object / self._num_tilts
 
-                (
-                    self._object,
-                    self._probe,
-                    _,
-                ) = self._constraints(
+                (self._object, self._probe, _,) = self._constraints(
                     self._object,
                     self._probe,
                     None,

From 783e8bb6a90e4436ad9741e7a4a25367dbd42eae Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Sat, 8 Jul 2023 07:00:14 -0700
Subject: [PATCH 262/362] bug fix

---
 py4DSTEM/process/phase/iterative_parallax.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/py4DSTEM/process/phase/iterative_parallax.py b/py4DSTEM/process/phase/iterative_parallax.py
index 5ab4c6cdd..576342631 100644
--- a/py4DSTEM/process/phase/iterative_parallax.py
+++ b/py4DSTEM/process/phase/iterative_parallax.py
@@ -171,6 +171,7 @@ def preprocess(
             self._datacube,
             require_calibrations=True,
         )
+        self._intensities = xp.asarray(self._intensities, dtype=xp.float32)
 
         # make sure mean diffraction pattern is shaped correctly
         if (self._dp_mean.shape[0] != self._intensities.shape[2]) or (

From fd87c3d471f9d7bdba60d53a495f97395f1ce09c Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Sun, 9 Jul 2023 19:04:59 -0700
Subject: [PATCH 263/362] Adding probe amplitude regularization

---
 py4DSTEM/process/phase/utils.py | 242 ++++++++++++++++++++++++++++++++
 1 file changed, 242 insertions(+)

diff --git a/py4DSTEM/process/phase/utils.py b/py4DSTEM/process/phase/utils.py
index d57ad820a..8442b6cbc 100644
--- a/py4DSTEM/process/phase/utils.py
+++ b/py4DSTEM/process/phase/utils.py
@@ -3,6 +3,7 @@
 import matplotlib.pyplot as plt
 import numpy as np
 import functools
+from scipy.optimize import curve_fit
 
 try:
     import cupy as cp
@@ -1274,3 +1275,244 @@ def nesterov_gamma(zero_indexed_iter_num):
     return (1 - nesterov_lambda(one_indexed_iter_num)) / nesterov_lambda(
         one_indexed_iter_num + 1
     )
+
+
+
+
+
+
+def regularize_probe_amp(
+    probe_init,
+    width_max_pixels = 2.0,
+    plot_polar = False,
+    plot_result = False,
+    figsize = (5,5),
+    ):
+    """
+    Assume that the probe is centered in Fourier space.  Note that I re-implemented the polar/cartesian transforms here for portability.
+    """
+
+    # Get probe intensity
+    probe_amp = np.abs(probe_init)
+    probe_int = probe_amp**2
+    
+    # coordinates
+    xa,ya = np.meshgrid(
+        np.arange(probe_init.shape[0]),
+        np.arange(probe_init.shape[1]),
+        indexing = 'ij',
+        )
+
+    # Center of mass for probe intensity
+    int_total = np.sum(probe_int)
+    xy_center = (
+        np.sum(probe_int * xa) / int_total,
+        np.sum(probe_int * ya) / int_total,
+        )
+
+    # Convert intensity to polar coordinates
+    polar_int = im_cart_to_polar(
+        probe_int,
+        xy_center = xy_center,
+        )
+
+    # Fit corrected probe intensity
+    radius = np.arange(polar_int.shape[1])
+
+    # estimate initial parameters
+    sub = polar_int > (np.max(polar_int)*0.5)
+    sig_0 = np.mean(polar_int[sub])
+    rad_0 = np.max(np.argwhere(np.sum(sub,axis=0)))
+    width = np.minimum(1.0, width_max_pixels)
+
+    # init
+    coefs_all = np.zeros((polar_int.shape[0],3))
+    coefs_all[:,0] = sig_0
+    coefs_all[:,1] = rad_0
+    coefs_all[:,2] = width
+
+    # bounds
+    lb = (0, 0, 0.5)
+    ub = (np.inf, np.inf, width_max_pixels)
+
+    # refine parameters, generate polar image
+    polar_fit = np.zeros_like(polar_int)
+    for a0 in range(polar_int.shape[0]):
+        coefs_all[a0,:] = curve_fit(
+                step_model, 
+                radius, 
+                polar_int[a0,:], 
+                p0 = coefs_all[a0,:],
+                xtol = 1e-12,
+                bounds = (lb,ub),
+            )[0]
+        polar_fit[a0,:] = step_model(
+            radius,
+            coefs_all[a0,:])
+
+    # Compute best-fit constant intensity inside probe
+    sig_0 = np.median(coefs_all[:,0])
+    coefs_all[:,0] = sig_0
+    lb = (sig_0-1e-8, 0, 0.5)
+    ub = (sig_0+1e-8, np.inf, width_max_pixels)
+
+    # refine parameters, generate polar image
+    polar_int_corr = np.zeros_like(polar_int)
+    for a0 in range(polar_int.shape[0]):
+        coefs_all[a0,:] = curve_fit(
+                step_model, 
+                radius, 
+                polar_int[a0,:], 
+                p0 = coefs_all[a0,:],
+                xtol = 1e-12,
+                bounds = (lb,ub),
+            )[0]
+        polar_int_corr[a0,:] = step_model(
+            radius,
+            coefs_all[a0,:])
+
+    # Convert back to cartesian coordinates
+    int_corr = im_polar_to_cart(
+        polar_int_corr,
+        xy_size = probe_init.shape, 
+        xy_center = xy_center,
+        )
+
+    # Assemble output probe
+    probe_corr = np.sqrt(np.maximum(int_corr,0)) \
+        * np.exp(1j*np.angle(probe_init))
+
+    # plotting
+    if plot_result:
+        fig,ax = plt.subplots(figsize = (figsize[0]*2, figsize[1]))
+        ax.imshow(
+            np.hstack((
+                probe_int,
+                int_corr,
+            )),
+            cmap = 'turbo',
+            )
+    if plot_polar:
+        fig,ax = plt.subplots(figsize = figsize)
+        ax.imshow(
+            np.hstack((
+                polar_int,
+                polar_fit,
+                polar_int_corr,
+            )),
+            cmap = 'turbo',
+            )    
+
+    return probe_corr
+    
+
+def step_model(radius, *coefs):
+    coefs = np.squeeze(np.array(coefs))
+
+    sig_0 = coefs[0]
+    rad_0 = coefs[1]
+    width = coefs[2]
+
+    return sig_0 * np.clip((rad_0 - radius) / width, 0, 1)
+
+
+def im_cart_to_polar(
+    im_cart,
+    xy_center,
+    num_theta_bins = 180,
+    radius_max = None,
+    ):
+    """
+    Quick cartesian to polar conversion.
+    """
+
+    # coordinates
+    xa,ya = np.meshgrid(
+        np.arange(im_cart.shape[0]),
+        np.arange(im_cart.shape[1]),
+        indexing = 'ij',
+        )    
+    if radius_max is None:
+        radius_max = np.ceil(np.sqrt(np.sum(
+            np.array(im_cart.shape).astype('float')**2
+            )) / 2.0).astype('int')
+    r = np.arange(radius_max)
+    t = np.linspace(
+        0,
+        2.0*np.pi,
+        num_theta_bins,
+        endpoint = False,
+        )
+    ra,ta = np.meshgrid(r,t)
+
+    # resampling coordinates
+    x = (ra * np.cos(ta) + xy_center[0])
+    y = (ra * np.sin(ta) + xy_center[1])
+    xf = np.floor(x).astype('int')
+    yf = np.floor(y).astype('int')
+    dx = x - xf
+    dy = y - yf
+
+    # resample image
+    im_polar = \
+        im_cart.ravel()[np.ravel_multi_index(
+            (xf,    yf),
+            im_cart.shape,
+            mode='clip',
+            )] * (1-dx) * (1-dy) + \
+        im_cart.ravel()[np.ravel_multi_index(
+            (xf+1,  yf),
+            im_cart.shape,
+            mode='clip',
+            )] * (  dx) * (1-dy) + \
+        im_cart.ravel()[np.ravel_multi_index(
+            (xf,    yf+1),
+            im_cart.shape,
+            mode='clip',
+            )] * (1-dx) * (  dy) + \
+        im_cart.ravel()[np.ravel_multi_index(
+            (xf+1,  yf+1),
+            im_cart.shape,
+            mode='clip',
+            )] * (  dx) * (  dy)
+
+    return im_polar
+
+
+def im_polar_to_cart(
+    im_polar,
+    xy_size,
+    xy_center,
+    ):
+    """
+    Quick cartesian to polar conversion.
+    """
+
+    # coordinates
+    xa,ya = np.meshgrid(
+        np.arange(xy_size[0]) - xy_center[0],
+        np.arange(xy_size[1]) - xy_center[1],
+        indexing = 'ij',
+        )  
+    ra = np.sqrt(xa**2 + ya**2)
+    ta = np.arctan2(ya,xa)
+    t = np.linspace(0,2*np.pi,im_polar.shape[0],endpoint = False)
+    t_step = t[1] - t[0]
+
+    # resampling coordinates
+    t_ind = ta / t_step
+    r_ind = ra.copy()
+    tf = np.floor(t_ind).astype('int')
+    rf = np.floor(r_ind).astype('int')
+    dt = t_ind - tf
+    dr = r_ind - rf
+
+    # resample image
+    im_cart = im_polar.ravel()[np.ravel_multi_index(
+            (np.mod(tf, im_polar.shape[0]),    rf),
+            im_polar.shape,
+            mode='clip',
+            )]
+
+    return im_cart
+

From d33b62693220ba9c7bcd185c67ee53a39514e6ea Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Sun, 9 Jul 2023 19:08:45 -0700
Subject: [PATCH 264/362] Adding docstrings

---
 py4DSTEM/process/phase/utils.py | 32 ++++++++++++++++++++++++++++++--
 1 file changed, 30 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/process/phase/utils.py b/py4DSTEM/process/phase/utils.py
index 8442b6cbc..112b1242c 100644
--- a/py4DSTEM/process/phase/utils.py
+++ b/py4DSTEM/process/phase/utils.py
@@ -1284,12 +1284,40 @@ def nesterov_gamma(zero_indexed_iter_num):
 def regularize_probe_amp(
     probe_init,
     width_max_pixels = 2.0,
-    plot_polar = False,
     plot_result = False,
+    plot_polar = False,
+    cmap = 'turbo',
     figsize = (5,5),
     ):
     """
-    Assume that the probe is centered in Fourier space.  Note that I re-implemented the polar/cartesian transforms here for portability.
+    Assume that the probe is centered in Fourier space.  Note we 
+    re-implemented the polar/cartesian transforms here for portability.
+    
+    Parameters
+    --------
+    probe_init: np.array
+        2D complex image of the probe in Fourier space.
+    width_max_pixels: float
+        Maximum edge width of the probe in pixels.
+    plot_result: bool
+        Plot the input and output probes.
+    plot_polar: bool
+        Plot the polar transformed images:
+        1 - initial probe
+        2 - best fit of step model for each line
+        3 - best fit enforcing constant intensity inside aperture
+    cmap: string
+        colormap of the plots.
+    figsize: tuple
+        size of the output figures.
+        (will be doubled along horizontal axis for cartesian images)
+
+    Returns
+    --------
+    probe_corr: np.array
+        2D complex image of the corrected probe in Fourier space.
+
+
     """
 
     # Get probe intensity

From c62d3e4ab9c5a0c6cf7c33d80f0797db3b20ab8f Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Sun, 9 Jul 2023 19:23:55 -0700
Subject: [PATCH 265/362] adding more options, cleaning up

---
 py4DSTEM/process/phase/utils.py | 64 ++++++++++++++++++++-------------
 1 file changed, 40 insertions(+), 24 deletions(-)

diff --git a/py4DSTEM/process/phase/utils.py b/py4DSTEM/process/phase/utils.py
index 112b1242c..29b76165c 100644
--- a/py4DSTEM/process/phase/utils.py
+++ b/py4DSTEM/process/phase/utils.py
@@ -1284,6 +1284,8 @@ def nesterov_gamma(zero_indexed_iter_num):
 def regularize_probe_amp(
     probe_init,
     width_max_pixels = 2.0,
+    enforce_constant_intensity = True,
+    return_coefs = False,
     plot_result = False,
     plot_polar = False,
     cmap = 'turbo',
@@ -1299,6 +1301,10 @@ def regularize_probe_amp(
         2D complex image of the probe in Fourier space.
     width_max_pixels: float
         Maximum edge width of the probe in pixels.
+    enforce_constant_intensity: bool
+        Set to true to make intensity inside the aperture constant.
+    return_coefs: bool
+        If true, fitting coefficients will also be returned.
     plot_result: bool
         Plot the input and output probes.
     plot_polar: bool
@@ -1316,6 +1322,9 @@ def regularize_probe_amp(
     --------
     probe_corr: np.array
         2D complex image of the corrected probe in Fourier space.
+    coefs_all: np.array (optional)
+        coefficients for the 
+
 
 
     """
@@ -1323,7 +1332,7 @@ def regularize_probe_amp(
     # Get probe intensity
     probe_amp = np.abs(probe_init)
     probe_int = probe_amp**2
-    
+
     # coordinates
     xa,ya = np.meshgrid(
         np.arange(probe_init.shape[0]),
@@ -1351,7 +1360,7 @@ def regularize_probe_amp(
     sub = polar_int > (np.max(polar_int)*0.5)
     sig_0 = np.mean(polar_int[sub])
     rad_0 = np.max(np.argwhere(np.sum(sub,axis=0)))
-    width = np.minimum(1.0, width_max_pixels)
+    width = width_max_pixels * 0.5
 
     # init
     coefs_all = np.zeros((polar_int.shape[0],3))
@@ -1360,7 +1369,7 @@ def regularize_probe_amp(
     coefs_all[:,2] = width
 
     # bounds
-    lb = (0, 0, 0.5)
+    lb = (0.0, 0.0, 1e-4)
     ub = (np.inf, np.inf, width_max_pixels)
 
     # refine parameters, generate polar image
@@ -1378,26 +1387,30 @@ def regularize_probe_amp(
             radius,
             coefs_all[a0,:])
 
-    # Compute best-fit constant intensity inside probe
-    sig_0 = np.median(coefs_all[:,0])
-    coefs_all[:,0] = sig_0
-    lb = (sig_0-1e-8, 0, 0.5)
-    ub = (sig_0+1e-8, np.inf, width_max_pixels)
+    if enforce_constant_intensity:
+        # Compute best-fit constant intensity inside probe, update bounds
+        sig_0 = np.median(coefs_all[:,0])
+        coefs_all[:,0] = sig_0
+        lb = (sig_0-1e-8, 0.0, 1e-4)
+        ub = (sig_0+1e-8, np.inf, width_max_pixels)
+
+        # refine parameters, generate polar image
+        polar_int_corr = np.zeros_like(polar_int)
+        for a0 in range(polar_int.shape[0]):
+            coefs_all[a0,:] = curve_fit(
+                    step_model, 
+                    radius, 
+                    polar_int[a0,:], 
+                    p0 = coefs_all[a0,:],
+                    xtol = 1e-12,
+                    bounds = (lb,ub),
+                )[0]
+            polar_int_corr[a0,:] = step_model(
+                radius,
+                coefs_all[a0,:])
 
-    # refine parameters, generate polar image
-    polar_int_corr = np.zeros_like(polar_int)
-    for a0 in range(polar_int.shape[0]):
-        coefs_all[a0,:] = curve_fit(
-                step_model, 
-                radius, 
-                polar_int[a0,:], 
-                p0 = coefs_all[a0,:],
-                xtol = 1e-12,
-                bounds = (lb,ub),
-            )[0]
-        polar_int_corr[a0,:] = step_model(
-            radius,
-            coefs_all[a0,:])
+    else:
+        polar_int_corr = polar_fit
 
     # Convert back to cartesian coordinates
     int_corr = im_polar_to_cart(
@@ -1431,7 +1444,10 @@ def regularize_probe_amp(
             cmap = 'turbo',
             )    
 
-    return probe_corr
+    if return_coefs:
+        return probe_corr, coefs_all
+    else:
+        return probe_corr
     
 
 def step_model(radius, *coefs):
@@ -1441,7 +1457,7 @@ def step_model(radius, *coefs):
     rad_0 = coefs[1]
     width = coefs[2]
 
-    return sig_0 * np.clip((rad_0 - radius) / width, 0, 1)
+    return sig_0 * np.clip((rad_0 - radius) / width, 0.0, 1.0)
 
 
 def im_cart_to_polar(

From a7ee689ed67d67bf153be45923aacbe0cf6e6206 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Sun, 9 Jul 2023 21:44:02 -0700
Subject: [PATCH 266/362] updated Colins code to work with corner-centered
 probes. will clean up and port to constraints tomorrow morning.

---
 py4DSTEM/process/phase/utils.py | 283 ++++++++++++++++----------------
 1 file changed, 140 insertions(+), 143 deletions(-)

diff --git a/py4DSTEM/process/phase/utils.py b/py4DSTEM/process/phase/utils.py
index 29b76165c..c92f0d38b 100644
--- a/py4DSTEM/process/phase/utils.py
+++ b/py4DSTEM/process/phase/utils.py
@@ -14,6 +14,7 @@
 
 from py4DSTEM.process.utils.cross_correlate import align_and_shift_images
 from py4DSTEM.process.utils.utils import electron_wavelength_angstrom
+from py4DSTEM.process.utils import get_CoM
 from scipy.ndimage import gaussian_filter
 
 # fmt: off
@@ -1277,24 +1278,20 @@ def nesterov_gamma(zero_indexed_iter_num):
     )
 
 
-
-
-
-
 def regularize_probe_amp(
     probe_init,
-    width_max_pixels = 2.0,
-    enforce_constant_intensity = True,
-    return_coefs = False,
-    plot_result = False,
-    plot_polar = False,
-    cmap = 'turbo',
-    figsize = (5,5),
-    ):
+    width_max_pixels=2.0,
+    enforce_constant_intensity=True,
+    return_coefs=False,
+    plot_result=False,
+    plot_polar=False,
+    cmap="turbo",
+    figsize=(5, 5),
+):
     """
-    Assume that the probe is centered in Fourier space.  Note we 
+    Assumes the probe is corner-centered in Fourier space.  Note we
     re-implemented the polar/cartesian transforms here for portability.
-    
+
     Parameters
     --------
     probe_init: np.array
@@ -1323,50 +1320,36 @@ def regularize_probe_amp(
     probe_corr: np.array
         2D complex image of the corrected probe in Fourier space.
     coefs_all: np.array (optional)
-        coefficients for the 
-
-
-
+        coefficients for the
     """
 
     # Get probe intensity
     probe_amp = np.abs(probe_init)
     probe_int = probe_amp**2
 
-    # coordinates
-    xa,ya = np.meshgrid(
-        np.arange(probe_init.shape[0]),
-        np.arange(probe_init.shape[1]),
-        indexing = 'ij',
-        )
-
     # Center of mass for probe intensity
-    int_total = np.sum(probe_int)
-    xy_center = (
-        np.sum(probe_int * xa) / int_total,
-        np.sum(probe_int * ya) / int_total,
-        )
+    xy_center = get_CoM(probe_int, device="cpu", corner_centered=True)
 
     # Convert intensity to polar coordinates
-    polar_int = im_cart_to_polar(
+    polar_int = cartesian_to_polar_transform_2Ddata(
         probe_int,
-        xy_center = xy_center,
-        )
+        xy_center=xy_center,
+    )
 
     # Fit corrected probe intensity
     radius = np.arange(polar_int.shape[1])
 
     # estimate initial parameters
-    sub = polar_int > (np.max(polar_int)*0.5)
+    sub = polar_int > (np.max(polar_int) * 0.5)
     sig_0 = np.mean(polar_int[sub])
-    rad_0 = np.max(np.argwhere(np.sum(sub,axis=0)))
+    rad_0 = np.max(np.argwhere(np.sum(sub, axis=0)))
     width = width_max_pixels * 0.5
 
     # init
-    coefs_all = np.zeros((polar_int.shape[0],3))
-    coefs_all[:,0] = sig_0
-    coefs_all[:,1] = rad_0
-    coefs_all[:,2] = width
+    coefs_all = np.zeros((polar_int.shape[0], 3))
+    coefs_all[:, 0] = sig_0
+    coefs_all[:, 1] = rad_0
+    coefs_all[:, 2] = width
 
     # bounds
     lb = (0.0, 0.0, 1e-4)
@@ -1375,80 +1358,79 @@ def regularize_probe_amp(
     # refine parameters, generate polar image
     polar_fit = np.zeros_like(polar_int)
     for a0 in range(polar_int.shape[0]):
-        coefs_all[a0,:] = curve_fit(
-                step_model, 
-                radius, 
-                polar_int[a0,:], 
-                p0 = coefs_all[a0,:],
-                xtol = 1e-12,
-                bounds = (lb,ub),
-            )[0]
-        polar_fit[a0,:] = step_model(
+        coefs_all[a0, :] = curve_fit(
+            step_model,
             radius,
-            coefs_all[a0,:])
+            polar_int[a0, :],
+            p0=coefs_all[a0, :],
+            xtol=1e-12,
+            bounds=(lb, ub),
+        )[0]
+        polar_fit[a0, :] = step_model(radius, coefs_all[a0, :])
 
     if enforce_constant_intensity:
         # Compute best-fit constant intensity inside probe, update bounds
-        sig_0 = np.median(coefs_all[:,0])
-        coefs_all[:,0] = sig_0
-        lb = (sig_0-1e-8, 0.0, 1e-4)
-        ub = (sig_0+1e-8, np.inf, width_max_pixels)
+        sig_0 = np.median(coefs_all[:, 0])
+        coefs_all[:, 0] = sig_0
+        lb = (sig_0 - 1e-8, 0.0, 1e-4)
+        ub = (sig_0 + 1e-8, np.inf, width_max_pixels)
 
         # refine parameters, generate polar image
         polar_int_corr = np.zeros_like(polar_int)
         for a0 in range(polar_int.shape[0]):
-            coefs_all[a0,:] = curve_fit(
-                    step_model, 
-                    radius, 
-                    polar_int[a0,:], 
-                    p0 = coefs_all[a0,:],
-                    xtol = 1e-12,
-                    bounds = (lb,ub),
-                )[0]
-            polar_int_corr[a0,:] = step_model(
+            coefs_all[a0, :] = curve_fit(
+                step_model,
                 radius,
-                coefs_all[a0,:])
+                polar_int[a0, :],
+                p0=coefs_all[a0, :],
+                xtol=1e-12,
+                bounds=(lb, ub),
+            )[0]
+            polar_int_corr[a0, :] = step_model(radius, coefs_all[a0, :])
 
     else:
         polar_int_corr = polar_fit
 
     # Convert back to cartesian coordinates
-    int_corr = im_polar_to_cart(
+    int_corr = polar_to_cartesian_transform_2Ddata(
         polar_int_corr,
-        xy_size = probe_init.shape, 
-        xy_center = xy_center,
-        )
+        xy_size=probe_init.shape,
+        xy_center=xy_center,
+    )
 
     # Assemble output probe
-    probe_corr = np.sqrt(np.maximum(int_corr,0)) \
-        * np.exp(1j*np.angle(probe_init))
+    probe_corr = np.sqrt(np.maximum(int_corr, 0)) * np.exp(1j * np.angle(probe_init))
 
     # plotting
     if plot_result:
-        fig,ax = plt.subplots(figsize = (figsize[0]*2, figsize[1]))
+        fig, ax = plt.subplots(figsize=(figsize[0] * 2, figsize[1]))
         ax.imshow(
-            np.hstack((
-                probe_int,
-                int_corr,
-            )),
-            cmap = 'turbo',
-            )
+            np.hstack(
+                (
+                    np.fft.fftshift(probe_int),
+                    np.fft.fftshift(int_corr),
+                )
+            ),
+            cmap="turbo",
+        )
     if plot_polar:
-        fig,ax = plt.subplots(figsize = figsize)
+        fig, ax = plt.subplots(figsize=figsize)
         ax.imshow(
-            np.hstack((
-                polar_int,
-                polar_fit,
-                polar_int_corr,
-            )),
-            cmap = 'turbo',
-            )    
+            np.hstack(
+                (
+                    polar_int,
+                    polar_fit,
+                    polar_int_corr,
+                )
+            ),
+            cmap="turbo",
+        )
 
     if return_coefs:
         return probe_corr, coefs_all
     else:
         return probe_corr
-    
+
 
 def step_model(radius, *coefs):
     coefs = np.squeeze(np.array(coefs))
@@ -1460,103 +1442,118 @@ def step_model(radius, *coefs):
     return sig_0 * np.clip((rad_0 - radius) / width, 0.0, 1.0)
 
 
-def im_cart_to_polar(
+def cartesian_to_polar_transform_2Ddata(
     im_cart,
     xy_center,
-    num_theta_bins = 180,
-    radius_max = None,
-    ):
+    num_theta_bins=180,
+    radius_max=None,
+):
     """
     Quick cartesian to polar conversion.
     """
 
     # coordinates
-    xa,ya = np.meshgrid(
-        np.arange(im_cart.shape[0]),
-        np.arange(im_cart.shape[1]),
-        indexing = 'ij',
-        )    
     if radius_max is None:
-        radius_max = np.ceil(np.sqrt(np.sum(
-            np.array(im_cart.shape).astype('float')**2
-            )) / 2.0).astype('int')
+        radius_max = np.min(np.array(im_cart.shape) // 2)
+
     r = np.arange(radius_max)
     t = np.linspace(
         0,
-        2.0*np.pi,
+        2.0 * np.pi,
         num_theta_bins,
-        endpoint = False,
-        )
-    ra,ta = np.meshgrid(r,t)
+        endpoint=False,
+    )
+    ra, ta = np.meshgrid(r, t)
 
     # resampling coordinates
-    x = (ra * np.cos(ta) + xy_center[0])
-    y = (ra * np.sin(ta) + xy_center[1])
-    xf = np.floor(x).astype('int')
-    yf = np.floor(y).astype('int')
+    x = ra * np.cos(ta) + xy_center[0]
+    y = ra * np.sin(ta) + xy_center[1]
+
+    xf = np.floor(x).astype("int")
+    yf = np.floor(y).astype("int")
     dx = x - xf
     dy = y - yf
 
     # resample image
-    im_polar = \
-        im_cart.ravel()[np.ravel_multi_index(
-            (xf,    yf),
-            im_cart.shape,
-            mode='clip',
-            )] * (1-dx) * (1-dy) + \
-        im_cart.ravel()[np.ravel_multi_index(
-            (xf+1,  yf),
-            im_cart.shape,
-            mode='clip',
-            )] * (  dx) * (1-dy) + \
-        im_cart.ravel()[np.ravel_multi_index(
-            (xf,    yf+1),
-            im_cart.shape,
-            mode='clip',
-            )] * (1-dx) * (  dy) + \
-        im_cart.ravel()[np.ravel_multi_index(
-            (xf+1,  yf+1),
-            im_cart.shape,
-            mode='clip',
-            )] * (  dx) * (  dy)
+    im_polar = (
+        im_cart.ravel()[
+            np.ravel_multi_index(
+                (xf, yf),
+                im_cart.shape,
+                mode="wrap",
+            )
+        ]
+        * (1 - dx)
+        * (1 - dy)
+        + im_cart.ravel()[
+            np.ravel_multi_index(
+                (xf + 1, yf),
+                im_cart.shape,
+                mode="wrap",
+            )
+        ]
+        * (dx)
+        * (1 - dy)
+        + im_cart.ravel()[
+            np.ravel_multi_index(
+                (xf, yf + 1),
+                im_cart.shape,
+                mode="wrap",
+            )
+        ]
+        * (1 - dx)
+        * (dy)
+        + im_cart.ravel()[
+            np.ravel_multi_index(
+                (xf + 1, yf + 1),
+                im_cart.shape,
+                mode="wrap",
+            )
+        ]
+        * (dx)
+        * (dy)
+    )
 
     return im_polar
 
 
-def im_polar_to_cart(
+def polar_to_cartesian_transform_2Ddata(
     im_polar,
     xy_size,
     xy_center,
-    ):
+):
     """
     Quick cartesian to polar conversion.
     """
 
     # coordinates
-    xa,ya = np.meshgrid(
-        np.arange(xy_size[0]) - xy_center[0],
-        np.arange(xy_size[1]) - xy_center[1],
-        indexing = 'ij',
-        )  
-    ra = np.sqrt(xa**2 + ya**2)
-    ta = np.arctan2(ya,xa)
-    t = np.linspace(0,2*np.pi,im_polar.shape[0],endpoint = False)
+    sx, sy = xy_size
+    cx, cy = xy_center
+
+    x = np.fft.fftfreq(sx, d=1 / sx)
+    y = np.fft.fftfreq(sy, d=1 / sy)
+    xa, ya = np.meshgrid(x, y, indexing="ij")
+    ra = np.hypot(xa - cx, ya - cy)
+    ta = np.arctan2(ya, xa)
+
+    t = np.linspace(0, 2 * np.pi, im_polar.shape[0], endpoint=False)
     t_step = t[1] - t[0]
 
     # resampling coordinates
     t_ind = ta / t_step
     r_ind = ra.copy()
-    tf = np.floor(t_ind).astype('int')
-    rf = np.floor(r_ind).astype('int')
+    tf = np.floor(t_ind).astype("int")
+    rf = np.floor(r_ind).astype("int")
     dt = t_ind - tf
     dr = r_ind - rf
 
     # resample image
-    im_cart = im_polar.ravel()[np.ravel_multi_index(
-            (np.mod(tf, im_polar.shape[0]),    rf),
+    im_cart = im_polar.ravel()[
+        np.ravel_multi_index(
+            (tf, rf),
             im_polar.shape,
-            mode='clip',
-            )]
+            mode=("wrap", "clip"),
+        )
+    ]
 
     return im_cart
-

From c4f4b26425adb3501c1ee37ed2c4a0a2ee8046e9 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Mon, 10 Jul 2023 20:23:35 -0700
Subject: [PATCH 267/362] adding probe aperture constraint, aberration fitting.
 Only changed single-slice, will do rest of the classes tomorrow.

---
 .../iterative_ptychographic_constraints.py    | 121 ++---
 .../iterative_singleslice_ptychography.py     | 105 +++--
 py4DSTEM/process/phase/utils.py               | 415 ++++++++++--------
 3 files changed, 304 insertions(+), 337 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
index 274e86f39..d3c5b34a9 100644
--- a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
+++ b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
@@ -3,6 +3,8 @@
     array_slice,
     estimate_global_transformation_ransac,
     fft_shift,
+    regularize_probe_amplitude,
+    fit_aberration_surface,
 )
 from py4DSTEM.process.utils import get_CoM
 
@@ -338,67 +340,6 @@ def _probe_center_of_mass_constraint(self, current_probe):
 
         return shifted_probe
 
-    def _probe_radial_symmetrization_constraint_base(
-        self,
-        current_probe,
-        num_bins=None,
-        center=None,
-    ):
-        xp = self._xp
-
-        sx, sy = current_probe.shape
-
-        if center is None:
-            center = (0, 0)
-
-        if num_bins is None:
-            num_bins = np.maximum(sx, sy) * 2 + 1
-
-        cx, cy = center
-        X = xp.fft.fftfreq(sx, d=1 / sx)[:, None]
-        Y = xp.fft.fftfreq(sy, d=1 / sy)[None]
-        r = xp.hypot(X - cx, Y - cy)
-
-        rbin = (num_bins * r / r.max()).astype("int")
-        num = xp.bincount(rbin.ravel(), current_probe.ravel())
-        denom = xp.bincount(rbin.ravel())
-        denom[denom == 0] = 1
-
-        radial_mean = num / denom
-
-        for r_bin, r_mean in enumerate(radial_mean):
-            if r_bin != 0.0:
-                current_probe[np.where(rbin == r_bin)] = r_mean
-
-        return current_probe
-
-    def _probe_radial_symmetrization_constraint(
-        self,
-        current_probe,
-        num_bins=None,
-        center=None,
-    ):
-        xp = self._xp
-
-        current_probe_sum = xp.sum(xp.abs(current_probe) ** 2)
-        fourier_probe = xp.fft.fft2(current_probe)
-
-        fourier_probe_real = fourier_probe.real.copy()
-        fourier_probe_imag = fourier_probe.imag.copy()
-
-        fourier_probe_real = self._probe_radial_symmetrization_constraint_base(
-            fourier_probe_real, num_bins, center
-        )
-        fourier_probe_imag = self._probe_radial_symmetrization_constraint_base(
-            fourier_probe_imag, num_bins, center
-        )
-
-        fourier_probe = fourier_probe_real + 1.0j * fourier_probe_imag
-        current_probe = xp.fft.ifft2(fourier_probe)
-        current_probe *= xp.sqrt(current_probe_sum / np.sum(np.abs(current_probe) ** 2))
-
-        return current_probe
-
     def _probe_amplitude_constraint(
         self, current_probe, relative_radius, relative_width
     ):
@@ -439,7 +380,10 @@ def _probe_amplitude_constraint(
         return updated_probe * normalization
 
     def _probe_fourier_amplitude_constraint(
-        self, current_probe, threshold, relative_width
+        self,
+        current_probe,
+        width_max_pixels,
+        enforce_constant_intensity,
     ):
         """
         Ptychographic top-hat filtering of Fourier probe.
@@ -460,27 +404,20 @@ def _probe_fourier_amplitude_constraint(
             Constrained probe estimate
         """
         xp = self._xp
-        erf = self._erf
+        asnumpy = self._asnumpy
 
         current_probe_sum = xp.sum(xp.abs(current_probe) ** 2)
         current_probe_fft = xp.fft.fft2(current_probe)
-        current_probe_fft_amp = xp.abs(current_probe_fft)
 
-        threshold_px = xp.argmax(
-            current_probe_fft_amp < xp.max(current_probe_fft_amp) * threshold
+        updated_probe_fft, _, _, _ = regularize_probe_amplitude(
+            asnumpy(current_probe_fft),
+            width_max_pixels=width_max_pixels,
+            enforce_constant_intensity=enforce_constant_intensity,
+            corner_centered=True,
         )
 
-        if threshold_px == 0:
-            return current_probe
-
-        qx = xp.fft.fftfreq(current_probe.shape[0], 1)
-        qy = xp.fft.fftfreq(current_probe.shape[1], 1)
-        qya, qxa = xp.meshgrid(qy, qx)
-        qra = xp.sqrt(qxa**2 + qya**2) - threshold_px / current_probe.shape[0]
-
-        sigma = np.sqrt(np.pi) / relative_width
-        tophat_mask = 0.5 * (1 - erf(sigma * qra / (1 - qra**2)))
-        updated_probe = xp.fft.ifft2(current_probe_fft * tophat_mask)
+        updated_probe_fft = xp.asarray(updated_probe_fft)
+        updated_probe = xp.fft.ifft2(updated_probe_fft)
         updated_probe_sum = xp.sum(xp.abs(updated_probe) ** 2)
         normalization = xp.sqrt(current_probe_sum / updated_probe_sum)
 
@@ -517,11 +454,11 @@ def _probe_aperture_constraint(
 
         return updated_probe * normalization
 
-    def _probe_residual_aberration_filtering_constraint(
+    def _probe_aberration_fitting_constraint(
         self,
         current_probe,
-        gaussian_filter_sigma,
-        fix_amplitude,
+        max_angular_order,
+        max_radial_order,
     ):
         """
         Ptychographic probe smoothing constraint.
@@ -543,24 +480,20 @@ def _probe_residual_aberration_filtering_constraint(
         """
 
         xp = self._xp
-        gaussian_filter = self._gaussian_filter
-        known_aberrations_array = self._known_aberrations_array
-        gaussian_filter_sigma /= self._reciprocal_sampling[0]
 
         fourier_probe = xp.fft.fft2(current_probe)
-        if fix_amplitude:
-            fourier_probe_abs = xp.abs(fourier_probe)
-
-        fourier_probe *= xp.conjugate(known_aberrations_array)
-        fourier_probe = gaussian_filter(
-            fourier_probe, gaussian_filter_sigma, mode="wrap"
+        fourier_probe_abs = xp.abs(fourier_probe)
+        sampling = self.sampling
+
+        fitted_angle = fit_aberration_surface(
+            fourier_probe,
+            sampling,
+            max_angular_order,
+            max_radial_order,
+            xp=xp,
         )
-        fourier_probe *= known_aberrations_array
-
-        if fix_amplitude:
-            fourier_probe_angle = xp.angle(fourier_probe)
-            fourier_probe = fourier_probe_abs * xp.exp(1.0j * fourier_probe_angle)
 
+        fourier_probe = fourier_probe_abs * xp.exp(1.0j * fitted_angle)
         current_probe = xp.fft.ifft2(fourier_probe)
 
         return current_probe
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index 791e3ffb5..bd7d57d68 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -1000,15 +1000,15 @@ def _constraints(
         current_positions,
         pure_phase_object,
         fix_com,
-        symmetrize_probe,
-        probe_gaussian_filter,
-        probe_gaussian_filter_sigma,
-        probe_gaussian_filter_fix_amplitude,
+        fit_probe_aberrations,
+        fit_probe_aberrations_max_angular_order,
+        fit_probe_aberrations_max_radial_order,
         constrain_probe_amplitude,
         constrain_probe_amplitude_relative_radius,
         constrain_probe_amplitude_relative_width,
         constrain_probe_fourier_amplitude,
-        constrain_probe_fourier_amplitude_threshold,
+        constrain_probe_fourier_amplitude_max_width_pixels,
+        constrain_probe_fourier_amplitude_constant_intensity,
         fix_probe_aperture,
         initial_probe_aperture,
         fix_positions,
@@ -1038,14 +1038,12 @@ def _constraints(
             If True, object amplitude is set to unity
         fix_com: bool
             If True, probe CoM is fixed to the center
-        symmetrize_probe: bool
-            If True, the probe is radially-averaged
-        probe_gaussian_filter: bool
-            If True, applies reciprocal-space gaussian filtering on residual aberrations
-        probe_gaussian_filter_sigma: float
-            Standard deviation of gaussian kernel in A^-1
-        probe_gaussian_filter_fix_amplitude: bool
-            If True, only the probe phase is smoothed
+        fit_probe_aberrations: bool
+            If True, fits the probe aberrations to a low-order expansion
+        fit_probe_aberrations_max_angular_order: bool
+            Max angular order of probe aberrations basis functions
+        fit_probe_aberrations_max_radial_order: bool
+            Max radial order of probe aberrations basis functions
         constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
         constrain_probe_amplitude_relative_radius: float
@@ -1053,10 +1051,11 @@ def _constraints(
         constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
         constrain_probe_fourier_amplitude: bool
-            If True, probe fourier amplitude is constrained by top hat function
-        constrain_probe_fourier_amplitude_threshold: float
-            Threshold value for current probe fourier mask. Value should
-            be between 0 and 1, where higher values provide the most masking.
+            If True, probe aperture is constrained by fitting a sigmoid for each angular frequency.
+        constrain_probe_fourier_amplitude_max_width_pixels: float
+            Maximum pixel width of fitted sigmoid functions.
+        constrain_probe_fourier_amplitude_constant_intensity: bool
+            If True, the probe aperture is additionally constrained to a constant intensity.
         fix_probe_aperture: bool,
             If True, probe Fourier amplitude is replaced by initial probe aperture.
         initial_probe_aperture: np.ndarray,
@@ -1122,31 +1121,29 @@ def _constraints(
         if fix_com:
             current_probe = self._probe_center_of_mass_constraint(current_probe)
 
-        if probe_gaussian_filter:
-            current_probe = self._probe_residual_aberration_filtering_constraint(
-                current_probe,
-                probe_gaussian_filter_sigma,
-                probe_gaussian_filter_fix_amplitude,
-            )
-
-        if symmetrize_probe:
-            current_probe = self._probe_radial_symmetrization_constraint(current_probe)
-
         if fix_probe_aperture:
             current_probe = self._probe_aperture_constraint(
                 current_probe,
                 initial_probe_aperture,
             )
-        elif constrain_probe_amplitude:
-            current_probe = self._probe_amplitude_constraint(
-                current_probe,
-                constrain_probe_amplitude_relative_radius,
-                constrain_probe_amplitude_relative_width,
-            )
         elif constrain_probe_fourier_amplitude:
             current_probe = self._probe_fourier_amplitude_constraint(
                 current_probe,
-                constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_max_width_pixels,
+                constrain_probe_fourier_amplitude_constant_intensity,
+            )
+
+        if fit_probe_aberrations:
+            current_probe = self._probe_aberration_fitting_constraint(
+                current_probe,
+                fit_probe_aberrations_max_angular_order,
+                fit_probe_aberrations_max_radial_order,
+            )
+
+        if constrain_probe_amplitude:
+            current_probe = self._probe_amplitude_constraint(
+                current_probe,
+                constrain_probe_amplitude_relative_radius,
                 constrain_probe_amplitude_relative_width,
             )
 
@@ -1179,20 +1176,20 @@ def reconstruct(
         fix_com: bool = True,
         fix_probe_iter: int = 0,
         fix_probe_aperture_iter: int = 0,
-        symmetrize_probe_iter: int = 0,
         constrain_probe_amplitude_iter: int = 0,
         constrain_probe_amplitude_relative_radius: float = 0.5,
         constrain_probe_amplitude_relative_width: float = 0.05,
         constrain_probe_fourier_amplitude_iter: int = 0,
-        constrain_probe_fourier_amplitude_threshold: float = 0.9,
+        constrain_probe_fourier_amplitude_max_width_pixels: float = 3.0,
+        constrain_probe_fourier_amplitude_constant_intensity: bool = False,
         fix_positions_iter: int = np.inf,
         constrain_position_distance: float = None,
         global_affine_transformation: bool = True,
         gaussian_filter_sigma: float = None,
         gaussian_filter_iter: int = np.inf,
-        probe_gaussian_filter_sigma: float = None,
-        probe_gaussian_filter_residual_aberrations_iter: int = np.inf,
-        probe_gaussian_filter_fix_amplitude: bool = True,
+        fit_probe_aberrations_iter: int = 0,
+        fit_probe_aberrations_max_angular_order: int = 4,
+        fit_probe_aberrations_max_radial_order: int = 4,
         butterworth_filter_iter: int = np.inf,
         q_lowpass: float = None,
         q_highpass: float = None,
@@ -1246,19 +1243,18 @@ def reconstruct(
             Number of iterations to run with a fixed probe before updating probe estimate
         fix_probe_aperture_iter: int, optional
             Number of iterations to run with a fixed probe Fourier amplitude before updating probe estimate
-        symmetrize_probe_iter: int, optional
-            Number of iterations to run before radially-averaging the probe
-        constrain_probe_amplitude: bool
-            If True, probe amplitude is constrained by top hat function
+        constrain_probe_amplitude_iter: int, optional
+            Number of iterations to run while constraining the real-space probe with a top-hat support.
         constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
         constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        constrain_probe_fourier_amplitude: bool
-            If True, probe fourier amplitude is constrained by top hat function
-        constrain_probe_fourier_amplitude_threshold: float
-            Threshold value for current probe fourier mask. Value should
-            be between 0 and 1, where higher values provide the most masking.
+        constrain_probe_fourier_amplitude_iter: int, optional
+            Number of iterations to run while constraining the Fourier-space probe by fitting a sigmoid for each angular frequency.
+        constrain_probe_fourier_amplitude_max_width_pixels: float
+            Maximum pixel width of fitted sigmoid functions.
+        constrain_probe_fourier_amplitude_constant_intensity: bool
+            If True, the probe aperture is additionally constrained to a constant intensity.
         fix_positions_iter: int, optional
             Number of iterations to run with fixed positions before updating positions estimate
         constrain_position_distance: float, optional
@@ -1593,12 +1589,6 @@ def reconstruct(
                 self._probe,
                 self._positions_px,
                 fix_com=fix_com and a0 >= fix_probe_iter,
-                symmetrize_probe=a0 < symmetrize_probe_iter,
-                probe_gaussian_filter=a0
-                < probe_gaussian_filter_residual_aberrations_iter
-                and probe_gaussian_filter_sigma is not None,
-                probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
-                probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
                 constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                 and a0 >= fix_probe_iter,
                 constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
@@ -1606,7 +1596,12 @@ def reconstruct(
                 constrain_probe_fourier_amplitude=a0
                 < constrain_probe_fourier_amplitude_iter
                 and a0 >= fix_probe_iter,
-                constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_max_width_pixels=constrain_probe_fourier_amplitude_max_width_pixels,
+                constrain_probe_fourier_amplitude_constant_intensity=constrain_probe_fourier_amplitude_constant_intensity,
+                fit_probe_aberrations=a0 < fit_probe_aberrations_iter
+                and a0 >= fix_probe_iter,
+                fit_probe_aberrations_max_angular_order=fit_probe_aberrations_max_angular_order,
+                fit_probe_aberrations_max_radial_order=fit_probe_aberrations_max_radial_order,
                 fix_probe_aperture=a0 < fix_probe_aperture_iter,
                 initial_probe_aperture=self._probe_initial_aperture,
                 fix_positions=a0 < fix_positions_iter,
diff --git a/py4DSTEM/process/phase/utils.py b/py4DSTEM/process/phase/utils.py
index c92f0d38b..7f5287b3b 100644
--- a/py4DSTEM/process/phase/utils.py
+++ b/py4DSTEM/process/phase/utils.py
@@ -16,6 +16,7 @@
 from py4DSTEM.process.utils.utils import electron_wavelength_angstrom
 from py4DSTEM.process.utils import get_CoM
 from scipy.ndimage import gaussian_filter
+from skimage.restoration import unwrap_phase
 
 # fmt: off
 
@@ -1278,19 +1279,143 @@ def nesterov_gamma(zero_indexed_iter_num):
     )
 
 
-def regularize_probe_amp(
+def cartesian_to_polar_transform_2Ddata(
+    im_cart,
+    xy_center,
+    num_theta_bins=180,
+    radius_max=None,
+    corner_centered=False,
+    xp=np,
+):
+    """
+    Quick cartesian to polar conversion.
+    """
+
+    # coordinates
+    if radius_max is None:
+        if corner_centered:
+            radius_max = np.min(np.array(im_cart.shape) // 2)
+        else:
+            radius_max = np.sqrt(np.sum(np.array(im_cart.shape) ** 2)) // 2
+
+    r = xp.arange(radius_max)
+    t = xp.linspace(
+        0,
+        2.0 * np.pi,
+        num_theta_bins,
+        endpoint=False,
+    )
+    ra, ta = xp.meshgrid(r, t)
+
+    # resampling coordinates
+    x = ra * xp.cos(ta) + xy_center[0]
+    y = ra * xp.sin(ta) + xy_center[1]
+
+    xf = xp.floor(x).astype("int")
+    yf = xp.floor(y).astype("int")
+    dx = x - xf
+    dy = y - yf
+
+    mode = "wrap" if corner_centered else "clip"
+
+    # resample image
+    im_polar = (
+        im_cart.ravel()[
+            xp.ravel_multi_index(
+                (xf, yf),
+                im_cart.shape,
+                mode=mode,
+            )
+        ]
+        * (1 - dx)
+        * (1 - dy)
+        + im_cart.ravel()[
+            xp.ravel_multi_index(
+                (xf + 1, yf),
+                im_cart.shape,
+                mode=mode,
+            )
+        ]
+        * (dx)
+        * (1 - dy)
+        + im_cart.ravel()[
+            xp.ravel_multi_index(
+                (xf, yf + 1),
+                im_cart.shape,
+                mode=mode,
+            )
+        ]
+        * (1 - dx)
+        * (dy)
+        + im_cart.ravel()[
+            xp.ravel_multi_index(
+                (xf + 1, yf + 1),
+                im_cart.shape,
+                mode=mode,
+            )
+        ]
+        * (dx)
+        * (dy)
+    )
+
+    return im_polar
+
+
+def polar_to_cartesian_transform_2Ddata(
+    im_polar,
+    xy_size,
+    xy_center,
+    corner_centered=False,
+    xp=np,
+):
+    """
+    Quick polar to cartesian conversion.
+    """
+
+    # coordinates
+    sx, sy = xy_size
+    cx, cy = xy_center
+
+    if corner_centered:
+        x = xp.fft.fftfreq(sx, d=1 / sx)
+        y = xp.fft.fftfreq(sy, d=1 / sy)
+    else:
+        x = xp.arange(sx)
+        y = xp.arange(sy)
+
+    xa, ya = xp.meshgrid(x, y, indexing="ij")
+    ra = xp.hypot(xa - cx, ya - cy)
+    ta = xp.arctan2(ya - cy, xa - cx)
+
+    t = xp.linspace(0, 2 * np.pi, im_polar.shape[0], endpoint=False)
+    t_step = t[1] - t[0]
+
+    # resampling coordinates
+    t_ind = ta / t_step
+    r_ind = ra.copy()
+    tf = xp.floor(t_ind).astype("int")
+    rf = xp.floor(r_ind).astype("int")
+
+    # resample image
+    im_cart = im_polar.ravel()[
+        xp.ravel_multi_index(
+            (tf, rf),
+            im_polar.shape,
+            mode=("wrap", "clip"),
+        )
+    ]
+
+    return im_cart
+
+
+def regularize_probe_amplitude(
     probe_init,
     width_max_pixels=2.0,
     enforce_constant_intensity=True,
-    return_coefs=False,
-    plot_result=False,
-    plot_polar=False,
-    cmap="turbo",
-    figsize=(5, 5),
+    corner_centered=False,
 ):
     """
-    Assumes the probe is corner-centered in Fourier space.  Note we
-    re-implemented the polar/cartesian transforms here for portability.
+    Fits sigmoid for each angular direction.
 
     Parameters
     --------
@@ -1300,40 +1425,31 @@ def regularize_probe_amp(
         Maximum edge width of the probe in pixels.
     enforce_constant_intensity: bool
         Set to true to make intensity inside the aperture constant.
-    return_coefs: bool
-        If true, fitting coefficients will also be returned.
-    plot_result: bool
-        Plot the input and output probes.
-    plot_polar: bool
-        Plot the polar transformed images:
-        1 - initial probe
-        2 - best fit of step model for each line
-        3 - best fit enforcing constant intensity inside aperture
-    cmap: string
-        colormap of the plots.
-    figsize: tuple
-        size of the output figures.
-        (will be doubled along horizontal axis for cartesian images)
+    corner_centered: bool
+        If True, the probe is assumed to be corner-centered
 
     Returns
     --------
-    probe_corr: np.array
+    probe_corr: np.ndarray
         2D complex image of the corrected probe in Fourier space.
-    coefs_all: np.array (optional)
-        coefficients for the
+    coefs_all: np.ndarray
+        coefficients for the sigmoid fits
     """
 
     # Get probe intensity
     probe_amp = np.abs(probe_init)
+    probe_angle = np.angle(probe_init)
     probe_int = probe_amp**2
 
     # Center of mass for probe intensity
-    xy_center = get_CoM(probe_int, device="cpu", corner_centered=True)
+    xy_center = get_CoM(probe_int, device="cpu", corner_centered=corner_centered)
 
     # Convert intensity to polar coordinates
     polar_int = cartesian_to_polar_transform_2Ddata(
         probe_int,
         xy_center=xy_center,
+        corner_centered=corner_centered,
+        xp=np,
     )
 
     # Fit corrected probe intensity
@@ -1346,6 +1462,9 @@ def regularize_probe_amp(
     width = width_max_pixels * 0.5
 
     # init
+    def step_model(radius, sig_0, rad_0, width):
+        return sig_0 * np.clip((rad_0 - radius) / width, 0.0, 1.0)
+
     coefs_all = np.zeros((polar_int.shape[0], 3))
     coefs_all[:, 0] = sig_0
     coefs_all[:, 1] = rad_0
@@ -1366,194 +1485,114 @@ def regularize_probe_amp(
             xtol=1e-12,
             bounds=(lb, ub),
         )[0]
-        polar_fit[a0, :] = step_model(radius, coefs_all[a0, :])
-
-    if enforce_constant_intensity:
-        # Compute best-fit constant intensity inside probe, update bounds
-        sig_0 = np.median(coefs_all[:, 0])
-        coefs_all[:, 0] = sig_0
-        lb = (sig_0 - 1e-8, 0.0, 1e-4)
-        ub = (sig_0 + 1e-8, np.inf, width_max_pixels)
-
-        # refine parameters, generate polar image
-        polar_int_corr = np.zeros_like(polar_int)
-        for a0 in range(polar_int.shape[0]):
-            coefs_all[a0, :] = curve_fit(
-                step_model,
-                radius,
-                polar_int[a0, :],
-                p0=coefs_all[a0, :],
-                xtol=1e-12,
-                bounds=(lb, ub),
-            )[0]
-            polar_int_corr[a0, :] = step_model(radius, coefs_all[a0, :])
+        polar_fit[a0, :] = step_model(radius, *coefs_all[a0, :])
 
-    else:
-        polar_int_corr = polar_fit
+    # Compute best-fit constant intensity inside probe, update bounds
+    sig_0 = np.median(coefs_all[:, 0])
+    coefs_all[:, 0] = sig_0
+    lb = (sig_0 - 1e-8, 0.0, 1e-4)
+    ub = (sig_0 + 1e-8, np.inf, width_max_pixels)
+
+    # refine parameters, generate polar image
+    polar_int_corr = np.zeros_like(polar_int)
+    for a0 in range(polar_int.shape[0]):
+        coefs_all[a0, :] = curve_fit(
+            step_model,
+            radius,
+            polar_int[a0, :],
+            p0=coefs_all[a0, :],
+            xtol=1e-12,
+            bounds=(lb, ub),
+        )[0]
+        polar_int_corr[a0, :] = step_model(radius, *coefs_all[a0, :])
 
     # Convert back to cartesian coordinates
     int_corr = polar_to_cartesian_transform_2Ddata(
         polar_int_corr,
         xy_size=probe_init.shape,
         xy_center=xy_center,
+        corner_centered=corner_centered,
     )
 
-    # Assemble output probe
-    probe_corr = np.sqrt(np.maximum(int_corr, 0)) * np.exp(1j * np.angle(probe_init))
-
-    # plotting
-    if plot_result:
-        fig, ax = plt.subplots(figsize=(figsize[0] * 2, figsize[1]))
-        ax.imshow(
-            np.hstack(
-                (
-                    np.fft.fftshift(probe_int),
-                    np.fft.fftshift(int_corr),
-                )
-            ),
-            cmap="turbo",
-        )
-    if plot_polar:
-        fig, ax = plt.subplots(figsize=figsize)
-        ax.imshow(
-            np.hstack(
-                (
-                    polar_int,
-                    polar_fit,
-                    polar_int_corr,
-                )
-            ),
-            cmap="turbo",
-        )
-
-    if return_coefs:
-        return probe_corr, coefs_all
-    else:
-        return probe_corr
-
+    amp_corr = np.sqrt(np.maximum(int_corr, 0))
 
-def step_model(radius, *coefs):
-    coefs = np.squeeze(np.array(coefs))
+    # Assemble output probe
+    if not enforce_constant_intensity:
+        max_coeff = np.sqrt(coefs_all[:, 0]).max()
+        amp_corr = amp_corr / max_coeff * probe_amp
 
-    sig_0 = coefs[0]
-    rad_0 = coefs[1]
-    width = coefs[2]
+    probe_corr = amp_corr * np.exp(1j * probe_angle)
 
-    return sig_0 * np.clip((rad_0 - radius) / width, 0.0, 1.0)
+    return probe_corr, polar_int, polar_int_corr, coefs_all
 
 
-def cartesian_to_polar_transform_2Ddata(
-    im_cart,
-    xy_center,
-    num_theta_bins=180,
-    radius_max=None,
+def aberrations_basis_function(
+    probe_size,
+    probe_sampling,
+    max_angular_order,
+    max_radial_order,
+    xp=np,
 ):
-    """
-    Quick cartesian to polar conversion.
-    """
+    """ """
+    sx, sy = probe_size
+    dx, dy = probe_sampling
+    qx = xp.fft.fftfreq(sx, dx)
+    qy = xp.fft.fftfreq(sy, dy)
 
-    # coordinates
-    if radius_max is None:
-        radius_max = np.min(np.array(im_cart.shape) // 2)
+    qxa, qya = xp.meshgrid(qx, qy, indexing="ij")
+    q2 = qxa**2 + qya**2
+    theta = xp.arctan2(qya, qxa)
 
-    r = np.arange(radius_max)
-    t = np.linspace(
-        0,
-        2.0 * np.pi,
-        num_theta_bins,
-        endpoint=False,
-    )
-    ra, ta = np.meshgrid(r, t)
+    basis = []
+    index = []
 
-    # resampling coordinates
-    x = ra * np.cos(ta) + xy_center[0]
-    y = ra * np.sin(ta) + xy_center[1]
+    for n in range(max_angular_order + 1):
+        for m in range((max_radial_order - n) // 2 + 1):
+            basis.append((q2 ** (m + n / 2) * np.cos(n * theta)))
+            index.append((m, n, 0))
+            if n > 0:
+                basis.append((q2 ** (m + n / 2) * np.sin(n * theta)))
+                index.append((m, n, 1))
 
-    xf = np.floor(x).astype("int")
-    yf = np.floor(y).astype("int")
-    dx = x - xf
-    dy = y - yf
+    basis = xp.array(basis)
 
-    # resample image
-    im_polar = (
-        im_cart.ravel()[
-            np.ravel_multi_index(
-                (xf, yf),
-                im_cart.shape,
-                mode="wrap",
-            )
-        ]
-        * (1 - dx)
-        * (1 - dy)
-        + im_cart.ravel()[
-            np.ravel_multi_index(
-                (xf + 1, yf),
-                im_cart.shape,
-                mode="wrap",
-            )
-        ]
-        * (dx)
-        * (1 - dy)
-        + im_cart.ravel()[
-            np.ravel_multi_index(
-                (xf, yf + 1),
-                im_cart.shape,
-                mode="wrap",
-            )
-        ]
-        * (1 - dx)
-        * (dy)
-        + im_cart.ravel()[
-            np.ravel_multi_index(
-                (xf + 1, yf + 1),
-                im_cart.shape,
-                mode="wrap",
-            )
-        ]
-        * (dx)
-        * (dy)
-    )
-
-    return im_polar
+    return basis, index
 
 
-def polar_to_cartesian_transform_2Ddata(
-    im_polar,
-    xy_size,
-    xy_center,
+def fit_aberration_surface(
+    complex_probe,
+    probe_sampling,
+    max_angular_order,
+    max_radial_order,
+    seed=1,
+    xp=np,
 ):
-    """
-    Quick cartesian to polar conversion.
-    """
+    """ """
+    probe_amp = xp.abs(complex_probe)
+    probe_angle = xp.angle(complex_probe)
 
-    # coordinates
-    sx, sy = xy_size
-    cx, cy = xy_center
+    if xp is np:
+        unwrapped_angle = unwrap_phase(probe_angle, wrap_around=True, seed=seed)
+    else:
+        unwrapped_angle = xp.asarray(
+            unwrap_phase(xp.asnumpy(probe_angle), wrap_around=True, seed=seed)
+        )
 
-    x = np.fft.fftfreq(sx, d=1 / sx)
-    y = np.fft.fftfreq(sy, d=1 / sy)
-    xa, ya = np.meshgrid(x, y, indexing="ij")
-    ra = np.hypot(xa - cx, ya - cy)
-    ta = np.arctan2(ya, xa)
+    basis, _ = aberrations_basis_function(
+        complex_probe.shape,
+        probe_sampling,
+        max_angular_order,
+        max_radial_order,
+        xp=xp,
+    )
 
-    t = np.linspace(0, 2 * np.pi, im_polar.shape[0], endpoint=False)
-    t_step = t[1] - t[0]
+    raveled_basis = basis.reshape((basis.shape[0], -1))
+    raveled_weights = probe_amp.ravel()
 
-    # resampling coordinates
-    t_ind = ta / t_step
-    r_ind = ra.copy()
-    tf = np.floor(t_ind).astype("int")
-    rf = np.floor(r_ind).astype("int")
-    dt = t_ind - tf
-    dr = r_ind - rf
+    Aw = raveled_basis.T * raveled_weights[:, None]
+    bw = unwrapped_angle.ravel() * raveled_weights
+    coeff = xp.linalg.lstsq(Aw, bw, rcond=None)[0]
 
-    # resample image
-    im_cart = im_polar.ravel()[
-        np.ravel_multi_index(
-            (tf, rf),
-            im_polar.shape,
-            mode=("wrap", "clip"),
-        )
-    ]
+    fitted_angle = xp.tensordot(coeff, basis, axes=1)
 
-    return im_cart
+    return fitted_angle

From 70ed4660782a923b1388fa68fa4b40be2ef157c2 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Tue, 11 Jul 2023 09:51:28 -0700
Subject: [PATCH 268/362] a bit of gpu cleaning

---
 .../process/phase/iterative_base_class.py     |  3 ---
 py4DSTEM/process/phase/iterative_dpc.py       | 11 +++++++-
 .../iterative_mixedstate_ptychography.py      | 10 +++++++
 .../iterative_multislice_ptychography.py      | 10 +++++++
 .../iterative_overlap_magnetic_tomography.py  | 10 +++++++
 .../phase/iterative_overlap_tomography.py     | 10 +++++++
 py4DSTEM/process/phase/iterative_parallax.py  | 27 ++++++++++++++++++-
 .../iterative_simultaneous_ptychography.py    | 10 +++++++
 .../iterative_singleslice_ptychography.py     | 10 +++++++
 9 files changed, 96 insertions(+), 5 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_base_class.py b/py4DSTEM/process/phase/iterative_base_class.py
index 76583815e..ae4c92d4b 100644
--- a/py4DSTEM/process/phase/iterative_base_class.py
+++ b/py4DSTEM/process/phase/iterative_base_class.py
@@ -161,8 +161,6 @@ def _preprocess_datacube_and_vacuum_probe(
                     "Datacube calibration can only handle uniform Q-sampling."
                 )
 
-            Q_pixel_size = datacube.calibration.get_Q_pixel_size()
-
             if com_shifts is not None:
                 com_shifts = (
                     com_shifts[0] * resampling_factor_x,
@@ -280,7 +278,6 @@ def _extract_intensities_and_calibrations_from_datacube(
         """
 
         # Copies intensities to device casting to float32
-        xp = self._xp
         intensities = datacube.data
         self._grid_scan_shape = intensities.shape[:2]
 
diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index 4e890db79..e364069e8 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -368,6 +368,11 @@ def preprocess(
 
         self._preprocessed = True
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _forward(
@@ -512,7 +517,6 @@ def _object_gaussian_constraint(self, current_object, gaussian_filter_sigma):
         constrained_object: np.ndarray
             Constrained object estimate
         """
-        xp = self._xp
         gaussian_filter = self._gaussian_filter
 
         gaussian_filter_sigma /= self.sampling[0]
@@ -815,6 +819,11 @@ def reconstruct(
         ]
         self.object_phase = asnumpy(self._object_phase)
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _visualize_last_iteration(
diff --git a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
index d4e2e5346..c80ec1062 100644
--- a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
@@ -574,6 +574,11 @@ def preprocess(
 
         self._preprocessed = True
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _overlap_projection(self, current_object, current_probe):
@@ -1727,6 +1732,11 @@ def reconstruct(
         self.probe = self.probe_centered
         self.error = error.item()
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _visualize_last_iteration_figax(
diff --git a/py4DSTEM/process/phase/iterative_multislice_ptychography.py b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
index d477da8ce..66c943ec6 100644
--- a/py4DSTEM/process/phase/iterative_multislice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
@@ -673,6 +673,11 @@ def preprocess(
 
         self._preprocessed = True
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _overlap_projection(self, current_object, current_probe):
@@ -2149,6 +2154,11 @@ def reconstruct(
         self.probe = self.probe_centered
         self.error = error.item()
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _visualize_last_iteration_figax(
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 939f42dec..75a8423a0 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -905,6 +905,11 @@ def preprocess(
 
         self._preprocessed = True
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _overlap_projection(
@@ -2540,6 +2545,11 @@ def reconstruct(
         self.probe = self.probe_centered
         self.error = error.item()
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _crop_rotate_object_manually(
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index 6b0a16e2e..c8f4487b5 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -817,6 +817,11 @@ def preprocess(
 
         self._preprocessed = True
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _overlap_projection(self, current_object, current_probe):
@@ -2261,6 +2266,11 @@ def reconstruct(
         self.probe = self.probe_centered
         self.error = error.item()
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _crop_rotate_object_manually(
diff --git a/py4DSTEM/process/phase/iterative_parallax.py b/py4DSTEM/process/phase/iterative_parallax.py
index 576342631..d55d5c353 100644
--- a/py4DSTEM/process/phase/iterative_parallax.py
+++ b/py4DSTEM/process/phase/iterative_parallax.py
@@ -172,7 +172,6 @@ def preprocess(
             require_calibrations=True,
         )
         self._intensities = xp.asarray(self._intensities, dtype=xp.float32)
-
         # make sure mean diffraction pattern is shaped correctly
         if (self._dp_mean.shape[0] != self._intensities.shape[2]) or (
             self._dp_mean.shape[1] != self._intensities.shape[3]
@@ -377,6 +376,12 @@ def preprocess(
             ax.set_title("Average Bright Field Image")
 
         self._preprocessed = True
+
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def tune_angle_and_defocus(
@@ -827,6 +832,11 @@ def reconstruct(
 
         self.recon_BF = asnumpy(self._recon_BF)
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def aberration_fit(
@@ -876,6 +886,11 @@ def aberration_fit(
         ) / 2.0  # factor /2 for A1 astigmatism? /4?
         self.aberration_A1y = (m_aberration[1, 0] + m_aberration[0, 1]) / 2.0
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         # Print results
         if self._verbose:
             print(
@@ -1061,6 +1076,11 @@ def aberration_correct(
         self._recon_phase_corrected = xp.real(xp.fft.ifft2(im_fft_corr))
         self.recon_phase_corrected = asnumpy(self._recon_phase_corrected)
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         # plotting
         if plot_corrected_phase:
             figsize = kwargs.pop("figsize", (6, 6))
@@ -1219,6 +1239,11 @@ def depth_section(
                 ax.set_yticks([])
                 ax.set_title(f"Depth section: {dz}A")
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return stack_depth
 
     def _crop_padded_object(
diff --git a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
index 545900634..8904012b2 100644
--- a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
@@ -814,6 +814,11 @@ def preprocess(
 
         self._preprocessed = True
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _warmup_overlap_projection(self, current_object, current_probe):
@@ -2926,6 +2931,11 @@ def reconstruct(
         self.probe = self.probe_centered
         self.error = error.item()
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _visualize_last_iteration_figax(
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index bd7d57d68..86878e78e 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -542,6 +542,11 @@ def preprocess(
 
         self._preprocessed = True
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _overlap_projection(self, current_object, current_probe):
@@ -1633,6 +1638,11 @@ def reconstruct(
         self.probe = self.probe_centered
         self.error = error.item()
 
+        if self._device == "gpu":
+            xp = self._xp
+            xp._default_memory_pool.free_all_blocks()
+            xp.clear_memo()
+
         return self
 
     def _visualize_last_iteration_figax(

From 689c5b125bca9cba91eee1e1ba6b0a73dbd9d34c Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Tue, 11 Jul 2023 11:09:24 -0700
Subject: [PATCH 269/362] removing unnecessary self._xp

---
 py4DSTEM/process/phase/iterative_dpc.py                       | 2 --
 py4DSTEM/process/phase/iterative_mixedstate_ptychography.py   | 2 --
 py4DSTEM/process/phase/iterative_multislice_ptychography.py   | 2 --
 .../process/phase/iterative_overlap_magnetic_tomography.py    | 2 --
 py4DSTEM/process/phase/iterative_overlap_tomography.py        | 2 --
 py4DSTEM/process/phase/iterative_parallax.py                  | 4 ----
 py4DSTEM/process/phase/iterative_simultaneous_ptychography.py | 2 --
 py4DSTEM/process/phase/iterative_singleslice_ptychography.py  | 2 --
 8 files changed, 18 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index e364069e8..b3d449fca 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -369,7 +369,6 @@ def preprocess(
         self._preprocessed = True
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
@@ -820,7 +819,6 @@ def reconstruct(
         self.object_phase = asnumpy(self._object_phase)
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
diff --git a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
index c80ec1062..69b2d8c45 100644
--- a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
@@ -575,7 +575,6 @@ def preprocess(
         self._preprocessed = True
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
@@ -1733,7 +1732,6 @@ def reconstruct(
         self.error = error.item()
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
diff --git a/py4DSTEM/process/phase/iterative_multislice_ptychography.py b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
index 66c943ec6..4706decf9 100644
--- a/py4DSTEM/process/phase/iterative_multislice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
@@ -674,7 +674,6 @@ def preprocess(
         self._preprocessed = True
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
@@ -2155,7 +2154,6 @@ def reconstruct(
         self.error = error.item()
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 75a8423a0..4dd7c3dbb 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -906,7 +906,6 @@ def preprocess(
         self._preprocessed = True
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
@@ -2546,7 +2545,6 @@ def reconstruct(
         self.error = error.item()
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index c8f4487b5..b5a3f71fa 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -818,7 +818,6 @@ def preprocess(
         self._preprocessed = True
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
@@ -2267,7 +2266,6 @@ def reconstruct(
         self.error = error.item()
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
diff --git a/py4DSTEM/process/phase/iterative_parallax.py b/py4DSTEM/process/phase/iterative_parallax.py
index d55d5c353..80cdd8cd8 100644
--- a/py4DSTEM/process/phase/iterative_parallax.py
+++ b/py4DSTEM/process/phase/iterative_parallax.py
@@ -378,7 +378,6 @@ def preprocess(
         self._preprocessed = True
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
@@ -833,7 +832,6 @@ def reconstruct(
         self.recon_BF = asnumpy(self._recon_BF)
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
@@ -887,7 +885,6 @@ def aberration_fit(
         self.aberration_A1y = (m_aberration[1, 0] + m_aberration[0, 1]) / 2.0
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
@@ -1077,7 +1074,6 @@ def aberration_correct(
         self.recon_phase_corrected = asnumpy(self._recon_phase_corrected)
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
diff --git a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
index 8904012b2..cf243192e 100644
--- a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
@@ -815,7 +815,6 @@ def preprocess(
         self._preprocessed = True
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
@@ -2932,7 +2931,6 @@ def reconstruct(
         self.error = error.item()
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index 86878e78e..5691828f2 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -543,7 +543,6 @@ def preprocess(
         self._preprocessed = True
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 
@@ -1639,7 +1638,6 @@ def reconstruct(
         self.error = error.item()
 
         if self._device == "gpu":
-            xp = self._xp
             xp._default_memory_pool.free_all_blocks()
             xp.clear_memo()
 

From 793f36a4a95bee1df24f29f24b839cda04f5e29f Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Tue, 11 Jul 2023 15:55:20 -0700
Subject: [PATCH 270/362] bugfixes for probe constraints

---
 .../iterative_ptychographic_constraints.py    |  3 +-
 py4DSTEM/process/phase/utils.py               | 31 ++++++++++++++-----
 2 files changed, 25 insertions(+), 9 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
index d3c5b34a9..5fe1a1a35 100644
--- a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
+++ b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
@@ -412,6 +412,7 @@ def _probe_fourier_amplitude_constraint(
         updated_probe_fft, _, _, _ = regularize_probe_amplitude(
             asnumpy(current_probe_fft),
             width_max_pixels=width_max_pixels,
+            nearest_angular_neighbor_averaging=5,
             enforce_constant_intensity=enforce_constant_intensity,
             corner_centered=True,
         )
@@ -485,7 +486,7 @@ def _probe_aberration_fitting_constraint(
         fourier_probe_abs = xp.abs(fourier_probe)
         sampling = self.sampling
 
-        fitted_angle = fit_aberration_surface(
+        fitted_angle, _ = fit_aberration_surface(
             fourier_probe,
             sampling,
             max_angular_order,
diff --git a/py4DSTEM/process/phase/utils.py b/py4DSTEM/process/phase/utils.py
index 7f5287b3b..2d36284ee 100644
--- a/py4DSTEM/process/phase/utils.py
+++ b/py4DSTEM/process/phase/utils.py
@@ -12,10 +12,11 @@
     cp = None
     from scipy.fft import dstn, idstn
 
+
 from py4DSTEM.process.utils.cross_correlate import align_and_shift_images
 from py4DSTEM.process.utils.utils import electron_wavelength_angstrom
 from py4DSTEM.process.utils import get_CoM
-from scipy.ndimage import gaussian_filter
+from scipy.ndimage import gaussian_filter, uniform_filter1d
 from skimage.restoration import unwrap_phase
 
 # fmt: off
@@ -1282,7 +1283,7 @@ def nesterov_gamma(zero_indexed_iter_num):
 def cartesian_to_polar_transform_2Ddata(
     im_cart,
     xy_center,
-    num_theta_bins=180,
+    num_theta_bins=90,
     radius_max=None,
     corner_centered=False,
     xp=np,
@@ -1411,6 +1412,7 @@ def polar_to_cartesian_transform_2Ddata(
 def regularize_probe_amplitude(
     probe_init,
     width_max_pixels=2.0,
+    nearest_angular_neighbor_averaging=5,
     enforce_constant_intensity=True,
     corner_centered=False,
 ):
@@ -1423,6 +1425,8 @@ def regularize_probe_amplitude(
         2D complex image of the probe in Fourier space.
     width_max_pixels: float
         Maximum edge width of the probe in pixels.
+    nearest_angular_neighbor_averaging: int
+        Number of nearest angular neighbor pixels to average to make aperture less jagged.
     enforce_constant_intensity: bool
         Set to true to make intensity inside the aperture constant.
     corner_centered: bool
@@ -1504,6 +1508,17 @@ def step_model(radius, sig_0, rad_0, width):
             xtol=1e-12,
             bounds=(lb, ub),
         )[0]
+        # polar_int_corr[a0, :] = step_model(radius, *coefs_all[a0, :])
+
+    # make aperture less jagged, using moving mean
+    coefs_all = np.apply_along_axis(
+        uniform_filter1d,
+        0,
+        coefs_all,
+        size=nearest_angular_neighbor_averaging,
+        mode="wrap",
+    )
+    for a0 in range(polar_int.shape[0]):
         polar_int_corr[a0, :] = step_model(radius, *coefs_all[a0, :])
 
     # Convert back to cartesian coordinates
@@ -1564,7 +1579,6 @@ def fit_aberration_surface(
     probe_sampling,
     max_angular_order,
     max_radial_order,
-    seed=1,
     xp=np,
 ):
     """ """
@@ -1572,11 +1586,12 @@ def fit_aberration_surface(
     probe_angle = xp.angle(complex_probe)
 
     if xp is np:
-        unwrapped_angle = unwrap_phase(probe_angle, wrap_around=True, seed=seed)
+        probe_angle = probe_angle.astype(np.float64)
+        unwrapped_angle = unwrap_phase(probe_angle, wrap_around=True).astype(xp.float32)
     else:
-        unwrapped_angle = xp.asarray(
-            unwrap_phase(xp.asnumpy(probe_angle), wrap_around=True, seed=seed)
-        )
+        probe_angle = xp.asnumpy(probe_angle).astype(np.float64)
+        unwrapped_angle = unwrap_phase(probe_angle, wrap_around=True)
+        unwrapped_angle = xp.asarray(unwrapped_angle).astype(xp.float32)
 
     basis, _ = aberrations_basis_function(
         complex_probe.shape,
@@ -1595,4 +1610,4 @@ def fit_aberration_surface(
 
     fitted_angle = xp.tensordot(coeff, basis, axes=1)
 
-    return fitted_angle
+    return fitted_angle, coeff

From 2864b2457070b5c9f7764c9989b5e2a33a0c7fe1 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Tue, 11 Jul 2023 16:27:57 -0700
Subject: [PATCH 271/362] probe constraints for mixed-state

---
 .../iterative_mixedstate_ptychography.py      | 95 +++++++++----------
 .../iterative_singleslice_ptychography.py     | 12 +--
 2 files changed, 51 insertions(+), 56 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
index 69b2d8c45..56fec1004 100644
--- a/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_mixedstate_ptychography.py
@@ -1106,15 +1106,15 @@ def _constraints(
         current_positions,
         pure_phase_object,
         fix_com,
-        symmetrize_probe,
-        probe_gaussian_filter,
-        probe_gaussian_filter_sigma,
-        probe_gaussian_filter_fix_amplitude,
+        fit_probe_aberrations,
+        fit_probe_aberrations_max_angular_order,
+        fit_probe_aberrations_max_radial_order,
         constrain_probe_amplitude,
         constrain_probe_amplitude_relative_radius,
         constrain_probe_amplitude_relative_width,
         constrain_probe_fourier_amplitude,
-        constrain_probe_fourier_amplitude_threshold,
+        constrain_probe_fourier_amplitude_max_width_pixels,
+        constrain_probe_fourier_amplitude_constant_intensity,
         fix_probe_aperture,
         initial_probe_aperture,
         fix_positions,
@@ -1145,14 +1145,12 @@ def _constraints(
             If True, object amplitude is set to unity
         fix_com: bool
             If True, probe CoM is fixed to the center
-        probe_gaussian_filter: bool
-            If True, applies reciprocal-space gaussian filtering on residual aberrations
-        probe_gaussian_filter_sigma: float
-            Standard deviation of gaussian kernel in A^-1
-        probe_gaussian_filter_fix_amplitude: bool
-            If True, only the probe phase is smoothed
-        symmetrize_probe: bool
-            If True, the probe is radially-averaged
+        fit_probe_aberrations: bool
+            If True, fits the probe aberrations to a low-order expansion
+        fit_probe_aberrations_max_angular_order: bool
+            Max angular order of probe aberrations basis functions
+        fit_probe_aberrations_max_radial_order: bool
+            Max radial order of probe aberrations basis functions
         constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
         constrain_probe_amplitude_relative_radius: float
@@ -1160,10 +1158,11 @@ def _constraints(
         constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
         constrain_probe_fourier_amplitude: bool
-            If True, probe fourier amplitude is constrained by top hat function
-        constrain_probe_fourier_amplitude_threshold: float
-            Threshold value for current probe fourier mask. Value should
-            be between 0 and 1, where higher values provide the most masking.
+            If True, probe aperture is constrained by fitting a sigmoid for each angular frequency.
+        constrain_probe_fourier_amplitude_max_width_pixels: float
+            Maximum pixel width of fitted sigmoid functions.
+        constrain_probe_fourier_amplitude_constant_intensity: bool
+            If True, the probe aperture is additionally constrained to a constant intensity.
         fix_probe_aperture: bool,
             If True, probe fourier amplitude is replaced by initial probe aperture.
         initial_probe_aperture: np.ndarray
@@ -1232,16 +1231,14 @@ def _constraints(
             current_probe = self._probe_center_of_mass_constraint(current_probe)
 
         # These constraints don't _really_ make sense for mixed-state
-        if probe_gaussian_filter:
-            raise NotImplementedError()
-        if symmetrize_probe:
-            raise NotImplementedError()
         if fix_probe_aperture:
             raise NotImplementedError()
-        elif constrain_probe_amplitude:
-            raise NotImplementedError()
         elif constrain_probe_fourier_amplitude:
             raise NotImplementedError()
+        if fit_probe_aberrations:
+            raise NotImplementedError()
+        if constrain_probe_amplitude:
+            raise NotImplementedError()
 
         if orthogonalize_probe:
             current_probe = self._probe_orthogonalization_constraint(current_probe)
@@ -1276,19 +1273,19 @@ def reconstruct(
         orthogonalize_probe: bool = True,
         fix_probe_iter: int = 0,
         fix_probe_aperture_iter: int = 0,
-        symmetrize_probe_iter: int = 0,
         constrain_probe_amplitude_iter: int = 0,
         constrain_probe_amplitude_relative_radius: float = 0.5,
         constrain_probe_amplitude_relative_width: float = 0.05,
         constrain_probe_fourier_amplitude_iter: int = 0,
-        constrain_probe_fourier_amplitude_threshold: float = 0.9,
+        constrain_probe_fourier_amplitude_max_width_pixels: float = 3.0,
+        constrain_probe_fourier_amplitude_constant_intensity: bool = False,
         fix_positions_iter: int = np.inf,
         global_affine_transformation: bool = True,
         gaussian_filter_sigma: float = None,
         gaussian_filter_iter: int = np.inf,
-        probe_gaussian_filter_sigma: float = None,
-        probe_gaussian_filter_residual_aberrations_iter: int = np.inf,
-        probe_gaussian_filter_fix_amplitude: bool = True,
+        fit_probe_aberrations_iter: int = 0,
+        fit_probe_aberrations_max_angular_order: int = 4,
+        fit_probe_aberrations_max_radial_order: int = 4,
         butterworth_filter_iter: int = np.inf,
         q_lowpass: float = None,
         q_highpass: float = None,
@@ -1342,19 +1339,18 @@ def reconstruct(
             Number of iterations to run with a fixed probe before updating probe estimate
         fix_probe_aperture_iter: int, optional
             Number of iterations to run with a fixed probe fourier amplitude before updating probe estimate
-        symmetrize_probe_iter: int, optional
-            Number of iterations to run before radially-averaging the probe
-        constrain_probe_amplitude: bool
-            If True, probe amplitude is constrained by top hat function
+        constrain_probe_amplitude_iter: int, optional
+            Number of iterations to run while constraining the real-space probe with a top-hat support.
         constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
         constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        constrain_probe_fourier_amplitude: bool
-            If True, probe fourier amplitude is constrained by top hat function
-        constrain_probe_fourier_amplitude_threshold: float
-            Threshold value for current probe fourier mask. Value should
-            be between 0 and 1, where higher values provide the most masking.
+        constrain_probe_fourier_amplitude_iter: int, optional
+            Number of iterations to run while constraining the Fourier-space probe by fitting a sigmoid for each angular frequency.
+        constrain_probe_fourier_amplitude_max_width_pixels: float
+            Maximum pixel width of fitted sigmoid functions.
+        constrain_probe_fourier_amplitude_constant_intensity: bool
+            If True, the probe aperture is additionally constrained to a constant intensity.
         fix_positions_iter: int, optional
             Number of iterations to run with fixed positions before updating positions estimate
         global_affine_transformation: bool, optional
@@ -1363,12 +1359,12 @@ def reconstruct(
             Standard deviation of gaussian kernel in A
         gaussian_filter_iter: int, optional
             Number of iterations to run using object smoothness constraint
-        probe_gaussian_filter_sigma: float, optional
-            Standard deviation of probe gaussian kernel in A^-1
-        probe_gaussian_filter_residual_aberrations_iter: int, optional
-            Number of iterations to run using probe smoothing of residual aberrations
-        probe_gaussian_filter_fix_amplitude: bool
-            If True, only the probe phase is smoothed
+        fit_probe_aberrations_iter: int, optional
+            Number of iterations to run while fitting the probe aberrations to a low-order expansion
+        fit_probe_aberrations_max_angular_order: bool
+            Max angular order of probe aberrations basis functions
+        fit_probe_aberrations_max_radial_order: bool
+            Max radial order of probe aberrations basis functions
         butterworth_filter_iter: int, optional
             Number of iterations to run using high-pass butteworth filter
         q_lowpass: float
@@ -1685,12 +1681,6 @@ def reconstruct(
                 self._probe,
                 self._positions_px,
                 fix_com=fix_com and a0 >= fix_probe_iter,
-                symmetrize_probe=a0 < symmetrize_probe_iter,
-                probe_gaussian_filter=a0
-                < probe_gaussian_filter_residual_aberrations_iter
-                and probe_gaussian_filter_sigma is not None,
-                probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
-                probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
                 constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                 and a0 >= fix_probe_iter,
                 constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
@@ -1698,7 +1688,12 @@ def reconstruct(
                 constrain_probe_fourier_amplitude=a0
                 < constrain_probe_fourier_amplitude_iter
                 and a0 >= fix_probe_iter,
-                constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_max_width_pixels=constrain_probe_fourier_amplitude_max_width_pixels,
+                constrain_probe_fourier_amplitude_constant_intensity=constrain_probe_fourier_amplitude_constant_intensity,
+                fit_probe_aberrations=a0 < fit_probe_aberrations_iter
+                and a0 >= fix_probe_iter,
+                fit_probe_aberrations_max_angular_order=fit_probe_aberrations_max_angular_order,
+                fit_probe_aberrations_max_radial_order=fit_probe_aberrations_max_radial_order,
                 fix_probe_aperture=a0 < fix_probe_aperture_iter,
                 initial_probe_aperture=self._probe_initial_aperture,
                 fix_positions=a0 < fix_positions_iter,
diff --git a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
index 5691828f2..0480bae8a 100644
--- a/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_singleslice_ptychography.py
@@ -1270,12 +1270,12 @@ def reconstruct(
             Standard deviation of gaussian kernel in A
         gaussian_filter_iter: int, optional
             Number of iterations to run using object smoothness constraint
-        probe_gaussian_filter_sigma: float, optional
-            Standard deviation of probe gaussian kernel in A^-1
-        probe_gaussian_filter_fix_amplitude: bool
-            If True, only the probe phase is smoothed
-        probe_gaussian_filter_residual_aberrations_iter: int, optional
-            Number of iterations to run using probe smoothing of residual aberrations
+        fit_probe_aberrations_iter: int, optional
+            Number of iterations to run while fitting the probe aberrations to a low-order expansion
+        fit_probe_aberrations_max_angular_order: bool
+            Max angular order of probe aberrations basis functions
+        fit_probe_aberrations_max_radial_order: bool
+            Max radial order of probe aberrations basis functions
         butterworth_filter_iter: int, optional
             Number of iterations to run using high-pass butteworth filter
         q_lowpass: float

From a1a1cca2c071e7b2894d0040ea1860b07da728ce Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Tue, 11 Jul 2023 16:37:46 -0700
Subject: [PATCH 272/362] probe constraints for multislice

---
 .../iterative_multislice_ptychography.py      | 117 +++++++++---------
 1 file changed, 56 insertions(+), 61 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_multislice_ptychography.py b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
index 4706decf9..1e9bd2cbb 100644
--- a/py4DSTEM/process/phase/iterative_multislice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
@@ -1455,15 +1455,15 @@ def _constraints(
         current_probe,
         current_positions,
         fix_com,
-        symmetrize_probe,
-        probe_gaussian_filter,
-        probe_gaussian_filter_sigma,
-        probe_gaussian_filter_fix_amplitude,
+        fit_probe_aberrations,
+        fit_probe_aberrations_max_angular_order,
+        fit_probe_aberrations_max_radial_order,
         constrain_probe_amplitude,
         constrain_probe_amplitude_relative_radius,
         constrain_probe_amplitude_relative_width,
         constrain_probe_fourier_amplitude,
-        constrain_probe_fourier_amplitude_threshold,
+        constrain_probe_fourier_amplitude_max_width_pixels,
+        constrain_probe_fourier_amplitude_constant_intensity,
         fix_probe_aperture,
         initial_probe_aperture,
         fix_positions,
@@ -1498,14 +1498,12 @@ def _constraints(
             Current positions estimate
         fix_com: bool
             If True, probe CoM is fixed to the center
-        symmetrize_probe: bool
-            If True, the probe is radially-averaged
-        probe_gaussian_filter: bool
-            If True, applies reciprocal-space gaussian filtering on residual aberrations
-        probe_gaussian_filter_sigma: float
-            Standard deviation of gaussian kernel in A^-1
-        probe_gaussian_filter_fix_amplitude: bool
-            If True, only the probe phase is smoothed
+        fit_probe_aberrations: bool
+            If True, fits the probe aberrations to a low-order expansion
+        fit_probe_aberrations_max_angular_order: bool
+            Max angular order of probe aberrations basis functions
+        fit_probe_aberrations_max_radial_order: bool
+            Max radial order of probe aberrations basis functions
         constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
         constrain_probe_amplitude_relative_radius: float
@@ -1513,10 +1511,11 @@ def _constraints(
         constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
         constrain_probe_fourier_amplitude: bool
-            If True, probe fourier amplitude is constrained by top hat function
-        constrain_probe_fourier_amplitude_threshold: float
-            Threshold value for current probe fourier mask. Value should
-            be between 0 and 1, where higher values provide the most masking.
+            If True, probe aperture is constrained by fitting a sigmoid for each angular frequency.
+        constrain_probe_fourier_amplitude_max_width_pixels: float
+            Maximum pixel width of fitted sigmoid functions.
+        constrain_probe_fourier_amplitude_constant_intensity: bool
+            If True, the probe aperture is additionally constrained to a constant intensity.
         fix_probe_aperture: bool
             If True, probe Fourier amplitude is replaced by initial_probe_aperture
         initial_probe_aperture: np.ndarray
@@ -1612,31 +1611,29 @@ def _constraints(
         if fix_com:
             current_probe = self._probe_center_of_mass_constraint(current_probe)
 
-        if probe_gaussian_filter:
-            current_probe = self._probe_residual_aberration_filtering_constraint(
-                current_probe,
-                probe_gaussian_filter_sigma,
-                probe_gaussian_filter_fix_amplitude,
-            )
-
-        if symmetrize_probe:
-            current_probe = self._probe_radial_symmetrization_constraint(current_probe)
-
         if fix_probe_aperture:
             current_probe = self._probe_aperture_constraint(
                 current_probe,
                 initial_probe_aperture,
             )
-        elif constrain_probe_amplitude:
-            current_probe = self._probe_amplitude_constraint(
-                current_probe,
-                constrain_probe_amplitude_relative_radius,
-                constrain_probe_amplitude_relative_width,
-            )
         elif constrain_probe_fourier_amplitude:
             current_probe = self._probe_fourier_amplitude_constraint(
                 current_probe,
-                constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_max_width_pixels,
+                constrain_probe_fourier_amplitude_constant_intensity,
+            )
+
+        if fit_probe_aberrations:
+            current_probe = self._probe_aberration_fitting_constraint(
+                current_probe,
+                fit_probe_aberrations_max_angular_order,
+                fit_probe_aberrations_max_radial_order,
+            )
+
+        if constrain_probe_amplitude:
+            current_probe = self._probe_amplitude_constraint(
+                current_probe,
+                constrain_probe_amplitude_relative_radius,
                 constrain_probe_amplitude_relative_width,
             )
 
@@ -1668,20 +1665,20 @@ def reconstruct(
         fix_com: bool = True,
         fix_probe_iter: int = 0,
         fix_probe_aperture_iter: int = 0,
-        symmetrize_probe_iter: int = 0,
         constrain_probe_amplitude_iter: int = 0,
         constrain_probe_amplitude_relative_radius: float = 0.5,
         constrain_probe_amplitude_relative_width: float = 0.05,
         constrain_probe_fourier_amplitude_iter: int = 0,
-        constrain_probe_fourier_amplitude_threshold: float = 0.9,
+        constrain_probe_fourier_amplitude_max_width_pixels: float = 3.0,
+        constrain_probe_fourier_amplitude_constant_intensity: bool = False,
         fix_positions_iter: int = np.inf,
         constrain_position_distance: float = None,
         global_affine_transformation: bool = True,
         gaussian_filter_sigma: float = None,
         gaussian_filter_iter: int = np.inf,
-        probe_gaussian_filter_sigma: float = None,
-        probe_gaussian_filter_residual_aberrations_iter: int = np.inf,
-        probe_gaussian_filter_fix_amplitude: bool = True,
+        fit_probe_aberrations_iter: int = 0,
+        fit_probe_aberrations_max_angular_order: int = 4,
+        fit_probe_aberrations_max_radial_order: int = 4,
         butterworth_filter_iter: int = np.inf,
         q_lowpass: float = None,
         q_highpass: float = None,
@@ -1740,19 +1737,18 @@ def reconstruct(
             Number of iterations to run with a fixed probe before updating probe estimate
         fix_probe_aperture_iter: int, optional
             Number of iterations to run with a fixed probe Fourier amplitude before updating probe estimate
-        symmetrize_probe_iter: int, optional
-            Number of iterations to run before radially-averaging the probe
-        constrain_probe_amplitude: bool
-            If True, probe amplitude is constrained by top hat function
+        constrain_probe_amplitude_iter: int, optional
+            Number of iterations to run while constraining the real-space probe with a top-hat support.
         constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
         constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        constrain_probe_fourier_amplitude: bool
-            If True, probe fourier amplitude is constrained by top hat function
-        constrain_probe_fourier_amplitude_threshold: float
-            Threshold value for current probe fourier mask. Value should
-            be between 0 and 1, where higher values provide the most masking.
+        constrain_probe_fourier_amplitude_iter: int, optional
+            Number of iterations to run while constraining the Fourier-space probe by fitting a sigmoid for each angular frequency.
+        constrain_probe_fourier_amplitude_max_width_pixels: float
+            Maximum pixel width of fitted sigmoid functions.
+        constrain_probe_fourier_amplitude_constant_intensity: bool
+            If True, the probe aperture is additionally constrained to a constant intensity.
         fix_positions_iter: int, optional
             Number of iterations to run with fixed positions before updating positions estimate
         global_affine_transformation: bool, optional
@@ -1761,12 +1757,12 @@ def reconstruct(
             Standard deviation of gaussian kernel in A
         gaussian_filter_iter: int, optional
             Number of iterations to run using object smoothness constraint
-        probe_gaussian_filter_sigma: float, optional
-            Standard deviation of probe gaussian kernel in A^-1
-        probe_gaussian_filter_residual_aberrations_iter: int, optional
-            Number of iterations to run using probe smoothing of residual aberrations
-        probe_gaussian_filter_fix_amplitude: bool
-            If True, only the probe phase is smoothed
+        fit_probe_aberrations_iter: int, optional
+            Number of iterations to run while fitting the probe aberrations to a low-order expansion
+        fit_probe_aberrations_max_angular_order: bool
+            Max angular order of probe aberrations basis functions
+        fit_probe_aberrations_max_radial_order: bool
+            Max radial order of probe aberrations basis functions
         butterworth_filter_iter: int, optional
             Number of iterations to run using high-pass butteworth filter
         q_lowpass: float
@@ -2098,12 +2094,6 @@ def reconstruct(
                 self._probe,
                 self._positions_px,
                 fix_com=fix_com and a0 >= fix_probe_iter,
-                symmetrize_probe=a0 < symmetrize_probe_iter,
-                probe_gaussian_filter=a0
-                < probe_gaussian_filter_residual_aberrations_iter
-                and probe_gaussian_filter_sigma is not None,
-                probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
-                probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
                 constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                 and a0 >= fix_probe_iter,
                 constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
@@ -2111,7 +2101,12 @@ def reconstruct(
                 constrain_probe_fourier_amplitude=a0
                 < constrain_probe_fourier_amplitude_iter
                 and a0 >= fix_probe_iter,
-                constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_max_width_pixels=constrain_probe_fourier_amplitude_max_width_pixels,
+                constrain_probe_fourier_amplitude_constant_intensity=constrain_probe_fourier_amplitude_constant_intensity,
+                fit_probe_aberrations=a0 < fit_probe_aberrations_iter
+                and a0 >= fix_probe_iter,
+                fit_probe_aberrations_max_angular_order=fit_probe_aberrations_max_angular_order,
+                fit_probe_aberrations_max_radial_order=fit_probe_aberrations_max_radial_order,
                 fix_probe_aperture=a0 < fix_probe_aperture_iter,
                 initial_probe_aperture=self._probe_initial_aperture,
                 fix_positions=a0 < fix_positions_iter,

From 245957f8268550b620e488f68366b76d9a2aadb0 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Tue, 11 Jul 2023 16:51:30 -0700
Subject: [PATCH 273/362] probe constraints for overlap tomography

---
 .../iterative_overlap_magnetic_tomography.py  | 130 +++++++++---------
 .../phase/iterative_overlap_tomography.py     | 130 +++++++++---------
 2 files changed, 124 insertions(+), 136 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 4dd7c3dbb..875bce735 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -1685,15 +1685,15 @@ def _constraints(
         current_probe,
         current_positions,
         fix_com,
-        symmetrize_probe,
-        probe_gaussian_filter,
-        probe_gaussian_filter_sigma,
-        probe_gaussian_filter_fix_amplitude,
+        fit_probe_aberrations,
+        fit_probe_aberrations_max_angular_order,
+        fit_probe_aberrations_max_radial_order,
         constrain_probe_amplitude,
         constrain_probe_amplitude_relative_radius,
         constrain_probe_amplitude_relative_width,
         constrain_probe_fourier_amplitude,
-        constrain_probe_fourier_amplitude_threshold,
+        constrain_probe_fourier_amplitude_max_width_pixels,
+        constrain_probe_fourier_amplitude_constant_intensity,
         fix_probe_aperture,
         initial_probe_aperture,
         fix_positions,
@@ -1725,14 +1725,12 @@ def _constraints(
             Current positions estimate
         fix_com: bool
             If True, probe CoM is fixed to the center
-        symmetrize_probe: bool
-            If True, the probe is radially-averaged
-        probe_gaussian_filter: bool
-            If True, applies reciprocal-space gaussian filtering on residual aberrations
-        probe_gaussian_filter_sigma: float
-            Standard deviation of gaussian kernel in A^-1
-        probe_gaussian_filter_fix_amplitude: bool
-            If True, only the probe phase is smoothed
+        fit_probe_aberrations: bool
+            If True, fits the probe aberrations to a low-order expansion
+        fit_probe_aberrations_max_angular_order: bool
+            Max angular order of probe aberrations basis functions
+        fit_probe_aberrations_max_radial_order: bool
+            Max radial order of probe aberrations basis functions
         constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
         constrain_probe_amplitude_relative_radius: float
@@ -1740,10 +1738,11 @@ def _constraints(
         constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
         constrain_probe_fourier_amplitude: bool
-            If True, probe fourier amplitude is constrained by top hat function
-        constrain_probe_fourier_amplitude_threshold: float
-            Threshold value for current probe fourier mask. Value should
-            be between 0 and 1, where higher values provide the most masking.
+            If True, probe aperture is constrained by fitting a sigmoid for each angular frequency.
+        constrain_probe_fourier_amplitude_max_width_pixels: float
+            Maximum pixel width of fitted sigmoid functions.
+        constrain_probe_fourier_amplitude_constant_intensity: bool
+            If True, the probe aperture is additionally constrained to a constant intensity.
         fix_probe_aperture: bool,
             If True, probe Fourier amplitude is replaced by initial probe aperture.
         initial_probe_aperture: np.ndarray,
@@ -1836,31 +1835,29 @@ def _constraints(
         if fix_com:
             current_probe = self._probe_center_of_mass_constraint(current_probe)
 
-        if probe_gaussian_filter:
-            current_probe = self._probe_residual_aberration_filtering_constraint(
-                current_probe,
-                probe_gaussian_filter_sigma,
-                probe_gaussian_filter_fix_amplitude,
-            )
-
-        if symmetrize_probe:
-            current_probe = self._probe_radial_symmetrization_constraint(current_probe)
-
         if fix_probe_aperture:
             current_probe = self._probe_aperture_constraint(
                 current_probe,
                 initial_probe_aperture,
             )
-        elif constrain_probe_amplitude:
-            current_probe = self._probe_amplitude_constraint(
-                current_probe,
-                constrain_probe_amplitude_relative_radius,
-                constrain_probe_amplitude_relative_width,
-            )
         elif constrain_probe_fourier_amplitude:
             current_probe = self._probe_fourier_amplitude_constraint(
                 current_probe,
-                constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_max_width_pixels,
+                constrain_probe_fourier_amplitude_constant_intensity,
+            )
+
+        if fit_probe_aberrations:
+            current_probe = self._probe_aberration_fitting_constraint(
+                current_probe,
+                fit_probe_aberrations_max_angular_order,
+                fit_probe_aberrations_max_radial_order,
+            )
+
+        if constrain_probe_amplitude:
+            current_probe = self._probe_amplitude_constraint(
+                current_probe,
+                constrain_probe_amplitude_relative_radius,
                 constrain_probe_amplitude_relative_width,
             )
 
@@ -1892,21 +1889,21 @@ def reconstruct(
         fix_com: bool = True,
         fix_probe_iter: int = 0,
         fix_probe_aperture_iter: int = 0,
-        symmetrize_probe_iter: int = 0,
         constrain_probe_amplitude_iter: int = 0,
         constrain_probe_amplitude_relative_radius: float = 0.5,
         constrain_probe_amplitude_relative_width: float = 0.05,
         constrain_probe_fourier_amplitude_iter: int = 0,
-        constrain_probe_fourier_amplitude_threshold: float = 0.9,
+        constrain_probe_fourier_amplitude_max_width_pixels: float = 3.0,
+        constrain_probe_fourier_amplitude_constant_intensity: bool = False,
         fix_positions_iter: int = np.inf,
         constrain_position_distance: float = None,
         global_affine_transformation: bool = True,
         gaussian_filter_sigma_e: float = None,
         gaussian_filter_sigma_m: float = None,
         gaussian_filter_iter: int = np.inf,
-        probe_gaussian_filter_sigma: float = None,
-        probe_gaussian_filter_residual_aberrations_iter: int = np.inf,
-        probe_gaussian_filter_fix_amplitude: bool = True,
+        fit_probe_aberrations_iter: int = 0,
+        fit_probe_aberrations_max_angular_order: int = 4,
+        fit_probe_aberrations_max_radial_order: int = 4,
         butterworth_filter_iter: int = np.inf,
         q_lowpass_e: float = None,
         q_lowpass_m: float = None,
@@ -1960,19 +1957,18 @@ def reconstruct(
             Number of iterations to run with a fixed probe before updating probe estimate
         fix_probe_aperture_iter: int, optional
             Number of iterations to run with a fixed probe Fourier amplitude before updating probe estimate
-        symmetrize_probe_iter: int, optional
-            Number of iterations to run before radially-averaging the probe
-        constrain_probe_amplitude: bool
-            If True, probe amplitude is constrained by top hat function
+        constrain_probe_amplitude_iter: int, optional
+            Number of iterations to run while constraining the real-space probe with a top-hat support.
         constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
         constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        constrain_probe_fourier_amplitude: bool
-            If True, probe fourier amplitude is constrained by top hat function
-        constrain_probe_fourier_amplitude_threshold: float
-            Threshold value for current probe fourier mask. Value should
-            be between 0 and 1, where higher values provide the most masking.
+        constrain_probe_fourier_amplitude_iter: int, optional
+            Number of iterations to run while constraining the Fourier-space probe by fitting a sigmoid for each angular frequency.
+        constrain_probe_fourier_amplitude_max_width_pixels: float
+            Maximum pixel width of fitted sigmoid functions.
+        constrain_probe_fourier_amplitude_constant_intensity: bool
+            If True, the probe aperture is additionally constrained to a constant intensity.
         fix_positions_iter: int, optional
             Number of iterations to run with fixed positions before updating positions estimate
         constrain_position_distance: float, optional
@@ -1986,12 +1982,12 @@ def reconstruct(
             Standard deviation of gaussian kernel for magnetic object in A
         gaussian_filter_iter: int, optional
             Number of iterations to run using object smoothness constraint
-        probe_gaussian_filter_sigma: float, optional
-            Standard deviation of probe gaussian kernel in A^-1
-        probe_gaussian_filter_residual_aberrations_iter: int, optional
-            Number of iterations to run using probe smoothing of residual aberrations
-        probe_gaussian_filter_fix_amplitude: bool
-            If True, only the probe phase is smoothed
+        fit_probe_aberrations_iter: int, optional
+            Number of iterations to run while fitting the probe aberrations to a low-order expansion
+        fit_probe_aberrations_max_angular_order: bool
+            Max angular order of probe aberrations basis functions
+        fit_probe_aberrations_max_radial_order: bool
+            Max radial order of probe aberrations basis functions
         butterworth_filter_iter: int, optional
             Number of iterations to run using high-pass butteworth filter
         q_lowpass: float
@@ -2447,12 +2443,6 @@ def reconstruct(
                         self._probe,
                         self._positions_px_all[start_tilt:end_tilt],
                         fix_com=fix_com and a0 >= fix_probe_iter,
-                        symmetrize_probe=a0 < symmetrize_probe_iter,
-                        probe_gaussian_filter=a0
-                        < probe_gaussian_filter_residual_aberrations_iter
-                        and probe_gaussian_filter_sigma is not None,
-                        probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
-                        probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
                         constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                         and a0 >= fix_probe_iter,
                         constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
@@ -2460,7 +2450,12 @@ def reconstruct(
                         constrain_probe_fourier_amplitude=a0
                         < constrain_probe_fourier_amplitude_iter
                         and a0 >= fix_probe_iter,
-                        constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                        constrain_probe_fourier_amplitude_max_width_pixels=constrain_probe_fourier_amplitude_max_width_pixels,
+                        constrain_probe_fourier_amplitude_constant_intensity=constrain_probe_fourier_amplitude_constant_intensity,
+                        fit_probe_aberrations=a0 < fit_probe_aberrations_iter
+                        and a0 >= fix_probe_iter,
+                        fit_probe_aberrations_max_angular_order=fit_probe_aberrations_max_angular_order,
+                        fit_probe_aberrations_max_radial_order=fit_probe_aberrations_max_radial_order,
                         fix_probe_aperture=a0 < fix_probe_aperture_iter,
                         initial_probe_aperture=self._probe_initial_aperture,
                         fix_positions=a0 < fix_positions_iter,
@@ -2497,12 +2492,6 @@ def reconstruct(
                     self._probe,
                     None,
                     fix_com=fix_com and a0 >= fix_probe_iter,
-                    symmetrize_probe=a0 < symmetrize_probe_iter,
-                    probe_gaussian_filter=a0
-                    < probe_gaussian_filter_residual_aberrations_iter
-                    and probe_gaussian_filter_sigma is not None,
-                    probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
-                    probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
                     constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                     and a0 >= fix_probe_iter,
                     constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
@@ -2510,7 +2499,12 @@ def reconstruct(
                     constrain_probe_fourier_amplitude=a0
                     < constrain_probe_fourier_amplitude_iter
                     and a0 >= fix_probe_iter,
-                    constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                    constrain_probe_fourier_amplitude_max_width_pixels=constrain_probe_fourier_amplitude_max_width_pixels,
+                    constrain_probe_fourier_amplitude_constant_intensity=constrain_probe_fourier_amplitude_constant_intensity,
+                    fit_probe_aberrations=a0 < fit_probe_aberrations_iter
+                    and a0 >= fix_probe_iter,
+                    fit_probe_aberrations_max_angular_order=fit_probe_aberrations_max_angular_order,
+                    fit_probe_aberrations_max_radial_order=fit_probe_aberrations_max_radial_order,
                     fix_probe_aperture=a0 < fix_probe_aperture_iter,
                     initial_probe_aperture=self._probe_initial_aperture,
                     fix_positions=True,
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index b5a3f71fa..0293fd322 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -1533,15 +1533,15 @@ def _constraints(
         current_probe,
         current_positions,
         fix_com,
-        symmetrize_probe,
-        probe_gaussian_filter,
-        probe_gaussian_filter_sigma,
-        probe_gaussian_filter_fix_amplitude,
+        fit_probe_aberrations,
+        fit_probe_aberrations_max_angular_order,
+        fit_probe_aberrations_max_radial_order,
         constrain_probe_amplitude,
         constrain_probe_amplitude_relative_radius,
         constrain_probe_amplitude_relative_width,
         constrain_probe_fourier_amplitude,
-        constrain_probe_fourier_amplitude_threshold,
+        constrain_probe_fourier_amplitude_max_width_pixels,
+        constrain_probe_fourier_amplitude_constant_intensity,
         fix_probe_aperture,
         initial_probe_aperture,
         fix_positions,
@@ -1569,14 +1569,12 @@ def _constraints(
             Current positions estimate
         fix_com: bool
             If True, probe CoM is fixed to the center
-        symmetrize_probe_iter: int, optional
-            Number of iterations to run before radially-averaging the probe
-        probe_gaussian_filter: bool
-            If True, applies reciprocal-space gaussian filtering on residual aberrations
-        probe_gaussian_filter_sigma: float
-            Standard deviation of gaussian kernel in A^-1
-        probe_gaussian_filter_fix_amplitude: bool
-            If True, only the probe phase is smoothed
+        fit_probe_aberrations: bool
+            If True, fits the probe aberrations to a low-order expansion
+        fit_probe_aberrations_max_angular_order: bool
+            Max angular order of probe aberrations basis functions
+        fit_probe_aberrations_max_radial_order: bool
+            Max radial order of probe aberrations basis functions
         constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
         constrain_probe_amplitude_relative_radius: float
@@ -1584,10 +1582,11 @@ def _constraints(
         constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
         constrain_probe_fourier_amplitude: bool
-            If True, probe fourier amplitude is constrained by top hat function
-        constrain_probe_fourier_amplitude_threshold: float
-            Threshold value for current probe fourier mask. Value should
-            be between 0 and 1, where higher values provide the most masking.
+            If True, probe aperture is constrained by fitting a sigmoid for each angular frequency.
+        constrain_probe_fourier_amplitude_max_width_pixels: float
+            Maximum pixel width of fitted sigmoid functions.
+        constrain_probe_fourier_amplitude_constant_intensity: bool
+            If True, the probe aperture is additionally constrained to a constant intensity.
         fix_probe_aperture: bool,
             If True, probe Fourier amplitude is replaced by initial probe aperture.
         initial_probe_aperture: np.ndarray,
@@ -1649,31 +1648,29 @@ def _constraints(
         if fix_com:
             current_probe = self._probe_center_of_mass_constraint(current_probe)
 
-        if probe_gaussian_filter:
-            current_probe = self._probe_residual_aberration_filtering_constraint(
-                current_probe,
-                probe_gaussian_filter_sigma,
-                probe_gaussian_filter_fix_amplitude,
-            )
-
-        if symmetrize_probe:
-            current_probe = self._probe_radial_symmetrization_constraint(current_probe)
-
         if fix_probe_aperture:
             current_probe = self._probe_aperture_constraint(
                 current_probe,
                 initial_probe_aperture,
             )
-        elif constrain_probe_amplitude:
-            current_probe = self._probe_amplitude_constraint(
-                current_probe,
-                constrain_probe_amplitude_relative_radius,
-                constrain_probe_amplitude_relative_width,
-            )
         elif constrain_probe_fourier_amplitude:
             current_probe = self._probe_fourier_amplitude_constraint(
                 current_probe,
-                constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_max_width_pixels,
+                constrain_probe_fourier_amplitude_constant_intensity,
+            )
+
+        if fit_probe_aberrations:
+            current_probe = self._probe_aberration_fitting_constraint(
+                current_probe,
+                fit_probe_aberrations_max_angular_order,
+                fit_probe_aberrations_max_radial_order,
+            )
+
+        if constrain_probe_amplitude:
+            current_probe = self._probe_amplitude_constraint(
+                current_probe,
+                constrain_probe_amplitude_relative_radius,
                 constrain_probe_amplitude_relative_width,
             )
 
@@ -1705,20 +1702,20 @@ def reconstruct(
         fix_com: bool = True,
         fix_probe_iter: int = 0,
         fix_probe_aperture_iter: int = 0,
-        symmetrize_probe_iter: int = 0,
         constrain_probe_amplitude_iter: int = 0,
         constrain_probe_amplitude_relative_radius: float = 0.5,
         constrain_probe_amplitude_relative_width: float = 0.05,
         constrain_probe_fourier_amplitude_iter: int = 0,
-        constrain_probe_fourier_amplitude_threshold: float = 0.9,
+        constrain_probe_fourier_amplitude_max_width_pixels: float = 3.0,
+        constrain_probe_fourier_amplitude_constant_intensity: bool = False,
         fix_positions_iter: int = np.inf,
         constrain_position_distance: float = None,
         global_affine_transformation: bool = True,
         gaussian_filter_sigma: float = None,
         gaussian_filter_iter: int = np.inf,
-        probe_gaussian_filter_sigma: float = None,
-        probe_gaussian_filter_residual_aberrations_iter: int = np.inf,
-        probe_gaussian_filter_fix_amplitude: bool = True,
+        fit_probe_aberrations_iter: int = 0,
+        fit_probe_aberrations_max_angular_order: int = 4,
+        fit_probe_aberrations_max_radial_order: int = 4,
         butterworth_filter_iter: int = np.inf,
         q_lowpass: float = None,
         q_highpass: float = None,
@@ -1770,19 +1767,18 @@ def reconstruct(
             Number of iterations to run with a fixed probe before updating probe estimate
         fix_probe_aperture_iter: int, optional
             Number of iterations to run with a fixed probe Fourier amplitude before updating probe estimate
-        symmetrize_probe_iter: int, optional
-            Number of iterations to run before radially-averaging the probe
-        constrain_probe_amplitude: bool
-            If True, probe amplitude is constrained by top hat function
+        constrain_probe_amplitude_iter: int, optional
+            Number of iterations to run while constraining the real-space probe with a top-hat support.
         constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
         constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        constrain_probe_fourier_amplitude: bool
-            If True, probe fourier amplitude is constrained by top hat function
-        constrain_probe_fourier_amplitude_threshold: float
-            Threshold value for current probe fourier mask. Value should
-            be between 0 and 1, where higher values provide the most masking.
+        constrain_probe_fourier_amplitude_iter: int, optional
+            Number of iterations to run while constraining the Fourier-space probe by fitting a sigmoid for each angular frequency.
+        constrain_probe_fourier_amplitude_max_width_pixels: float
+            Maximum pixel width of fitted sigmoid functions.
+        constrain_probe_fourier_amplitude_constant_intensity: bool
+            If True, the probe aperture is additionally constrained to a constant intensity.
         fix_positions_iter: int, optional
             Number of iterations to run with fixed positions before updating positions estimate
         constrain_position_distance: float, optional
@@ -1794,12 +1790,12 @@ def reconstruct(
             Standard deviation of gaussian kernel in A
         gaussian_filter_iter: int, optional
             Number of iterations to run using object smoothness constraint
-        probe_gaussian_filter_sigma: float, optional
-            Standard deviation of probe gaussian kernel in A^-1
-        probe_gaussian_filter_residual_aberrations_iter: int, optional
-            Number of iterations to run using probe smoothing of residual aberrations
-        probe_gaussian_filter_fix_amplitude: bool
-            If True, only the probe phase is smoothed
+        fit_probe_aberrations_iter: int, optional
+            Number of iterations to run while fitting the probe aberrations to a low-order expansion
+        fit_probe_aberrations_max_angular_order: bool
+            Max angular order of probe aberrations basis functions
+        fit_probe_aberrations_max_radial_order: bool
+            Max radial order of probe aberrations basis functions
         butterworth_filter_iter: int, optional
             Number of iterations to run using high-pass butteworth filter
         q_lowpass: float
@@ -2176,12 +2172,6 @@ def reconstruct(
                         self._probe,
                         self._positions_px_all[start_tilt:end_tilt],
                         fix_com=fix_com and a0 >= fix_probe_iter,
-                        symmetrize_probe=a0 < symmetrize_probe_iter,
-                        probe_gaussian_filter=a0
-                        < probe_gaussian_filter_residual_aberrations_iter
-                        and probe_gaussian_filter_sigma is not None,
-                        probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
-                        probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
                         constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                         and a0 >= fix_probe_iter,
                         constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
@@ -2189,7 +2179,12 @@ def reconstruct(
                         constrain_probe_fourier_amplitude=a0
                         < constrain_probe_fourier_amplitude_iter
                         and a0 >= fix_probe_iter,
-                        constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                        constrain_probe_fourier_amplitude_max_width_pixels=constrain_probe_fourier_amplitude_max_width_pixels,
+                        constrain_probe_fourier_amplitude_constant_intensity=constrain_probe_fourier_amplitude_constant_intensity,
+                        fit_probe_aberrations=a0 < fit_probe_aberrations_iter
+                        and a0 >= fix_probe_iter,
+                        fit_probe_aberrations_max_angular_order=fit_probe_aberrations_max_angular_order,
+                        fit_probe_aberrations_max_radial_order=fit_probe_aberrations_max_radial_order,
                         fix_probe_aperture=a0 < fix_probe_aperture_iter,
                         initial_probe_aperture=self._probe_initial_aperture,
                         fix_positions=a0 < fix_positions_iter,
@@ -2221,12 +2216,6 @@ def reconstruct(
                     self._probe,
                     None,
                     fix_com=fix_com and a0 >= fix_probe_iter,
-                    symmetrize_probe=a0 < symmetrize_probe_iter,
-                    probe_gaussian_filter=a0
-                    < probe_gaussian_filter_residual_aberrations_iter
-                    and probe_gaussian_filter_sigma is not None,
-                    probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
-                    probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
                     constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                     and a0 >= fix_probe_iter,
                     constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
@@ -2234,7 +2223,12 @@ def reconstruct(
                     constrain_probe_fourier_amplitude=a0
                     < constrain_probe_fourier_amplitude_iter
                     and a0 >= fix_probe_iter,
-                    constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                    constrain_probe_fourier_amplitude_max_width_pixels=constrain_probe_fourier_amplitude_max_width_pixels,
+                    constrain_probe_fourier_amplitude_constant_intensity=constrain_probe_fourier_amplitude_constant_intensity,
+                    fit_probe_aberrations=a0 < fit_probe_aberrations_iter
+                    and a0 >= fix_probe_iter,
+                    fit_probe_aberrations_max_angular_order=fit_probe_aberrations_max_angular_order,
+                    fit_probe_aberrations_max_radial_order=fit_probe_aberrations_max_radial_order,
                     fix_probe_aperture=a0 < fix_probe_aperture_iter,
                     initial_probe_aperture=self._probe_initial_aperture,
                     fix_positions=True,

From 8aa3b60d58fbf44ed813189509bf443ec5161611 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Tue, 11 Jul 2023 16:56:03 -0700
Subject: [PATCH 274/362] probe constraints for simultaneous

---
 .../iterative_simultaneous_ptychography.py    | 111 +++++++++---------
 1 file changed, 56 insertions(+), 55 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
index cf243192e..8881d021c 100644
--- a/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_simultaneous_ptychography.py
@@ -2210,15 +2210,15 @@ def _constraints(
         current_positions,
         pure_phase_object,
         fix_com,
-        symmetrize_probe,
-        probe_gaussian_filter,
-        probe_gaussian_filter_sigma,
-        probe_gaussian_filter_fix_amplitude,
+        fit_probe_aberrations,
+        fit_probe_aberrations_max_angular_order,
+        fit_probe_aberrations_max_radial_order,
         constrain_probe_amplitude,
         constrain_probe_amplitude_relative_radius,
         constrain_probe_amplitude_relative_width,
         constrain_probe_fourier_amplitude,
-        constrain_probe_fourier_amplitude_threshold,
+        constrain_probe_fourier_amplitude_max_width_pixels,
+        constrain_probe_fourier_amplitude_constant_intensity,
         fix_probe_aperture,
         initial_probe_aperture,
         fix_positions,
@@ -2252,8 +2252,12 @@ def _constraints(
             If True, object amplitude is set to unity
         fix_com: bool
             If True, probe CoM is fixed to the center
-        symmetrize_probe: bool
-            If True, the probe is radially-averaged
+        fit_probe_aberrations: bool
+            If True, fits the probe aberrations to a low-order expansion
+        fit_probe_aberrations_max_angular_order: bool
+            Max angular order of probe aberrations basis functions
+        fit_probe_aberrations_max_radial_order: bool
+            Max radial order of probe aberrations basis functions
         constrain_probe_amplitude: bool
             If True, probe amplitude is constrained by top hat function
         constrain_probe_amplitude_relative_radius: float
@@ -2261,10 +2265,11 @@ def _constraints(
         constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
         constrain_probe_fourier_amplitude: bool
-            If True, probe fourier amplitude is constrained by top hat function
-        constrain_probe_fourier_amplitude_threshold: float
-            Threshold value for current probe fourier mask. Value should
-            be between 0 and 1, where higher values provide the most masking.
+            If True, probe aperture is constrained by fitting a sigmoid for each angular frequency.
+        constrain_probe_fourier_amplitude_max_width_pixels: float
+            Maximum pixel width of fitted sigmoid functions.
+        constrain_probe_fourier_amplitude_constant_intensity: bool
+            If True, the probe aperture is additionally constrained to a constant intensity.
         fix_probe_aperture: bool,
             If True, probe Fourier amplitude is replaced by initial probe aperture.
         initial_probe_aperture: np.ndarray,
@@ -2364,31 +2369,29 @@ def _constraints(
         if fix_com:
             current_probe = self._probe_center_of_mass_constraint(current_probe)
 
-        if probe_gaussian_filter:
-            current_probe = self._probe_residual_aberration_filtering_constraint(
-                current_probe,
-                probe_gaussian_filter_sigma,
-                probe_gaussian_filter_fix_amplitude,
-            )
-
-        if symmetrize_probe:
-            current_probe = self._probe_radial_symmetrization_constraint(current_probe)
-
         if fix_probe_aperture:
             current_probe = self._probe_aperture_constraint(
                 current_probe,
                 initial_probe_aperture,
             )
-        elif constrain_probe_amplitude:
-            current_probe = self._probe_amplitude_constraint(
-                current_probe,
-                constrain_probe_amplitude_relative_radius,
-                constrain_probe_amplitude_relative_width,
-            )
         elif constrain_probe_fourier_amplitude:
             current_probe = self._probe_fourier_amplitude_constraint(
                 current_probe,
-                constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_max_width_pixels,
+                constrain_probe_fourier_amplitude_constant_intensity,
+            )
+
+        if fit_probe_aberrations:
+            current_probe = self._probe_aberration_fitting_constraint(
+                current_probe,
+                fit_probe_aberrations_max_angular_order,
+                fit_probe_aberrations_max_radial_order,
+            )
+
+        if constrain_probe_amplitude:
+            current_probe = self._probe_amplitude_constraint(
+                current_probe,
+                constrain_probe_amplitude_relative_radius,
                 constrain_probe_amplitude_relative_width,
             )
 
@@ -2422,21 +2425,21 @@ def reconstruct(
         fix_probe_iter: int = 0,
         warmup_iter: int = 0,
         fix_probe_aperture_iter: int = 0,
-        symmetrize_probe_iter: int = 0,
         constrain_probe_amplitude_iter: int = 0,
         constrain_probe_amplitude_relative_radius: float = 0.5,
         constrain_probe_amplitude_relative_width: float = 0.05,
         constrain_probe_fourier_amplitude_iter: int = 0,
-        constrain_probe_fourier_amplitude_threshold: float = 0.9,
+        constrain_probe_fourier_amplitude_max_width_pixels: float = 3.0,
+        constrain_probe_fourier_amplitude_constant_intensity: bool = False,
         fix_positions_iter: int = np.inf,
         constrain_position_distance: float = None,
         global_affine_transformation: bool = True,
         gaussian_filter_sigma_e: float = None,
         gaussian_filter_sigma_m: float = None,
         gaussian_filter_iter: int = np.inf,
-        probe_gaussian_filter_sigma: float = None,
-        probe_gaussian_filter_residual_aberrations_iter: int = np.inf,
-        probe_gaussian_filter_fix_amplitude: bool = True,
+        fit_probe_aberrations_iter: int = 0,
+        fit_probe_aberrations_max_angular_order: int = 4,
+        fit_probe_aberrations_max_radial_order: int = 4,
         butterworth_filter_iter: int = np.inf,
         q_lowpass_e: float = None,
         q_lowpass_m: float = None,
@@ -2492,19 +2495,18 @@ def reconstruct(
             Number of iterations to run with a fixed probe before updating probe estimate
         fix_probe_aperture_iter: int, optional
             Number of iterations to run with a fixed probe Fourier amplitude before updating probe estimate
-        symmetrize_probe_iter: int, optional
-            Number of iterations to run before radially-averaging the probe
-        constrain_probe_amplitude: bool
-            If True, probe amplitude is constrained by top hat function
+        constrain_probe_amplitude_iter: int, optional
+            Number of iterations to run while constraining the real-space probe with a top-hat support.
         constrain_probe_amplitude_relative_radius: float
             Relative location of top-hat inflection point, between 0 and 0.5
         constrain_probe_amplitude_relative_width: float
             Relative width of top-hat sigmoid, between 0 and 0.5
-        constrain_probe_fourier_amplitude: bool
-            If True, probe fourier amplitude is constrained by top hat function
-        constrain_probe_fourier_amplitude_threshold: float
-            Threshold value for current probe fourier mask. Value should
-            be between 0 and 1, where higher values provide the most masking.
+        constrain_probe_fourier_amplitude_iter: int, optional
+            Number of iterations to run while constraining the Fourier-space probe by fitting a sigmoid for each angular frequency.
+        constrain_probe_fourier_amplitude_max_width_pixels: float
+            Maximum pixel width of fitted sigmoid functions.
+        constrain_probe_fourier_amplitude_constant_intensity: bool
+            If True, the probe aperture is additionally constrained to a constant intensity.
         fix_positions_iter: int, optional
             Number of iterations to run with fixed positions before updating positions estimate
         constrain_position_distance: float
@@ -2518,12 +2520,12 @@ def reconstruct(
             Standard deviation of gaussian kernel for magnetic object in A
         gaussian_filter_iter: int, optional
             Number of iterations to run using object smoothness constraint
-        probe_gaussian_filter_sigma: float, optional
-            Standard deviation of probe gaussian kernel in A^-1
-        probe_gaussian_filter_residual_aberrations_iter: int, optional
-            Number of iterations to run using probe smoothing of residual aberrations
-        probe_gaussian_filter_fix_amplitude: bool
-            If True, only the probe phase is smoothed
+        fit_probe_aberrations_iter: int, optional
+            Number of iterations to run while fitting the probe aberrations to a low-order expansion
+        fit_probe_aberrations_max_angular_order: bool
+            Max angular order of probe aberrations basis functions
+        fit_probe_aberrations_max_radial_order: bool
+            Max radial order of probe aberrations basis functions
         butterworth_filter_iter: int, optional
             Number of iterations to run using high-pass butteworth filter
         q_lowpass_e: float
@@ -2868,12 +2870,6 @@ def reconstruct(
                 self._probe,
                 self._positions_px,
                 fix_com=fix_com and a0 >= fix_probe_iter,
-                symmetrize_probe=a0 < symmetrize_probe_iter,
-                probe_gaussian_filter=a0
-                < probe_gaussian_filter_residual_aberrations_iter
-                and probe_gaussian_filter_sigma is not None,
-                probe_gaussian_filter_sigma=probe_gaussian_filter_sigma,
-                probe_gaussian_filter_fix_amplitude=probe_gaussian_filter_fix_amplitude,
                 constrain_probe_amplitude=a0 < constrain_probe_amplitude_iter
                 and a0 >= fix_probe_iter,
                 constrain_probe_amplitude_relative_radius=constrain_probe_amplitude_relative_radius,
@@ -2881,7 +2877,12 @@ def reconstruct(
                 constrain_probe_fourier_amplitude=a0
                 < constrain_probe_fourier_amplitude_iter
                 and a0 >= fix_probe_iter,
-                constrain_probe_fourier_amplitude_threshold=constrain_probe_fourier_amplitude_threshold,
+                constrain_probe_fourier_amplitude_max_width_pixels=constrain_probe_fourier_amplitude_max_width_pixels,
+                constrain_probe_fourier_amplitude_constant_intensity=constrain_probe_fourier_amplitude_constant_intensity,
+                fit_probe_aberrations=a0 < fit_probe_aberrations_iter
+                and a0 >= fix_probe_iter,
+                fit_probe_aberrations_max_angular_order=fit_probe_aberrations_max_angular_order,
+                fit_probe_aberrations_max_radial_order=fit_probe_aberrations_max_radial_order,
                 fix_probe_aperture=a0 < fix_probe_aperture_iter,
                 initial_probe_aperture=self._probe_initial_aperture,
                 fix_positions=a0 < fix_positions_iter,

From f6ed1080fe6d3658ce222d8b27721a139d126ed9 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Tue, 11 Jul 2023 17:04:43 -0700
Subject: [PATCH 275/362] imports, formatting, linting

---
 py4DSTEM/process/phase/.gitignore             |  1 +
 py4DSTEM/process/phase/__init__.py            | 29 ++++++++++++++-----
 py4DSTEM/process/phase/iterative_dpc.py       |  2 +-
 .../iterative_overlap_magnetic_tomography.py  |  6 +++-
 .../phase/iterative_overlap_tomography.py     |  6 +++-
 .../iterative_ptychographic_constraints.py    |  2 +-
 py4DSTEM/process/phase/utils.py               |  5 ++--
 7 files changed, 37 insertions(+), 14 deletions(-)
 create mode 100644 py4DSTEM/process/phase/.gitignore

diff --git a/py4DSTEM/process/phase/.gitignore b/py4DSTEM/process/phase/.gitignore
new file mode 100644
index 000000000..c97f963b3
--- /dev/null
+++ b/py4DSTEM/process/phase/.gitignore
@@ -0,0 +1 @@
+*.sh
diff --git a/py4DSTEM/process/phase/__init__.py b/py4DSTEM/process/phase/__init__.py
index cb9176375..178079349 100644
--- a/py4DSTEM/process/phase/__init__.py
+++ b/py4DSTEM/process/phase/__init__.py
@@ -3,13 +3,28 @@
 _emd_hook = True
 
 from py4DSTEM.process.phase.iterative_dpc import DPCReconstruction
-from py4DSTEM.process.phase.iterative_mixedstate_ptychography import MixedstatePtychographicReconstruction
-from py4DSTEM.process.phase.iterative_multislice_ptychography import MultislicePtychographicReconstruction
-from py4DSTEM.process.phase.iterative_overlap_magnetic_tomography import OverlapMagneticTomographicReconstruction
-from py4DSTEM.process.phase.iterative_overlap_tomography import OverlapTomographicReconstruction
+from py4DSTEM.process.phase.iterative_mixedstate_ptychography import (
+    MixedstatePtychographicReconstruction,
+)
+from py4DSTEM.process.phase.iterative_multislice_ptychography import (
+    MultislicePtychographicReconstruction,
+)
+from py4DSTEM.process.phase.iterative_overlap_magnetic_tomography import (
+    OverlapMagneticTomographicReconstruction,
+)
+from py4DSTEM.process.phase.iterative_overlap_tomography import (
+    OverlapTomographicReconstruction,
+)
 from py4DSTEM.process.phase.iterative_parallax import ParallaxReconstruction
-from py4DSTEM.process.phase.iterative_simultaneous_ptychography import SimultaneousPtychographicReconstruction
-from py4DSTEM.process.phase.iterative_singleslice_ptychography import SingleslicePtychographicReconstruction
-from py4DSTEM.process.phase.parameter_optimize import OptimizationParameter, PtychographyOptimizer
+from py4DSTEM.process.phase.iterative_simultaneous_ptychography import (
+    SimultaneousPtychographicReconstruction,
+)
+from py4DSTEM.process.phase.iterative_singleslice_ptychography import (
+    SingleslicePtychographicReconstruction,
+)
+from py4DSTEM.process.phase.parameter_optimize import (
+    OptimizationParameter,
+    PtychographyOptimizer,
+)
 
 # fmt: on
diff --git a/py4DSTEM/process/phase/iterative_dpc.py b/py4DSTEM/process/phase/iterative_dpc.py
index b3d449fca..4c80ed177 100644
--- a/py4DSTEM/process/phase/iterative_dpc.py
+++ b/py4DSTEM/process/phase/iterative_dpc.py
@@ -4,7 +4,7 @@
 """
 
 import warnings
-from typing import Tuple, Union, Sequence
+from typing import Sequence, Tuple, Union
 
 import matplotlib.pyplot as plt
 import numpy as np
diff --git a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
index 875bce735..6ca51f87b 100644
--- a/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py
@@ -2487,7 +2487,11 @@ def reconstruct(
             if collective_tilt_updates:
                 self._object += collective_object / self._num_tilts
 
-                (self._object, self._probe, _,) = self._constraints(
+                (
+                    self._object,
+                    self._probe,
+                    _,
+                ) = self._constraints(
                     self._object,
                     self._probe,
                     None,
diff --git a/py4DSTEM/process/phase/iterative_overlap_tomography.py b/py4DSTEM/process/phase/iterative_overlap_tomography.py
index 0293fd322..d6bee12fd 100644
--- a/py4DSTEM/process/phase/iterative_overlap_tomography.py
+++ b/py4DSTEM/process/phase/iterative_overlap_tomography.py
@@ -2211,7 +2211,11 @@ def reconstruct(
             if collective_tilt_updates:
                 self._object += collective_object / self._num_tilts
 
-                (self._object, self._probe, _,) = self._constraints(
+                (
+                    self._object,
+                    self._probe,
+                    _,
+                ) = self._constraints(
                     self._object,
                     self._probe,
                     None,
diff --git a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
index 5fe1a1a35..c5aef16c6 100644
--- a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
+++ b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
@@ -3,8 +3,8 @@
     array_slice,
     estimate_global_transformation_ransac,
     fft_shift,
-    regularize_probe_amplitude,
     fit_aberration_surface,
+    regularize_probe_amplitude,
 )
 from py4DSTEM.process.utils import get_CoM
 
diff --git a/py4DSTEM/process/phase/utils.py b/py4DSTEM/process/phase/utils.py
index 2d36284ee..c2e1d3b77 100644
--- a/py4DSTEM/process/phase/utils.py
+++ b/py4DSTEM/process/phase/utils.py
@@ -1,8 +1,8 @@
+import functools
 from typing import Mapping, Tuple, Union
 
 import matplotlib.pyplot as plt
 import numpy as np
-import functools
 from scipy.optimize import curve_fit
 
 try:
@@ -12,10 +12,9 @@
     cp = None
     from scipy.fft import dstn, idstn
 
-
+from py4DSTEM.process.utils import get_CoM
 from py4DSTEM.process.utils.cross_correlate import align_and_shift_images
 from py4DSTEM.process.utils.utils import electron_wavelength_angstrom
-from py4DSTEM.process.utils import get_CoM
 from scipy.ndimage import gaussian_filter, uniform_filter1d
 from skimage.restoration import unwrap_phase
 

From 67dc9dc4c44a28281eb4a33aad39bc68ab70e7e1 Mon Sep 17 00:00:00 2001
From: Georgios Varnavides <gvarnavides@berkeley.edu>
Date: Wed, 12 Jul 2023 11:34:13 -0700
Subject: [PATCH 276/362] commenting out probe renormalizations
 post-constraints

---
 .../iterative_ptychographic_constraints.py    | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
index c5aef16c6..9af22ba92 100644
--- a/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
+++ b/py4DSTEM/process/phase/iterative_ptychographic_constraints.py
@@ -364,7 +364,7 @@ def _probe_amplitude_constraint(
         erf = self._erf
 
         probe_intensity = xp.abs(current_probe) ** 2
-        current_probe_sum = xp.sum(probe_intensity)
+        #current_probe_sum = xp.sum(probe_intensity)
 
         X = xp.fft.fftfreq(current_probe.shape[0])[:, None]
         Y = xp.fft.fftfreq(current_probe.shape[1])[None]
@@ -374,10 +374,10 @@ def _probe_amplitude_constraint(
         tophat_mask = 0.5 * (1 - erf(sigma * r / (1 - r**2)))
 
         updated_probe = current_probe * tophat_mask
-        updated_probe_sum = xp.sum(xp.abs(updated_probe) ** 2)
-        normalization = xp.sqrt(current_probe_sum / updated_probe_sum)
+        #updated_probe_sum = xp.sum(xp.abs(updated_probe) ** 2)
+        #normalization = xp.sqrt(current_probe_sum / updated_probe_sum)
 
-        return updated_probe * normalization
+        return updated_probe #* normalization
 
     def _probe_fourier_amplitude_constraint(
         self,
@@ -406,7 +406,7 @@ def _probe_fourier_amplitude_constraint(
         xp = self._xp
         asnumpy = self._asnumpy
 
-        current_probe_sum = xp.sum(xp.abs(current_probe) ** 2)
+        #current_probe_sum = xp.sum(xp.abs(current_probe) ** 2)
         current_probe_fft = xp.fft.fft2(current_probe)
 
         updated_probe_fft, _, _, _ = regularize_probe_amplitude(
@@ -419,10 +419,10 @@ def _probe_fourier_amplitude_constraint(
 
         updated_probe_fft = xp.asarray(updated_probe_fft)
         updated_probe = xp.fft.ifft2(updated_probe_fft)
-        updated_probe_sum = xp.sum(xp.abs(updated_probe) ** 2)
-        normalization = xp.sqrt(current_probe_sum / updated_probe_sum)
+        #updated_probe_sum = xp.sum(xp.abs(updated_probe) ** 2)
+        #normalization = xp.sqrt(current_probe_sum / updated_probe_sum)
 
-        return updated_probe * normalization
+        return updated_probe #* normalization
 
     def _probe_aperture_constraint(
         self,
@@ -444,16 +444,16 @@ def _probe_aperture_constraint(
         """
         xp = self._xp
 
-        current_probe_sum = xp.sum(xp.abs(current_probe) ** 2)
+        #current_probe_sum = xp.sum(xp.abs(current_probe) ** 2)
         current_probe_fft_phase = xp.angle(xp.fft.fft2(current_probe))
 
         updated_probe = xp.fft.ifft2(
             xp.exp(1j * current_probe_fft_phase) * initial_probe_aperture
         )
-        updated_probe_sum = xp.sum(xp.abs(updated_probe) ** 2)
-        normalization = xp.sqrt(current_probe_sum / updated_probe_sum)
+        #updated_probe_sum = xp.sum(xp.abs(updated_probe) ** 2)
+        #normalization = xp.sqrt(current_probe_sum / updated_probe_sum)
 
-        return updated_probe * normalization
+        return updated_probe #* normalization
 
     def _probe_aberration_fitting_constraint(
         self,

From 2ebfb32509f01c12fbaf0421fadb6186360cd56a Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Thu, 13 Jul 2023 14:03:54 -0700
Subject: [PATCH 277/362] bragg vectors copy

---
 py4DSTEM/braggvectors/braggvectors.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/py4DSTEM/braggvectors/braggvectors.py b/py4DSTEM/braggvectors/braggvectors.py
index da8ffd3b2..366dbe9f8 100644
--- a/py4DSTEM/braggvectors/braggvectors.py
+++ b/py4DSTEM/braggvectors/braggvectors.py
@@ -285,7 +285,13 @@ def get_vectors(
 
     def copy(self, name=None):
         name = name if name is not None else self.name+"_copy"
-        braggvector_copy = BraggVectors(self.Rshape, self.Qshape, name=name)
+        braggvector_copy = BraggVectors(
+            self.Rshape, 
+            self.Qshape, 
+            name=name, 
+            calibration = self.calibration.copy()
+        )
+        
         braggvector_copy._v_uncal = self._v_uncal.copy()
         for k in self.metadata.keys():
             braggvector_copy.metadata = self.metadata[k].copy()

From d693ed9ad35c66859dd963a7915c0658bf7b24bc Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Thu, 13 Jul 2023 14:12:35 -0700
Subject: [PATCH 278/362] bug fix

---
 py4DSTEM/braggvectors/braggvectors.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/braggvectors/braggvectors.py b/py4DSTEM/braggvectors/braggvectors.py
index 366dbe9f8..14b89fd98 100644
--- a/py4DSTEM/braggvectors/braggvectors.py
+++ b/py4DSTEM/braggvectors/braggvectors.py
@@ -226,7 +226,7 @@ def setcal(
         if pixel:
             assert(c.get_Q_pixel_size() is not None), "Requested calibration not found"
         if rotate:
-            assert(c.get_RQ_rotflip() is not None), "Requested calibration not found"
+            assert(c.get_QR_rotflip() is not None), "Requested calibration not found"
 
         # set the calibrations
         self._calstate = {

From ab295ac1fa8ef1639271bd01233aa7657f4301ff Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Thu, 13 Jul 2023 15:21:52 -0700
Subject: [PATCH 279/362] bin and pad fixes

---
 py4DSTEM/preprocess/preprocess.py | 23 ++++++++++++++++++++---
 1 file changed, 20 insertions(+), 3 deletions(-)

diff --git a/py4DSTEM/preprocess/preprocess.py b/py4DSTEM/preprocess/preprocess.py
index 6342a60ae..87cb689c5 100644
--- a/py4DSTEM/preprocess/preprocess.py
+++ b/py4DSTEM/preprocess/preprocess.py
@@ -262,10 +262,13 @@ def bin_data_diffraction(
         bin_factor,
     ).sum(axis=(3, 5)).astype(dtype)
 
-
     # set dim vectors
     Qpixsize = datacube.calibration.get_Q_pixel_size() * bin_factor
     Qpixunits = datacube.calibration.get_Q_pixel_units()
+    
+    # set calibration pixel size
+    datacube.calibration.set_Q_pixel_size(Qpixsize)
+
     datacube.set_dim(
         2,
         [0,Qpixsize],
@@ -278,8 +281,6 @@ def bin_data_diffraction(
         units = Qpixunits,
         name = 'Qy'
     )
-    # set calibration pixel size
-    datacube.calibration.set_Q_pixel_size(Qpixsize)
 
     # return
     return datacube
@@ -753,6 +754,22 @@ def pad_data_diffraction(datacube, pad_factor=None, output_size=None):
 
     datacube.data = np.pad(datacube.data, pad_width=pad_width, mode="constant")
 
+    Qpixsize  = datacube.calibration.get_Q_pixel_size()
+    Qpixunits = datacube.calibration.get_Q_pixel_units()
+
+    datacube.set_dim(
+        2,
+        [0,Qpixsize],
+        units = Qpixunits,
+        name = 'Qx'
+    )
+    datacube.set_dim(
+        3,
+        [0,Qpixsize],
+        units = Qpixunits,
+        name = 'Qy'
+    )
+
     return datacube
 
 

From 7e266f2774c6123556570c060ebb5fefad979394 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Thu, 13 Jul 2023 18:00:38 -0700
Subject: [PATCH 280/362] another bin and pad fix

---
 py4DSTEM/preprocess/preprocess.py | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/py4DSTEM/preprocess/preprocess.py b/py4DSTEM/preprocess/preprocess.py
index 87cb689c5..c156c228e 100644
--- a/py4DSTEM/preprocess/preprocess.py
+++ b/py4DSTEM/preprocess/preprocess.py
@@ -266,9 +266,7 @@ def bin_data_diffraction(
     Qpixsize = datacube.calibration.get_Q_pixel_size() * bin_factor
     Qpixunits = datacube.calibration.get_Q_pixel_units()
     
-    # set calibration pixel size
-    datacube.calibration.set_Q_pixel_size(Qpixsize)
-
+    
     datacube.set_dim(
         2,
         [0,Qpixsize],
@@ -282,6 +280,10 @@ def bin_data_diffraction(
         name = 'Qy'
     )
 
+    # set calibration pixel size
+    datacube.calibration.set_Q_pixel_size(Qpixsize)
+
+
     # return
     return datacube
 
@@ -770,6 +772,8 @@ def pad_data_diffraction(datacube, pad_factor=None, output_size=None):
         name = 'Qy'
     )
 
+    datacube.calibrate()
+
     return datacube
 
 

From bde93c5c8c6fe71729d630f088cb8ba2bf837d87 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Thu, 13 Jul 2023 21:48:25 -0400
Subject: [PATCH 281/362] updates

---
 py4DSTEM/process/strain.py        | 402 ++++++++++++++++++++++++++----
 py4DSTEM/visualize/vis_special.py |  96 -------
 test/test_strain.py               |   2 +
 3 files changed, 351 insertions(+), 149 deletions(-)

diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index e999c02d1..3088afa51 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -1,10 +1,12 @@
 # Defines the Strain class
 
 import numpy as np
+import matplotlib.pyplot as plt
 from typing import Optional
 from py4DSTEM.data import RealSlice, Data
 from py4DSTEM.braggvectors import BraggVectors
-
+from py4DSTEM.preprocess.utils import get_maxima_2D
+from py4DSTEM.visualize import show,add_pointlabels,add_vector
 
 
 class StrainMap(RealSlice,Data):
@@ -45,19 +47,26 @@ def __init__(
         )
 
         # set up braggvectors
+        # this assigns the bvs, ensures the origin is calibrated,
+        # and adds the strainmap to the bvs' tree
         self.braggvectors = braggvectors
-        # TODO - how to handle changes to braggvectors
-        #   option: register with calibrations and add a .calibrate method
-        #   which {{does something}} when origin changes
-        # TODO - include ellipse cal or no?
-
-        assert(self.root is not None)
 
         # initialize as Data
-        Data.__init__(
-            self,
-            calibration = self.braggvectors.calibration
-        )
+        Data.__init__(self)
+
+        # set calstate
+        # this property is used only to check to make sure that
+        # the braggvectors being used throughout a workflow are
+        # the same. The state of calibration of the vectors is noted
+        # here, and then checked each time the vectors are used -
+        # if they differ, an error message and instructions for
+        # re-calibration are issued
+        self.calstate = self.braggvectors.calstate
+
+        # get the BVM
+        # a new BVM using the current calstate is computed
+        self.bvm = self.braggvectors.histogram()
+
 
 
     # braggvector properties
@@ -73,6 +82,20 @@ def braggvectors(self,x):
         self._braggvectors.tree(self,force=True)
 
 
+    def reset_calstate(self):
+        """
+        Resets the calibration state. This recomputes the BVM, and removes any computations
+        this StrainMap instance has stored, which will need to be recomputed.
+        """
+        del(
+            self.g0,
+            self.g1,
+            self.g2,
+        )
+        self.calstate = self.braggvectors.calstate
+        pass
+
+
 
     # Class methods
 
@@ -81,8 +104,6 @@ def choose_lattice_vectors(
         index_g0,
         index_g1,
         index_g2,
-        mode = 'centered',
-        plot = True,
         subpixel = 'multicorr',
         upsample_factor = 16,
         sigma=0,
@@ -92,39 +113,94 @@ def choose_lattice_vectors(
         minSpacing=0,
         edgeBoundary=1,
         maxNumPeaks=10,
-        bvm_vis_params = {},
+        figsize=(12,6),
+        c_indices='lightblue',
+        c0='g',
+        c1='r',
+        c2='r',
+        c_vectors='r',
+        c_vectorlabels='w',
+        size_indices=20,
+        width_vectors=1,
+        size_vectorlabels=20,
+        vis_params = {},
         returncalc = False,
+        returnfig=False,
         ):
         """
         Choose which lattice vectors to use for strain mapping.
 
-        Args:
-            index_g0 (int): origin
-            index_g1 (int): second point of vector 1
-            index_g2 (int): second point of vector 2
-            mode (str): centered or raw bragg map
-            plot (bool): plot bragg vector maps and vectors
-            subpixel (str): specifies the subpixel resolution algorithm to use.
-                must be in ('pixel','poly','multicorr'), which correspond
-                to pixel resolution, subpixel resolution by fitting a
-                parabola, and subpixel resultion by Fourier upsampling.
-            upsample_factor: the upsampling factor for the 'multicorr'
-                algorithm
-            sigma: if >0, applies a gaussian filter
-            maxNumPeaks: the maximum number of maxima to return
-            minAbsoluteIntensity, minRelativeIntensity, relativeToPeak,
-                minSpacing, edgeBoundary, maxNumPeaks: filtering applied
-                after maximum detection and before subpixel refinement
+        Overlays the bvm with the points detected via local 2D
+        maxima detection, plus an index for each point. User selects
+        3 points using the overlaid indices, which are identified as
+        the origin and the termini of the lattice vectors g1 and g2.
+
+        Parameters
+        ----------
+        index_g0 : int
+            selected index for the origin
+        index_g1 : int
+            selected index for g1
+        index_g2 :int
+            selected index for g2
+        subpixel : str in ('pixel','poly','multicorr')
+            See the docstring for py4DSTEM.preprocess.get_maxima_2D
+        upsample_factor : int
+            See the py4DSTEM.preprocess.get_maxima_2D docstring
+        sigma : number
+            See the py4DSTEM.preprocess.get_maxima_2D docstring
+        minAbsoluteIntensity : number
+            See the py4DSTEM.preprocess.get_maxima_2D docstring
+        minRelativeIntensity : number
+            See the py4DSTEM.preprocess.get_maxima_2D docstring
+        relativeToPeak : int
+            See the py4DSTEM.preprocess.get_maxima_2D docstring
+        minSpacing : number
+            See the py4DSTEM.preprocess.get_maxima_2D docstring
+        edgeBoundary : number
+            See the py4DSTEM.preprocess.get_maxima_2D docstring
+        maxNumPeaks : int
+            See the py4DSTEM.preprocess.get_maxima_2D docstring
+        figsize : 2-tuple
+            the size of the figure
+        c_indices : color
+            color of the maxima
+        c0 : color
+            color of the origin
+        c1 : color
+            color of g1 point
+        c2 : color
+            color of g2 point
+        c_vectors : color
+            color of the g1/g2 vectors
+        c_vectorlabels : color
+            color of the vector labels
+        size_indices : number
+            size of the indices
+        width_vectors : number
+            width of the vectors
+        size_vectorlabels : number
+            size of the vector labels
+        vis_params : dict
+            additional visualization parameters passed to `show`
+        returncalc : bool
+            toggles returning the answer
+        returnfig : bool
+            toggles returning the figure
+
+        Returns
+        -------
+        (optional) : None or (g0,g1,g2) or (fig,(ax1,ax2)) or both of the latter
         """
-        from py4DSTEM.process.utils import get_maxima_2D
-
-        if mode == "centered":
-            bvm = self.bvm_centered
-        else:
-            bvm = self.bvm_raw
+        # validate inputs
+        for i in (index_g0,index_g1,index_g2):
+            assert isinstance(i,(int,np.integer)), "indices must be integers!"
+        # check the calstate
+        assert(self.calstate == self.braggvectors.calstate), "The calibration state has changed! To resync the calibration state, use `.reset_calstate`."
 
+        # find the maxima
         g = get_maxima_2D(
-            bvm,
+            self.bvm.data,
             subpixel = subpixel,
             upsample_factor = upsample_factor,
             sigma = sigma,
@@ -136,26 +212,246 @@ def choose_lattice_vectors(
             maxNumPeaks = maxNumPeaks,
         )
 
-        self.g = g
-
-        from py4DSTEM.visualize import select_lattice_vectors
-        g1,g2 = select_lattice_vectors(
-            bvm,
-            gx = g['x'],
-            gy = g['y'],
-            i0 = index_g0,
-            i1 = index_g1,
-            i2 = index_g2,
-            **bvm_vis_params,
-        )
-
+        # get the lattice vectors
+        gx,gy = g['x'],g['y']
+        g0 = gx[index_g0],gy[index_g0]
+        g1x = gx[index_g1] - g0[0]
+        g1y = gy[index_g1] - g0[1]
+        g2x = gx[index_g2] - g0[0]
+        g2y = gy[index_g2] - g0[1]
+        g1,g2 = (g1x,g1y),(g2x,g2y)
+
+        # make the figure
+        fig,(ax1,ax2) = plt.subplots(1,2,figsize=figsize)
+        show(self.bvm.data,figax=(fig,ax1),**vis_params)
+        show(self.bvm.data,figax=(fig,ax2),**vis_params)
+
+        # Add indices to left panel
+        d = {'x':gx,'y':gy,'size':size_indices,'color':c_indices}
+        d0 = {'x':gx[index_g0],'y':gy[index_g0],'size':size_indices,
+              'color':c0,'fontweight':'bold','labels':[str(index_g0)]}
+        d1 = {'x':gx[index_g1],'y':gy[index_g1],'size':size_indices,
+              'color':c1,'fontweight':'bold','labels':[str(index_g1)]}
+        d2 = {'x':gx[index_g2],'y':gy[index_g2],'size':size_indices,
+              'color':c2,'fontweight':'bold','labels':[str(index_g2)]}
+        add_pointlabels(ax1,d)
+        add_pointlabels(ax1,d0)
+        add_pointlabels(ax1,d1)
+        add_pointlabels(ax1,d2)
+
+        # Add vectors to right panel
+        dg1 = {'x0':gx[index_g0],'y0':gy[index_g0],'vx':g1[0],'vy':g1[1],'width':width_vectors,
+               'color':c_vectors,'label':r'$g_1$','labelsize':size_vectorlabels,'labelcolor':c_vectorlabels}
+        dg2 = {'x0':gx[index_g0],'y0':gy[index_g0],'vx':g2[0],'vy':g2[1],'width':width_vectors,
+               'color':c_vectors,'label':r'$g_2$','labelsize':size_vectorlabels,'labelcolor':c_vectorlabels}
+        add_vector(ax2,dg1)
+        add_vector(ax2,dg2)
+
+        # store vectors
+        self.g0 = g0
         self.g1 = g1
         self.g2 = g2
 
-        if returncalc:
-            return g1, g2
+        # return
+        if returncalc and returnfig:
+            return (g0,g1,g2),(fig,(ax1,ax2))
+        elif returncalc:
+            return (g0,g1,g2)
+        elif returnfig:
+            return (fig,(ax1,ax2))
+        else:
+            return
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+def index_bragg_directions(x0, y0, gx, gy, g1, g2):
+    """
+    From an origin (x0,y0), a set of reciprocal lattice vectors gx,gy, and an pair of
+    lattice vectors g1=(g1x,g1y), g2=(g2x,g2y), find the indices (h,k) of all the
+    reciprocal lattice directions.
+
+    The approach is to solve the matrix equation
+            ``alpha = beta * M``
+    where alpha is the 2xN array of the (x,y) coordinates of N measured bragg directions,
+    beta is the 2x2 array of the two lattice vectors u,v, and M is the 2xN array of the
+    h,k indices.
+
+    Args:
+        x0 (float): x-coord of origin
+        y0 (float): y-coord of origin
+        gx (1d array): x-coord of the reciprocal lattice vectors
+        gy (1d array): y-coord of the reciprocal lattice vectors
+        g1 (2-tuple of floats): g1x,g1y
+        g2 (2-tuple of floats): g2x,g2y
+
+    Returns:
+        (3-tuple) A 3-tuple containing:
+
+            * **h**: *(ndarray of ints)* first index of the bragg directions
+            * **k**: *(ndarray of ints)* second index of the bragg directions
+            * **bragg_directions**: *(PointList)* a 4-coordinate PointList with the
+              indexed bragg directions; coords 'qx' and 'qy' contain bragg_x and bragg_y
+              coords 'h' and 'k' contain h and k.
+    """
+    # Get beta, the matrix of lattice vectors
+    beta = np.array([[g1[0],g2[0]],[g1[1],g2[1]]])
+
+    # Get alpha, the matrix of measured bragg angles
+    alpha = np.vstack([gx-x0,gy-y0])
+
+    # Calculate M, the matrix of peak positions
+    M = lstsq(beta, alpha, rcond=None)[0].T
+    M = np.round(M).astype(int)
 
+    # Get h,k
+    h = M[:,0]
+    k = M[:,1]
 
+    # Store in a PointList
+    coords = [('qx',float),('qy',float),('h',int),('k',int)]
+    temp_array = np.zeros([], dtype = coords)
+    bragg_directions = PointList(data = temp_array)
+    bragg_directions.add_data_by_field((gx,gy,h,k))
+
+    return h,k, bragg_directions
+
+
+
+def add_indices_to_braggpeaks(braggpeaks, lattice, maxPeakSpacing, qx_shift=0,
+                              qy_shift=0, mask=None):
+    """
+    Using the peak positions (qx,qy) and indices (h,k) in the PointList lattice,
+    identify the indices for each peak in the PointListArray braggpeaks.
+    Return a new braggpeaks_indexed PointListArray, containing a copy of braggpeaks plus
+    three additional data columns -- 'h','k', and 'index_mask' -- specifying the peak
+    indices with the ints (h,k) and indicating whether the peak was successfully indexed
+    or not with the bool index_mask. If `mask` is specified, only the locations where
+    mask is True are indexed.
+
+    Args:
+        braggpeaks (PointListArray): the braggpeaks to index. Must contain
+            the coordinates 'qx', 'qy', and 'intensity'
+        lattice (PointList): the positions (qx,qy) of the (h,k) lattice points.
+            Must contain the coordinates 'qx', 'qy', 'h', and 'k'
+        maxPeakSpacing (float): Maximum distance from the ideal lattice points
+            to include a peak for indexing
+        qx_shift,qy_shift (number): the shift of the origin in the `lattice` PointList
+            relative to the `braggpeaks` PointListArray
+        mask (bool): Boolean mask, same shape as the pointlistarray, indicating which
+            locations should be indexed. This can be used to index different regions of
+            the scan with different lattices
+
+    Returns:
+        (PointListArray): The original braggpeaks pointlistarray, with new coordinates
+        'h', 'k', containing the indices of each indexable peak.
+    """
+
+    assert isinstance(braggpeaks,PointListArray)
+    assert np.all([name in braggpeaks.dtype.names for name in ('qx','qy','intensity')])
+    assert isinstance(lattice, PointList)
+    assert np.all([name in lattice.dtype.names for name in ('qx','qy','h','k')])
+
+    if mask is None:
+        mask = np.ones(braggpeaks.shape,dtype=bool)
+
+    assert mask.shape == braggpeaks.shape, 'mask must have same shape as pointlistarray'
+    assert mask.dtype == bool, 'mask must be boolean'
+
+    indexed_braggpeaks = braggpeaks.copy()
+
+    # add the coordinates if they don't exist
+    if not ('h' in braggpeaks.dtype.names):
+        indexed_braggpeaks = indexed_braggpeaks.add_fields([('h',int)])
+    if not ('k' in braggpeaks.dtype.names):
+        indexed_braggpeaks = indexed_braggpeaks.add_fields([('k',int)])
+
+    # loop over all the scan positions
+    for Rx, Ry in tqdmnd(mask.shape[0],mask.shape[1]):
+        if mask[Rx,Ry]:
+            pl = indexed_braggpeaks.get_pointlist(Rx,Ry)
+            rm_peak_mask = np.zeros(pl.length,dtype=bool)
+
+            for i in range(pl.length):
+                r2 = (pl.data['qx'][i]-lattice.data['qx'] + qx_shift)**2 + \
+                     (pl.data['qy'][i]-lattice.data['qy'] + qy_shift)**2
+                ind = np.argmin(r2)
+                if r2[ind] <= maxPeakSpacing**2:
+                    pl.data['h'][i] = lattice.data['h'][ind]
+                    pl.data['k'][i] = lattice.data['k'][ind]
+                else:
+                    rm_peak_mask[i] = True
+            pl.remove(rm_peak_mask)
+
+    indexed_braggpeaks.name = braggpeaks.name + "_indexed"
+    return indexed_braggpeaks
+
+
+
+
+
+
+
+
+
+
+
+
+    def show_lattice_vectors(ar,x0,y0,g1,g2,color='r',width=1,labelsize=20,labelcolor='w',returnfig=False,**kwargs):
+        """ Adds the vectors g1,g2 to an image, with tail positions at (x0,y0).  g1 and g2 are 2-tuples (gx,gy).
+        """
+        fig,ax = show(ar,returnfig=True,**kwargs)
+
+        # Add vectors
+        dg1 = {'x0':x0,'y0':y0,'vx':g1[0],'vy':g1[1],'width':width,
+               'color':color,'label':r'$g_1$','labelsize':labelsize,'labelcolor':labelcolor}
+        dg2 = {'x0':x0,'y0':y0,'vx':g2[0],'vy':g2[1],'width':width,
+               'color':color,'label':r'$g_2$','labelsize':labelsize,'labelcolor':labelcolor}
+        add_vector(ax,dg1)
+        add_vector(ax,dg2)
+
+        if returnfig:
+            return fig,ax
+        else:
+            plt.show()
+            return
+
+
+    def show_bragg_indexing(ar,braggdirections,voffset=5,hoffset=0,color='w',size=20,
+                            points=True,pointcolor='r',pointsize=50,returnfig=False,**kwargs):
+        """
+        Shows an array with an overlay describing the Bragg directions
+
+        Accepts:
+            ar                  (arrray) the image
+            bragg_directions    (PointList) the bragg scattering directions; must have coordinates
+                                'qx','qy','h', and 'k'. Optionally may also have 'l'.
+        """
+        assert isinstance(braggdirections,PointList)
+        for k in ('qx','qy','h','k'):
+            assert k in braggdirections.data.dtype.fields
+
+        fig,ax = show(ar,returnfig=True,**kwargs)
+        d = {'braggdirections':braggdirections,'voffset':voffset,'hoffset':hoffset,'color':color,
+             'size':size,'points':points,'pointsize':pointsize,'pointcolor':pointcolor}
+        add_bragg_index_labels(ax,d)
+
+        if returnfig:
+            return fig,ax
+        else:
+            plt.show()
+            return
 
 
 
diff --git a/py4DSTEM/visualize/vis_special.py b/py4DSTEM/visualize/vis_special.py
index b487048e2..43cf7fff8 100644
--- a/py4DSTEM/visualize/vis_special.py
+++ b/py4DSTEM/visualize/vis_special.py
@@ -590,102 +590,6 @@ def select_point(ar,x,y,i,color='lightblue',color_selected='r',size=20,returnfig
         return
 
 
-def select_lattice_vectors(ar,gx,gy,i0,i1,i2,
-               c_indices='lightblue',c0='g',c1='r',c2='r',c_vectors='r',c_vectorlabels='w',
-               size_indices=20,width_vectors=1,size_vectorlabels=20,
-               figsize=(12,6),returnfig=False,**kwargs):
-    """
-    This function accepts a set of reciprocal lattice points (gx,gy) and three indices
-    (i0,i1,i2).  Using those indices as, respectively, the origin, the endpoint of g1, and
-    the endpoint of g2, this function computes the basis lattice vectors g1,g2, visualizes
-    them, and returns them.  To compute these vectors without visualizing, use
-    latticevectors.get_selected_lattice_vectors().
-
-    Returns:
-        if returnfig==False:    g1,g2
-        if returnfig==True      g1,g2,fig,ax
-    """
-    from py4DSTEM.process.latticevectors import get_selected_lattice_vectors
-
-    # Make the figure
-    fig,(ax1,ax2) = plt.subplots(1,2,figsize=figsize)
-    show(ar,figax=(fig,ax1),**kwargs)
-    show(ar,figax=(fig,ax2),**kwargs)
-
-    # Add indices to left panel
-    d = {'x':gx,'y':gy,'size':size_indices,'color':c_indices}
-    d0 = {'x':gx[i0],'y':gy[i0],'size':size_indices,'color':c0,'fontweight':'bold','labels':[str(i0)]}
-    d1 = {'x':gx[i1],'y':gy[i1],'size':size_indices,'color':c1,'fontweight':'bold','labels':[str(i1)]}
-    d2 = {'x':gx[i2],'y':gy[i2],'size':size_indices,'color':c2,'fontweight':'bold','labels':[str(i2)]}
-    add_pointlabels(ax1,d)
-    add_pointlabels(ax1,d0)
-    add_pointlabels(ax1,d1)
-    add_pointlabels(ax1,d2)
-
-    # Compute vectors
-    g1,g2 = get_selected_lattice_vectors(gx,gy,i0,i1,i2)
-
-    # Add vectors to right panel
-    dg1 = {'x0':gx[i0],'y0':gy[i0],'vx':g1[0],'vy':g1[1],'width':width_vectors,
-           'color':c_vectors,'label':r'$g_1$','labelsize':size_vectorlabels,'labelcolor':c_vectorlabels}
-    dg2 = {'x0':gx[i0],'y0':gy[i0],'vx':g2[0],'vy':g2[1],'width':width_vectors,
-           'color':c_vectors,'label':r'$g_2$','labelsize':size_vectorlabels,'labelcolor':c_vectorlabels}
-    add_vector(ax2,dg1)
-    add_vector(ax2,dg2)
-
-    if returnfig:
-        return g1,g2,fig,(ax1,ax2)
-    else:
-        plt.show()
-        return g1,g2
-
-
-def show_lattice_vectors(ar,x0,y0,g1,g2,color='r',width=1,labelsize=20,labelcolor='w',returnfig=False,**kwargs):
-    """ Adds the vectors g1,g2 to an image, with tail positions at (x0,y0).  g1 and g2 are 2-tuples (gx,gy).
-    """
-    fig,ax = show(ar,returnfig=True,**kwargs)
-
-    # Add vectors
-    dg1 = {'x0':x0,'y0':y0,'vx':g1[0],'vy':g1[1],'width':width,
-           'color':color,'label':r'$g_1$','labelsize':labelsize,'labelcolor':labelcolor}
-    dg2 = {'x0':x0,'y0':y0,'vx':g2[0],'vy':g2[1],'width':width,
-           'color':color,'label':r'$g_2$','labelsize':labelsize,'labelcolor':labelcolor}
-    add_vector(ax,dg1)
-    add_vector(ax,dg2)
-
-    if returnfig:
-        return fig,ax
-    else:
-        plt.show()
-        return
-
-
-def show_bragg_indexing(ar,braggdirections,voffset=5,hoffset=0,color='w',size=20,
-                        points=True,pointcolor='r',pointsize=50,returnfig=False,**kwargs):
-    """
-    Shows an array with an overlay describing the Bragg directions
-
-    Accepts:
-        ar                  (arrray) the image
-        bragg_directions    (PointList) the bragg scattering directions; must have coordinates
-                            'qx','qy','h', and 'k'. Optionally may also have 'l'.
-    """
-    assert isinstance(braggdirections,PointList)
-    for k in ('qx','qy','h','k'):
-        assert k in braggdirections.data.dtype.fields
-
-    fig,ax = show(ar,returnfig=True,**kwargs)
-    d = {'braggdirections':braggdirections,'voffset':voffset,'hoffset':hoffset,'color':color,
-         'size':size,'points':points,'pointsize':pointsize,'pointcolor':pointcolor}
-    add_bragg_index_labels(ax,d)
-
-    if returnfig:
-        return fig,ax
-    else:
-        plt.show()
-        return
-
-
 def show_max_peak_spacing(ar,spacing,braggdirections,color='g',lw=2,returnfig=False,**kwargs):
     """ Show a circle of radius `spacing` about each Bragg direction
     """
diff --git a/test/test_strain.py b/test/test_strain.py
index 5bfa0efd3..bc9b8b58c 100644
--- a/test/test_strain.py
+++ b/test/test_strain.py
@@ -27,5 +27,7 @@ def test_strainmap_instantiation(self):
         )
 
         assert(isinstance(strainmap, StrainMap))
+        assert(strainmap.calibration is not None)
+        assert(strainmap.calibration is strainmap.braggvectors.calibration)
 
 

From 884450d286d3b676122bd8c964193a3a9309e71e Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Thu, 13 Jul 2023 22:49:42 -0400
Subject: [PATCH 282/362] fix

---
 py4DSTEM/process/strain.py | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index 3088afa51..07dcb91bd 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -87,11 +87,13 @@ def reset_calstate(self):
         Resets the calibration state. This recomputes the BVM, and removes any computations
         this StrainMap instance has stored, which will need to be recomputed.
         """
-        del(
-            self.g0,
-            self.g1,
-            self.g2,
-        )
+        for attr in )
+            'g0',
+            'g1',
+            'g2',
+        ):
+            if hasattr(self,attr):
+                delattr(self,attr)
         self.calstate = self.braggvectors.calstate
         pass
 

From bb09061965ad6d36f1873143a67663579a2537d5 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 14 Jul 2023 06:18:46 -0700
Subject: [PATCH 283/362] fit lattice vectors

---
 py4DSTEM/process/latticevectors/fit.py   |  15 +-
 py4DSTEM/process/latticevectors/index.py |  65 ++++--
 py4DSTEM/process/strain.py               | 284 +++++++++++++++--------
 3 files changed, 244 insertions(+), 120 deletions(-)

diff --git a/py4DSTEM/process/latticevectors/fit.py b/py4DSTEM/process/latticevectors/fit.py
index 822ffdea5..fef72aca3 100644
--- a/py4DSTEM/process/latticevectors/fit.py
+++ b/py4DSTEM/process/latticevectors/fit.py
@@ -104,13 +104,22 @@ def fit_lattice_vectors_all_DPs(braggpeaks, x0=0, y0=0, minNumPeaks=5):
 
     # Make RealSlice to contain outputs
     slicelabels = ('x0','y0','g1x','g1y','g2x','g2y','error','mask')
-    g1g2_map = RealSlice(data=np.zeros((braggpeaks.shape[0],braggpeaks.shape[1],8)),
-                       slicelabels=slicelabels, name='g1g2_map')
+    g1g2_map = RealSlice(
+        data=np.zeros(
+            (8, braggpeaks.shape[0],braggpeaks.shape[1])
+            ),
+            slicelabels=slicelabels, name='g1g2_map'
+    )
 
     # Fit lattice vectors
     for (Rx, Ry) in tqdmnd(braggpeaks.shape[0],braggpeaks.shape[1]):
         braggpeaks_curr = braggpeaks.get_pointlist(Rx,Ry)
-        qx0,qy0,g1x,g1y,g2x,g2y,error = fit_lattice_vectors(braggpeaks_curr, x0, y0, minNumPeaks)
+        qx0,qy0,g1x,g1y,g2x,g2y,error = fit_lattice_vectors(
+            braggpeaks_curr, 
+            x0, 
+            y0, 
+            minNumPeaks
+        )
         # Store data
         if g1x is not None:
             g1g2_map.get_slice('x0').data[Rx,Ry] = qx0
diff --git a/py4DSTEM/process/latticevectors/index.py b/py4DSTEM/process/latticevectors/index.py
index cdf6b00fd..13d41d54c 100644
--- a/py4DSTEM/process/latticevectors/index.py
+++ b/py4DSTEM/process/latticevectors/index.py
@@ -80,6 +80,9 @@ def index_bragg_directions(x0, y0, gx, gy, g1, g2):
     temp_array = np.zeros([], dtype = coords)
     bragg_directions = PointList(data = temp_array)
     bragg_directions.add_data_by_field((gx,gy,h,k))
+    mask = np.zeros(bragg_directions['qx'].shape[0])
+    mask[0] = 1
+    bragg_directions.remove(mask)
 
     return h,k, bragg_directions
 
@@ -152,8 +155,14 @@ def generate_lattice(ux,uy,vx,vy,x0,y0,Q_Nx,Q_Ny,h_max=None,k_max=None):
 
     return ideal_lattice
 
-def add_indices_to_braggpeaks(braggpeaks, lattice, maxPeakSpacing, qx_shift=0,
-                              qy_shift=0, mask=None):
+def add_indices_to_braggvectors(
+    braggpeaks, 
+    lattice, 
+    maxPeakSpacing, 
+    qx_shift=0,
+    qy_shift=0, 
+    mask=None
+    ):
     """
     Using the peak positions (qx,qy) and indices (h,k) in the PointList lattice,
     identify the indices for each peak in the PointListArray braggpeaks.
@@ -181,43 +190,51 @@ def add_indices_to_braggpeaks(braggpeaks, lattice, maxPeakSpacing, qx_shift=0,
         'h', 'k', containing the indices of each indexable peak.
     """
 
-    assert isinstance(braggpeaks,PointListArray)
-    assert np.all([name in braggpeaks.dtype.names for name in ('qx','qy','intensity')])
-    assert isinstance(lattice, PointList)
-    assert np.all([name in lattice.dtype.names for name in ('qx','qy','h','k')])
+    # assert isinstance(braggpeaks,BraggVectors)
+    # assert isinstance(lattice, PointList)
+    # assert np.all([name in lattice.dtype.names for name in ('qx','qy','h','k')])
 
     if mask is None:
-        mask = np.ones(braggpeaks.shape,dtype=bool)
+        mask = np.ones(braggpeaks.Rshape,dtype=bool)
 
-    assert mask.shape == braggpeaks.shape, 'mask must have same shape as pointlistarray'
+    assert mask.shape == braggpeaks.Rshape, 'mask must have same shape as pointlistarray'
     assert mask.dtype == bool, 'mask must be boolean'
 
-    indexed_braggpeaks = braggpeaks.copy()
 
-    # add the coordinates if they don't exist
-    if not ('h' in braggpeaks.dtype.names):
-        indexed_braggpeaks = indexed_braggpeaks.add_fields([('h',int)])
-    if not ('k' in braggpeaks.dtype.names):
-        indexed_braggpeaks = indexed_braggpeaks.add_fields([('k',int)])
+    coords = [('qx',float),('qy',float),('intensity',float),('h',int),('k',int)]
+
+    indexed_braggpeaks = PointListArray(    
+        dtype = coords,
+        shape = braggpeaks.Rshape,
+    )
+
+    ellipse = braggpeaks.calstate["ellipse"]
 
     # loop over all the scan positions
     for Rx, Ry in tqdmnd(mask.shape[0],mask.shape[1]):
         if mask[Rx,Ry]:
-            pl = indexed_braggpeaks.get_pointlist(Rx,Ry)
-            rm_peak_mask = np.zeros(pl.length,dtype=bool)
-
-            for i in range(pl.length):
+            pl = braggpeaks.get_vectors(
+                scan_x=Rx,
+                scan_y=Ry,
+                center=True,
+                ellipse=ellipse,
+                pixel=False,
+                rotate=False
+            )
+            
+            for i in range(pl.data.shape[0]):
                 r2 = (pl.data['qx'][i]-lattice.data['qx'] + qx_shift)**2 + \
                      (pl.data['qy'][i]-lattice.data['qy'] + qy_shift)**2
                 ind = np.argmin(r2)
                 if r2[ind] <= maxPeakSpacing**2:
-                    pl.data['h'][i] = lattice.data['h'][ind]
-                    pl.data['k'][i] = lattice.data['k'][ind]
-                else:
-                    rm_peak_mask[i] = True
-            pl.remove(rm_peak_mask)
+                    indexed_braggpeaks[Rx,Ry].add_data_by_field((
+                        pl.data['qx'],
+                        pl.data['qy'],
+                        pl.data['intensity'],
+                        lattice.data['h'][ind],
+                        lattice.data['k'][ind]
+                        ))
 
-    indexed_braggpeaks.name = braggpeaks.name + "_indexed"
     return indexed_braggpeaks
 
 
diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index 07dcb91bd..ec10fe5f9 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -6,8 +6,8 @@
 from py4DSTEM.data import RealSlice, Data
 from py4DSTEM.braggvectors import BraggVectors
 from py4DSTEM.preprocess.utils import get_maxima_2D
-from py4DSTEM.visualize import show,add_pointlabels,add_vector
-
+from py4DSTEM.visualize import show,add_pointlabels,add_vector, add_bragg_index_labels
+from py4DSTEM import PointList
 
 class StrainMap(RealSlice,Data):
     """
@@ -62,7 +62,7 @@ def __init__(
         # if they differ, an error message and instructions for
         # re-calibration are issued
         self.calstate = self.braggvectors.calstate
-
+        assert self.calstate["center"], "braggvectors must be centered"
         # get the BVM
         # a new BVM using the current calstate is computed
         self.bvm = self.braggvectors.histogram()
@@ -87,7 +87,7 @@ def reset_calstate(self):
         Resets the calibration state. This recomputes the BVM, and removes any computations
         this StrainMap instance has stored, which will need to be recomputed.
         """
-        for attr in )
+        for attr in (
             'g0',
             'g1',
             'g2',
@@ -250,6 +250,7 @@ def choose_lattice_vectors(
         add_vector(ax2,dg2)
 
         # store vectors
+        self.g = g
         self.g0 = g0
         self.g1 = g1
         self.g2 = g2
@@ -263,75 +264,218 @@ def choose_lattice_vectors(
             return (fig,(ax1,ax2))
         else:
             return
+    
+    def fit_lattice_vectors(
+        self,
+        x0 = None,
+        y0 = None,
+        max_peak_spacing = 2,
+        mask = None,
+        plot = True,
+        vis_params = {},
+        returncalc = False,
+        ):
+        """
+        From an origin (x0,y0), a set of reciprocal lattice vectors gx,gy, and an pair of
+        lattice vectors g1=(g1x,g1y), g2=(g2x,g2y), find the indices (h,k) of all the
+        reciprocal lattice directions.
+
+        Args:
+            x0 : floagt
+                x-coord of origin
+            y0 : float
+                y-coord of origin
+            max_peak_spacing: float
+                Maximum distance from the ideal lattice points
+                to include a peak for indexing
+            mask: bool
+                Boolean mask, same shape as the pointlistarray, indicating which
+                locations should be indexed. This can be used to index different regions of
+                the scan with different lattices
+            plot:bool
+                plot results if tru
+            vis_params : dict
+                additional visualization parameters passed to `show`
+            returncalc : bool
+                if True, returns braggdirections, bragg_vectors_indexed, g1g2_map
+        """
+        # check the calstate
+        assert(self.calstate == self.braggvectors.calstate), "The calibration state has changed! To resync the calibration state, use `.reset_calstate`."
 
+        if x0 is None:
+            x0 = self.braggvectors.Qshape[0]/2
+        if y0 is None:
+            y0 = self.braggvectors.Qshape[0]/2
+
+        #index braggvectors
+        from py4DSTEM.process.latticevectors import index_bragg_directions
+        _, _, braggdirections = index_bragg_directions(
+            x0,
+            y0,
+            self.g['x'],
+            self.g['y'],
+            self.g1,
+            self.g2
+        )
 
+        self.braggdirections = braggdirections
+
+        if plot:
+            self.show_bragg_indexing(
+                self.bvm,
+                braggdirections = braggdirections,
+                points = True,
+                **vis_params,
+            )
+
+        #add indicies to braggvectors
+        from py4DSTEM.process.latticevectors import add_indices_to_braggvectors
+
+        bragg_vectors_indexed = add_indices_to_braggvectors(
+            self.braggvectors,
+            self.braggdirections,
+            maxPeakSpacing = max_peak_spacing,
+            qx_shift = self.braggvectors.Qshape[0]/2,
+            qy_shift = self.braggvectors.Qshape[1]/2,
+            mask = mask
+        )
 
+        self.bragg_vectors_indexed = bragg_vectors_indexed
 
+        #fit bragg vectors
+        from py4DSTEM.process.latticevectors import fit_lattice_vectors_all_DPs
+        g1g2_map = fit_lattice_vectors_all_DPs(
+            self.bragg_vectors_indexed
+        )
+        self.g1g2_map = g1g2_map
 
+        if returncalc:
+            braggdirections, bragg_vectors_indexed, g1g2_map
+    
+    def show_lattice_vectors(ar,x0,y0,g1,g2,color='r',width=1,labelsize=20,labelcolor='w',returnfig=False,**kwargs):
+        """ Adds the vectors g1,g2 to an image, with tail positions at (x0,y0).  g1 and g2 are 2-tuples (gx,gy).
+        """
+        fig,ax = show(ar,returnfig=True,**kwargs)
 
+        # Add vectors
+        dg1 = {'x0':x0,'y0':y0,'vx':g1[0],'vy':g1[1],'width':width,
+               'color':color,'label':r'$g_1$','labelsize':labelsize,'labelcolor':labelcolor}
+        dg2 = {'x0':x0,'y0':y0,'vx':g2[0],'vy':g2[1],'width':width,
+               'color':color,'label':r'$g_2$','labelsize':labelsize,'labelcolor':labelcolor}
+        add_vector(ax,dg1)
+        add_vector(ax,dg2)
+
+        if returnfig:
+            return fig,ax
+        else:
+            plt.show()
+            return
 
 
 
+    
 
+    def show_bragg_indexing(
+        self, 
+        ar,
+        braggdirections,
+        voffset=5,
+        hoffset=0,
+        color='w',
+        size=20,
+        points=True,
+        pointcolor='r',
+        pointsize=50,
+        returnfig=False,
+        **kwargs
+    ):
+        """
+        Shows an array with an overlay describing the Bragg directions
 
+        Accepts:
+            ar                  (arrray) the image
+            bragg_directions    (PointList) the bragg scattering directions; must have coordinates
+                                'qx','qy','h', and 'k'. Optionally may also have 'l'.
+        """
+        assert isinstance(braggdirections,PointList)
+        for k in ('qx','qy','h','k'):
+            assert k in braggdirections.data.dtype.fields
 
+        fig,ax = show(ar,returnfig=True,**kwargs)
+        d = {'braggdirections':braggdirections,'voffset':voffset,'hoffset':hoffset,'color':color,
+             'size':size,'points':points,'pointsize':pointsize,'pointcolor':pointcolor}
+        add_bragg_index_labels(ax,d)
 
+        if returnfig:
+            return fig,ax
+        else:
+            plt.show()
+            return
 
 
-def index_bragg_directions(x0, y0, gx, gy, g1, g2):
-    """
-    From an origin (x0,y0), a set of reciprocal lattice vectors gx,gy, and an pair of
-    lattice vectors g1=(g1x,g1y), g2=(g2x,g2y), find the indices (h,k) of all the
-    reciprocal lattice directions.
 
-    The approach is to solve the matrix equation
-            ``alpha = beta * M``
-    where alpha is the 2xN array of the (x,y) coordinates of N measured bragg directions,
-    beta is the 2x2 array of the two lattice vectors u,v, and M is the 2xN array of the
-    h,k indices.
 
-    Args:
-        x0 (float): x-coord of origin
-        y0 (float): y-coord of origin
-        gx (1d array): x-coord of the reciprocal lattice vectors
-        gy (1d array): y-coord of the reciprocal lattice vectors
-        g1 (2-tuple of floats): g1x,g1y
-        g2 (2-tuple of floats): g2x,g2y
 
-    Returns:
-        (3-tuple) A 3-tuple containing:
 
-            * **h**: *(ndarray of ints)* first index of the bragg directions
-            * **k**: *(ndarray of ints)* second index of the bragg directions
-            * **bragg_directions**: *(PointList)* a 4-coordinate PointList with the
-              indexed bragg directions; coords 'qx' and 'qy' contain bragg_x and bragg_y
-              coords 'h' and 'k' contain h and k.
-    """
-    # Get beta, the matrix of lattice vectors
-    beta = np.array([[g1[0],g2[0]],[g1[1],g2[1]]])
 
-    # Get alpha, the matrix of measured bragg angles
-    alpha = np.vstack([gx-x0,gy-y0])
 
-    # Calculate M, the matrix of peak positions
-    M = lstsq(beta, alpha, rcond=None)[0].T
-    M = np.round(M).astype(int)
 
-    # Get h,k
-    h = M[:,0]
-    k = M[:,1]
 
-    # Store in a PointList
-    coords = [('qx',float),('qy',float),('h',int),('k',int)]
-    temp_array = np.zeros([], dtype = coords)
-    bragg_directions = PointList(data = temp_array)
-    bragg_directions.add_data_by_field((gx,gy,h,k))
 
-    return h,k, bragg_directions
+# def index_bragg_directions(x0, y0, gx, gy, g1, g2):
+#     """
+#     From an origin (x0,y0), a set of reciprocal lattice vectors gx,gy, and an pair of
+#     lattice vectors g1=(g1x,g1y), g2=(g2x,g2y), find the indices (h,k) of all the
+#     reciprocal lattice directions.
 
+#     The approach is to solve the matrix equation
+#             ``alpha = beta * M``
+#     where alpha is the 2xN array of the (x,y) coordinates of N measured bragg directions,
+#     beta is the 2x2 array of the two lattice vectors u,v, and M is the 2xN array of the
+#     h,k indices.
 
+#     Args:
+#         x0 (float): x-coord of origin
+#         y0 (float): y-coord of origin
+#         gx (1d array): x-coord of the reciprocal lattice vectors
+#         gy (1d array): y-coord of the reciprocal lattice vectors
+#         g1 (2-tuple of floats): g1x,g1y
+#         g2 (2-tuple of floats): g2x,g2y
 
-def add_indices_to_braggpeaks(braggpeaks, lattice, maxPeakSpacing, qx_shift=0,
+#     Returns:
+#         (3-tuple) A 3-tuple containing:
+
+#             * **h**: *(ndarray of ints)* first index of the bragg directions
+#             * **k**: *(ndarray of ints)* second index of the bragg directions
+#             * **bragg_directions**: *(PointList)* a 4-coordinate PointList with the
+#               indexed bragg directions; coords 'qx' and 'qy' contain bragg_x and bragg_y
+#               coords 'h' and 'k' contain h and k.
+#     """
+#     # Get beta, the matrix of lattice vectors
+#     beta = np.array([[g1[0],g2[0]],[g1[1],g2[1]]])
+
+#     # Get alpha, the matrix of measured bragg angles
+#     alpha = np.vstack([gx-x0,gy-y0])
+
+#     # Calculate M, the matrix of peak positions
+#     M = lstsq(beta, alpha, rcond=None)[0].T
+#     M = np.round(M).astype(int)
+
+#     # Get h,k
+#     h = M[:,0]
+#     k = M[:,1]
+
+#     # Store in a PointList
+#     coords = [('qx',float),('qy',float),('h',int),('k',int)]
+#     temp_array = np.zeros([], dtype = coords)
+#     bragg_directions = PointList(data = temp_array)
+#     bragg_directions.add_data_by_field((gx,gy,h,k))
+
+#     return h,k, bragg_directions
+
+
+
+def add_indices_to_braggvectors(braggpeaks, lattice, maxPeakSpacing, qx_shift=0,
                               qy_shift=0, mask=None):
     """
     Using the peak positions (qx,qy) and indices (h,k) in the PointList lattice,
@@ -407,53 +551,7 @@ def add_indices_to_braggpeaks(braggpeaks, lattice, maxPeakSpacing, qx_shift=0,
 
 
 
-
-
-
-    def show_lattice_vectors(ar,x0,y0,g1,g2,color='r',width=1,labelsize=20,labelcolor='w',returnfig=False,**kwargs):
-        """ Adds the vectors g1,g2 to an image, with tail positions at (x0,y0).  g1 and g2 are 2-tuples (gx,gy).
-        """
-        fig,ax = show(ar,returnfig=True,**kwargs)
-
-        # Add vectors
-        dg1 = {'x0':x0,'y0':y0,'vx':g1[0],'vy':g1[1],'width':width,
-               'color':color,'label':r'$g_1$','labelsize':labelsize,'labelcolor':labelcolor}
-        dg2 = {'x0':x0,'y0':y0,'vx':g2[0],'vy':g2[1],'width':width,
-               'color':color,'label':r'$g_2$','labelsize':labelsize,'labelcolor':labelcolor}
-        add_vector(ax,dg1)
-        add_vector(ax,dg2)
-
-        if returnfig:
-            return fig,ax
-        else:
-            plt.show()
-            return
-
-
-    def show_bragg_indexing(ar,braggdirections,voffset=5,hoffset=0,color='w',size=20,
-                            points=True,pointcolor='r',pointsize=50,returnfig=False,**kwargs):
-        """
-        Shows an array with an overlay describing the Bragg directions
-
-        Accepts:
-            ar                  (arrray) the image
-            bragg_directions    (PointList) the bragg scattering directions; must have coordinates
-                                'qx','qy','h', and 'k'. Optionally may also have 'l'.
-        """
-        assert isinstance(braggdirections,PointList)
-        for k in ('qx','qy','h','k'):
-            assert k in braggdirections.data.dtype.fields
-
-        fig,ax = show(ar,returnfig=True,**kwargs)
-        d = {'braggdirections':braggdirections,'voffset':voffset,'hoffset':hoffset,'color':color,
-             'size':size,'points':points,'pointsize':pointsize,'pointcolor':pointcolor}
-        add_bragg_index_labels(ax,d)
-
-        if returnfig:
-            return fig,ax
-        else:
-            plt.show()
-            return
+    
 
 
 

From 4625d3987a5a7a09bb3ade371f6c778412310414 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 14 Jul 2023 06:38:29 -0700
Subject: [PATCH 284/362] small changes

---
 py4DSTEM/braggvectors/braggvector_methods.py | 6 +++---
 py4DSTEM/process/strain.py                   | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/py4DSTEM/braggvectors/braggvector_methods.py b/py4DSTEM/braggvectors/braggvector_methods.py
index 53f800ed1..8dd6abe76 100644
--- a/py4DSTEM/braggvectors/braggvector_methods.py
+++ b/py4DSTEM/braggvectors/braggvector_methods.py
@@ -687,7 +687,7 @@ def index_bragg_directions(
 
 
 
-    def add_indices_to_braggpeaks(
+    def add_indices_to_braggvectors(
         self,
         maxPeakSpacing,
         mask = None,
@@ -711,9 +711,9 @@ def add_indices_to_braggpeaks(
                 locations should be indexed. This can be used to index different regions of
                 the scan with different lattices
         """
-        from py4DSTEM.process.latticevectors import add_indices_to_braggpeaks
+        from py4DSTEM.process.latticevectors import add_indices_to_braggvectors
 
-        bragg_peaks_indexed = add_indices_to_braggpeaks(
+        bragg_peaks_indexed = add_indices_to_braggvectors(
             self.vectors,
             self.braggdirections,
             maxPeakSpacing = maxPeakSpacing,
diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index ec10fe5f9..76dbbbfb8 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -65,7 +65,7 @@ def __init__(
         assert self.calstate["center"], "braggvectors must be centered"
         # get the BVM
         # a new BVM using the current calstate is computed
-        self.bvm = self.braggvectors.histogram()
+        self.bvm = self.braggvectors.histogram( mode = 'cal')
 
 
 

From 70f0152ee54c548036becd4d35030aaae8a19f72 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 14 Jul 2023 08:38:11 -0700
Subject: [PATCH 285/362] fix calibration for bragg vectors

---
 py4DSTEM/process/latticevectors/index.py | 14 ++------------
 1 file changed, 2 insertions(+), 12 deletions(-)

diff --git a/py4DSTEM/process/latticevectors/index.py b/py4DSTEM/process/latticevectors/index.py
index 13d41d54c..e75ee09e1 100644
--- a/py4DSTEM/process/latticevectors/index.py
+++ b/py4DSTEM/process/latticevectors/index.py
@@ -208,20 +208,10 @@ def add_indices_to_braggvectors(
         shape = braggpeaks.Rshape,
     )
 
-    ellipse = braggpeaks.calstate["ellipse"]
-
     # loop over all the scan positions
     for Rx, Ry in tqdmnd(mask.shape[0],mask.shape[1]):
-        if mask[Rx,Ry]:
-            pl = braggpeaks.get_vectors(
-                scan_x=Rx,
-                scan_y=Ry,
-                center=True,
-                ellipse=ellipse,
-                pixel=False,
-                rotate=False
-            )
-            
+        if mask[Rx,Ry]: 
+            pl = braggpeaks.cal[Rx,Ry]
             for i in range(pl.data.shape[0]):
                 r2 = (pl.data['qx'][i]-lattice.data['qx'] + qx_shift)**2 + \
                      (pl.data['qy'][i]-lattice.data['qy'] + qy_shift)**2

From 5d973ea202e6931ed851add7ebe305d281065308 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 14 Jul 2023 09:17:24 -0700
Subject: [PATCH 286/362] strain!!!

---
 py4DSTEM/process/latticevectors/index.py  |  6 ++---
 py4DSTEM/process/latticevectors/strain.py | 11 +++++---
 py4DSTEM/process/strain.py                | 33 +++++++++++++++++++++++
 3 files changed, 43 insertions(+), 7 deletions(-)

diff --git a/py4DSTEM/process/latticevectors/index.py b/py4DSTEM/process/latticevectors/index.py
index e75ee09e1..189e7f10f 100644
--- a/py4DSTEM/process/latticevectors/index.py
+++ b/py4DSTEM/process/latticevectors/index.py
@@ -218,9 +218,9 @@ def add_indices_to_braggvectors(
                 ind = np.argmin(r2)
                 if r2[ind] <= maxPeakSpacing**2:
                     indexed_braggpeaks[Rx,Ry].add_data_by_field((
-                        pl.data['qx'],
-                        pl.data['qy'],
-                        pl.data['intensity'],
+                        pl.data['qx'][i],
+                        pl.data['qy'][i],
+                        pl.data['intensity'][i],
                         lattice.data['h'][ind],
                         lattice.data['k'][ind]
                         ))
diff --git a/py4DSTEM/process/latticevectors/strain.py b/py4DSTEM/process/latticevectors/strain.py
index 50b9bddc9..518f38885 100644
--- a/py4DSTEM/process/latticevectors/strain.py
+++ b/py4DSTEM/process/latticevectors/strain.py
@@ -71,9 +71,11 @@ def get_strain_from_reference_g1g2(g1g2_map, g1, g2):
 
     # Get RealSlice for output storage
     R_Nx,R_Ny = g1g2_map.get_slice('g1x').shape
-    strain_map = RealSlice(data=np.zeros((R_Nx,R_Ny,5)),
-                           slicelabels=('e_xx','e_yy','e_xy','theta','mask'),
-                           name='strain_map')
+    strain_map = RealSlice(
+        data=np.zeros((5, R_Nx, R_Ny)),
+        slicelabels=('e_xx','e_yy','e_xy','theta','mask'),
+        name='strain_map'
+    )
 
     # Get reference lattice matrix
     g1x,g1y = g1
@@ -130,7 +132,8 @@ def get_strain_from_reference_region(g1g2_map, mask):
         Note 1: the strain matrix has been symmetrized, so e_xy and e_yx are identical
     """
     assert isinstance(g1g2_map, RealSlice)
-    assert np.all([name in g1g2_map.slicelabels for name in ('g1x','g1y','g2x','g2y','mask')])
+    assert np.all(
+        [name in g1g2_map.slicelabels for name in ('g1x','g1y','g2x','g2y','mask')])
     assert mask.dtype == bool
 
     g1,g2 = get_reference_g1g2(g1g2_map,mask)
diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index 76dbbbfb8..c6a8fe88e 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -352,6 +352,39 @@ def fit_lattice_vectors(
         if returncalc:
             braggdirections, bragg_vectors_indexed, g1g2_map
     
+    def get_strain(
+        self,
+        mask = None,
+        returncalc = True
+        ):
+        """
+
+        """
+        if mask is None: 
+            mask = np.ones(self.g1g2_map.shape, dtype = "bool")
+
+        from py4DSTEM.process.latticevectors import get_strain_from_reference_region
+
+        strainmap_median_g1g2 = get_strain_from_reference_region(
+            self.g1g2_map,
+            mask = mask,
+        )
+
+        self.strainmap_median_g1g2 = strainmap_median_g1g2
+        from py4DSTEM.visualize import show_strain
+        show_strain(
+            strainmap_median_g1g2,
+            vrange_exx = [-2.0, 2.0],
+            vrange_theta = [-2.0, 2.0],
+            ticknumber = 3,
+            axes_plots = (),
+            bkgrd = False,
+            figsize = (14,4)
+        )
+        if returncalc:
+            return strainmap_median_g1g2
+
+    
     def show_lattice_vectors(ar,x0,y0,g1,g2,color='r',width=1,labelsize=20,labelcolor='w',returnfig=False,**kwargs):
         """ Adds the vectors g1,g2 to an image, with tail positions at (x0,y0).  g1 and g2 are 2-tuples (gx,gy).
         """

From 9174f0b1322465624e69529fc9f7b55a8672f01e Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Fri, 14 Jul 2023 12:19:37 -0400
Subject: [PATCH 287/362] bugfixes

---
 py4DSTEM/io/google_drive_downloader.py | 22 +++++++++++-----------
 test/test_nonnative_io/test_arina.py   |  2 +-
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/py4DSTEM/io/google_drive_downloader.py b/py4DSTEM/io/google_drive_downloader.py
index 69f4545f9..57a3b298b 100644
--- a/py4DSTEM/io/google_drive_downloader.py
+++ b/py4DSTEM/io/google_drive_downloader.py
@@ -84,47 +84,47 @@
         '1siH80-eRJwG5R6AnU4vkoqGWByrrEz1y'
     ),
     'test_arina_master' : (
-        'STO-STEM_bench_20us_master.h5',
+        'STO_STEM_bench_20us_master.h5',
         '1q_4IjFuWRkw5VM84NhxrNTdIq4563BOC'
     ),
     'test_arina_01' : (
-        'STO-STEM_bench_20us_000001.h5',
+        'STO_STEM_bench_20us_data_000001.h5',
         '1_3Dbm22-hV58iffwK9x-3vqJUsEXZBFQ'
     ),
     'test_arina_02' : (
-        'STO-STEM_bench_20us_000002.h5',
+        'STO_STEM_bench_20us_data_000002.h5',
         '1x29RzHLnCzP0qthLhA1kdlUQ09ENViR8'
     ),
     'test_arina_03' : (
-        'STO-STEM_bench_20us_000003.h5',
+        'STO_STEM_bench_20us_data_000003.h5',
         '1qsbzdEVD8gt4DYKnpwjfoS_Mg4ggObAA'
     ),
     'test_arina_04' : (
-        'STO-STEM_bench_20us_000004.h5',
+        'STO_STEM_bench_20us_data_000004.h5',
         '1Lcswld0Y9fNBk4-__C9iJbc854BuHq-h'
     ),
     'test_arina_05' : (
-        'STO-STEM_bench_20us_000005.h5',
+        'STO_STEM_bench_20us_data_000005.h5',
         '13YTO2ABsTK5nObEr7RjOZYCV3sEk3gt9'
     ),
     'test_arina_06' : (
-        'STO-STEM_bench_20us_000006.h5',
+        'STO_STEM_bench_20us_data_000006.h5',
         '1RywPXt6HRbCvjgjSuYFf60QHWlOPYXwy'
     ),
     'test_arina_07' : (
-        'STO-STEM_bench_20us_000007.h5',
+        'STO_STEM_bench_20us_data_000007.h5',
         '1GRoBecCvAUeSIujzsPywv1vXKSIsNyoT'
     ),
     'test_arina_08' : (
-        'STO-STEM_bench_20us_000008.h5',
+        'STO_STEM_bench_20us_data_000008.h5',
         '1sTFuuvgKbTjZz1lVUfkZbbTDTQmwqhuU'
     ),
     'test_arina_09' : (
-        'STO-STEM_bench_20us_000009.h5',
+        'STO_STEM_bench_20us_data_000009.h5',
         '1JmBiMg16iMVfZ5wz8z_QqcNPVRym1Ezh'
     ),
     'test_arina_10' : (
-        'STO-STEM_bench_20us_000010.h5',
+        'STO_STEM_bench_20us_data_000010.h5',
         '1_90xAfclNVwMWwQ-YKxNNwBbfR1nfHoB'
     ),
 }
diff --git a/test/test_nonnative_io/test_arina.py b/test/test_nonnative_io/test_arina.py
index bf9bf8e73..c27cb8ef5 100644
--- a/test/test_nonnative_io/test_arina.py
+++ b/test/test_nonnative_io/test_arina.py
@@ -4,7 +4,7 @@
 
 
 # Set filepaths
-filepath = join(py4DSTEM._TESTPATH, "test_arina/STO-STEM_bench_20us_master.h5")
+filepath = join(py4DSTEM._TESTPATH, "test_arina/STO_STEM_bench_20us_master.h5")
 
 
 def test_read_arina():

From b0e1ac613968a664294ead264ec1371b9f0db4fd Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 14 Jul 2023 09:28:21 -0700
Subject: [PATCH 288/362] cleaning up formatting

---
 py4DSTEM/process/strain.py | 468 ++++++++++++++++++++-----------------
 1 file changed, 249 insertions(+), 219 deletions(-)

diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index c6a8fe88e..afe00dba4 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -1,15 +1,17 @@
 # Defines the Strain class
 
-import numpy as np
-import matplotlib.pyplot as plt
 from typing import Optional
-from py4DSTEM.data import RealSlice, Data
+
+import matplotlib.pyplot as plt
+import numpy as np
+from py4DSTEM import PointList
 from py4DSTEM.braggvectors import BraggVectors
+from py4DSTEM.data import Data, RealSlice
 from py4DSTEM.preprocess.utils import get_maxima_2D
-from py4DSTEM.visualize import show,add_pointlabels,add_vector, add_bragg_index_labels
-from py4DSTEM import PointList
+from py4DSTEM.visualize import add_bragg_index_labels, add_pointlabels, add_vector, show
+
 
-class StrainMap(RealSlice,Data):
+class StrainMap(RealSlice, Data):
     """
     Stores strain map.
 
@@ -17,33 +19,26 @@ class StrainMap(RealSlice,Data):
 
     """
 
-    def __init__(
-        self,
-        braggvectors: BraggVectors,
-        name: Optional[str] = 'strainmap'
-        ):
+    def __init__(self, braggvectors: BraggVectors, name: Optional[str] = "strainmap"):
         """
         TODO
         """
-        assert(isinstance(braggvectors,BraggVectors)), f"braggvectors myst be BraggVectors, not type {type(braggvectors)}"
+        assert isinstance(
+            braggvectors, BraggVectors
+        ), f"braggvectors myst be BraggVectors, not type {type(braggvectors)}"
 
         # initialize as a RealSlice
         RealSlice.__init__(
             self,
-            name = name,
-            data = np.empty((
-                6,
-                braggvectors.Rshape[0],
-                braggvectors.Rshape[1],
-            )),
-            slicelabels = [
-                'exx',
-                'eyy',
-                'exy',
-                'theta',
-                'mask',
-                'error'
-            ]
+            name=name,
+            data=np.empty(
+                (
+                    6,
+                    braggvectors.Rshape[0],
+                    braggvectors.Rshape[1],
+                )
+            ),
+            slicelabels=["exx", "eyy", "exy", "theta", "mask", "error"],
         )
 
         # set up braggvectors
@@ -65,22 +60,24 @@ def __init__(
         assert self.calstate["center"], "braggvectors must be centered"
         # get the BVM
         # a new BVM using the current calstate is computed
-        self.bvm = self.braggvectors.histogram( mode = 'cal')
-
-
+        self.bvm = self.braggvectors.histogram(mode="cal")
 
     # braggvector properties
 
     @property
     def braggvectors(self):
         return self._braggvectors
+
     @braggvectors.setter
-    def braggvectors(self,x):
-        assert(isinstance(x,BraggVectors)), f".braggvectors must be BraggVectors, not type {type(x)}"
-        assert(x.calibration.origin is not None), f"braggvectors must have a calibrated origin"
+    def braggvectors(self, x):
+        assert isinstance(
+            x, BraggVectors
+        ), f".braggvectors must be BraggVectors, not type {type(x)}"
+        assert (
+            x.calibration.origin is not None
+        ), f"braggvectors must have a calibrated origin"
         self._braggvectors = x
-        self._braggvectors.tree(self,force=True)
-
+        self._braggvectors.tree(self, force=True)
 
     def reset_calstate(self):
         """
@@ -88,17 +85,15 @@ def reset_calstate(self):
         this StrainMap instance has stored, which will need to be recomputed.
         """
         for attr in (
-            'g0',
-            'g1',
-            'g2',
+            "g0",
+            "g1",
+            "g2",
         ):
-            if hasattr(self,attr):
-                delattr(self,attr)
+            if hasattr(self, attr):
+                delattr(self, attr)
         self.calstate = self.braggvectors.calstate
         pass
 
-
-
     # Class methods
 
     def choose_lattice_vectors(
@@ -106,8 +101,8 @@ def choose_lattice_vectors(
         index_g0,
         index_g1,
         index_g2,
-        subpixel = 'multicorr',
-        upsample_factor = 16,
+        subpixel="multicorr",
+        upsample_factor=16,
         sigma=0,
         minAbsoluteIntensity=0,
         minRelativeIntensity=0,
@@ -115,20 +110,20 @@ def choose_lattice_vectors(
         minSpacing=0,
         edgeBoundary=1,
         maxNumPeaks=10,
-        figsize=(12,6),
-        c_indices='lightblue',
-        c0='g',
-        c1='r',
-        c2='r',
-        c_vectors='r',
-        c_vectorlabels='w',
+        figsize=(12, 6),
+        c_indices="lightblue",
+        c0="g",
+        c1="r",
+        c2="r",
+        c_vectors="r",
+        c_vectorlabels="w",
         size_indices=20,
         width_vectors=1,
         size_vectorlabels=20,
-        vis_params = {},
-        returncalc = False,
+        vis_params={},
+        returncalc=False,
         returnfig=False,
-        ):
+    ):
         """
         Choose which lattice vectors to use for strain mapping.
 
@@ -195,59 +190,97 @@ def choose_lattice_vectors(
         (optional) : None or (g0,g1,g2) or (fig,(ax1,ax2)) or both of the latter
         """
         # validate inputs
-        for i in (index_g0,index_g1,index_g2):
-            assert isinstance(i,(int,np.integer)), "indices must be integers!"
+        for i in (index_g0, index_g1, index_g2):
+            assert isinstance(i, (int, np.integer)), "indices must be integers!"
         # check the calstate
-        assert(self.calstate == self.braggvectors.calstate), "The calibration state has changed! To resync the calibration state, use `.reset_calstate`."
+        assert (
+            self.calstate == self.braggvectors.calstate
+        ), "The calibration state has changed! To resync the calibration state, use `.reset_calstate`."
 
         # find the maxima
         g = get_maxima_2D(
             self.bvm.data,
-            subpixel = subpixel,
-            upsample_factor = upsample_factor,
-            sigma = sigma,
-            minAbsoluteIntensity = minAbsoluteIntensity,
-            minRelativeIntensity = minRelativeIntensity,
-            relativeToPeak = relativeToPeak,
-            minSpacing = minSpacing,
-            edgeBoundary = edgeBoundary,
-            maxNumPeaks = maxNumPeaks,
+            subpixel=subpixel,
+            upsample_factor=upsample_factor,
+            sigma=sigma,
+            minAbsoluteIntensity=minAbsoluteIntensity,
+            minRelativeIntensity=minRelativeIntensity,
+            relativeToPeak=relativeToPeak,
+            minSpacing=minSpacing,
+            edgeBoundary=edgeBoundary,
+            maxNumPeaks=maxNumPeaks,
         )
 
         # get the lattice vectors
-        gx,gy = g['x'],g['y']
-        g0 = gx[index_g0],gy[index_g0]
+        gx, gy = g["x"], g["y"]
+        g0 = gx[index_g0], gy[index_g0]
         g1x = gx[index_g1] - g0[0]
         g1y = gy[index_g1] - g0[1]
         g2x = gx[index_g2] - g0[0]
         g2y = gy[index_g2] - g0[1]
-        g1,g2 = (g1x,g1y),(g2x,g2y)
+        g1, g2 = (g1x, g1y), (g2x, g2y)
 
         # make the figure
-        fig,(ax1,ax2) = plt.subplots(1,2,figsize=figsize)
-        show(self.bvm.data,figax=(fig,ax1),**vis_params)
-        show(self.bvm.data,figax=(fig,ax2),**vis_params)
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=figsize)
+        show(self.bvm.data, figax=(fig, ax1), **vis_params)
+        show(self.bvm.data, figax=(fig, ax2), **vis_params)
 
         # Add indices to left panel
-        d = {'x':gx,'y':gy,'size':size_indices,'color':c_indices}
-        d0 = {'x':gx[index_g0],'y':gy[index_g0],'size':size_indices,
-              'color':c0,'fontweight':'bold','labels':[str(index_g0)]}
-        d1 = {'x':gx[index_g1],'y':gy[index_g1],'size':size_indices,
-              'color':c1,'fontweight':'bold','labels':[str(index_g1)]}
-        d2 = {'x':gx[index_g2],'y':gy[index_g2],'size':size_indices,
-              'color':c2,'fontweight':'bold','labels':[str(index_g2)]}
-        add_pointlabels(ax1,d)
-        add_pointlabels(ax1,d0)
-        add_pointlabels(ax1,d1)
-        add_pointlabels(ax1,d2)
+        d = {"x": gx, "y": gy, "size": size_indices, "color": c_indices}
+        d0 = {
+            "x": gx[index_g0],
+            "y": gy[index_g0],
+            "size": size_indices,
+            "color": c0,
+            "fontweight": "bold",
+            "labels": [str(index_g0)],
+        }
+        d1 = {
+            "x": gx[index_g1],
+            "y": gy[index_g1],
+            "size": size_indices,
+            "color": c1,
+            "fontweight": "bold",
+            "labels": [str(index_g1)],
+        }
+        d2 = {
+            "x": gx[index_g2],
+            "y": gy[index_g2],
+            "size": size_indices,
+            "color": c2,
+            "fontweight": "bold",
+            "labels": [str(index_g2)],
+        }
+        add_pointlabels(ax1, d)
+        add_pointlabels(ax1, d0)
+        add_pointlabels(ax1, d1)
+        add_pointlabels(ax1, d2)
 
         # Add vectors to right panel
-        dg1 = {'x0':gx[index_g0],'y0':gy[index_g0],'vx':g1[0],'vy':g1[1],'width':width_vectors,
-               'color':c_vectors,'label':r'$g_1$','labelsize':size_vectorlabels,'labelcolor':c_vectorlabels}
-        dg2 = {'x0':gx[index_g0],'y0':gy[index_g0],'vx':g2[0],'vy':g2[1],'width':width_vectors,
-               'color':c_vectors,'label':r'$g_2$','labelsize':size_vectorlabels,'labelcolor':c_vectorlabels}
-        add_vector(ax2,dg1)
-        add_vector(ax2,dg2)
+        dg1 = {
+            "x0": gx[index_g0],
+            "y0": gy[index_g0],
+            "vx": g1[0],
+            "vy": g1[1],
+            "width": width_vectors,
+            "color": c_vectors,
+            "label": r"$g_1$",
+            "labelsize": size_vectorlabels,
+            "labelcolor": c_vectorlabels,
+        }
+        dg2 = {
+            "x0": gx[index_g0],
+            "y0": gy[index_g0],
+            "vx": g2[0],
+            "vy": g2[1],
+            "width": width_vectors,
+            "color": c_vectors,
+            "label": r"$g_2$",
+            "labelsize": size_vectorlabels,
+            "labelcolor": c_vectorlabels,
+        }
+        add_vector(ax2, dg1)
+        add_vector(ax2, dg2)
 
         # store vectors
         self.g = g
@@ -257,24 +290,24 @@ def choose_lattice_vectors(
 
         # return
         if returncalc and returnfig:
-            return (g0,g1,g2),(fig,(ax1,ax2))
+            return (g0, g1, g2), (fig, (ax1, ax2))
         elif returncalc:
-            return (g0,g1,g2)
+            return (g0, g1, g2)
         elif returnfig:
-            return (fig,(ax1,ax2))
+            return (fig, (ax1, ax2))
         else:
             return
-    
+
     def fit_lattice_vectors(
         self,
-        x0 = None,
-        y0 = None,
-        max_peak_spacing = 2,
-        mask = None,
-        plot = True,
-        vis_params = {},
-        returncalc = False,
-        ):
+        x0=None,
+        y0=None,
+        max_peak_spacing=2,
+        mask=None,
+        plot=True,
+        vis_params={},
+        returncalc=False,
+    ):
         """
         From an origin (x0,y0), a set of reciprocal lattice vectors gx,gy, and an pair of
         lattice vectors g1=(g1x,g1y), g2=(g2x,g2y), find the indices (h,k) of all the
@@ -300,22 +333,20 @@ def fit_lattice_vectors(
                 if True, returns braggdirections, bragg_vectors_indexed, g1g2_map
         """
         # check the calstate
-        assert(self.calstate == self.braggvectors.calstate), "The calibration state has changed! To resync the calibration state, use `.reset_calstate`."
+        assert (
+            self.calstate == self.braggvectors.calstate
+        ), "The calibration state has changed! To resync the calibration state, use `.reset_calstate`."
 
         if x0 is None:
-            x0 = self.braggvectors.Qshape[0]/2
+            x0 = self.braggvectors.Qshape[0] / 2
         if y0 is None:
-            y0 = self.braggvectors.Qshape[0]/2
+            y0 = self.braggvectors.Qshape[0] / 2
 
-        #index braggvectors
+        # index braggvectors
         from py4DSTEM.process.latticevectors import index_bragg_directions
+
         _, _, braggdirections = index_bragg_directions(
-            x0,
-            y0,
-            self.g['x'],
-            self.g['y'],
-            self.g1,
-            self.g2
+            x0, y0, self.g["x"], self.g["y"], self.g1, self.g2
         )
 
         self.braggdirections = braggdirections
@@ -323,104 +354,122 @@ def fit_lattice_vectors(
         if plot:
             self.show_bragg_indexing(
                 self.bvm,
-                braggdirections = braggdirections,
-                points = True,
+                braggdirections=braggdirections,
+                points=True,
                 **vis_params,
             )
 
-        #add indicies to braggvectors
+        # add indicies to braggvectors
         from py4DSTEM.process.latticevectors import add_indices_to_braggvectors
 
         bragg_vectors_indexed = add_indices_to_braggvectors(
             self.braggvectors,
             self.braggdirections,
-            maxPeakSpacing = max_peak_spacing,
-            qx_shift = self.braggvectors.Qshape[0]/2,
-            qy_shift = self.braggvectors.Qshape[1]/2,
-            mask = mask
+            maxPeakSpacing=max_peak_spacing,
+            qx_shift=self.braggvectors.Qshape[0] / 2,
+            qy_shift=self.braggvectors.Qshape[1] / 2,
+            mask=mask,
         )
 
         self.bragg_vectors_indexed = bragg_vectors_indexed
 
-        #fit bragg vectors
+        # fit bragg vectors
         from py4DSTEM.process.latticevectors import fit_lattice_vectors_all_DPs
-        g1g2_map = fit_lattice_vectors_all_DPs(
-            self.bragg_vectors_indexed
-        )
+
+        g1g2_map = fit_lattice_vectors_all_DPs(self.bragg_vectors_indexed)
         self.g1g2_map = g1g2_map
 
         if returncalc:
             braggdirections, bragg_vectors_indexed, g1g2_map
-    
-    def get_strain(
-        self,
-        mask = None,
-        returncalc = True
-        ):
-        """
 
-        """
-        if mask is None: 
-            mask = np.ones(self.g1g2_map.shape, dtype = "bool")
+    def get_strain(self, mask=None, returncalc=True):
+        """ """
+        if mask is None:
+            mask = np.ones(self.g1g2_map.shape, dtype="bool")
 
         from py4DSTEM.process.latticevectors import get_strain_from_reference_region
 
         strainmap_median_g1g2 = get_strain_from_reference_region(
             self.g1g2_map,
-            mask = mask,
+            mask=mask,
         )
 
         self.strainmap_median_g1g2 = strainmap_median_g1g2
         from py4DSTEM.visualize import show_strain
+
         show_strain(
             strainmap_median_g1g2,
-            vrange_exx = [-2.0, 2.0],
-            vrange_theta = [-2.0, 2.0],
-            ticknumber = 3,
-            axes_plots = (),
-            bkgrd = False,
-            figsize = (14,4)
+            vrange_exx=[-2.0, 2.0],
+            vrange_theta=[-2.0, 2.0],
+            ticknumber=3,
+            axes_plots=(),
+            bkgrd=False,
+            figsize=(14, 4),
         )
         if returncalc:
             return strainmap_median_g1g2
 
-    
-    def show_lattice_vectors(ar,x0,y0,g1,g2,color='r',width=1,labelsize=20,labelcolor='w',returnfig=False,**kwargs):
-        """ Adds the vectors g1,g2 to an image, with tail positions at (x0,y0).  g1 and g2 are 2-tuples (gx,gy).
-        """
-        fig,ax = show(ar,returnfig=True,**kwargs)
+    def show_lattice_vectors(
+        ar,
+        x0,
+        y0,
+        g1,
+        g2,
+        color="r",
+        width=1,
+        labelsize=20,
+        labelcolor="w",
+        returnfig=False,
+        **kwargs,
+    ):
+        """Adds the vectors g1,g2 to an image, with tail positions at (x0,y0).  g1 and g2 are 2-tuples (gx,gy)."""
+        fig, ax = show(ar, returnfig=True, **kwargs)
 
         # Add vectors
-        dg1 = {'x0':x0,'y0':y0,'vx':g1[0],'vy':g1[1],'width':width,
-               'color':color,'label':r'$g_1$','labelsize':labelsize,'labelcolor':labelcolor}
-        dg2 = {'x0':x0,'y0':y0,'vx':g2[0],'vy':g2[1],'width':width,
-               'color':color,'label':r'$g_2$','labelsize':labelsize,'labelcolor':labelcolor}
-        add_vector(ax,dg1)
-        add_vector(ax,dg2)
+        dg1 = {
+            "x0": x0,
+            "y0": y0,
+            "vx": g1[0],
+            "vy": g1[1],
+            "width": width,
+            "color": color,
+            "label": r"$g_1$",
+            "labelsize": labelsize,
+            "labelcolor": labelcolor,
+        }
+        dg2 = {
+            "x0": x0,
+            "y0": y0,
+            "vx": g2[0],
+            "vy": g2[1],
+            "width": width,
+            "color": color,
+            "label": r"$g_2$",
+            "labelsize": labelsize,
+            "labelcolor": labelcolor,
+        }
+        add_vector(ax, dg1)
+        add_vector(ax, dg2)
 
         if returnfig:
-            return fig,ax
+            return fig, ax
         else:
             plt.show()
             return
 
-
-
-    
-
     def show_bragg_indexing(
-        self, 
+        self,
         ar,
         braggdirections,
         voffset=5,
         hoffset=0,
-        color='w',
+        color="w",
         size=20,
         points=True,
-        pointcolor='r',
+        pointcolor="r",
         pointsize=50,
         returnfig=False,
-        **kwargs
+        **kwargs,
     ):
         """
         Shows an array with an overlay describing the Bragg directions
@@ -430,31 +479,30 @@ def show_bragg_indexing(
             bragg_directions    (PointList) the bragg scattering directions; must have coordinates
                                 'qx','qy','h', and 'k'. Optionally may also have 'l'.
         """
-        assert isinstance(braggdirections,PointList)
-        for k in ('qx','qy','h','k'):
+        assert isinstance(braggdirections, PointList)
+        for k in ("qx", "qy", "h", "k"):
             assert k in braggdirections.data.dtype.fields
 
-        fig,ax = show(ar,returnfig=True,**kwargs)
-        d = {'braggdirections':braggdirections,'voffset':voffset,'hoffset':hoffset,'color':color,
-             'size':size,'points':points,'pointsize':pointsize,'pointcolor':pointcolor}
-        add_bragg_index_labels(ax,d)
+        fig, ax = show(ar, returnfig=True, **kwargs)
+        d = {
+            "braggdirections": braggdirections,
+            "voffset": voffset,
+            "hoffset": hoffset,
+            "color": color,
+            "size": size,
+            "points": points,
+            "pointsize": pointsize,
+            "pointcolor": pointcolor,
+        }
+        add_bragg_index_labels(ax, d)
 
         if returnfig:
-            return fig,ax
+            return fig, ax
         else:
             plt.show()
             return
 
 
-
-
-
-
-
-
-
-
-
 # def index_bragg_directions(x0, y0, gx, gy, g1, g2):
 #     """
 #     From an origin (x0,y0), a set of reciprocal lattice vectors gx,gy, and an pair of
@@ -507,9 +555,9 @@ def show_bragg_indexing(
 #     return h,k, bragg_directions
 
 
-
-def add_indices_to_braggvectors(braggpeaks, lattice, maxPeakSpacing, qx_shift=0,
-                              qy_shift=0, mask=None):
+def add_indices_to_braggvectors(
+    braggpeaks, lattice, maxPeakSpacing, qx_shift=0, qy_shift=0, mask=None
+):
     """
     Using the peak positions (qx,qy) and indices (h,k) in the PointList lattice,
     identify the indices for each peak in the PointListArray braggpeaks.
@@ -537,38 +585,41 @@ def add_indices_to_braggvectors(braggpeaks, lattice, maxPeakSpacing, qx_shift=0,
         'h', 'k', containing the indices of each indexable peak.
     """
 
-    assert isinstance(braggpeaks,PointListArray)
-    assert np.all([name in braggpeaks.dtype.names for name in ('qx','qy','intensity')])
+    assert isinstance(braggpeaks, PointListArray)
+    assert np.all(
+        [name in braggpeaks.dtype.names for name in ("qx", "qy", "intensity")]
+    )
     assert isinstance(lattice, PointList)
-    assert np.all([name in lattice.dtype.names for name in ('qx','qy','h','k')])
+    assert np.all([name in lattice.dtype.names for name in ("qx", "qy", "h", "k")])
 
     if mask is None:
-        mask = np.ones(braggpeaks.shape,dtype=bool)
+        mask = np.ones(braggpeaks.shape, dtype=bool)
 
-    assert mask.shape == braggpeaks.shape, 'mask must have same shape as pointlistarray'
-    assert mask.dtype == bool, 'mask must be boolean'
+    assert mask.shape == braggpeaks.shape, "mask must have same shape as pointlistarray"
+    assert mask.dtype == bool, "mask must be boolean"
 
     indexed_braggpeaks = braggpeaks.copy()
 
     # add the coordinates if they don't exist
-    if not ('h' in braggpeaks.dtype.names):
-        indexed_braggpeaks = indexed_braggpeaks.add_fields([('h',int)])
-    if not ('k' in braggpeaks.dtype.names):
-        indexed_braggpeaks = indexed_braggpeaks.add_fields([('k',int)])
+    if not ("h" in braggpeaks.dtype.names):
+        indexed_braggpeaks = indexed_braggpeaks.add_fields([("h", int)])
+    if not ("k" in braggpeaks.dtype.names):
+        indexed_braggpeaks = indexed_braggpeaks.add_fields([("k", int)])
 
     # loop over all the scan positions
-    for Rx, Ry in tqdmnd(mask.shape[0],mask.shape[1]):
-        if mask[Rx,Ry]:
-            pl = indexed_braggpeaks.get_pointlist(Rx,Ry)
-            rm_peak_mask = np.zeros(pl.length,dtype=bool)
+    for Rx, Ry in tqdmnd(mask.shape[0], mask.shape[1]):
+        if mask[Rx, Ry]:
+            pl = indexed_braggpeaks.get_pointlist(Rx, Ry)
+            rm_peak_mask = np.zeros(pl.length, dtype=bool)
 
             for i in range(pl.length):
-                r2 = (pl.data['qx'][i]-lattice.data['qx'] + qx_shift)**2 + \
-                     (pl.data['qy'][i]-lattice.data['qy'] + qy_shift)**2
+                r2 = (pl.data["qx"][i] - lattice.data["qx"] + qx_shift) ** 2 + (
+                    pl.data["qy"][i] - lattice.data["qy"] + qy_shift
+                ) ** 2
                 ind = np.argmin(r2)
                 if r2[ind] <= maxPeakSpacing**2:
-                    pl.data['h'][i] = lattice.data['h'][ind]
-                    pl.data['k'][i] = lattice.data['k'][ind]
+                    pl.data["h"][i] = lattice.data["h"][ind]
+                    pl.data["k"][i] = lattice.data["k"][ind]
                 else:
                     rm_peak_mask[i] = True
             pl.remove(rm_peak_mask)
@@ -576,40 +627,19 @@ def add_indices_to_braggvectors(braggpeaks, lattice, maxPeakSpacing, qx_shift=0,
     indexed_braggpeaks.name = braggpeaks.name + "_indexed"
     return indexed_braggpeaks
 
-
-
-
-
-
-
-
-
-    
-
-
-
-
-
-
-
-
-
     # IO methods
 
     # TODO - copy method
 
     # read
     @classmethod
-    def _get_constructor_args(cls,group):
+    def _get_constructor_args(cls, group):
         """
         Returns a dictionary of args/values to pass to the class constructor
         """
         ar_constr_args = RealSlice._get_constructor_args(group)
         args = {
-            'data' : ar_constr_args['data'],
-            'name' : ar_constr_args['name'],
+            "data": ar_constr_args["data"],
+            "name": ar_constr_args["name"],
         }
         return args
-
-
-

From 0d5ba337f4f6a9702335777317c50ae47837a3c3 Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Fri, 14 Jul 2023 09:32:15 -0700
Subject: [PATCH 289/362] Update defaults for polar fits

---
 py4DSTEM/process/polar/polar_fits.py | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/py4DSTEM/process/polar/polar_fits.py b/py4DSTEM/process/polar/polar_fits.py
index ad418939f..a9da2fe2a 100644
--- a/py4DSTEM/process/polar/polar_fits.py
+++ b/py4DSTEM/process/polar/polar_fits.py
@@ -7,8 +7,8 @@
 
 def fit_amorphous_ring(
     im,
-    center,
-    radial_range,
+    center = None,
+    radial_range = None,
     coefs = None,
     show_fit_mask = False,
     verbose = False,
@@ -27,9 +27,11 @@ def fit_amorphous_ring(
     im: np.array
         2D image array to perform fitting on
     center: np.array
-        (x,y) center coordinates for fitting mask
+        (x,y) center coordinates for fitting mask. If not specified 
+        by the user, we will assume the center coordinate is (im.shape-1)/2.
     radial_range: np.array
-        (radius_inner, radius_outer) radial range to perform fitting over
+        (radius_inner, radius_outer) radial range to perform fitting over.
+        If not specified by the user, we will assume (im.shape[0]/4,im.shape[0]/2).
     show_fit_mask: bool
         Set to true to preview the fitting mask and initial guess for the ellipse params
     verbose: bool
@@ -53,6 +55,14 @@ def fit_amorphous_ring(
         11 parameter elliptic fit coefficients
     """
 
+    # Default values
+    if center is None:
+        center = np.array((
+            (im.shape[0]-1)/2,
+            (im.shape[1]-1)/2))
+    if radial_range is None:
+        radial_range = (im.shape[0]/4, im.shape[0]/2)
+
     # coordinates
     xa,ya = np.meshgrid(
         np.arange(im.shape[0]),

From 0609c6ad7d55ea882b9f3ca3f782aea186b384dc Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 14 Jul 2023 10:11:38 -0700
Subject: [PATCH 290/362] working on strain plotting

---
 py4DSTEM/process/strain.py | 36 +++++++++++++++++++++++++++---------
 1 file changed, 27 insertions(+), 9 deletions(-)

diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index afe00dba4..a275f9e6b 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -382,7 +382,12 @@ def fit_lattice_vectors(
         if returncalc:
             braggdirections, bragg_vectors_indexed, g1g2_map
 
-    def get_strain(self, mask=None, returncalc=True):
+    def get_strain(
+        self, 
+        mask=None,
+        returncalc=False,
+        **kwargs
+    ):
         """ """
         if mask is None:
             mask = np.ones(self.g1g2_map.shape, dtype="bool")
@@ -395,17 +400,30 @@ def get_strain(self, mask=None, returncalc=True):
         )
 
         self.strainmap_median_g1g2 = strainmap_median_g1g2
+        
         from py4DSTEM.visualize import show_strain
-
-        show_strain(
+        figsize = kwargs.pop("figsize", (14, 4))
+        vrange_exx = kwargs.pop("vrange_exx", [-2.0, 2.0])
+        vrange_theta = kwargs.pop("vrange_theta", [-2.0, 2.0])
+        ticknumber = kwargs.pop("ticknumber", 3)
+        bkgrd = kwargs.pop("bkgrd", False) 
+        axes_plots = kwargs.pop("axes_plots",())
+
+        fig, ax = show_strain(
             strainmap_median_g1g2,
-            vrange_exx=[-2.0, 2.0],
-            vrange_theta=[-2.0, 2.0],
-            ticknumber=3,
-            axes_plots=(),
-            bkgrd=False,
-            figsize=(14, 4),
+            vrange_exx=vrange_exx,
+            vrange_theta=vrange_theta,
+            ticknumber=ticknumber,
+            axes_plots=axes_plots,
+            bkgrd=bkgrd,
+            figsize=figsize,
+            **kwargs,
+            returnfig = True,
         )
+
+        if not np.all(mask == True): 
+            for axs in ax.flatten():
+                axs.imshow(mask, alpha = 0.2, cmap = "binary")
         if returncalc:
             return strainmap_median_g1g2
 

From aa75d529352afb88823494d31443066cd2e92dad Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Fri, 14 Jul 2023 14:05:26 -0400
Subject: [PATCH 291/362] autoupdate braggvects calstate

---
 py4DSTEM/braggvectors/braggvectors.py | 27 +++++++--------------------
 py4DSTEM/data/calibration.py          |  7 ++++---
 2 files changed, 11 insertions(+), 23 deletions(-)

diff --git a/py4DSTEM/braggvectors/braggvectors.py b/py4DSTEM/braggvectors/braggvectors.py
index 0bd87bbcb..e3173e466 100644
--- a/py4DSTEM/braggvectors/braggvectors.py
+++ b/py4DSTEM/braggvectors/braggvectors.py
@@ -239,6 +239,13 @@ def setcal(
             print('current calibration state: ', self.calstate)
         pass
 
+    def calibrate(self):
+        """
+        Autoupdate the calstate when relevant calibrations are set
+        """
+        self.setcal()
+
+
 
     # vector getter method
 
@@ -281,26 +288,6 @@ def get_vectors(
         )
         return BVects(ans)
 
-    def get_vectors_calibrated(
-        self,
-        scan_x,
-        scan_y,
-        ):
-        """
-        Returns the calibrated bragg vectors at the specified scan position.
-        """
-        ans = self._v_uncal[scan_x,scan_y].data
-        ans = self.cal._transform(
-            data = ans,
-            cal = self.calibration,
-            scanxy = (scan_x,scan_y),
-            center = True,
-            ellipse = True,
-            pixel = True,
-            rotate = True,
-        )
-        return BVects(ans)
-
 
     # copy
     def copy(self, name=None):
diff --git a/py4DSTEM/data/calibration.py b/py4DSTEM/data/calibration.py
index 6077864f3..b5ef200d8 100644
--- a/py4DSTEM/data/calibration.py
+++ b/py4DSTEM/data/calibration.py
@@ -64,8 +64,8 @@ class Calibration(Metadata):
         theta,                                        *
         p_ellipse,                                    *
         ellipse,                                      *
-        QR_rotation_degrees,
-        QR_flip,
+        QR_rotation_degrees,                          *
+        QR_flip,                                      *
         QR_rotflip,                                   *
         probe_semiangle,
         probe_param,
@@ -598,17 +598,18 @@ def ellipse(self,x):
 
     # Q/R-space rotation and flip
 
+    @call_calibrate
     def set_QR_rotation_degrees(self,x):
         self._params['QR_rotation_degrees'] = x
     def get_QR_rotation_degrees(self):
         return self._get_value('QR_rotation_degrees')
 
+    @call_calibrate
     def set_QR_flip(self,x):
         self._params['QR_flip'] = x
     def get_QR_flip(self):
         return self._get_value('QR_flip')
 
-    @call_calibrate
     def set_QR_rotflip(self, rot_flip):
         """
         Args:

From 61cc2f19c48be531fdb81a120fbb28aaf3eff8bb Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 14 Jul 2023 11:39:16 -0700
Subject: [PATCH 292/362] strain mapping functions

---
 py4DSTEM/braggvectors/braggvector_methods.py | 350 +++++++++----------
 py4DSTEM/process/latticevectors/strain.py    |  20 +-
 py4DSTEM/process/strain.py                   | 205 ++++++-----
 3 files changed, 309 insertions(+), 266 deletions(-)

diff --git a/py4DSTEM/braggvectors/braggvector_methods.py b/py4DSTEM/braggvectors/braggvector_methods.py
index 8dd6abe76..009f5a193 100644
--- a/py4DSTEM/braggvectors/braggvector_methods.py
+++ b/py4DSTEM/braggvectors/braggvector_methods.py
@@ -637,187 +637,187 @@ def fit_p_ellipse(
 
     # Deprecated??
 
-    def index_bragg_directions(
-        self,
-        x0 = None,
-        y0 = None,
-        plot = True,
-        bvm_vis_params = {},
-        returncalc = False,
-        ):
-        """
-        From an origin (x0,y0), a set of reciprocal lattice vectors gx,gy, and an pair of
-        lattice vectors g1=(g1x,g1y), g2=(g2x,g2y), find the indices (h,k) of all the
-        reciprocal lattice directions.
-
-        Args:
-            x0 (float): x-coord of origin
-            y0 (float): y-coord of origin
-            Plot (bool): plot results
-        """
-
-        if x0 is None:
-            x0 = self.Qshape[0]/2
-        if y0 is None:
-            y0 = self.Qshape[0]/2
-
-        from py4DSTEM.process.latticevectors import index_bragg_directions
-        _, _, braggdirections = index_bragg_directions(
-            x0,
-            y0,
-            self.g['x'],
-            self.g['y'],
-            self.g1,
-            self.g2
-        )
-
-        self.braggdirections = braggdirections
-
-        if plot:
-            from py4DSTEM.visualize import show_bragg_indexing
-            show_bragg_indexing(
-                self.bvm_centered,
-                **bvm_vis_params,
-                braggdirections = braggdirections,
-                points = True
-            )
-
-        if returncalc:
-            return braggdirections
-
-
-
-    def add_indices_to_braggvectors(
-        self,
-        maxPeakSpacing,
-        mask = None,
-        returncalc = False,
-        ):
-        """
-        Using the peak positions (qx,qy) and indices (h,k) in the PointList lattice,
-        identify the indices for each peak in the PointListArray braggpeaks.
-        Return a new braggpeaks_indexed PointListArray, containing a copy of braggpeaks plus
-        three additional data columns -- 'h','k', and 'index_mask' -- specifying the peak
-        indices with the ints (h,k) and indicating whether the peak was successfully indexed
-        or not with the bool index_mask. If `mask` is specified, only the locations where
-        mask is True are indexed.
-
-        Args:
-            maxPeakSpacing (float): Maximum distance from the ideal lattice points
-                to include a peak for indexing
-            qx_shift,qy_shift (number): the shift of the origin in the `lattice` PointList
-                relative to the `braggpeaks` PointListArray
-            mask (bool): Boolean mask, same shape as the pointlistarray, indicating which
-                locations should be indexed. This can be used to index different regions of
-                the scan with different lattices
-        """
-        from py4DSTEM.process.latticevectors import add_indices_to_braggvectors
-
-        bragg_peaks_indexed = add_indices_to_braggvectors(
-            self.vectors,
-            self.braggdirections,
-            maxPeakSpacing = maxPeakSpacing,
-            qx_shift = self.Qshape[0]/2,
-            qy_shift = self.Qshape[1]/2,
-        )
-
-        self.bragg_peaks_indexed = bragg_peaks_indexed
-
-        if returncalc:
-            return bragg_peaks_indexed
-
-
-    def fit_lattice_vectors_all_DPs(self, returncalc = False):
-        """
-        Fits lattice vectors g1,g2 to each diffraction pattern in braggpeaks, given some
-        known (h,k) indexing.
-
+    # def index_bragg_directions(
+    #     self,
+    #     x0 = None,
+    #     y0 = None,
+    #     plot = True,
+    #     bvm_vis_params = {},
+    #     returncalc = False,
+    #     ):
+    #     """
+    #     From an origin (x0,y0), a set of reciprocal lattice vectors gx,gy, and an pair of
+    #     lattice vectors g1=(g1x,g1y), g2=(g2x,g2y), find the indices (h,k) of all the
+    #     reciprocal lattice directions.
+
+    #     Args:
+    #         x0 (float): x-coord of origin
+    #         y0 (float): y-coord of origin
+    #         Plot (bool): plot results
+    #     """
+
+    #     if x0 is None:
+    #         x0 = self.Qshape[0]/2
+    #     if y0 is None:
+    #         y0 = self.Qshape[0]/2
+
+    #     from py4DSTEM.process.latticevectors import index_bragg_directions
+    #     _, _, braggdirections = index_bragg_directions(
+    #         x0,
+    #         y0,
+    #         self.g['x'],
+    #         self.g['y'],
+    #         self.g1,
+    #         self.g2
+    #     )
+
+    #     self.braggdirections = braggdirections
+
+    #     if plot:
+    #         from py4DSTEM.visualize import show_bragg_indexing
+    #         show_bragg_indexing(
+    #             self.bvm_centered,
+    #             **bvm_vis_params,
+    #             braggdirections = braggdirections,
+    #             points = True
+    #         )
+
+    #     if returncalc:
+    #         return braggdirections
+
+
+
+    # def add_indices_to_braggvectors(
+    #     self,
+    #     maxPeakSpacing,
+    #     mask = None,
+    #     returncalc = False,
+    #     ):
+    #     """
+    #     Using the peak positions (qx,qy) and indices (h,k) in the PointList lattice,
+    #     identify the indices for each peak in the PointListArray braggpeaks.
+    #     Return a new braggpeaks_indexed PointListArray, containing a copy of braggpeaks plus
+    #     three additional data columns -- 'h','k', and 'index_mask' -- specifying the peak
+    #     indices with the ints (h,k) and indicating whether the peak was successfully indexed
+    #     or not with the bool index_mask. If `mask` is specified, only the locations where
+    #     mask is True are indexed.
+
+    #     Args:
+    #         maxPeakSpacing (float): Maximum distance from the ideal lattice points
+    #             to include a peak for indexing
+    #         qx_shift,qy_shift (number): the shift of the origin in the `lattice` PointList
+    #             relative to the `braggpeaks` PointListArray
+    #         mask (bool): Boolean mask, same shape as the pointlistarray, indicating which
+    #             locations should be indexed. This can be used to index different regions of
+    #             the scan with different lattices
+    #     """
+    #     from py4DSTEM.process.latticevectors import add_indices_to_braggvectors
+
+    #     bragg_peaks_indexed = add_indices_to_braggvectors(
+    #         self.vectors,
+    #         self.braggdirections,
+    #         maxPeakSpacing = maxPeakSpacing,
+    #         qx_shift = self.Qshape[0]/2,
+    #         qy_shift = self.Qshape[1]/2,
+    #     )
+
+    #     self.bragg_peaks_indexed = bragg_peaks_indexed
+
+    #     if returncalc:
+    #         return bragg_peaks_indexed
+
+
+    # def fit_lattice_vectors_all_DPs(self, returncalc = False):
+    #     """
+    #     Fits lattice vectors g1,g2 to each diffraction pattern in braggpeaks, given some
+    #     known (h,k) indexing.
+
+
+    #     """
+
+    #     from py4DSTEM.process.latticevectors import fit_lattice_vectors_all_DPs
+    #     g1g2_map = fit_lattice_vectors_all_DPs(self.bragg_peaks_indexed)
+    #     self.g1g2_map = g1g2_map
+    #     if returncalc:
+    #         return g1g2_map
+
+    # def get_strain_from_reference_region(self, mask, returncalc = False):
+    #     """
+    #     Gets a strain map from the reference region of real space specified by mask and the
+    #     lattice vector map g1g2_map.
+
+    #     Args:
+    #         mask (ndarray of bools): use lattice vectors from g1g2_map scan positions
+    #             wherever mask==True
+
+    #     """
+    #     from py4DSTEM.process.latticevectors import get_strain_from_reference_region
+
+    #     strainmap_median_g1g2 = get_strain_from_reference_region(
+    #         self.g1g2_map,
+    #         mask = mask,
+    #     )
+
+    #     self.strainmap_median_g1g2 = strainmap_median_g1g2
+
+    #     if returncalc:
+    #         return strainmap_median_g1g2
+
+
+    # def get_strain_from_reference_g1g2(self, mask, returncalc = False):
+    #     """
+    #     Gets a strain map from the reference lattice vectors g1,g2 and lattice vector map
+    #     g1g2_map.
+
+
+    #     Args:
+    #         mask (ndarray of bools): use lattice vectors from g1g2_map scan positions
+    #             wherever mask==True
+
+    #     """
+    #     from py4DSTEM.process.latticevectors import get_reference_g1g2
+    #     g1_ref,g2_ref = get_reference_g1g2(self.g1g2_map, mask)
+
+    #     from py4DSTEM.process.latticevectors import get_strain_from_reference_g1g2
+    #     strainmap_reference_g1g2 = get_strain_from_reference_g1g2(self.g1g2_map, g1_ref, g2_ref)
 
-        """
-
-        from py4DSTEM.process.latticevectors import fit_lattice_vectors_all_DPs
-        g1g2_map = fit_lattice_vectors_all_DPs(self.bragg_peaks_indexed)
-        self.g1g2_map = g1g2_map
-        if returncalc:
-            return g1g2_map
-
-    def get_strain_from_reference_region(self, mask, returncalc = False):
-        """
-        Gets a strain map from the reference region of real space specified by mask and the
-        lattice vector map g1g2_map.
-
-        Args:
-            mask (ndarray of bools): use lattice vectors from g1g2_map scan positions
-                wherever mask==True
-
-        """
-        from py4DSTEM.process.latticevectors import get_strain_from_reference_region
-
-        strainmap_median_g1g2 = get_strain_from_reference_region(
-            self.g1g2_map,
-            mask = mask,
-        )
-
-        self.strainmap_median_g1g2 = strainmap_median_g1g2
-
-        if returncalc:
-            return strainmap_median_g1g2
-
-
-    def get_strain_from_reference_g1g2(self, mask, returncalc = False):
-        """
-        Gets a strain map from the reference lattice vectors g1,g2 and lattice vector map
-        g1g2_map.
+    #     self.strainmap_reference_g1g2 = strainmap_reference_g1g2
+
+    #     if returncalc:
+    #         return strainmap_reference_g1g2
+
+    # def get_rotated_strain_map(self, mode, g_reference = None, returncalc = True, flip_theta = False):
+    #     """
+    #     Starting from a strain map defined with respect to the xy coordinate system of
+    #     diffraction space, i.e. where exx and eyy are the compression/tension along the Qx
+    #     and Qy directions, respectively, get a strain map defined with respect to some other
+    #     right-handed coordinate system, in which the x-axis is oriented along (xaxis_x,
+    #     xaxis_y).
+
+    #     Args:
+    #         g_referencce (tupe): reference coordinate system for xaxis_x and xaxis_y
+    #     """
 
+    #     assert mode in ("median","reference")
+    #     if g_reference is None:
+    #         g_reference = np.subtract(self.g1, self.g2)
 
-        Args:
-            mask (ndarray of bools): use lattice vectors from g1g2_map scan positions
-                wherever mask==True
+    #     from py4DSTEM.process.latticevectors import get_rotated_strain_map
 
-        """
-        from py4DSTEM.process.latticevectors import get_reference_g1g2
-        g1_ref,g2_ref = get_reference_g1g2(self.g1g2_map, mask)
+    #     if mode == "median":
+    #         strainmap_raw = self.strainmap_median_g1g2
+    #     elif mode == "reference":
+    #         strainmap_raw = self.strainmap_reference_g1g2
 
-        from py4DSTEM.process.latticevectors import get_strain_from_reference_g1g2
-        strainmap_reference_g1g2 = get_strain_from_reference_g1g2(self.g1g2_map, g1_ref, g2_ref)
+    #     strainmap = get_rotated_strain_map(
+    #         strainmap_raw,
+    #         xaxis_x = g_reference[0],
+    #         xaxis_y = g_reference[1],
+    #         flip_theta = flip_theta
+    #     )
 
-        self.strainmap_reference_g1g2 = strainmap_reference_g1g2
-
-        if returncalc:
-            return strainmap_reference_g1g2
-
-    def get_rotated_strain_map(self, mode, g_reference = None, returncalc = True, flip_theta = False):
-        """
-        Starting from a strain map defined with respect to the xy coordinate system of
-        diffraction space, i.e. where exx and eyy are the compression/tension along the Qx
-        and Qy directions, respectively, get a strain map defined with respect to some other
-        right-handed coordinate system, in which the x-axis is oriented along (xaxis_x,
-        xaxis_y).
-
-        Args:
-            g_referencce (tupe): reference coordinate system for xaxis_x and xaxis_y
-        """
-
-        assert mode in ("median","reference")
-        if g_reference is None:
-            g_reference = np.subtract(self.g1, self.g2)
-
-        from py4DSTEM.process.latticevectors import get_rotated_strain_map
-
-        if mode == "median":
-            strainmap_raw = self.strainmap_median_g1g2
-        elif mode == "reference":
-            strainmap_raw = self.strainmap_reference_g1g2
-
-        strainmap = get_rotated_strain_map(
-            strainmap_raw,
-            xaxis_x = g_reference[0],
-            xaxis_y = g_reference[1],
-            flip_theta = flip_theta
-        )
-
-        if returncalc:
-            return strainmap
+    #     if returncalc:
+    #         return strainmap
 
 
     def mask_in_Q(
diff --git a/py4DSTEM/process/latticevectors/strain.py b/py4DSTEM/process/latticevectors/strain.py
index 518f38885..7a586bd69 100644
--- a/py4DSTEM/process/latticevectors/strain.py
+++ b/py4DSTEM/process/latticevectors/strain.py
@@ -172,18 +172,20 @@ def get_rotated_strain_map(unrotated_strain_map, xaxis_x, xaxis_y, flip_theta):
     sint2 = sint**2
 
     Rx,Ry = unrotated_strain_map.get_slice('e_xx').data.shape
-    rotated_strain_map = RealSlice(data=np.zeros((Rx,Ry,5)),
-                                   slicelabels=['e_xx','e_xy','e_yy','theta','mask'],
-                                   name=unrotated_strain_map.name+"_rotated".format(np.degrees(theta)))
+    rotated_strain_map = RealSlice(
+        data=np.zeros((5, Rx,Ry)),
+        slicelabels=['e_xx','e_xy','e_yy','theta','mask'],
+        name=unrotated_strain_map.name+"_rotated".format(np.degrees(theta))
+    )
 
-    rotated_strain_map.data[:,:,0] = cost2*unrotated_strain_map.get_slice('e_xx').data - 2*cost*sint*unrotated_strain_map.get_slice('e_xy').data + sint2*unrotated_strain_map.get_slice('e_yy').data
-    rotated_strain_map.data[:,:,1] = cost*sint*(unrotated_strain_map.get_slice('e_xx').data-unrotated_strain_map.get_slice('e_yy').data) + (cost2-sint2)*unrotated_strain_map.get_slice('e_xy').data
-    rotated_strain_map.data[:,:,2] = sint2*unrotated_strain_map.get_slice('e_xx').data + 2*cost*sint*unrotated_strain_map.get_slice('e_xy').data + cost2*unrotated_strain_map.get_slice('e_yy').data
+    rotated_strain_map.data[0,:,:] = cost2*unrotated_strain_map.get_slice('e_xx').data - 2*cost*sint*unrotated_strain_map.get_slice('e_xy').data + sint2*unrotated_strain_map.get_slice('e_yy').data
+    rotated_strain_map.data[1,:,:] = cost*sint*(unrotated_strain_map.get_slice('e_xx').data-unrotated_strain_map.get_slice('e_yy').data) + (cost2-sint2)*unrotated_strain_map.get_slice('e_xy').data
+    rotated_strain_map.data[2,:,:] = sint2*unrotated_strain_map.get_slice('e_xx').data + 2*cost*sint*unrotated_strain_map.get_slice('e_xy').data + cost2*unrotated_strain_map.get_slice('e_yy').data
     if flip_theta == True:
-        rotated_strain_map.data[:,:,3] = -unrotated_strain_map.get_slice('theta').data
+        rotated_strain_map.data[3,:,:] = -unrotated_strain_map.get_slice('theta').data
     else: 
-        rotated_strain_map.data[:,:,3] = unrotated_strain_map.get_slice('theta').data
-    rotated_strain_map.data[:,:,4] = unrotated_strain_map.get_slice('mask').data
+        rotated_strain_map.data[3,:,:] = unrotated_strain_map.get_slice('theta').data
+    rotated_strain_map.data[4,:,:] = unrotated_strain_map.get_slice('mask').data
     return rotated_strain_map
 
 
diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index a275f9e6b..0424e92e0 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -385,21 +385,57 @@ def fit_lattice_vectors(
     def get_strain(
         self, 
         mask=None,
+        g_reference=None,
+        flip_theta=False,
         returncalc=False,
         **kwargs
     ):
-        """ """
+        """ 
+        mask: nd.array (bool) 
+            Use lattice vectors from g1g2_map scan positions
+            wherever mask==True. If mask is None gets median strain
+            map from entire field of view. If mask is not None, gets 
+            reference g1 and g2 from region and then calculates strain.
+        g_reference: nd.array of form [x,y]
+            G_reference (tupe): reference coordinate system for 
+            xaxis_x and xaxis_y
+        flip_theta: bool
+            If True, flips rotation coordinate system
+        returncal: bool
+            It True, returns rotated map
+        """
         if mask is None:
             mask = np.ones(self.g1g2_map.shape, dtype="bool")
 
-        from py4DSTEM.process.latticevectors import get_strain_from_reference_region
+            from py4DSTEM.process.latticevectors import get_strain_from_reference_region
 
-        strainmap_median_g1g2 = get_strain_from_reference_region(
-            self.g1g2_map,
-            mask=mask,
+            strainmap_g1g2 = get_strain_from_reference_region(
+                self.g1g2_map,
+                mask=mask,
+            )
+        else:
+            from py4DSTEM.process.latticevectors import get_reference_g1g2
+            g1_ref,g2_ref = get_reference_g1g2(self.g1g2_map, mask)
+            
+            from py4DSTEM.process.latticevectors import get_strain_from_reference_g1g2
+            strainmap_g1g2 = get_strain_from_reference_g1g2(self.g1g2_map, g1_ref, g2_ref)
+
+        self.strainmap_g1g2 = strainmap_g1g2
+
+        if g_reference is None:
+            g_reference = np.subtract(self.g1, self.g2)
+
+        print(g_reference)
+        from py4DSTEM.process.latticevectors import get_rotated_strain_map
+
+        strainmap_rotated = get_rotated_strain_map(
+            self.strainmap_g1g2,
+            xaxis_x = g_reference[0],
+            xaxis_y = g_reference[1],
+            flip_theta = flip_theta
         )
 
-        self.strainmap_median_g1g2 = strainmap_median_g1g2
+        self.strainmap_rotated = strainmap_rotated
         
         from py4DSTEM.visualize import show_strain
         figsize = kwargs.pop("figsize", (14, 4))
@@ -410,7 +446,7 @@ def get_strain(
         axes_plots = kwargs.pop("axes_plots",())
 
         fig, ax = show_strain(
-            strainmap_median_g1g2,
+            self.strainmap_rotated,
             vrange_exx=vrange_exx,
             vrange_theta=vrange_theta,
             ticknumber=ticknumber,
@@ -422,10 +458,13 @@ def get_strain(
         )
 
         if not np.all(mask == True): 
-            for axs in ax.flatten():
-                axs.imshow(mask, alpha = 0.2, cmap = "binary")
+           ax[0][0].imshow(mask, alpha = 0.2, cmap = "binary")
+           ax[0][1].imshow(mask, alpha = 0.2, cmap = "binary")
+           ax[1][0].imshow(mask, alpha = 0.2, cmap = "binary")
+           ax[1][1].imshow(mask, alpha = 0.2, cmap = "binary")
+        
         if returncalc:
-            return strainmap_median_g1g2
+            return self.strainmap_rotated
 
     def show_lattice_vectors(
         ar,
@@ -519,7 +558,9 @@ def show_bragg_indexing(
         else:
             plt.show()
             return
-
+    
+    # def copy():
+    #     # TODO - copy method
 
 # def index_bragg_directions(x0, y0, gx, gy, g1, g2):
 #     """
@@ -573,81 +614,81 @@ def show_bragg_indexing(
 #     return h,k, bragg_directions
 
 
-def add_indices_to_braggvectors(
-    braggpeaks, lattice, maxPeakSpacing, qx_shift=0, qy_shift=0, mask=None
-):
-    """
-    Using the peak positions (qx,qy) and indices (h,k) in the PointList lattice,
-    identify the indices for each peak in the PointListArray braggpeaks.
-    Return a new braggpeaks_indexed PointListArray, containing a copy of braggpeaks plus
-    three additional data columns -- 'h','k', and 'index_mask' -- specifying the peak
-    indices with the ints (h,k) and indicating whether the peak was successfully indexed
-    or not with the bool index_mask. If `mask` is specified, only the locations where
-    mask is True are indexed.
-
-    Args:
-        braggpeaks (PointListArray): the braggpeaks to index. Must contain
-            the coordinates 'qx', 'qy', and 'intensity'
-        lattice (PointList): the positions (qx,qy) of the (h,k) lattice points.
-            Must contain the coordinates 'qx', 'qy', 'h', and 'k'
-        maxPeakSpacing (float): Maximum distance from the ideal lattice points
-            to include a peak for indexing
-        qx_shift,qy_shift (number): the shift of the origin in the `lattice` PointList
-            relative to the `braggpeaks` PointListArray
-        mask (bool): Boolean mask, same shape as the pointlistarray, indicating which
-            locations should be indexed. This can be used to index different regions of
-            the scan with different lattices
-
-    Returns:
-        (PointListArray): The original braggpeaks pointlistarray, with new coordinates
-        'h', 'k', containing the indices of each indexable peak.
-    """
+# def add_indices_to_braggvectors(
+#     braggpeaks, lattice, maxPeakSpacing, qx_shift=0, qy_shift=0, mask=None
+# ):
+#     """
+#     Using the peak positions (qx,qy) and indices (h,k) in the PointList lattice,
+#     identify the indices for each peak in the PointListArray braggpeaks.
+#     Return a new braggpeaks_indexed PointListArray, containing a copy of braggpeaks plus
+#     three additional data columns -- 'h','k', and 'index_mask' -- specifying the peak
+#     indices with the ints (h,k) and indicating whether the peak was successfully indexed
+#     or not with the bool index_mask. If `mask` is specified, only the locations where
+#     mask is True are indexed.
+
+#     Args:
+#         braggpeaks (PointListArray): the braggpeaks to index. Must contain
+#             the coordinates 'qx', 'qy', and 'intensity'
+#         lattice (PointList): the positions (qx,qy) of the (h,k) lattice points.
+#             Must contain the coordinates 'qx', 'qy', 'h', and 'k'
+#         maxPeakSpacing (float): Maximum distance from the ideal lattice points
+#             to include a peak for indexing
+#         qx_shift,qy_shift (number): the shift of the origin in the `lattice` PointList
+#             relative to the `braggpeaks` PointListArray
+#         mask (bool): Boolean mask, same shape as the pointlistarray, indicating which
+#             locations should be indexed. This can be used to index different regions of
+#             the scan with different lattices
+
+#     Returns:
+#         (PointListArray): The original braggpeaks pointlistarray, with new coordinates
+#         'h', 'k', containing the indices of each indexable peak.
+#     """
 
-    assert isinstance(braggpeaks, PointListArray)
-    assert np.all(
-        [name in braggpeaks.dtype.names for name in ("qx", "qy", "intensity")]
-    )
-    assert isinstance(lattice, PointList)
-    assert np.all([name in lattice.dtype.names for name in ("qx", "qy", "h", "k")])
-
-    if mask is None:
-        mask = np.ones(braggpeaks.shape, dtype=bool)
-
-    assert mask.shape == braggpeaks.shape, "mask must have same shape as pointlistarray"
-    assert mask.dtype == bool, "mask must be boolean"
-
-    indexed_braggpeaks = braggpeaks.copy()
-
-    # add the coordinates if they don't exist
-    if not ("h" in braggpeaks.dtype.names):
-        indexed_braggpeaks = indexed_braggpeaks.add_fields([("h", int)])
-    if not ("k" in braggpeaks.dtype.names):
-        indexed_braggpeaks = indexed_braggpeaks.add_fields([("k", int)])
-
-    # loop over all the scan positions
-    for Rx, Ry in tqdmnd(mask.shape[0], mask.shape[1]):
-        if mask[Rx, Ry]:
-            pl = indexed_braggpeaks.get_pointlist(Rx, Ry)
-            rm_peak_mask = np.zeros(pl.length, dtype=bool)
-
-            for i in range(pl.length):
-                r2 = (pl.data["qx"][i] - lattice.data["qx"] + qx_shift) ** 2 + (
-                    pl.data["qy"][i] - lattice.data["qy"] + qy_shift
-                ) ** 2
-                ind = np.argmin(r2)
-                if r2[ind] <= maxPeakSpacing**2:
-                    pl.data["h"][i] = lattice.data["h"][ind]
-                    pl.data["k"][i] = lattice.data["k"][ind]
-                else:
-                    rm_peak_mask[i] = True
-            pl.remove(rm_peak_mask)
-
-    indexed_braggpeaks.name = braggpeaks.name + "_indexed"
-    return indexed_braggpeaks
+#     assert isinstance(braggpeaks, PointListArray)
+#     assert np.all(
+#         [name in braggpeaks.dtype.names for name in ("qx", "qy", "intensity")]
+#     )
+#     assert isinstance(lattice, PointList)
+#     assert np.all([name in lattice.dtype.names for name in ("qx", "qy", "h", "k")])
+
+#     if mask is None:
+#         mask = np.ones(braggpeaks.shape, dtype=bool)
+
+#     assert mask.shape == braggpeaks.shape, "mask must have same shape as pointlistarray"
+#     assert mask.dtype == bool, "mask must be boolean"
+
+#     indexed_braggpeaks = braggpeaks.copy()
+
+#     # add the coordinates if they don't exist
+#     if not ("h" in braggpeaks.dtype.names):
+#         indexed_braggpeaks = indexed_braggpeaks.add_fields([("h", int)])
+#     if not ("k" in braggpeaks.dtype.names):
+#         indexed_braggpeaks = indexed_braggpeaks.add_fields([("k", int)])
+
+#     # loop over all the scan positions
+#     for Rx, Ry in tqdmnd(mask.shape[0], mask.shape[1]):
+#         if mask[Rx, Ry]:
+#             pl = indexed_braggpeaks.get_pointlist(Rx, Ry)
+#             rm_peak_mask = np.zeros(pl.length, dtype=bool)
+
+#             for i in range(pl.length):
+#                 r2 = (pl.data["qx"][i] - lattice.data["qx"] + qx_shift) ** 2 + (
+#                     pl.data["qy"][i] - lattice.data["qy"] + qy_shift
+#                 ) ** 2
+#                 ind = np.argmin(r2)
+#                 if r2[ind] <= maxPeakSpacing**2:
+#                     pl.data["h"][i] = lattice.data["h"][ind]
+#                     pl.data["k"][i] = lattice.data["k"][ind]
+#                 else:
+#                     rm_peak_mask[i] = True
+#             pl.remove(rm_peak_mask)
+
+#     indexed_braggpeaks.name = braggpeaks.name + "_indexed"
+#     return indexed_braggpeaks
 
     # IO methods
 
-    # TODO - copy method
+    
 
     # read
     @classmethod

From 93d20defa4e14390b263d43d4e49bdae129e9bc2 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 14 Jul 2023 11:47:35 -0700
Subject: [PATCH 293/362] strain copy

---
 py4DSTEM/process/strain.py | 324 +++++++++++++++++++------------------
 1 file changed, 165 insertions(+), 159 deletions(-)

diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index 0424e92e0..3ce202e4b 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -25,7 +25,7 @@ def __init__(self, braggvectors: BraggVectors, name: Optional[str] = "strainmap"
         """
         assert isinstance(
             braggvectors, BraggVectors
-        ), f"braggvectors myst be BraggVectors, not type {type(braggvectors)}"
+        ), f"braggvectors must be BraggVectors, not type {type(braggvectors)}"
 
         # initialize as a RealSlice
         RealSlice.__init__(
@@ -383,27 +383,27 @@ def fit_lattice_vectors(
             braggdirections, bragg_vectors_indexed, g1g2_map
 
     def get_strain(
-        self, 
-        mask=None,
-        g_reference=None,
-        flip_theta=False,
-        returncalc=False,
-        **kwargs
+        self, mask=None, g_reference=None, flip_theta=False, returncalc=False, **kwargs
     ):
-        """ 
-        mask: nd.array (bool) 
+        """
+        mask: nd.array (bool)
             Use lattice vectors from g1g2_map scan positions
             wherever mask==True. If mask is None gets median strain
-            map from entire field of view. If mask is not None, gets 
+            map from entire field of view. If mask is not None, gets
             reference g1 and g2 from region and then calculates strain.
         g_reference: nd.array of form [x,y]
-            G_reference (tupe): reference coordinate system for 
+            G_reference (tupe): reference coordinate system for
             xaxis_x and xaxis_y
         flip_theta: bool
             If True, flips rotation coordinate system
         returncal: bool
             It True, returns rotated map
         """
+        # check the calstate
+        assert (
+            self.calstate == self.braggvectors.calstate
+        ), "The calibration state has changed! To resync the calibration state, use `.reset_calstate`."
+
         if mask is None:
             mask = np.ones(self.g1g2_map.shape, dtype="bool")
 
@@ -415,38 +415,42 @@ def get_strain(
             )
         else:
             from py4DSTEM.process.latticevectors import get_reference_g1g2
-            g1_ref,g2_ref = get_reference_g1g2(self.g1g2_map, mask)
-            
+
+            g1_ref, g2_ref = get_reference_g1g2(self.g1g2_map, mask)
+
             from py4DSTEM.process.latticevectors import get_strain_from_reference_g1g2
-            strainmap_g1g2 = get_strain_from_reference_g1g2(self.g1g2_map, g1_ref, g2_ref)
+
+            strainmap_g1g2 = get_strain_from_reference_g1g2(
+                self.g1g2_map, g1_ref, g2_ref
+            )
 
         self.strainmap_g1g2 = strainmap_g1g2
 
         if g_reference is None:
             g_reference = np.subtract(self.g1, self.g2)
 
-        print(g_reference)
         from py4DSTEM.process.latticevectors import get_rotated_strain_map
 
         strainmap_rotated = get_rotated_strain_map(
             self.strainmap_g1g2,
-            xaxis_x = g_reference[0],
-            xaxis_y = g_reference[1],
-            flip_theta = flip_theta
+            xaxis_x=g_reference[0],
+            xaxis_y=g_reference[1],
+            flip_theta=flip_theta,
         )
 
-        self.strainmap_rotated = strainmap_rotated
-        
+        self.data = strainmap_rotated
+
         from py4DSTEM.visualize import show_strain
+
         figsize = kwargs.pop("figsize", (14, 4))
         vrange_exx = kwargs.pop("vrange_exx", [-2.0, 2.0])
         vrange_theta = kwargs.pop("vrange_theta", [-2.0, 2.0])
         ticknumber = kwargs.pop("ticknumber", 3)
-        bkgrd = kwargs.pop("bkgrd", False) 
-        axes_plots = kwargs.pop("axes_plots",())
+        bkgrd = kwargs.pop("bkgrd", False)
+        axes_plots = kwargs.pop("axes_plots", ())
 
         fig, ax = show_strain(
-            self.strainmap_rotated,
+            self.data,
             vrange_exx=vrange_exx,
             vrange_theta=vrange_theta,
             ticknumber=ticknumber,
@@ -454,15 +458,15 @@ def get_strain(
             bkgrd=bkgrd,
             figsize=figsize,
             **kwargs,
-            returnfig = True,
+            returnfig=True,
         )
 
-        if not np.all(mask == True): 
-           ax[0][0].imshow(mask, alpha = 0.2, cmap = "binary")
-           ax[0][1].imshow(mask, alpha = 0.2, cmap = "binary")
-           ax[1][0].imshow(mask, alpha = 0.2, cmap = "binary")
-           ax[1][1].imshow(mask, alpha = 0.2, cmap = "binary")
-        
+        if not np.all(mask == True):
+            ax[0][0].imshow(mask, alpha=0.2, cmap="binary")
+            ax[0][1].imshow(mask, alpha=0.2, cmap="binary")
+            ax[1][0].imshow(mask, alpha=0.2, cmap="binary")
+            ax[1][1].imshow(mask, alpha=0.2, cmap="binary")
+
         if returncalc:
             return self.strainmap_rotated
 
@@ -558,137 +562,139 @@ def show_bragg_indexing(
         else:
             plt.show()
             return
-    
-    # def copy():
-    #     # TODO - copy method
-
-# def index_bragg_directions(x0, y0, gx, gy, g1, g2):
-#     """
-#     From an origin (x0,y0), a set of reciprocal lattice vectors gx,gy, and an pair of
-#     lattice vectors g1=(g1x,g1y), g2=(g2x,g2y), find the indices (h,k) of all the
-#     reciprocal lattice directions.
-
-#     The approach is to solve the matrix equation
-#             ``alpha = beta * M``
-#     where alpha is the 2xN array of the (x,y) coordinates of N measured bragg directions,
-#     beta is the 2x2 array of the two lattice vectors u,v, and M is the 2xN array of the
-#     h,k indices.
-
-#     Args:
-#         x0 (float): x-coord of origin
-#         y0 (float): y-coord of origin
-#         gx (1d array): x-coord of the reciprocal lattice vectors
-#         gy (1d array): y-coord of the reciprocal lattice vectors
-#         g1 (2-tuple of floats): g1x,g1y
-#         g2 (2-tuple of floats): g2x,g2y
-
-#     Returns:
-#         (3-tuple) A 3-tuple containing:
-
-#             * **h**: *(ndarray of ints)* first index of the bragg directions
-#             * **k**: *(ndarray of ints)* second index of the bragg directions
-#             * **bragg_directions**: *(PointList)* a 4-coordinate PointList with the
-#               indexed bragg directions; coords 'qx' and 'qy' contain bragg_x and bragg_y
-#               coords 'h' and 'k' contain h and k.
-#     """
-#     # Get beta, the matrix of lattice vectors
-#     beta = np.array([[g1[0],g2[0]],[g1[1],g2[1]]])
-
-#     # Get alpha, the matrix of measured bragg angles
-#     alpha = np.vstack([gx-x0,gy-y0])
-
-#     # Calculate M, the matrix of peak positions
-#     M = lstsq(beta, alpha, rcond=None)[0].T
-#     M = np.round(M).astype(int)
-
-#     # Get h,k
-#     h = M[:,0]
-#     k = M[:,1]
-
-#     # Store in a PointList
-#     coords = [('qx',float),('qy',float),('h',int),('k',int)]
-#     temp_array = np.zeros([], dtype = coords)
-#     bragg_directions = PointList(data = temp_array)
-#     bragg_directions.add_data_by_field((gx,gy,h,k))
-
-#     return h,k, bragg_directions
-
-
-# def add_indices_to_braggvectors(
-#     braggpeaks, lattice, maxPeakSpacing, qx_shift=0, qy_shift=0, mask=None
-# ):
-#     """
-#     Using the peak positions (qx,qy) and indices (h,k) in the PointList lattice,
-#     identify the indices for each peak in the PointListArray braggpeaks.
-#     Return a new braggpeaks_indexed PointListArray, containing a copy of braggpeaks plus
-#     three additional data columns -- 'h','k', and 'index_mask' -- specifying the peak
-#     indices with the ints (h,k) and indicating whether the peak was successfully indexed
-#     or not with the bool index_mask. If `mask` is specified, only the locations where
-#     mask is True are indexed.
-
-#     Args:
-#         braggpeaks (PointListArray): the braggpeaks to index. Must contain
-#             the coordinates 'qx', 'qy', and 'intensity'
-#         lattice (PointList): the positions (qx,qy) of the (h,k) lattice points.
-#             Must contain the coordinates 'qx', 'qy', 'h', and 'k'
-#         maxPeakSpacing (float): Maximum distance from the ideal lattice points
-#             to include a peak for indexing
-#         qx_shift,qy_shift (number): the shift of the origin in the `lattice` PointList
-#             relative to the `braggpeaks` PointListArray
-#         mask (bool): Boolean mask, same shape as the pointlistarray, indicating which
-#             locations should be indexed. This can be used to index different regions of
-#             the scan with different lattices
-
-#     Returns:
-#         (PointListArray): The original braggpeaks pointlistarray, with new coordinates
-#         'h', 'k', containing the indices of each indexable peak.
-#     """
-
-#     assert isinstance(braggpeaks, PointListArray)
-#     assert np.all(
-#         [name in braggpeaks.dtype.names for name in ("qx", "qy", "intensity")]
-#     )
-#     assert isinstance(lattice, PointList)
-#     assert np.all([name in lattice.dtype.names for name in ("qx", "qy", "h", "k")])
-
-#     if mask is None:
-#         mask = np.ones(braggpeaks.shape, dtype=bool)
-
-#     assert mask.shape == braggpeaks.shape, "mask must have same shape as pointlistarray"
-#     assert mask.dtype == bool, "mask must be boolean"
-
-#     indexed_braggpeaks = braggpeaks.copy()
-
-#     # add the coordinates if they don't exist
-#     if not ("h" in braggpeaks.dtype.names):
-#         indexed_braggpeaks = indexed_braggpeaks.add_fields([("h", int)])
-#     if not ("k" in braggpeaks.dtype.names):
-#         indexed_braggpeaks = indexed_braggpeaks.add_fields([("k", int)])
-
-#     # loop over all the scan positions
-#     for Rx, Ry in tqdmnd(mask.shape[0], mask.shape[1]):
-#         if mask[Rx, Ry]:
-#             pl = indexed_braggpeaks.get_pointlist(Rx, Ry)
-#             rm_peak_mask = np.zeros(pl.length, dtype=bool)
-
-#             for i in range(pl.length):
-#                 r2 = (pl.data["qx"][i] - lattice.data["qx"] + qx_shift) ** 2 + (
-#                     pl.data["qy"][i] - lattice.data["qy"] + qy_shift
-#                 ) ** 2
-#                 ind = np.argmin(r2)
-#                 if r2[ind] <= maxPeakSpacing**2:
-#                     pl.data["h"][i] = lattice.data["h"][ind]
-#                     pl.data["k"][i] = lattice.data["k"][ind]
-#                 else:
-#                     rm_peak_mask[i] = True
-#             pl.remove(rm_peak_mask)
-
-#     indexed_braggpeaks.name = braggpeaks.name + "_indexed"
-#     return indexed_braggpeaks
 
-    # IO methods
+    def copy(self, name=None):
+        name = name if name is not None else self.name + "_copy"
+        strainmap_copy = StrainMap(self.braggvectors)
+
+        for k in self.metadata.keys():
+            strainmap_copy.metadata = self.metadata[k].copy()
+        return strainmap_copy
+
+    # def index_bragg_directions(x0, y0, gx, gy, g1, g2):
+    #     """
+    #     From an origin (x0,y0), a set of reciprocal lattice vectors gx,gy, and an pair of
+    #     lattice vectors g1=(g1x,g1y), g2=(g2x,g2y), find the indices (h,k) of all the
+    #     reciprocal lattice directions.
+
+    #     The approach is to solve the matrix equation
+    #             ``alpha = beta * M``
+    #     where alpha is the 2xN array of the (x,y) coordinates of N measured bragg directions,
+    #     beta is the 2x2 array of the two lattice vectors u,v, and M is the 2xN array of the
+    #     h,k indices.
+
+    #     Args:
+    #         x0 (float): x-coord of origin
+    #         y0 (float): y-coord of origin
+    #         gx (1d array): x-coord of the reciprocal lattice vectors
+    #         gy (1d array): y-coord of the reciprocal lattice vectors
+    #         g1 (2-tuple of floats): g1x,g1y
+    #         g2 (2-tuple of floats): g2x,g2y
+
+    #     Returns:
+    #         (3-tuple) A 3-tuple containing:
+
+    #             * **h**: *(ndarray of ints)* first index of the bragg directions
+    #             * **k**: *(ndarray of ints)* second index of the bragg directions
+    #             * **bragg_directions**: *(PointList)* a 4-coordinate PointList with the
+    #               indexed bragg directions; coords 'qx' and 'qy' contain bragg_x and bragg_y
+    #               coords 'h' and 'k' contain h and k.
+    #     """
+    #     # Get beta, the matrix of lattice vectors
+    #     beta = np.array([[g1[0],g2[0]],[g1[1],g2[1]]])
+
+    #     # Get alpha, the matrix of measured bragg angles
+    #     alpha = np.vstack([gx-x0,gy-y0])
+
+    #     # Calculate M, the matrix of peak positions
+    #     M = lstsq(beta, alpha, rcond=None)[0].T
+    #     M = np.round(M).astype(int)
+
+    #     # Get h,k
+    #     h = M[:,0]
+    #     k = M[:,1]
+
+    #     # Store in a PointList
+    #     coords = [('qx',float),('qy',float),('h',int),('k',int)]
+    #     temp_array = np.zeros([], dtype = coords)
+    #     bragg_directions = PointList(data = temp_array)
+    #     bragg_directions.add_data_by_field((gx,gy,h,k))
+
+    #     return h,k, bragg_directions
+
+    # def add_indices_to_braggvectors(
+    #     braggpeaks, lattice, maxPeakSpacing, qx_shift=0, qy_shift=0, mask=None
+    # ):
+    #     """
+    #     Using the peak positions (qx,qy) and indices (h,k) in the PointList lattice,
+    #     identify the indices for each peak in the PointListArray braggpeaks.
+    #     Return a new braggpeaks_indexed PointListArray, containing a copy of braggpeaks plus
+    #     three additional data columns -- 'h','k', and 'index_mask' -- specifying the peak
+    #     indices with the ints (h,k) and indicating whether the peak was successfully indexed
+    #     or not with the bool index_mask. If `mask` is specified, only the locations where
+    #     mask is True are indexed.
+
+    #     Args:
+    #         braggpeaks (PointListArray): the braggpeaks to index. Must contain
+    #             the coordinates 'qx', 'qy', and 'intensity'
+    #         lattice (PointList): the positions (qx,qy) of the (h,k) lattice points.
+    #             Must contain the coordinates 'qx', 'qy', 'h', and 'k'
+    #         maxPeakSpacing (float): Maximum distance from the ideal lattice points
+    #             to include a peak for indexing
+    #         qx_shift,qy_shift (number): the shift of the origin in the `lattice` PointList
+    #             relative to the `braggpeaks` PointListArray
+    #         mask (bool): Boolean mask, same shape as the pointlistarray, indicating which
+    #             locations should be indexed. This can be used to index different regions of
+    #             the scan with different lattices
+
+    #     Returns:
+    #         (PointListArray): The original braggpeaks pointlistarray, with new coordinates
+    #         'h', 'k', containing the indices of each indexable peak.
+    #     """
+
+    #     assert isinstance(braggpeaks, PointListArray)
+    #     assert np.all(
+    #         [name in braggpeaks.dtype.names for name in ("qx", "qy", "intensity")]
+    #     )
+    #     assert isinstance(lattice, PointList)
+    #     assert np.all([name in lattice.dtype.names for name in ("qx", "qy", "h", "k")])
+
+    #     if mask is None:
+    #         mask = np.ones(braggpeaks.shape, dtype=bool)
+
+    #     assert mask.shape == braggpeaks.shape, "mask must have same shape as pointlistarray"
+    #     assert mask.dtype == bool, "mask must be boolean"
+
+    #     indexed_braggpeaks = braggpeaks.copy()
+
+    #     # add the coordinates if they don't exist
+    #     if not ("h" in braggpeaks.dtype.names):
+    #         indexed_braggpeaks = indexed_braggpeaks.add_fields([("h", int)])
+    #     if not ("k" in braggpeaks.dtype.names):
+    #         indexed_braggpeaks = indexed_braggpeaks.add_fields([("k", int)])
+
+    #     # loop over all the scan positions
+    #     for Rx, Ry in tqdmnd(mask.shape[0], mask.shape[1]):
+    #         if mask[Rx, Ry]:
+    #             pl = indexed_braggpeaks.get_pointlist(Rx, Ry)
+    #             rm_peak_mask = np.zeros(pl.length, dtype=bool)
+
+    #             for i in range(pl.length):
+    #                 r2 = (pl.data["qx"][i] - lattice.data["qx"] + qx_shift) ** 2 + (
+    #                     pl.data["qy"][i] - lattice.data["qy"] + qy_shift
+    #                 ) ** 2
+    #                 ind = np.argmin(r2)
+    #                 if r2[ind] <= maxPeakSpacing**2:
+    #                     pl.data["h"][i] = lattice.data["h"][ind]
+    #                     pl.data["k"][i] = lattice.data["k"][ind]
+    #                 else:
+    #                     rm_peak_mask[i] = True
+    #             pl.remove(rm_peak_mask)
+
+    #     indexed_braggpeaks.name = braggpeaks.name + "_indexed"
+    #     return indexed_braggpeaks
 
-    
+    # IO methods
 
     # read
     @classmethod

From 3ba12c9ee2ae60c5dd8496e63835c3ca35848192 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 14 Jul 2023 11:57:28 -0700
Subject: [PATCH 294/362] Revert "Merge remote-tracking branch 'origin/dev'
 into strain_refactor"

This reverts commit 6055859961f0ebf4500dcf836c0946ad4e8af4ac, reversing
changes made to 93d20defa4e14390b263d43d4e49bdae129e9bc2.
---
 py4DSTEM/braggvectors/braggvector_methods.py  |   57 +-
 py4DSTEM/braggvectors/braggvectors.py         |   17 +-
 py4DSTEM/braggvectors/probe.py                |    1 -
 py4DSTEM/data/calibration.py                  |    7 +-
 py4DSTEM/datacube/datacube.py                 |   56 +-
 py4DSTEM/preprocess/preprocess.py             |    3 +
 py4DSTEM/process/calibration/origin.py        |   11 +-
 py4DSTEM/process/diffraction/crystal.py       |   15 +-
 py4DSTEM/process/diffraction/crystal_ACOM.py  |   46 +-
 .../process/diffraction/crystal_calibrate.py  |   33 +-
 py4DSTEM/process/diffraction/crystal_viz.py   |   72 +-
 py4DSTEM/process/diffraction/flowlines.py     |    2 +-
 py4DSTEM/process/fit/fit.py                   |  226 +--
 .../iterative_multislice_ptychography.py      |    4 +-
 py4DSTEM/process/polar/__init__.py            |    2 +-
 py4DSTEM/process/polar/polar_datacube.py      |   86 +-
 py4DSTEM/process/polar/polar_fits.py          |   37 +-
 py4DSTEM/process/polar/polar_peaks.py         | 1271 -----------------
 py4DSTEM/visualize/show.py                    |   13 +-
 19 files changed, 171 insertions(+), 1788 deletions(-)
 delete mode 100644 py4DSTEM/process/polar/polar_peaks.py

diff --git a/py4DSTEM/braggvectors/braggvector_methods.py b/py4DSTEM/braggvectors/braggvector_methods.py
index 597c7b166..009f5a193 100644
--- a/py4DSTEM/braggvectors/braggvector_methods.py
+++ b/py4DSTEM/braggvectors/braggvector_methods.py
@@ -186,11 +186,7 @@ def get_virtual_image(
         mode = None,
         geometry = None,
         name = 'bragg_virtual_image',
-        returncalc = True,
-        center = True,
-        ellipse = True,
-        pixel = True,
-        rotate = True,
+        returncalc = True
         ):
         '''
         Calculates a virtual image based on the values of the Braggvectors
@@ -208,22 +204,13 @@ def get_virtual_image(
               - 'circle', 'circular': nested 2-tuple, ((qx,qy),radius)
               - 'annular' or 'annulus': nested 2-tuple,
                 ((qx,qy),(radius_i,radius_o))
-             Values can be in pixels or calibrated units. Note that (qx,qy) 
-             can be skipped, which assumes peaks centered at (0,0).
-        center: bool
-            Apply calibration - center coordinate.
-        ellipse: bool
-            Apply calibration - elliptical correction.
-        pixel: bool
-            Apply calibration - pixel size.
-        rotate: bool
-            Apply calibration - QR rotation.
+             All values are in pixels.  Note that (qx,qy) can be skipped, which
+             assumes peaks centered at (0,0)
 
         Returns
         -------
         virtual_im : VirtualImage
         '''
-
         # parse inputs
         circle_modes = ['circular','circle']
         annulus_modes = ['annular','annulus']
@@ -233,13 +220,13 @@ def get_virtual_image(
         # set geometry
         if mode is None:
             if geometry is None:
-                qxy_center = None
+                center = None
                 radial_range = np.array((0,np.inf))
             else:
                 if len(geometry[0]) == 0:
-                    qxy_center = None
+                    center = None
                 else:
-                    qxy_center = np.array(geometry[0])
+                    center = np.array(geometry[0])
                 if isinstance(geometry[1], int) or isinstance(geometry[1], float):
                     radial_range = np.array((0,geometry[1]))
                 elif len(geometry[1]) == 0:
@@ -249,44 +236,30 @@ def get_virtual_image(
         elif mode == 'circular' or mode == 'circle':
             radial_range = np.array((0,geometry[1]))
             if len(geometry[0]) == 0:
-                    qxy_center = None
+                    center = None
             else:
-                qxy_center = np.array(geometry[0])
+                center = np.array(geometry[0])
         elif mode == 'annular' or mode == 'annulus':
             radial_range = np.array(geometry[1])
             if len(geometry[0]) == 0:
-                    qxy_center = None
+                    center = None
             else:
-                qxy_center = np.array(geometry[0])
+                center = np.array(geometry[0])
 
         # allocate space
         im_virtual = np.zeros(self.shape)
 
         # generate image
-        for rx,ry in tqdmnd(
-            self.shape[0],
-            self.shape[1],
-            ):
-            # Get user-specified Bragg vectors
-            p = self.get_vectors(
-                rx,
-                ry,
-                center = center,
-                ellipse = ellipse,
-                pixel = pixel,
-                rotate = rotate,
-                )
-
+        for rx,ry in tqdmnd(self.shape[0],self.shape[1]):
+            p = self.raw[rx,ry]
             if p.data.shape[0] > 0:
                 if radial_range is None:
                     im_virtual[rx,ry] = np.sum(p.I)
                 else:
-                    if qxy_center is None:
+                    if center is None:
                         qr = np.hypot(p.qx,p.qy)
                     else:
-                        qr = np.hypot(
-                            p.qx - qxy_center[0],
-                            p.qy - qxy_center[1])
+                        qr = np.hypot(p.qx - center[0],p.qy - center[1])
                     sub = np.logical_and(
                         qr >= radial_range[0],
                         qr <  radial_range[1])
@@ -311,7 +284,7 @@ def get_virtual_image(
             }
         )
         # attach to the tree
-        self.attach(ans)
+        self.attach( ans)
 
         # return
         if returncalc:
diff --git a/py4DSTEM/braggvectors/braggvectors.py b/py4DSTEM/braggvectors/braggvectors.py
index e3173e466..14b89fd98 100644
--- a/py4DSTEM/braggvectors/braggvectors.py
+++ b/py4DSTEM/braggvectors/braggvectors.py
@@ -65,7 +65,7 @@ def __init__(
         Rshape,
         Qshape,
         name = 'braggvectors',
-        verbose = False,
+        verbose = True,
         calibration = None
         ):
         Custom.__init__(self,name=name)
@@ -236,16 +236,9 @@ def setcal(
             "rotate" : rotate,
         }
         if self.verbose:
-            print('current calibration state: ', self.calstate)
+            print('current calstate: ', self.calstate)
         pass
 
-    def calibrate(self):
-        """
-        Autoupdate the calstate when relevant calibrations are set
-        """
-        self.setcal()
-
-
 
     # vector getter method
 
@@ -257,7 +250,7 @@ def get_vectors(
         ellipse,
         pixel,
         rotate
-        ):
+    ):
         """
         Returns the bragg vectors at the specified scan position with
         the specified calibration state.
@@ -275,7 +268,6 @@ def get_vectors(
         -------
         vectors : BVects
         """
-
         ans = self._v_uncal[scan_x,scan_y].data
         ans = self.cal._transform(
             data = ans,
@@ -290,6 +282,7 @@ def get_vectors(
 
 
     # copy
+
     def copy(self, name=None):
         name = name if name is not None else self.name+"_copy"
         braggvector_copy = BraggVectors(
@@ -302,8 +295,6 @@ def copy(self, name=None):
         braggvector_copy._v_uncal = self._v_uncal.copy()
         for k in self.metadata.keys():
             braggvector_copy.metadata = self.metadata[k].copy()
-        # TODO - fix this calibration line?
-        braggvector_copy.calibration = self.calibration
         return braggvector_copy
 
 
diff --git a/py4DSTEM/braggvectors/probe.py b/py4DSTEM/braggvectors/probe.py
index 856550616..9195d06bd 100644
--- a/py4DSTEM/braggvectors/probe.py
+++ b/py4DSTEM/braggvectors/probe.py
@@ -559,7 +559,6 @@ def get_probe_kernel_edge_sigmoid(
             np.mod(np.arange(Q_Ny) + Q_Ny//2, Q_Ny) - Q_Ny//2,
             np.mod(np.arange(Q_Nx) + Q_Nx//2, Q_Nx) - Q_Nx//2)
         qr = np.sqrt(qx**2 + qy**2)
-        
         # Calculate sigmoid
         if type == 'logistic':
             r0 = 0.5*(ro+ri)
diff --git a/py4DSTEM/data/calibration.py b/py4DSTEM/data/calibration.py
index b5ef200d8..6077864f3 100644
--- a/py4DSTEM/data/calibration.py
+++ b/py4DSTEM/data/calibration.py
@@ -64,8 +64,8 @@ class Calibration(Metadata):
         theta,                                        *
         p_ellipse,                                    *
         ellipse,                                      *
-        QR_rotation_degrees,                          *
-        QR_flip,                                      *
+        QR_rotation_degrees,
+        QR_flip,
         QR_rotflip,                                   *
         probe_semiangle,
         probe_param,
@@ -598,18 +598,17 @@ def ellipse(self,x):
 
     # Q/R-space rotation and flip
 
-    @call_calibrate
     def set_QR_rotation_degrees(self,x):
         self._params['QR_rotation_degrees'] = x
     def get_QR_rotation_degrees(self):
         return self._get_value('QR_rotation_degrees')
 
-    @call_calibrate
     def set_QR_flip(self,x):
         self._params['QR_flip'] = x
     def get_QR_flip(self):
         return self._get_value('QR_flip')
 
+    @call_calibrate
     def set_QR_rotflip(self, rot_flip):
         """
         Args:
diff --git a/py4DSTEM/datacube/datacube.py b/py4DSTEM/datacube/datacube.py
index f56836555..3031b3ff9 100644
--- a/py4DSTEM/datacube/datacube.py
+++ b/py4DSTEM/datacube/datacube.py
@@ -3,7 +3,7 @@
 import numpy as np
 from scipy.interpolate import interp1d
 from scipy.ndimage import (binary_opening, binary_dilation,
-    distance_transform_edt, binary_fill_holes, gaussian_filter1d, gaussian_filter)
+    distance_transform_edt, binary_fill_holes, gaussian_filter1d)
 from typing import Optional,Union
 
 from emdfile import Array, Metadata, Node, Root, tqdmnd
@@ -1015,11 +1015,8 @@ def find_Bragg_disks(
     def get_beamstop_mask(
         self,
         threshold = 0.25,
-        distance_edge = 2.0,
+        distance_edge = 4.0,
         include_edges = True,
-        sigma = 0,
-        use_max_dp = False,
-        scale_radial = None,
         name = "mask_beamstop",
         returncalc = True,
         ):
@@ -1034,12 +1031,6 @@ def get_beamstop_mask(
             distance_edge (float): How many pixels to expand the mask.
             include_edges (bool): If set to True, edge pixels will be included
                 in the mask.
-            sigma (float):
-                Gaussain blur std to apply to image before thresholding.
-            use_max_dp (bool):
-                Use the max DP instead of the mean DP.
-            scale_radial (float):
-                Scale from center of image by this factor (can help with edge)
             name (string): Name of the output array.
             returncalc (bool): Set to true to return the result.
 
@@ -1048,42 +1039,19 @@ def get_beamstop_mask(
 
         """
 
-        if scale_radial is not None:
-            x = np.arange(self.data.shape[2]) * 2.0 / self.data.shape[2]
-            y = np.arange(self.data.shape[3]) * 2.0 / self.data.shape[3]
-            ya, xa = np.meshgrid(y - np.mean(y), x - np.mean(x))
-            im_scale = 1.0 + np.sqrt(xa**2 + ya**2)*scale_radial
-
-        # Get image for beamstop mask
-        if use_max_dp:
-            # if not "dp_mean" in self.tree.keys():
-            #     self.get_dp_max();
-            # im = self.tree["dp_max"].data.astype('float')
-            if not "dp_max" in self._branch.keys():
-                self.get_dp_max();
-            im = self.tree("dp_max").data.copy().astype('float')
-        else:
-            if not "dp_mean" in self._branch.keys():
-                self.get_dp_mean();
-            im = self.tree("dp_mean").data.copy()
-
-            # if not "dp_mean" in self.tree.keys():
-            #     self.get_dp_mean();
-            # im = self.tree["dp_mean"].data.astype('float')
-
-        # smooth and scale if needed
-        if sigma > 0.0:
-            im = gaussian_filter(im, sigma, mode='nearest')
-        if scale_radial is not None:
-            im *= im_scale
-
-        # Calculate beamstop mask
-        int_sort = np.sort(im.ravel())
+        # Calculate dp_mean if needed
+        if not "dp_mean" in self._branch.keys():
+            self.get_dp_mean();
+
+        # normalized dp_mean
+        int_sort = np.sort(self.tree("dp_mean").data.ravel())
         ind = np.round(np.clip(
                 int_sort.shape[0]*threshold,
                 0,int_sort.shape[0])).astype('int')
         intensity_threshold = int_sort[ind]
-        mask_beamstop = im >= intensity_threshold
+
+        # Use threshold to calculate initial mask
+        mask_beamstop = self.tree("dp_mean").data >= intensity_threshold
 
         # clean up mask
         mask_beamstop = np.logical_not(binary_fill_holes(np.logical_not(mask_beamstop)))
@@ -1120,7 +1088,7 @@ def get_beamstop_mask(
         )
 
         # Add to tree
-        self.tree(x)
+        self.attach( mask_beamstop )
 
         # return
         if returncalc:
diff --git a/py4DSTEM/preprocess/preprocess.py b/py4DSTEM/preprocess/preprocess.py
index 162b9a32d..c156c228e 100644
--- a/py4DSTEM/preprocess/preprocess.py
+++ b/py4DSTEM/preprocess/preprocess.py
@@ -265,6 +265,8 @@ def bin_data_diffraction(
     # set dim vectors
     Qpixsize = datacube.calibration.get_Q_pixel_size() * bin_factor
     Qpixunits = datacube.calibration.get_Q_pixel_units()
+    
+    
     datacube.set_dim(
         2,
         [0,Qpixsize],
@@ -281,6 +283,7 @@ def bin_data_diffraction(
     # set calibration pixel size
     datacube.calibration.set_Q_pixel_size(Qpixsize)
 
+
     # return
     return datacube
 
diff --git a/py4DSTEM/process/calibration/origin.py b/py4DSTEM/process/calibration/origin.py
index 8821b43d0..0b27f5a85 100644
--- a/py4DSTEM/process/calibration/origin.py
+++ b/py4DSTEM/process/calibration/origin.py
@@ -73,12 +73,11 @@ def fit_origin(
 ):
     """
     Fits the position of the origin of diffraction space to a plane or parabola,
-    given some 2D arrays (qx0_meas,qy0_meas) of measured center positions,
-    optionally masked by the Boolean array `mask`. The 2D data arrays may be
-    passed directly as a 2-tuple to the arg `data`, or, if `data` is either a
-    DataCube or Calibration instance, they will be retreived automatically. If a
-    DataCube or Calibration are passed, fitted origin and residuals are stored
-    there directly.
+    given some 2D arrays (qx0_meas,qy0_meas) of measured center positions, optionally
+    masked by the Boolean array `mask`. The 2D data arrays may be passed directly as
+    a 2-tuple to the arg `data`, or, if `data` is either a DataCube or Calibration
+    instance, they will be retreived automatically. If a DataCube or Calibration are
+    passed, fitted origin and residuals are stored there directly.
 
     Args:
         data (2-tuple of 2d arrays): the measured origin position (qx0,qy0)
diff --git a/py4DSTEM/process/diffraction/crystal.py b/py4DSTEM/process/diffraction/crystal.py
index 3be87eb25..228602692 100644
--- a/py4DSTEM/process/diffraction/crystal.py
+++ b/py4DSTEM/process/diffraction/crystal.py
@@ -898,19 +898,12 @@ def calculate_bragg_peak_histogram(
         k = np.arange(k_min, k_max + k_step, k_step)
         k_num = k.shape[0]
 
-        # concatenate all peaks
+        # experimental data histogram
         bigpl = np.concatenate(
             [
-                bragg_peaks.get_vectors(
-                    rx,
-                    ry,
-                    center = True,
-                    ellipse = True,
-                    pixel = True,
-                    rotate = True,
-                ).data
-                for rx in range(bragg_peaks.shape[0])
-                for ry in range(bragg_peaks.shape[1])
+                bragg_peaks.cal[i, j].data
+                for i in range(bragg_peaks.shape[0])
+                for j in range(bragg_peaks.shape[1])
             ]
         )
         qr = np.sqrt(bigpl["qx"] ** 2 + bigpl["qy"] ** 2)
diff --git a/py4DSTEM/process/diffraction/crystal_ACOM.py b/py4DSTEM/process/diffraction/crystal_ACOM.py
index 686de7847..4d02dcb0b 100644
--- a/py4DSTEM/process/diffraction/crystal_ACOM.py
+++ b/py4DSTEM/process/diffraction/crystal_ACOM.py
@@ -8,8 +8,6 @@
 from py4DSTEM.process.diffraction.utils import Orientation, OrientationMap, axisEqual3D
 from py4DSTEM.process.utils import electron_wavelength_angstrom
 
-from warnings import warn
-
 from numpy.linalg import lstsq
 try:
     import cupy as cp
@@ -769,18 +767,6 @@ def match_orientations(
         num_x=bragg_peaks_array.shape[0],
         num_y=bragg_peaks_array.shape[1],
         num_matches=num_matches_return)
-    
-    #check cal state
-    if bragg_peaks_array.calstate['ellipse'] == False:
-        ellipse = False
-        warn('Warning: bragg peaks not elliptically calibrated')
-    else:
-        ellipse = True
-    if bragg_peaks_array.calstate['rotate'] == False:
-        rotate = False
-        warn('bragg peaks not rotationally calibrated')
-    else:
-        rotate = True
 
     for rx, ry in tqdmnd(
         *bragg_peaks_array.shape,
@@ -788,17 +774,9 @@ def match_orientations(
         unit=" PointList",
         disable=not progress_bar,
     ):
-        vectors = bragg_peaks_array.get_vectors(
-            scan_x=rx,
-            scan_y=ry,
-            center=True,
-            ellipse=ellipse,
-            pixel=True,
-            rotate=rotate
-        )
 
         orientation = self.match_single_pattern(
-            bragg_peaks=vectors,
+            bragg_peaks_array.cal[rx, ry],
             num_matches_return=num_matches_return,
             min_number_peaks=min_number_peaks,
             inversion_symmetry=inversion_symmetry,
@@ -1661,18 +1639,6 @@ def calculate_strain(
         corr_kernel_size = self.orientation_kernel_size
     radius_max_2 = corr_kernel_size**2
 
-    #check cal state
-    if bragg_peaks_array.calstate['ellipse'] == False:
-        ellipse = False
-        warn('bragg peaks not elliptically calibrated')
-    else:
-        ellipse = True
-    if bragg_peaks_array.calstate['rotate'] == False:
-        rotate = False
-        warn('bragg peaks not rotationally calibrated')
-    else:
-        rotate = True
-
     # Loop over all probe positions
     for rx, ry in tqdmnd(
         *bragg_peaks_array.shape,
@@ -1681,14 +1647,7 @@ def calculate_strain(
         disable=not progress_bar,
         ):
         # Get bragg peaks from experiment and reference
-        p = bragg_peaks_array.get_vectors(
-            scan_x=rx,
-            scan_y=ry,
-            center=True,
-            ellipse=ellipse,
-            pixel=True,
-            rotate=rotate
-        )
+        p = bragg_peaks_array.cal[rx,ry]
 
         if p.data.shape[0] >= min_num_peaks:
             p_ref = self.generate_diffraction_pattern(
@@ -2112,3 +2071,4 @@ def symmetry_reduce_directions(
 
     # "-3m": ["fiber", [0, 0, 1], [90.0, 60.0]],
     # "-3m": ["fiber", [0, 0, 1], [180.0, 30.0]],
+
diff --git a/py4DSTEM/process/diffraction/crystal_calibrate.py b/py4DSTEM/process/diffraction/crystal_calibrate.py
index d4be6abce..2d08cd03c 100644
--- a/py4DSTEM/process/diffraction/crystal_calibrate.py
+++ b/py4DSTEM/process/diffraction/crystal_calibrate.py
@@ -24,7 +24,7 @@ def calibrate_pixel_size(
         k_step = 0.002,
         k_broadening = 0.002,
         fit_all_intensities = True,
-        set_calibration_in_place = False,
+        set_calibration = True,
         verbose = True,
         plot_result = False,
         figsize: Union[list, tuple, np.ndarray] = (12, 6),
@@ -60,13 +60,8 @@ def calibrate_pixel_size(
         figsize (list, tuple, np.ndarray): Figure size of the plot.
         returnfig (bool): Return handles figure and axis
 
-    Returns
-    _______
-
-    
-
-    fig, ax: handles, optional 
-        Figure and axis handles, if returnfig=True.
+    Returns:
+        fig, ax (handles): Optional figure and axis handles, if returnfig=True.
 
     """
 
@@ -117,21 +112,17 @@ def fit_profile(k, *coefs):
 
     # Get the answer
     pix_size_prev = bragg_peaks.calibration.get_Q_pixel_size()
-    pixel_size_new = pix_size_prev / scale_pixel_size
+    ans = pix_size_prev / scale_pixel_size
 
-    # if requested, apply calibrations in place
-    if set_calibration_in_place:
-        bragg_peaks.calibration.set_Q_pixel_size( pixel_size_new )
+    # if requested, apply calibrations
+    if set_calibration:
+        bragg_peaks.calibration.set_Q_pixel_size( ans )
         bragg_peaks.calibration.set_Q_pixel_units('A^-1')
+        bragg_peaks.setcal()
 
-    # Output calibrated Bragg peaks
-    bragg_peaks_cali = bragg_peaks.copy()
-    bragg_peaks_cali.calibration.set_Q_pixel_size( pixel_size_new )
-    bragg_peaks_cali.calibration.set_Q_pixel_units('A^-1')
-
-    # Output pixel size
+    # Output
     if verbose:
-        print(f"Calibrated pixel size = {np.round(pixel_size_new, decimals=8)} A^-1")
+        print(f"Calibrated pixel size = {np.round(ans, decimals=8)} A^-1")
 
     # Plotting
     if plot_result:
@@ -172,9 +163,9 @@ def fit_profile(k, *coefs):
 
     # return
     if returnfig and plot_result:
-        return bragg_peaks_cali, (fig,ax)
+        return ans, (fig,ax)
     else:
-        return bragg_peaks_cali
+        return ans
 
 
 
diff --git a/py4DSTEM/process/diffraction/crystal_viz.py b/py4DSTEM/process/diffraction/crystal_viz.py
index 9395682a0..9c1f5b667 100644
--- a/py4DSTEM/process/diffraction/crystal_viz.py
+++ b/py4DSTEM/process/diffraction/crystal_viz.py
@@ -296,48 +296,30 @@ def plot_scattering_intensity(
     bragg_k_power=0.0,
     bragg_intensity_power=1.0,
     bragg_k_broadening=0.005,
-    figsize: Union[list, tuple, np.ndarray] = (10, 4),
+    figsize: Union[list, tuple, np.ndarray] = (12, 6),
     returnfig: bool = False,
 ):
     """
     1D plot of the structure factors
 
-    Parameters
-    --------
-
-    k_min: float                      
-        min k value for profile range.
-    k_max: float                      
-        max k value for profile range.
-    k_step: float                     
-        Step size of k in profile range.
-    k_broadening: float               
-        Broadening of simulated pattern.
-    k_power_scale: float              
-        Scale SF intensities by k**k_power_scale.
-    int_power_scale: float            
-        Scale SF intensities**int_power_scale.
-    int_scale: float                  
-        Scale output profile by this value.
-    remove_origin: bool               
-        Remove origin from plot.
-    bragg_peaks: BraggVectors         
-        Passed in bragg_peaks for comparison with simulated pattern.
-    bragg_k_power: float              
-        bragg_peaks scaled by k**bragg_k_power.
-    bragg_intensity_power: float      
-        bragg_peaks scaled by intensities**bragg_intensity_power.
-    bragg_k_broadening: float  
-        Broadening applied to bragg_peaks.
-    figsize: list, tuple, np.ndarray
-        Figure size for plot.
-    returnfig (bool):                   
-        Return figure and axes handles if this is True.
-
-    Returns
-    --------
-    fig, ax (optional) 
-        figure and axes handles
+    Args:
+        k_min (float):                      min k value for profile range.
+        k_max (float):                      max k value for profile range.
+        k_step (float):                     step size of k in profile range.
+        k_broadening (float):               Broadening of simulated pattern.
+        k_power_scale (float):              Scale SF intensities by k**k_power_scale.
+        int_power_scale (float):            Scale SF intensities**int_power_scale.
+        int_scale (float):                  Scale output profile by this value.
+        remove_origin (bool):               Remove origin from plot.
+        bragg_peaks (BraggVectors):         Passed in bragg_peaks for comparison with simulated pattern.
+        bragg_k_power (float):              bragg_peaks scaled by k**bragg_k_power.
+        bragg_intensity_power (float):      bragg_peaks scaled by intensities**bragg_intensity_power.
+        bragg_k_broadening float):          Broadening applied to bragg_peaks.
+        figsize (list, tuple, np.ndarray):  Figure size for plot.
+        returnfig (bool):                   Return figure and axes handles if this is True.
+
+    Returns:
+        fig, ax                     (optional) figure and axes handles
     """
 
     # k coordinates
@@ -363,16 +345,9 @@ def plot_scattering_intensity(
         # concatenate all peaks
         bigpl = np.concatenate(
             [
-                bragg_peaks.get_vectors(
-                    rx,
-                    ry,
-                    center = True,
-                    ellipse = True,
-                    pixel = True,
-                    rotate = True,
-                ).data
-                for rx in range(bragg_peaks.shape[0])
-                for ry in range(bragg_peaks.shape[1])
+                bragg_peaks.cal[i, j].data
+                for i in range(bragg_peaks.shape[0])
+                for j in range(bragg_peaks.shape[1])
             ]
         )
 
@@ -928,9 +903,6 @@ def plot_diffraction_pattern(
     ax.set_ylabel("$q_x$ [Å$^{-1}$]")
 
     if plot_range_kx_ky is not None:
-        plot_range_kx_ky = np.array(plot_range_kx_ky)
-        if plot_range_kx_ky.ndim == 0:
-            plot_range_kx_ky = np.array((plot_range_kx_ky,plot_range_kx_ky))
         ax.set_xlim((-plot_range_kx_ky[0], plot_range_kx_ky[0]))
         ax.set_ylim((-plot_range_kx_ky[1], plot_range_kx_ky[1]))
     else:
diff --git a/py4DSTEM/process/diffraction/flowlines.py b/py4DSTEM/process/diffraction/flowlines.py
index 27d4f9381..c2fa224fa 100644
--- a/py4DSTEM/process/diffraction/flowlines.py
+++ b/py4DSTEM/process/diffraction/flowlines.py
@@ -15,7 +15,7 @@
 
 
 def make_orientation_histogram(
-    bragg_peaks: PointListArray = None,
+    bragg_peaks: PointList = None,
     radial_ranges: np.ndarray = None,
     orientation_map = None,
     orientation_ind: int = 0,
diff --git a/py4DSTEM/process/fit/fit.py b/py4DSTEM/process/fit/fit.py
index 9abb713f7..e3bb4d86e 100644
--- a/py4DSTEM/process/fit/fit.py
+++ b/py4DSTEM/process/fit/fit.py
@@ -29,49 +29,44 @@ def fit_1D_gaussian(xdata,ydata,xmin,xmax):
     A,mu,sigma = scale*popt[0],popt[1],popt[2]
     return A,mu,sigma
 
-def fit_2D(
-    function,
-    data,
-    data_mask=None,
-    popt=None,
-    robust=False,
-    robust_steps=3,
-    robust_thresh=2,
-    ):
+def fit_2D(function, data, data_mask=None, popt=None,
+    robust=False, robust_steps=3, robust_thresh=2):
     """
-    Performs a 2D fit.
-
-    TODO: make returning the mask optional
-
-    Parameters
-    ----------
-    function : callable
-        Some `function( xy, **p)` where `xy` is a length 2 vector (1D np array)
-        specifying the pixel position (x,y), and `p` is the function parameters
-    data : ndarray
-        Some 2D array of any shape (n,m)
-    data_mask : None or boolean array of shape (n,m), optional
-        If specified, fits only the pixels in `data` where this array is True
-    popt : dict
-        Initial guess at the parameters `p` of `function`. Note that positions
-        in pixels (i.e. the xy positions) are linearly scaled to the space [0,1]
-    robust : bool
-        Toggles robust fitting, which iteratively rejects outlier data points
-        which have a root-mean-square error beyond `robust_thresh`
-    robust_steps : int
-        The number of robust fitting iterations to perform
-    robust_thresh : int
-        The robust fitting cutoff
+    Performs a 2D fit, where the fit function takes its first input in the form of a
+    length 2 vector (ndarray) of (x,y) positions, followed by the remaining parameters,
+    and the data to fit takes the form of an (n,m) shaped array. Robust fitting can be
+    enabled to iteratively reject outlier data points, which have a root-mean-square
+    error beyond the user-specified threshold.
+
+    Args:
+        function: First input should be a length 2 array xy, where (xy[0],xy[1]) are the
+            (x,y) coordinates
+        data: Data to fit, in an (n,m) shaped ndarray
+        data_mask:  Optional parameter. If specified, must be a boolean array of the same
+            shape as data, specifying which elements of data to use in the fit
+        return_ar: Optional parameter. If False, only the fit parameters and covariance
+            matrix are returned. If True, return an array  of the same shape as data with
+            the fit values. Defaults to True
+        popt: Optional parameter for input. If specified, should be a tuple of initial
+            guesses for the fit parameters.
+        robust: Optional parameter. If set to True, fit will be repeated with outliers
+            removed.
+        robust_steps: Optional parameter. Number of robust iterations performed after
+            initial fit.
+        robust_thresh: Optional parameter. Threshold for including points, in units of
+            root-mean-square (standard deviations) error of the predicted values after
+            fitting.
 
     Returns:
-    (popt,pcov,fit_at, mask) : 4-tuple
-        The optimal fit parameters, the fitting covariance matrix, the
-        the fit array with the returned `popt` params, and the mask
+        (3-tuple) A 3-tuple containing:
+
+            * **popt**: optimal fit parameters to function
+            * **pcov**: the covariance matrix
+            * **fit_ar**: optional. If return_ar==True, fit_ar is returned, and is an
+              array of the same shape as data, containing the fit values
     """
-    # get shape
     shape = data.shape
     shape1D = [1,np.prod(shape)]
-
     # x and y coordinates normalized from 0 to 1
     x,y = np.linspace(0, 1, shape[0]),np.linspace(0, 1, shape[1])
     ry,rx = np.meshgrid(y,x)
@@ -83,10 +78,8 @@ def fit_2D(
     if robust==False:
         robust_steps=0
 
-    # least squares fitting
+    # least squares fitting - 1st iteration 
     for k in range(robust_steps+1):
-
-        # in 1st iteration, set up params and mask
         if k == 0:
             if popt is None:
                 popt = np.zeros((1,len(signature(function).parameters)-1))
@@ -94,26 +87,21 @@ def fit_2D(
                 mask = data_mask
             else:
                 mask = np.ones(shape,dtype=bool)
-
-        # otherwise, get fitting error and add high error pixels to mask
         else:
-            fit_mean_square_error = (
-                function(xy,*popt).reshape(shape) - data)**2
-            _mask = fit_mean_square_error > np.mean(
-                fit_mean_square_error) * robust_thresh**2
-            mask[_mask] == False
+            fit_mean_square_error = (function(xy,*popt).reshape(shape) - data)**2
+            mask = fit_mean_square_error <= np.mean(fit_mean_square_error) * robust_thresh**2
+            # include user-specified mask if provided
+            if data_mask is not None:
+                mask[data_mask==False] = False
 
         # perform fitting
-        popt, pcov = curve_fit(
-            function,
-            np.vstack((
-                rx_1D[mask.reshape(shape1D)],
-                ry_1D[mask.reshape(shape1D)])),
+        popt, pcov = curve_fit(function,
+            np.vstack((rx_1D[mask.reshape(shape1D)],ry_1D[mask.reshape(shape1D)])),
             data[mask],
             p0=popt)
 
     fit_ar = function(xy,*popt).reshape(shape)
-    return popt, pcov, fit_ar, mask
+    return popt, pcov, fit_ar
 
 
 # Functions for fitting
@@ -139,137 +127,5 @@ def bezier_two(xy, c00, c01, c02, c10, c11, c12, c20, c21, c22):
         c12*2*(1-xy[0])*xy[0] * (xy[1]**2) + \
         c22  *(xy[0]**2)      * (xy[1]**2)
 
-def polar_gaussian_2D(
-    tq,
-    I0,
-    mu_t,
-    mu_q,
-    sigma_t,
-    sigma_q,
-    C,
-    ):
-    # unpack position
-    t,q = tq
-    # set theta value to its closest periodic reflection to mu_t
-    #t = np.square(t-mu_t)
-    #t2 = np.min(np.vstack([t,1-t]))
-    t2 = np.square(t-mu_t)
-    return \
-        I0 * np.exp(
-            - ( t2/(2*sigma_t**2) + \
-                (q-mu_q)**2/(2*sigma_q**2) ) ) + C
-
-
-def polar_twofold_gaussian_2D(
-    tq,
-    I0,
-    mu_t,
-    mu_q,
-    sigma_t,
-    sigma_q,
-    ):
-    
-    # unpack position
-    t,q = tq
-
-    # theta periodicity
-    dt = np.mod(t - mu_t + np.pi/2, np.pi) - np.pi/2
-
-    # output intensity
-    return I0 * np.exp(
-        (dt**2 / (-2.0*sigma_t**2)) + \
-        ((q - mu_q)**2 / (-2.0*sigma_q**2)) )
-
-def polar_twofold_gaussian_2D_background(
-    tq,
-    I0,
-    mu_t,
-    mu_q,
-    sigma_t,
-    sigma_q,
-    C,
-    ):
-    
-    # unpack position
-    t,q = tq
-
-    # theta periodicity
-    dt = np.mod(t - mu_t + np.pi/2, np.pi) - np.pi/2
-
-    # output intensity
-    return C + I0 * np.exp(
-        (dt**2 / (-2.0*sigma_t**2)) + \
-        ((q - mu_q)**2 / (-2.0*sigma_q**2)) )
-
-
-def fit_2D_polar_gaussian(
-    data,
-    mask = None,
-    p0 = None,
-    robust = False,
-    robust_steps = 3,
-    robust_thresh = 2,
-    constant_background = False,
-    ):
-    """
-
-    NOTE - this cannot work without using pixel coordinates - something is wrong in the workflow.
-
-
-    Fits a 2D gaussian to the pixels in `data` which are set to True in `mask`.
-
-    The gaussian is anisotropic and oriented along (t,q), centered at
-    (mu_t,mu_q), has standard deviations (sigma_t,sigma_q), maximum of I0,
-    and an optional constant offset of C, and is periodic in t.
-
-        f(x,y) = I0 * exp( - (x-mu_x)^2/(2sig_x^2) + (y-mu_y)^2/(2sig_y^2) )
-        or
-        f(x,y) = I0 * exp( - (x-mu_x)^2/(2sig_x^2) + (y-mu_y)^2/(2sig_y^2) ) + C
-
-    Parameters
-    ----------
-    data : 2d array
-        the data to fit
-    p0 : 6-tuple
-        initial guess at fit parameters, (I0,mu_x,mu_y,sigma_x_sigma_y,C)
-    mask : 2d boolean array
-        ignore pixels where mask is False
-    robust : bool
-        toggle robust fitting
-    robust_steps : int
-        number of robust fit iterations
-    robust_thresh : number
-        the robust fitting threshold
-    constant_background : bool
-        whether or not to include constant background
-
-    Returns
-    -------
-    (popt,pcov,fit_ar) : 3-tuple
-        the optimal fit parameters, the covariance matrix, and the fit array
-    """
-
-    if constant_background:
-        return fit_2D(
-            polar_twofold_gaussian_2D_background,
-            data = data,
-            data_mask = mask,
-            popt = p0,
-            robust = robust,
-            robust_steps = robust_steps,
-            robust_thresh = robust_thresh
-        )
-    else:
-        return fit_2D(
-            polar_twofold_gaussian_2D,
-            data = data,
-            data_mask = mask,
-            popt = p0,
-            robust = robust,
-            robust_steps = robust_steps,
-            robust_thresh = robust_thresh
-        )
-
-
 
 
diff --git a/py4DSTEM/process/phase/iterative_multislice_ptychography.py b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
index 8be875b15..1e9bd2cbb 100644
--- a/py4DSTEM/process/phase/iterative_multislice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
@@ -974,7 +974,7 @@ def _gradient_descent_adjoint(
                 )
 
             # back-transmit
-            exit_waves *= xp.conj(obj) #/ xp.abs(obj) ** 2
+            exit_waves *= xp.conj(obj) / xp.abs(obj) ** 2
 
             if s > 0:
                 # back-propagate
@@ -1076,7 +1076,7 @@ def _projection_sets_adjoint(
                 )
 
             # back-transmit
-            exit_waves_copy *= xp.conj(obj) # / xp.abs(obj) ** 2
+            exit_waves_copy *= xp.conj(obj) / xp.abs(obj) ** 2
 
             if s > 0:
                 # back-propagate
diff --git a/py4DSTEM/process/polar/__init__.py b/py4DSTEM/process/polar/__init__.py
index ddf0a9e50..741e0c610 100644
--- a/py4DSTEM/process/polar/__init__.py
+++ b/py4DSTEM/process/polar/__init__.py
@@ -1,3 +1,3 @@
 from py4DSTEM.process.polar.polar_datacube import PolarDatacube
 from py4DSTEM.process.polar.polar_fits import fit_amorphous_ring, plot_amorphous_ring
-from py4DSTEM.process.polar.polar_peaks import find_peaks_single_pattern, find_peaks, refine_peaks, plot_radial_peaks, plot_radial_background, make_orientation_histogram
+
diff --git a/py4DSTEM/process/polar/polar_datacube.py b/py4DSTEM/process/polar/polar_datacube.py
index 3f3db0eca..f1d4277fb 100644
--- a/py4DSTEM/process/polar/polar_datacube.py
+++ b/py4DSTEM/process/polar/polar_datacube.py
@@ -21,7 +21,7 @@ def __init__(
         mask = None,
         mask_thresh = 0.25,
         ellipse = True,
-        two_fold_symmetry = False,
+        two_fold_rotation = False,
         ):
         """
         Parameters
@@ -29,15 +29,14 @@ def __init__(
         datacube : DataCube
             The datacube in cartesian coordinates
         qmin : number
-            Minumum radius of the polar transformation, in pixels
+            Minumum radius of the polar transformation
         qmax : number or None
-            Maximum radius of the polar transformation, in pixels
+            Maximum radius of the polar transformation
         qstep : number
-            Width of radial bins, in pixels
+            Width of radial bins
         n_annular : integer
             Number of bins in the annular direction. Bins will each
-            have a width of 360/n_annular, or 180/n_annular if
-            two_fold_rotation is set to True, in degrees
+            have a width of 360/num_annular_bins, in degrees
         qscale : number or None
             Radial scaling power to apply to polar transform
         mask : boolean array
@@ -50,10 +49,9 @@ def __init__(
             performs an elliptic transform iff elliptic calibrations are
             available.
         two_fold_rotation : bool
-            Setting to True computes the transform mod(theta,pi), i.e. assumes
-            all patterns possess two-fold rotation (Friedel symmetry).  The
-            output angular range in this case becomes [0, pi) as opposed to the
-            default of [0,2*pi).
+            Setting to True computes the transform mod(theta,pi), i.e. assumes all patterns
+            posess two-fold rotation (Friedel symmetry).  The output angular range in this case
+            becomes [0, pi) as opposed to the default of [0,2*pi).
         """
 
         # attach datacube
@@ -70,12 +68,17 @@ def __init__(
 
         # setup sampling
 
+        # annular range, depending on if polar transform spans pi or 2*pi
+        if two_fold_rotation:
+            self._annular_range = np.pi
+        else:
+            self._annular_range = 2.0 * np.pi
+
         # polar
         self._qscale = qscale
         if qmax is None:
             qmax = np.min(self._datacube.Qshape) / np.sqrt(2)
-        self._n_annular = n_annular
-        self.two_fold_symmetry = two_fold_symmetry #implicitly calls set_annular_bins
+        self.set_annular_bins(n_annular)
         self.set_radial_bins(qmin,qmax,qstep)
 
         # cartesian
@@ -99,16 +102,6 @@ def __init__(
         plot_FEM_global,
         calculate_FEM_local,
     )
-    from py4DSTEM.process.polar.polar_peaks import (
-        find_peaks_single_pattern,
-        find_peaks,
-        refine_peaks_local,
-        refine_peaks,
-        plot_radial_peaks,
-        plot_radial_background,
-        model_radial_background,
-        make_orientation_histogram,
-    )
 
 
     # sampling methods + properties
@@ -128,7 +121,6 @@ def set_radial_bins(
             self._qstep
         )
         self.qscale = self._qscale
-        self._radial_step = self._datacube.calibration.get_Q_pixel_size() * self._qstep
         self.set_polar_shape()
 
     @property
@@ -184,18 +176,6 @@ def annular_bins(self):
     @property
     def annular_step(self):
         return self._annular_step
-    @property
-    def two_fold_symmetry(self):
-        return self._two_fold_symmetry
-    @two_fold_symmetry.setter
-    def two_fold_symmetry(self,x):
-        assert(isinstance(x,bool)), f"two_fold_symmetry must be boolean, not type {type(x)}"
-        self._two_fold_symmetry = x
-        if x:
-            self._annular_range = np.pi
-        else:
-            self._annular_range = 2 * np.pi
-        self.set_annular_bins(self._n_annular)
 
     @property
     def n_annular(self):
@@ -215,22 +195,8 @@ def set_polar_shape(self):
             # set KDE params
             self._annular_bin_step = 1 / (self._annular_step * (self.radial_bins + self.qstep * 0.5))
             self._sigma_KDE = self._annular_bin_step * 0.5
-            # set array indices
-            self._annular_indices = np.arange(self.polar_shape[0]).astype(int)
-            self._radial_indices = np.arange(self.polar_shape[1]).astype(int)
 
 
-    # coordinate grid properties
-    @property
-    def tt(self):
-        return self._annular_bins
-    @property
-    def tt_deg(self):
-        return self._annular_bins * 180/np.pi
-    @property
-    def qq(self):
-        return self.radial_bins * self.calibration.get_Q_pixel_size()
-
 
 
     # scaling property
@@ -476,7 +442,6 @@ def _transform(
             )
             return ans
         elif returnval == 'nan':
-            ans[mask_bool] = np.nan
             return ans
         elif returnval == 'all':
             return ans, ans_norm, norm_array, mask_bool
@@ -507,7 +472,7 @@ def _transform_array(
             # get polar coords
             rr = np.sqrt(x**2 + y**2)
             tt = np.mod(
-                np.arctan2(y, x),
+                np.arctan2(y, x) - np.pi/2,
                 self._polarcube._annular_range)
 
         # elliptical
@@ -515,12 +480,21 @@ def _transform_array(
             # unpack ellipse
             a,b,theta = ellipse
 
-            # Get polar coords
-            xc = x*np.cos(theta) + y*np.sin(theta)
-            yc = (y*np.cos(theta) - x*np.sin(theta))*(a/b)
-            rr = (b/a) * np.hypot(xc,yc)
+            # transformation matrix (elliptic cartesian -> circular cartesian)
+            A = (a/b)*np.cos(theta)
+            B = -np.sin(theta)
+            C = (a/b)*np.sin(theta)
+            D = np.cos(theta)
+            det = 1 / (A*D - B*C)
+
+            # get circular cartesian coords
+            xc =  x*D - y*B
+            yc = -x*C + y*A
+
+            # get polar coords
+            rr = det * np.hypot(xc,yc)
             tt = np.mod(
-                np.arctan2(yc,xc) + theta,
+                np.arctan2(yc,xc) - np.pi/2,
                 self._polarcube._annular_range)
 
         # transform to bin sampling
diff --git a/py4DSTEM/process/polar/polar_fits.py b/py4DSTEM/process/polar/polar_fits.py
index 9d7e50290..ad418939f 100644
--- a/py4DSTEM/process/polar/polar_fits.py
+++ b/py4DSTEM/process/polar/polar_fits.py
@@ -7,14 +7,13 @@
 
 def fit_amorphous_ring(
     im,
-    center = None,
-    radial_range = None,
+    center,
+    radial_range,
     coefs = None,
-    mask_dp = None,
     show_fit_mask = False,
     verbose = False,
     plot_result = True,
-    plot_log_scale = False,
+    plot_log_scale = True,
     plot_int_scale = (-3,3),
     figsize = (8,8),
     return_all_coefs = True,
@@ -28,15 +27,9 @@ def fit_amorphous_ring(
     im: np.array
         2D image array to perform fitting on
     center: np.array
-        (x,y) center coordinates for fitting mask. If not specified 
-        by the user, we will assume the center coordinate is (im.shape-1)/2.
+        (x,y) center coordinates for fitting mask
     radial_range: np.array
-        (radius_inner, radius_outer) radial range to perform fitting over.
-        If not specified by the user, we will assume (im.shape[0]/4,im.shape[0]/2).
-    coefs: np.array (optional)
-        Array containing initial fitting coefficients for the amorphous fit.
-    mask_dp: np.array
-        Dark field mask for fitting, in addition to the radial range specified above.
+        (radius_inner, radius_outer) radial range to perform fitting over
     show_fit_mask: bool
         Set to true to preview the fitting mask and initial guess for the ellipse params
     verbose: bool
@@ -60,14 +53,6 @@ def fit_amorphous_ring(
         11 parameter elliptic fit coefficients
     """
 
-    # Default values
-    if center is None:
-        center = np.array((
-            (im.shape[0]-1)/2,
-            (im.shape[1]-1)/2))
-    if radial_range is None:
-        radial_range = (im.shape[0]/4, im.shape[0]/2)
-
     # coordinates
     xa,ya = np.meshgrid(
         np.arange(im.shape[0]),
@@ -81,9 +66,6 @@ def fit_amorphous_ring(
         ra2 >= radial_range[0]**2,
         ra2 <= radial_range[1]**2,
         )
-    if mask_dp is not None:
-        # Logical AND the radial mask with the user-provided mask
-        mask = np.logical_and(mask, mask_dp)
     vals = im[mask]
     basis = np.vstack((xa[mask],ya[mask]))
 
@@ -136,11 +118,9 @@ def fit_amorphous_ring(
             int_range = (
                 int_med + plot_int_scale[0]*int_std, 
                 int_med + plot_int_scale[1]*int_std)
-            im_plot = np.tile(
-                np.clip(
-                    (np.log(im[:,:,None]) - int_range[0]) / (int_range[1] - int_range[0]),
-                    0,1),
-                (1,1,3))
+            im_plot = np.tile(np.clip(
+                (np.log(im[:,:,None]) - int_range[0]) / (int_range[1] - int_range[0]),
+                0,1),(1,1,3))
 
         else:
             int_med = np.median(vals)
@@ -367,3 +347,4 @@ def amorphous_model(basis, *coefs):
     int_model[sub] += int12*np.exp(dr2[sub]/(-2*sigma2**2))
 
     return int_model
+
diff --git a/py4DSTEM/process/polar/polar_peaks.py b/py4DSTEM/process/polar/polar_peaks.py
deleted file mode 100644
index 3f367b398..000000000
--- a/py4DSTEM/process/polar/polar_peaks.py
+++ /dev/null
@@ -1,1271 +0,0 @@
-
-import numpy as np
-import matplotlib.pyplot as plt
-
-from scipy.ndimage import gaussian_filter, gaussian_filter1d
-from scipy.signal import peak_prominences
-from skimage.feature import peak_local_max
-from scipy.optimize import curve_fit
-import warnings
-
-# from emdfile import tqdmnd, PointList, PointListArray
-from py4DSTEM import tqdmnd, PointList, PointListArray
-from py4DSTEM.process.fit import polar_twofold_gaussian_2D, polar_twofold_gaussian_2D_background
-
-def find_peaks_single_pattern(
-    self,
-    x,
-    y,
-    mask = None,
-    bragg_peaks = None,
-    bragg_mask_radius = None,
-    sigma_annular_deg = 10.0,
-    sigma_radial_px = 3.0,
-    sigma_annular_deg_max = None,
-    radial_background_subtract = True,
-    radial_background_thresh = 0.25,
-    num_peaks_max = 100,
-    threshold_abs = 1.0,
-    threshold_prom_annular = None,
-    threshold_prom_radial = None,
-    remove_masked_peaks = False,
-    scale_sigma_annular = 0.5,
-    scale_sigma_radial = 0.25,
-    return_background = False,
-    plot_result = True,
-    plot_power_scale = 1.0,
-    plot_scale_size = 100.0,
-    returnfig = False,
-    ):
-    """
-    Peak detection function for polar transformations.
-
-    Parameters
-    --------
-    x: int
-        x index of diffraction pattern
-    y: int
-        y index of diffraction pattern
-    mask: np.array
-        Boolean mask in Cartesian space, to filter detected peaks.
-    bragg_peaks: py4DSTEM.BraggVectors
-        Set of Bragg peaks used to generated a mask in Cartesian space, to filter detected peaks
-    sigma_annular_deg: float
-        smoothing along the annular direction in degrees, periodic
-    sigma_radial_px: float
-        smoothing along the radial direction in pixels, not periodic
-    sigma_annular_deg_max: float
-        Specify this value for the max annular sigma.  Peaks larger than this will be split 
-        into multiple peaks, depending on the ratio.
-    radial_background_subtract: bool
-        If true, subtract radial background estimate
-    radial_background_thresh: float
-        Relative order of sorted values to use as background estimate.
-        Setting to 0.5 is equivalent to median, 0.0 is min value.
-    
-    Returns
-    --------
-
-    """
-
-    # if needed, generate mask from Bragg peaks
-    if bragg_peaks is not None:
-        mask_bragg = self._datacube.get_braggmask(
-            bragg_peaks,
-            x,
-            y,
-            radius = bragg_mask_radius,
-        )
-        if mask is None:
-            mask = mask_bragg
-        else:
-            mask = np.logical_or(mask, mask_bragg)
-
-
-    # Convert sigma values into units of bins
-    sigma_annular = np.deg2rad(sigma_annular_deg) / self.annular_step
-    sigma_radial = sigma_radial_px / self.qstep
-    
-    # Get transformed image and normalization array
-    im_polar, im_polar_norm, norm_array, mask_bool = self.transform(
-            self._datacube.data[x,y],
-            mask = mask,
-            returnval = 'all_zeros', 
-        )
-    # Change sign convention of mask
-    mask_bool = np.logical_not(mask_bool)
-
-    # Background subtraction
-    if radial_background_subtract:
-        sig_bg = np.zeros(im_polar.shape[1])
-        for a0 in range(im_polar.shape[1]):
-            if np.any(mask_bool[:,a0]):
-                vals = np.sort(im_polar[mask_bool[:,a0],a0])
-                ind = np.round(radial_background_thresh * (vals.shape[0]-1)).astype('int')
-                sig_bg[a0] = vals[ind]
-        sig_bg_mask = np.sum(mask_bool, axis=0) >= (im_polar.shape[0]//2)
-        im_polar = np.maximum(im_polar - sig_bg[None,:], 0)
-
-    # apply smoothing and normalization
-    im_polar_sm = gaussian_filter(
-        im_polar * norm_array,
-        sigma = (sigma_annular, sigma_radial),
-        mode = ('wrap', 'nearest'),
-        )
-    im_mask = gaussian_filter(
-        norm_array,
-        sigma = (sigma_annular, sigma_radial),
-        mode = ('wrap', 'nearest'),
-        )
-    sub = im_mask > 0.001 * np.max(im_mask)
-    im_polar_sm[sub] /= im_mask[sub]
-
-    # Find local maxima
-    peaks = peak_local_max(
-        im_polar_sm,
-        num_peaks = num_peaks_max,
-        threshold_abs = threshold_abs,
-        )
-
-    # check if peaks should be removed from the polar transformation mask
-    if remove_masked_peaks:
-        peaks = np.delete(
-                peaks,
-                mask_bool[peaks[:,0],peaks[:,1]] == False,
-                axis = 0,
-            )
-
-    # peak intensity
-    peaks_int = im_polar_sm[peaks[:,0],peaks[:,1]]
-
-    # Estimate prominance of peaks, and their size in units of pixels
-    peaks_prom = np.zeros((peaks.shape[0],4))
-    annular_ind_center = np.atleast_1d(np.array(im_polar_sm.shape[0]//2).astype('int'))
-    for a0 in range(peaks.shape[0]):
-
-        # annular
-        trace_annular = np.roll(
-            np.squeeze(im_polar_sm[:,peaks[a0,1]]),
-            annular_ind_center - peaks[a0,0])
-        p_annular = peak_prominences(
-            trace_annular, 
-            annular_ind_center,
-            )
-        sigma_annular = scale_sigma_annular * np.maximum(
-            annular_ind_center - p_annular[1],
-            p_annular[2] - annular_ind_center)
-
-        # radial
-        trace_radial  = im_polar_sm[peaks[a0,0],:]
-        p_radial = peak_prominences(
-            trace_radial, 
-            np.atleast_1d(peaks[a0,1]),
-            )
-        sigma_radial = scale_sigma_radial * np.maximum(
-            peaks[a0,1] - p_radial[1],
-            p_radial[2] - peaks[a0,1])
-
-        # output
-        peaks_prom[a0,0] = p_annular[0]
-        peaks_prom[a0,1] = sigma_annular[0]
-        peaks_prom[a0,2] = p_radial[0]
-        peaks_prom[a0,3] = sigma_radial[0]
-
-    # if needed, remove peaks using prominance criteria
-    if threshold_prom_annular is not None:
-        remove = peaks_prom[:,0] < threshold_prom_annular
-        peaks = np.delete(
-            peaks,
-            remove,
-            axis = 0,
-            )
-        peaks_int = np.delete(
-            peaks_int,
-            remove,
-            )
-        peaks_prom = np.delete(
-            peaks_prom,
-            remove,
-            axis = 0,
-            )
-    if threshold_prom_radial is not None:
-        remove = peaks_prom[:,2] < threshold_prom_radial
-        peaks = np.delete(
-            peaks,
-            remove,
-            axis = 0,
-            )
-        peaks_int = np.delete(
-            peaks_int,
-            remove,
-            )
-        peaks_prom = np.delete(
-            peaks_prom,
-            remove,
-            axis = 0,
-            )
-
-    # combine peaks into one array
-    peaks_all = np.column_stack((peaks, peaks_int, peaks_prom))
-
-    # Split peaks into multiple peaks if they have sigma values larger than user-specified threshold
-    if sigma_annular_deg_max is not None:
-        peaks_new = np.zeros((0,peaks_all.shape[1]))
-        for a0 in range(peaks_all.shape[0]):
-            if peaks_all[a0,4] >= (1.5*sigma_annular_deg_max):
-                num = np.round(peaks_all[a0,4] / sigma_annular_deg_max)
-                sigma_annular_new = peaks_all[a0,4] / num
-
-                v = np.arange(num)
-                v -= np.mean(v)
-                t_new = np.mod(peaks_all[a0,0] + 2*v*sigma_annular_new,
-                    self._n_annular)
-
-                for a1 in range(num.astype('int')):
-                    peaks_new = np.vstack((
-                        peaks_new,
-                        np.array((
-                            t_new[a1],
-                            peaks_all[a0,1],
-                            peaks_all[a0,2],
-                            peaks_all[a0,3],
-                            sigma_annular_new,
-                            peaks_all[a0,5],
-                            peaks_all[a0,6],
-                        )),
-                    ))
-            else:
-                peaks_new = np.vstack((
-                    peaks_new,
-                    peaks_all[a0,:]
-                ))
-        peaks_all = peaks_new
-
-
-    # Output data as a pointlist
-    peaks_polar = PointList(
-            peaks_all.ravel().view([
-            ('qt', float),
-            ('qr', float),
-            ('intensity', float),
-            ('prom_annular', float),
-            ('sigma_annular', float),
-            ('prom_radial', float),
-            ('sigma_radial', float),
-        ]),
-        name = 'peaks_polar')
-    
-
-    if plot_result:
-        # init
-        im_plot = im_polar.copy()
-        im_plot = np.maximum(im_plot, 0) ** plot_power_scale
-
-        t = np.linspace(0,2*np.pi,180+1)
-        ct = np.cos(t)
-        st = np.sin(t)
-
-
-        fig,ax = plt.subplots(figsize=(12,6))
-
-        ax.imshow(
-            im_plot,
-            cmap = 'gray',
-            )
-
-        # peaks
-        ax.scatter(
-            peaks_polar['qr'],
-            peaks_polar['qt'],
-            s = peaks_polar['intensity'] * plot_scale_size,
-            marker='o',
-            color = (1,0,0),
-            )
-        for a0 in range(peaks_polar.data.shape[0]):
-            ax.plot(
-                peaks_polar['qr'][a0] + st * peaks_polar['sigma_radial'][a0],
-                peaks_polar['qt'][a0] + ct * peaks_polar['sigma_annular'][a0],
-                linewidth = 1,
-                color = 'r',
-                )
-            if peaks_polar['qt'][a0] - peaks_polar['sigma_annular'][a0] < 0:
-                ax.plot(
-                    peaks_polar['qr'][a0] + st * peaks_polar['sigma_radial'][a0],
-                    peaks_polar['qt'][a0] + ct * peaks_polar['sigma_annular'][a0] + im_plot.shape[0],
-                    linewidth = 1,
-                    color = 'r',
-                    )
-            if peaks_polar['qt'][a0] + peaks_polar['sigma_annular'][a0] > im_plot.shape[0]:
-                ax.plot(
-                    peaks_polar['qr'][a0] + st * peaks_polar['sigma_radial'][a0],
-                    peaks_polar['qt'][a0] + ct * peaks_polar['sigma_annular'][a0] - im_plot.shape[0],
-                    linewidth = 1,
-                    color = 'r',
-                    )
-
-        # plot appearance
-        ax.set_xlim((0,im_plot.shape[1]-1))
-        ax.set_ylim((im_plot.shape[0]-1,0))
-
-    if returnfig and plot_result:
-        if return_background:
-            return peaks_polar, sig_bg, sig_bg_mask, fig, ax
-        else:
-            return peaks_polar, fig, ax            
-    else:
-        if return_background:
-            return peaks_polar, sig_bg, sig_bg_mask
-        else:
-            return peaks_polar
-
-
-def find_peaks(
-    self,
-    mask = None,
-    bragg_peaks = None,
-    bragg_mask_radius = None,
-    sigma_annular_deg = 10.0,
-    sigma_radial_px = 3.0,
-    sigma_annular_deg_max = None,
-    radial_background_subtract = True,
-    radial_background_thresh = 0.25,
-    num_peaks_max = 100,
-    threshold_abs = 1.0,
-    threshold_prom_annular = None,
-    threshold_prom_radial = None,
-    remove_masked_peaks = False,
-    scale_sigma_annular = 0.5,
-    scale_sigma_radial = 0.25,
-    progress_bar = True,
-    ):
-    """
-    Peak detection function for polar transformations. Loop through all probe positions,
-    find peaks.  Store the peak positions and background signals.
-
-    Parameters
-    --------
-    sigma_annular_deg: float
-        smoothing along the annular direction in degrees, periodic
-    sigma_radial_px: float
-        smoothing along the radial direction in pixels, not periodic
-    
-    Returns
-    --------
-
-    """
-
-    # init
-    self.bragg_peaks = bragg_peaks
-    self.bragg_mask_radius = bragg_mask_radius
-    self.peaks = PointListArray(
-        dtype = [
-        ('qt', '<f8'), 
-        ('qr', '<f8'), 
-        ('intensity', '<f8'), 
-        ('prom_annular', '<f8'), 
-        ('sigma_annular', '<f8'), 
-        ('prom_radial', '<f8'), 
-        ('sigma_radial', '<f8')],
-        shape = self._datacube.Rshape,
-        name = 'peaks_polardata',
-        )
-    self.background_radial = np.zeros((
-        self._datacube.Rshape[0],
-        self._datacube.Rshape[1],
-        self.radial_bins.shape[0],
-        ))
-    self.background_radial_mask = np.zeros((
-        self._datacube.Rshape[0],
-        self._datacube.Rshape[1],
-        self.radial_bins.shape[0],
-        ), dtype='bool')
-
-    # Loop over probe positions
-    for rx, ry in tqdmnd(
-        self._datacube.Rshape[0],
-        self._datacube.Rshape[1],
-        desc="Finding peaks ",
-        unit=" images",
-        disable=not progress_bar,
-        ):
-
-        polar_peaks, sig_bg, sig_bg_mask = self.find_peaks_single_pattern(
-            rx,
-            ry,
-            mask = mask,
-            bragg_peaks = bragg_peaks,
-            bragg_mask_radius = bragg_mask_radius,
-            sigma_annular_deg = sigma_annular_deg,
-            sigma_radial_px = sigma_radial_px,
-            sigma_annular_deg_max = sigma_annular_deg_max,
-            radial_background_subtract = radial_background_subtract,
-            radial_background_thresh = radial_background_thresh,
-            num_peaks_max = num_peaks_max,
-            threshold_abs = threshold_abs,
-            threshold_prom_annular = threshold_prom_annular,
-            threshold_prom_radial = threshold_prom_radial,
-            remove_masked_peaks = remove_masked_peaks,
-            scale_sigma_annular = scale_sigma_annular,
-            scale_sigma_radial = scale_sigma_radial,
-            return_background = True,
-            plot_result = False,
-            )
-
-        self.peaks[rx,ry] = polar_peaks
-        self.background_radial[rx,ry] = sig_bg
-        self.background_radial_mask[rx,ry] = sig_bg_mask
-
-
-def refine_peaks_local(
-    self,
-    mask = None,
-    radial_background_subtract = False,
-    reset_fits_to_init_positions = False,
-    fit_range_sigma_annular = 2.0,
-    fit_range_sigma_radial = 2.0,
-    min_num_pixels_fit = 10,
-    progress_bar = True,
-    ):
-    """
-    Use local 2D elliptic gaussian fitting to refine the peak locations. 
-    Optionally include background offset of the peaks.
-
-    Parameters
-    --------
-    mask: np.array
-        Mask image to apply to all images
-    radial_background_subtract: bool
-        Subtract radial background before fitting
-    reset_init_positions: bool
-        Use the initial peak parameters for fitting
-    fit_range_sigma_annular: float
-        Fit range in annular direction, in terms of the current sigma_annular
-    fit_range_sigma_radial: float
-        Fit range in radial direction, in terms of the current sigma_radial
-    min_num_pixels_fit: int
-        Minimum number of pixels to perform fitting
-    progress_bar: bool
-        Enable progress bar
-
-    Returns
-    --------
-
-    """
-    
-    # See if the intial detected peaks have been saved yet, copy them if needed
-    if not hasattr(self, "peaks_init"):
-        self.peaks_init = self.peaks.copy()
-
-    # coordinate scaling
-    t_step = self._annular_step
-    q_step = self._radial_step
-
-    # Coordinate array for the fit
-    qq,tt = np.meshgrid(
-        self.qq,
-        self.tt,
-        )
-    tq = np.vstack([
-        tt.ravel(),
-        qq.ravel(),
-    ])
-
-    # Loop over probe positions
-    for rx, ry in tqdmnd(
-        self._datacube.Rshape[0],
-        self._datacube.Rshape[1],
-        desc="Refining peaks ",
-        unit=" images",
-        disable=not progress_bar,
-        ):
-        # mask
-        # if needed, generate mask from Bragg peaks
-        if self.bragg_peaks is not None:
-            mask_bragg = self._datacube.get_braggmask(
-                self.bragg_peaks,
-                rx,
-                ry,
-                radius = self.bragg_mask_radius,
-            )
-            if mask is None:
-                mask_fit = mask_bragg
-            else:
-                mask_fit = np.logical_or(mask, mask_bragg)
-
-
-        # Get polar image
-        im_polar, im_polar_norm, norm_array, mask_bool = self.transform(
-                self._datacube.data[rx,ry],
-                mask = mask_fit,
-                returnval = 'all_zeros', 
-            )
-        # Change sign convention of mask
-        mask_bool = np.logical_not(mask_bool)
-        # Background subtraction
-        if radial_background_subtract:
-            sig_bg = self.background_radial[rx,ry]
-            im_polar = np.maximum(im_polar - sig_bg[None,:], 0)
-
-        # initial peak positions
-        if reset_fits_to_init_positions:
-            p = self.peaks_init[rx,ry]
-        else:
-            p = self.peaks[rx,ry]
-
-        # loop over peaks
-        for a0 in range(p.data.shape[0]):
-
-            if radial_background_subtract:
-                # initial parameters
-                p0 = [
-                    p['intensity'][a0],
-                    p['qt'][a0] * t_step,
-                    p['qr'][a0] * q_step,
-                    p['sigma_annular'][a0] * t_step,
-                    p['sigma_radial'][a0] * q_step,
-                    ]
-
-                # Mask around peak for fitting
-                dt = np.mod(tt - p0[1] + np.pi/2, np.pi) - np.pi/2
-                mask_peak = np.logical_and(mask_bool,
-                    dt**2/(fit_range_sigma_annular*p0[3])**2 \
-                    + (qq-p0[2])**2/(fit_range_sigma_radial*p0[4])**2 <= 1)
-
-                if np.sum(mask_peak) > min_num_pixels_fit:
-                    try:
-                        # perform fitting
-                        p0, pcov = curve_fit(
-                            polar_twofold_gaussian_2D, 
-                            tq[:,mask_peak.ravel()], 
-                            im_polar[mask_peak], 
-                            p0 = p0,
-                            # bounds = bounds,
-                            )
-
-                        # Output parameters
-                        self.peaks[rx,ry]['intensity'][a0] = p0[0]
-                        self.peaks[rx,ry]['qt'][a0] = p0[1] / t_step
-                        self.peaks[rx,ry]['qr'][a0] = p0[2] / q_step
-                        self.peaks[rx,ry]['sigma_annular'][a0] = p0[3] / t_step
-                        self.peaks[rx,ry]['sigma_radial'][a0] = p0[4] / q_step
-                    
-                    except:
-                        pass
-
-            else:
-                # initial parameters
-                p0 = [
-                    p['intensity'][a0],
-                    p['qt'][a0] * t_step,
-                    p['qr'][a0] * q_step,
-                    p['sigma_annular'][a0] * t_step,
-                    p['sigma_radial'][a0] * q_step,
-                    0,
-                    ]
-
-                # Mask around peak for fitting
-                dt = np.mod(tt - p0[1] + np.pi/2, np.pi) - np.pi/2
-                mask_peak = np.logical_and(mask_bool,
-                    dt**2/(fit_range_sigma_annular*p0[3])**2 \
-                    + (qq-p0[2])**2/(fit_range_sigma_radial*p0[4])**2 <= 1)
-
-                if np.sum(mask_peak) > min_num_pixels_fit:
-                    try:
-                        # perform fitting
-                        p0, pcov = curve_fit(
-                            polar_twofold_gaussian_2D_background, 
-                            tq[:,mask_peak.ravel()], 
-                            im_polar[mask_peak], 
-                            p0 = p0,
-                            # bounds = bounds,
-                            )
-
-                        # Output parameters
-                        self.peaks[rx,ry]['intensity'][a0] = p0[0]
-                        self.peaks[rx,ry]['qt'][a0] = p0[1] / t_step
-                        self.peaks[rx,ry]['qr'][a0] = p0[2] / q_step
-                        self.peaks[rx,ry]['sigma_annular'][a0] = p0[3] / t_step
-                        self.peaks[rx,ry]['sigma_radial'][a0] = p0[4] / q_step
-
-                    except:
-                        pass
-
-
-def plot_radial_peaks(
-    self,
-    q_pixel_units = False,
-    qmin = None,
-    qmax = None,
-    qstep = None,
-    label_y_axis = False,
-    figsize = (8,4),
-    returnfig = False,
-    ):
-    """
-    Calculate and plot the total peak signal as a function of the radial coordinate.
-
-    """
-    
-    # Get all peak data
-    vects = np.concatenate(
-        [self.peaks[i,j].data for i in range(self._datacube.Rshape[0]) for j in range(self._datacube.Rshape[1])])
-    if q_pixel_units:
-        qr = vects['qr']
-    else:
-        qr = (vects['qr'] + self.qmin) * self._radial_step
-    intensity = vects['intensity']
-
-    # bins
-    if qmin is None:
-        qmin = self.qq[0]
-    if qmax is None:
-        qmax = self.qq[-1]
-    if qstep is None:
-        qstep = self.qq[1] - self.qq[0]
-    q_bins = np.arange(qmin,qmax,qstep)
-    q_num = q_bins.shape[0]
-    if q_pixel_units:
-        q_bins /= self._radial_step
-
-    # histogram
-    q_ind = (qr - q_bins[0]) / (q_bins[1] - q_bins[0])
-    qf = np.floor(q_ind).astype("int")
-    dq = q_ind - qf
-
-    sub = np.logical_and(qf >= 0, qf < q_num)
-    int_peaks = np.bincount(
-        np.floor(q_ind[sub]).astype("int"),
-        weights=(1 - dq[sub]) * intensity[sub],
-        minlength=q_num,
-    )
-    sub = np.logical_and(q_ind >= -1, q_ind < q_num - 1)
-    int_peaks += np.bincount(
-        np.floor(q_ind[sub] + 1).astype("int"),
-        weights=dq[sub] * intensity[sub],
-        minlength=q_num,
-    )
-
-
-    # plotting
-    fig,ax = plt.subplots(figsize = figsize)
-    ax.plot(
-        q_bins,
-        int_peaks,
-        color = 'r',
-        linewidth = 2,
-        )
-    ax.set_xlim((q_bins[0],q_bins[-1]))
-    if q_pixel_units:
-        ax.set_xlabel(
-            'Scattering Angle (pixels)',
-            fontsize = 14,
-            )
-    else:
-        ax.set_xlabel(
-            'Scattering Angle (' + self.calibration.get_Q_pixel_units() +')',
-            fontsize = 14,
-            )
-    ax.set_ylabel(
-        'Total Peak Signal',
-        fontsize = 14,
-        )
-    if not label_y_axis:
-        ax.tick_params(
-            left = False,
-            labelleft = False)
-
-    if returnfig:
-        return fig,ax
-
-
-def model_radial_background(
-    self,
-    ring_position = None,
-    ring_sigma = None,
-    ring_int = None,
-    refine_model = True,
-    plot_result = True,
-    ):
-    """
-    User provided radial background model, of the form:
-
-    int = int_const
-        + int_0 * exp( - q**2 / (2*s0**2) )
-        + int_1 * exp( - (q - q_1)**2 / (2*s1**2) )
-        + ...
-        + int_n * exp( - (q - q_n)**2 / (2*sn**2) )
-
-    where n is the number of amorphous halos / rings included in the fit.
-        
-    """
-
-    # Get mean radial background and mask
-    self.background_radial_mean = np.sum(
-        self.background_radial * self.background_radial_mask,
-        axis=(0,1))
-    background_radial_mean_norm = np.sum(
-        self.background_radial_mask,
-        axis=(0,1))
-    self.background_mask = \
-        background_radial_mean_norm > (np.max(background_radial_mean_norm)*0.05)
-    self.background_radial_mean[self.background_mask] \
-        /= background_radial_mean_norm[self.background_mask]
-    self.background_radial_mean[np.logical_not(self.background_mask)] = 0
-
-    # init
-    if ring_position is not None:
-        ring_position = np.atleast_1d(np.array(ring_position))
-        num_rings = ring_position.shape[0]
-    else:
-        num_rings = 0
-    self.background_coefs = np.zeros(3 + 3*num_rings)
-
-    if ring_sigma is None:
-        ring_sigma = np.atleast_1d(np.ones(num_rings)) \
-            * self.polar_shape[1] * 0.05 * self._radial_step
-    else:
-        ring_sigma = np.atleast_1d(np.array(ring_sigma))
-
-    # Background model initial parameters
-    int_const = np.min(self.background_radial_mean)
-    int_0 = np.max(self.background_radial_mean) - int_const
-    sigma_0 = self.polar_shape[1] * 0.25 * self._radial_step
-    self.background_coefs[0] = int_const
-    self.background_coefs[1] = int_0
-    self.background_coefs[2] = sigma_0
-
-    # Additional Gaussians
-    if ring_int is None:
-        # Estimate peak intensities
-        sig_0 = int_const + int_0*np.exp(self.qq**2/(-2*sigma_0**2))
-        sig_peaks = np.maximum(self.background_radial_mean - sig_0, 0.0)
-
-        ring_int = np.atleast_1d(np.zeros(num_rings))
-        for a0 in range(num_rings):
-            ind = np.argmin(np.abs(self.qq - ring_position[a0]))
-            ring_int[a0] = sig_peaks[ind]
-
-    else:
-        ring_int = np.atleast_1d(np.array(ring_int))
-    for a0 in range(num_rings):
-        self.background_coefs[3*a0+3] = ring_int[a0]
-        self.background_coefs[3*a0+4] = ring_sigma[a0]
-        self.background_coefs[3*a0+5] = ring_position[a0]
-
-    # Create background model
-    def background_model(q, *coefs):
-        coefs = np.squeeze(np.array(coefs))
-        num_rings = np.round((coefs.shape[0] - 3)/3).astype('int')
-
-        sig = np.ones(q.shape[0])*coefs[0]
-        sig += coefs[1]*np.exp(q**2/(-2*coefs[2]**2))
-
-        for a0 in range(num_rings):
-            sig += coefs[3*a0+3]*np.exp(
-                (q-coefs[3*a0+5])**2 / (-2*coefs[3*a0+4]**2))
-
-        return sig
-
-    self.background_model = background_model
-
-    # Refine background model coefficients
-    if refine_model:
-        self.background_coefs = curve_fit(
-            self.background_model, 
-            self.qq[self.background_mask], 
-            self.background_radial_mean[self.background_mask], 
-            p0 = self.background_coefs,
-            xtol = 1e-12,
-            # bounds = (lb,ub),
-        )[0]
-
-    # plotting
-    if plot_result:
-        self.plot_radial_background(
-                q_pixel_units = False,   
-                plot_background_model = True,
-            )
-
-
-
-def refine_peaks(
-    self,
-    mask = None,
-    # reset_fits_to_init_positions = False,
-    scale_sigma_estimate = 0.5,
-    min_num_pixels_fit = 10,
-    progress_bar = True,
-    ):
-    """
-    Use global fitting model for all images. Requires an background model 
-    specified with self.model_radial_background().
-
-    TODO:   add fitting reset
-            add min number pixels condition
-            track any failed fitting points, output as a boolean array
-
-    Parameters
-    --------
-    mask: np.array
-        Mask image to apply to all images
-    radial_background_subtract: bool
-        Subtract radial background before fitting
-    reset_fits_to_init_positions: bool
-        Use the initial peak parameters for fitting
-    scale_sigma_estimate: float
-        Factor to reduce sigma of peaks by, to prevent fit from running away.
-    min_num_pixels_fit: int
-        Minimum number of pixels to perform fitting
-    progress_bar: bool
-        Enable progress bar
-
-    Returns
-    --------
-
-    """
-
-    # coordinate scaling
-    t_step = self._annular_step
-    q_step = self._radial_step
-
-    # Background model params
-    num_rings = np.round((self.background_coefs.shape[0]-3)/3).astype('int')
-
-    # basis
-    qq,tt = np.meshgrid(
-        self.qq,
-        self.tt,
-        )
-    basis = np.zeros((qq.size,3))
-    basis[:,0] = tt.ravel()
-    basis[:,1] = qq.ravel()
-    basis[:,2] = num_rings
-
-    # init
-    self.peaks_refine = PointListArray(
-        dtype = [
-        ('qt', 'float'), 
-        ('qr', 'float'), 
-        ('intensity', 'float'), 
-        ('sigma_annular', 'float'), 
-        ('sigma_radial', 'float')],
-        shape = self._datacube.Rshape,
-        name = 'peaks_polardata_refined',
-        )
-    self.background_refine = np.zeros((
-        self._datacube.Rshape[0],
-        self._datacube.Rshape[1],
-        np.round(3*num_rings+3).astype('int'),
-        ))
-
-
-    # Main loop over probe positions
-    for rx, ry in tqdmnd(
-        self._datacube.shape[0],
-        self._datacube.shape[1],
-        desc="Refining peaks ",
-        unit=" probe positions",
-        disable=not progress_bar):
-
-        # Get transformed image and normalization array
-        im_polar, im_polar_norm, norm_array, mask_bool = self.transform(
-                self._datacube.data[rx,ry],
-                mask = mask,
-                returnval = 'all_zeros', 
-            )
-        # Change sign convention of mask
-        mask_bool = np.logical_not(mask_bool)
-
-        # Get initial peaks, in dimensioned units
-        p = self.peaks[rx,ry]
-        qt = p.data['qt'] * t_step
-        qr = (p.data['qr'] + self.qmin) * q_step
-        int_peaks = p.data['intensity']
-        s_annular = p.data['sigma_annular'] * t_step
-        s_radial = p.data['sigma_radial'] * q_step
-        num_peaks = p['qt'].shape[0]
-
-        # unified coefficients
-        # Note we sharpen sigma estimate for refinement
-        coefs_all = np.hstack((
-            self.background_coefs,
-            qt,
-            qr,
-            int_peaks,
-            s_annular * scale_sigma_estimate,
-            s_radial * scale_sigma_estimate,
-            ))
-
-        # Construct fitting model
-        def fit_image(basis, *coefs):
-            coefs = np.squeeze(np.array(coefs))
-
-            num_rings = np.round(basis[0,2]).astype('int')
-            num_peaks = np.round((coefs.shape[0] - (3*num_rings+3))/5).astype('int')
-
-            coefs_bg = coefs[:(3*num_rings+3)]
-            coefs_peaks = coefs[(3*num_rings+3):]
-
-
-            # Background
-            sig = self.background_model(
-                basis[:,1],
-                coefs_bg)
-
-            # add peaks
-            for a0 in range(num_peaks):
-                dt = np.mod(basis[:,0] - coefs_peaks[num_peaks*0+a0] + np.pi/2, np.pi) - np.pi/2
-                dq = basis[:,1] - coefs_peaks[num_peaks*1+a0]
-
-                sig += coefs_peaks[num_peaks*2+a0] \
-                    * np.exp(
-                        dt**2 / (-2*coefs_peaks[num_peaks*3+a0]**2) + \
-                        dq**2 / (-2*coefs_peaks[num_peaks*4+a0]**2))
-
-            return sig
-
-        # refine fitting model
-        try:
-            with warnings.catch_warnings():
-                warnings.simplefilter('ignore')
-                coefs_all = curve_fit(
-                    fit_image, 
-                    basis[mask_bool.ravel(),:], 
-                    im_polar[mask_bool], 
-                    p0 = coefs_all,
-                    xtol = 1e-12,
-                    # bounds = (lb,ub),
-                )[0]
-
-            # Output refined peak parameters
-            coefs_peaks = np.reshape(
-                coefs_all[(3*num_rings+3):],
-                (5,num_peaks)).T
-            self.peaks_refine[rx,ry] = PointList(
-                coefs_peaks.ravel().view([
-                    ('qt', float),
-                    ('qr', float),
-                    ('intensity', float),
-                    ('sigma_annular', float),
-                    ('sigma_radial', float),
-                ]),
-                name = 'peaks_polar')
-        except:
-            # if fitting has failed, we will output the mean background signal,
-            # but none of the peaks.
-            pass
-
-        # Output refined parameters for background
-        coefs_bg = coefs_all[:(3*num_rings+3)]
-        self.background_refine[rx,ry] = coefs_bg
-
-
-    # # Testing
-    # im_fit = np.reshape(
-    #     fit_image(basis,coefs_all),
-    #     self.polar_shape)
-
-
-    # fig,ax = plt.subplots(figsize=(8,6))
-    # ax.imshow(
-    #     np.vstack((
-    #         im_polar,
-    #         im_fit,
-    #     )),
-    #     cmap = 'turbo',
-    #     )
-
-
-def plot_radial_background(
-    self,
-    q_pixel_units = False,
-    label_y_axis = False,
-    plot_background_model = False,
-    figsize = (8,4),
-    returnfig = False,
-    ):
-    """
-    Calculate and plot the mean background signal, background standard deviation.
-
-    """
-    
-    # mean
-    self.background_radial_mean = np.sum(
-        self.background_radial * self.background_radial_mask,
-        axis=(0,1))
-    background_radial_mean_norm = np.sum(
-        self.background_radial_mask,
-        axis=(0,1))
-    self.background_mask = \
-        background_radial_mean_norm > (np.max(background_radial_mean_norm)*0.05)
-    self.background_radial_mean[self.background_mask] \
-        /= background_radial_mean_norm[self.background_mask]
-    self.background_radial_mean[np.logical_not(self.background_mask)] = 0
-
-    # variance and standard deviation
-    self.background_radial_var = np.sum(
-        (self.background_radial - self.background_radial_mean[None,None,:])**2 \
-        * self.background_radial_mask,
-        axis=(0,1))
-    self.background_radial_var[self.background_mask] \
-        /= self.background_radial_var[self.background_mask]
-    self.background_radial_var[np.logical_not(self.background_mask)] = 0
-    self.background_radial_std = np.sqrt(self.background_radial_var)
-
-
-    if q_pixel_units:
-        q_axis = np.arange(self.qq.shape[0])
-    else:
-        q_axis = self.qq[self.background_mask]
-
-    fig,ax = plt.subplots(figsize = figsize)
-    ax.fill_between(
-        q_axis, 
-        self.background_radial_mean[self.background_mask] \
-        - self.background_radial_std[self.background_mask], 
-        self.background_radial_mean[self.background_mask] \
-        + self.background_radial_std[self.background_mask], 
-        color = 'r',
-        alpha=0.2,
-        )
-    ax.plot(
-        q_axis,
-        self.background_radial_mean[self.background_mask],
-        color = 'r',
-        linewidth = 2,
-        )
-
-    # overlay fitting model
-    if plot_background_model:
-        sig = self.background_model(
-            self.qq,
-            self.background_coefs,
-            )
-        ax.plot(
-            q_axis,
-            sig,
-            color = 'k',
-            linewidth = 2,
-            linestyle = '--'
-            )
-
-    # plot appearance
-    ax.set_xlim((
-        q_axis[0],
-        q_axis[-1]))
-    if q_pixel_units:
-        ax.set_xlabel(
-            'Scattering Angle (pixels)',
-            fontsize = 14,
-            )
-    else:
-        ax.set_xlabel(
-            'Scattering Angle (' + self.calibration.get_Q_pixel_units() +')',
-            fontsize = 14,
-            )
-    ax.set_ylabel(
-        'Background Signal',
-        fontsize = 14,
-        )
-    if not label_y_axis:
-        ax.tick_params(
-            left = False,
-            labelleft = False)
-
-    if returnfig:
-        return fig,ax
-
-
-def make_orientation_histogram(
-    self,
-    radial_ranges: np.ndarray = None,
-    orientation_flip_sign: bool = False,
-    orientation_offset_degrees: float = 0.0,
-    orientation_separate_bins: bool = False,
-    upsample_factor: float = 4.0,
-    use_refined_peaks = True,
-    use_peak_sigma = False,
-    peak_sigma_samples = 6,
-    theta_step_deg: float = None,
-    sigma_x: float = 1.0,
-    sigma_y: float = 1.0,
-    sigma_theta: float = 3.0,
-    normalize_intensity_image: bool = False,
-    normalize_intensity_stack: bool = True,
-    progress_bar: bool = True,
-    ):
-    """
-    Make an orientation histogram, in order to use flowline visualization of orientation maps.
-    Use peaks attached to polardatacube.
-
-    NOTE - currently assumes two fold rotation symmetry
-    TODO - add support for non two fold symmetry polardatacube
-
-    Args:
-        radial_ranges (np array):           Size (N x 2) array for N radial bins, or (2,) for a single bin.
-        orientation_flip_sign (bool):       Flip the direction of theta
-        orientation_offset_degrees (float): Offset for orientation angles
-        orientation_separate_bins (bool):   whether to place multiple angles into multiple radial bins.
-        upsample_factor (float):            Upsample factor
-        use_refined_peaks (float):          Use refined peak positions
-        use_peak_sigma (float):             Spread signal along annular direction using measured std.
-        theta_step_deg (float):             Step size along annular direction in degrees
-        sigma_x (float):                    Smoothing in x direction before upsample
-        sigma_y (float):                    Smoothing in x direction before upsample
-        sigma_theta (float):                Smoothing in annular direction (units of bins, periodic)
-        normalize_intensity_image (bool):   Normalize to max peak intensity = 1, per image
-        normalize_intensity_stack (bool):   Normalize to max peak intensity = 1, all images
-        progress_bar (bool):                Enable progress bar
-
-    Returns:
-        orient_hist (array):                4D array containing Bragg peak intensity histogram 
-                                            [radial_bin x_probe y_probe theta]
-    """
-
-    # coordinates
-    if theta_step_deg is None:
-        # Get angles from polardatacube
-        theta = self.tt
-    else:
-        theta = np.arange(0,180,theta_step_deg) * np.pi / 180.0
-    dtheta = theta[1] - theta[0]
-    dtheta_deg = dtheta * 180 / np.pi
-    num_theta_bins = np.size(theta)
-
-    # Input bins
-    radial_ranges = np.array(radial_ranges)
-    if radial_ranges.ndim == 1:
-        radial_ranges = radial_ranges[None,:]
-    radial_ranges_2 = radial_ranges**2
-    num_radii = radial_ranges.shape[0]
-    size_input = self._datacube.shape[0:2]
-
-    # Output size
-    size_output = np.round(np.array(size_input).astype('float') * upsample_factor).astype('int')
-
-    # output init
-    orient_hist = np.zeros([
-        num_radii,
-        size_output[0],
-        size_output[1],
-        num_theta_bins])
-
-    if use_peak_sigma:
-        v_sigma = np.linspace(-2,2,2*peak_sigma_samples+1)
-        w_sigma = np.exp(-v_sigma**2/2)
-
-    # Loop over all probe positions
-    for a0 in range(num_radii):
-        t = "Generating histogram " + str(a0)
-
-        for rx, ry in tqdmnd(
-                *size_input, 
-                desc=t,
-                unit=" probe positions", 
-                disable=not progress_bar
-            ):
-            x = (rx + 0.5)*upsample_factor - 0.5
-            y = (ry + 0.5)*upsample_factor - 0.5
-            x = np.clip(x,0,size_output[0]-2)
-            y = np.clip(y,0,size_output[1]-2)
-
-            xF = np.floor(x).astype('int')
-            yF = np.floor(y).astype('int')
-            dx = x - xF
-            dy = y - yF
-
-            add_data = False
-            if use_refined_peaks:
-                q = self.peaks_refine[rx,ry]['qr']
-            else:
-                q = (self.peaks[rx,ry]['qr'] + self.qmin) * self._radial_step
-            r2 = q**2
-            sub = np.logical_and(r2 >= radial_ranges_2[a0,0], r2 < radial_ranges_2[a0,1])                
-
-            if np.any(sub):
-                add_data = True
-                intensity = self.peaks[rx,ry]['intensity'][sub]
-
-                # Angles of all peaks
-                if use_refined_peaks:
-                    theta = self.peaks_refine[rx,ry]['qt'][sub]
-                else:
-                    theta = self.peaks[rx,ry]['qt'][sub] * self._annular_step
-                if orientation_flip_sign:
-                    theta *= -1
-                theta += orientation_offset_degrees
-
-                t = theta / dtheta
-
-                # If needed, expand signal using peak sigma to write into multiple bins
-                if use_peak_sigma:
-                    theta_std = self.peaks_refine[rx,ry]['sigma_annular'][sub] / dtheta
-                    t = (t[:,None] + theta_std[:,None]*v_sigma[None,:]).ravel()
-                    intensity = (intensity[:,None] * w_sigma[None,:]).ravel()
-
-            if add_data:
-                tF = np.floor(t).astype('int')
-                dt = t - tF
-
-                orient_hist[a0,xF  ,yF  ,:] = orient_hist[a0,xF  ,yF  ,:] + \
-                    np.bincount(np.mod(tF  ,num_theta_bins),
-                        weights=(1-dx)*(1-dy)*(1-dt)*intensity,minlength=num_theta_bins)
-                orient_hist[a0,xF  ,yF  ,:] = orient_hist[a0,xF  ,yF  ,:] + \
-                    np.bincount(np.mod(tF+1,num_theta_bins),
-                        weights=(1-dx)*(1-dy)*(  dt)*intensity,minlength=num_theta_bins)
-
-                orient_hist[a0,xF+1,yF  ,:] = orient_hist[a0,xF+1,yF  ,:] + \
-                    np.bincount(np.mod(tF  ,num_theta_bins),
-                        weights=(  dx)*(1-dy)*(1-dt)*intensity,minlength=num_theta_bins)
-                orient_hist[a0,xF+1,yF  ,:] = orient_hist[a0,xF+1,yF  ,:] + \
-                    np.bincount(np.mod(tF+1,num_theta_bins),
-                        weights=(  dx)*(1-dy)*(  dt)*intensity,minlength=num_theta_bins)
- 
-                orient_hist[a0,xF  ,yF+1,:] = orient_hist[a0,xF  ,yF+1,:] + \
-                    np.bincount(np.mod(tF  ,num_theta_bins),
-                        weights=(1-dx)*(  dy)*(1-dt)*intensity,minlength=num_theta_bins)
-                orient_hist[a0,xF  ,yF+1,:] = orient_hist[a0,xF  ,yF+1,:] + \
-                    np.bincount(np.mod(tF+1,num_theta_bins),
-                        weights=(1-dx)*(  dy)*(  dt)*intensity,minlength=num_theta_bins)
-
-                orient_hist[a0,xF+1,yF+1,:] = orient_hist[a0,xF+1,yF+1,:] + \
-                    np.bincount(np.mod(tF  ,num_theta_bins),
-                        weights=(  dx)*(  dy)*(1-dt)*intensity,minlength=num_theta_bins)
-                orient_hist[a0,xF+1,yF+1,:] = orient_hist[a0,xF+1,yF+1,:] + \
-                    np.bincount(np.mod(tF+1,num_theta_bins),
-                        weights=(  dx)*(  dy)*(  dt)*intensity,minlength=num_theta_bins)           
-
-    # smoothing / interpolation
-    if (sigma_x is not None) or (sigma_y is not None) or (sigma_theta is not None):
-        if num_radii > 1:
-            print('Interpolating orientation matrices ...', end='')
-        else:
-            print('Interpolating orientation matrix ...', end='')            
-        if sigma_x is not None and sigma_x > 0:
-            orient_hist = gaussian_filter1d(
-                orient_hist,sigma_x*upsample_factor,
-                mode='nearest',
-                axis=1,
-                truncate=3.0)
-        if sigma_y is not None and sigma_y > 0:
-            orient_hist = gaussian_filter1d(
-                orient_hist,sigma_y*upsample_factor,
-                mode='nearest',
-                axis=2,
-                truncate=3.0)
-        if sigma_theta is not None and sigma_theta > 0:
-            orient_hist = gaussian_filter1d(
-                orient_hist,sigma_theta/dtheta_deg,
-                mode='wrap',
-                axis=3,
-                truncate=2.0)
-        print(' done.')
-
-    # normalization
-    if normalize_intensity_stack is True:
-            orient_hist = orient_hist / np.max(orient_hist)
-    elif normalize_intensity_image is True:
-        for a0 in range(num_radii):
-            orient_hist[a0,:,:,:] = orient_hist[a0,:,:,:] / np.max(orient_hist[a0,:,:,:])
-
-    return orient_hist
\ No newline at end of file
diff --git a/py4DSTEM/visualize/show.py b/py4DSTEM/visualize/show.py
index 82ce248d2..3b9d99e43 100644
--- a/py4DSTEM/visualize/show.py
+++ b/py4DSTEM/visualize/show.py
@@ -320,9 +320,6 @@ def show(
         if intensity_range is None:
             intensity_range = clipvals
 
-    if scalebar == True: 
-        scalebar = {}
-
     # plot a grid if `ar` is a list, or use multichannel functionality to make an RGBa image
     ar = ar[0] if (isinstance(ar,list) and len(ar) == 1) else ar
     if isinstance(ar,list):
@@ -394,6 +391,8 @@ def show(
             # Output image for plotting
             ar = ar_rgb
 
+    if scalebar == True: 
+        scalebar = {}
 
     # support for native data types
     elif not isinstance(ar,np.ndarray):
@@ -568,12 +567,8 @@ def show(
                     ax.matshow(mask_display,cmap=cmap,alpha=mask_alpha,vmin=vmin,vmax=vmax)
         # ...or, plot its histogram
         else:
-            # hist,bin_edges = np.histogram(
-            #     _ar,
-            #     bins=np.linspace(np.min(_ar),np.max(_ar),num=n_bins))
-            hist,bin_edges = np.histogram(
-                _ar,
-                bins=np.linspace(vmin,vmax,num=n_bins))
+            hist,bin_edges = np.histogram(_ar,bins=np.linspace(np.min(_ar),
+                                                    np.max(_ar),num=n_bins))
             w = bin_edges[1]-bin_edges[0]
             x = bin_edges[:-1]+w/2.
             ax.bar(x,hist,width=w)

From 9c60597826a40e3e51aa2e062c92dcebab416703 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 14 Jul 2023 12:01:40 -0700
Subject: [PATCH 295/362] rotated

---
 py4DSTEM/process/strain.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index 3ce202e4b..372ae7397 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -438,7 +438,7 @@ def get_strain(
             flip_theta=flip_theta,
         )
 
-        self.data = strainmap_rotated
+        self.strainmap_rotated = strainmap_rotated
 
         from py4DSTEM.visualize import show_strain
 
@@ -450,7 +450,7 @@ def get_strain(
         axes_plots = kwargs.pop("axes_plots", ())
 
         fig, ax = show_strain(
-            self.data,
+            self.strainmap_rotated,
             vrange_exx=vrange_exx,
             vrange_theta=vrange_theta,
             ticknumber=ticknumber,

From 855ce3d5e27ee3a2afbcc09bf2458a08078651ed Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 14 Jul 2023 13:21:24 -0700
Subject: [PATCH 296/362] fix copy method

---
 py4DSTEM/process/strain.py    | 153 +++++-----------------------------
 py4DSTEM/visualize/overlay.py |  22 ++---
 2 files changed, 33 insertions(+), 142 deletions(-)

diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index 372ae7397..247b60a06 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -330,7 +330,7 @@ def fit_lattice_vectors(
             vis_params : dict
                 additional visualization parameters passed to `show`
             returncalc : bool
-                if True, returns braggdirections, bragg_vectors_indexed, g1g2_map
+                if True, returns bragg_directions, bragg_vectors_indexed, g1g2_map
         """
         # check the calstate
         assert (
@@ -354,7 +354,7 @@ def fit_lattice_vectors(
         if plot:
             self.show_bragg_indexing(
                 self.bvm,
-                braggdirections=braggdirections,
+                bragg_directions=braggdirections,
                 points=True,
                 **vis_params,
             )
@@ -364,7 +364,7 @@ def fit_lattice_vectors(
 
         bragg_vectors_indexed = add_indices_to_braggvectors(
             self.braggvectors,
-            self.braggdirections,
+            self.bragg_directions,
             maxPeakSpacing=max_peak_spacing,
             qx_shift=self.braggvectors.Qshape[0] / 2,
             qy_shift=self.braggvectors.Qshape[1] / 2,
@@ -380,7 +380,7 @@ def fit_lattice_vectors(
         self.g1g2_map = g1g2_map
 
         if returncalc:
-            braggdirections, bragg_vectors_indexed, g1g2_map
+            bragg_directions, bragg_vectors_indexed, g1g2_map
 
     def get_strain(
         self, mask=None, g_reference=None, flip_theta=False, returncalc=False, **kwargs
@@ -521,7 +521,7 @@ def show_lattice_vectors(
     def show_bragg_indexing(
         self,
         ar,
-        braggdirections,
+        bragg_directions,
         voffset=5,
         hoffset=0,
         color="w",
@@ -540,13 +540,13 @@ def show_bragg_indexing(
             bragg_directions    (PointList) the bragg scattering directions; must have coordinates
                                 'qx','qy','h', and 'k'. Optionally may also have 'l'.
         """
-        assert isinstance(braggdirections, PointList)
+        assert isinstance(bragg_directions, PointList)
         for k in ("qx", "qy", "h", "k"):
-            assert k in braggdirections.data.dtype.fields
+            assert k in bragg_directions.data.dtype.fields
 
         fig, ax = show(ar, returnfig=True, **kwargs)
         d = {
-            "braggdirections": braggdirections,
+            "bragg_directions": bragg_directions,
             "voffset": voffset,
             "hoffset": hoffset,
             "color": color,
@@ -566,134 +566,25 @@ def show_bragg_indexing(
     def copy(self, name=None):
         name = name if name is not None else self.name + "_copy"
         strainmap_copy = StrainMap(self.braggvectors)
+        for attr in (
+            "g",
+            "g0",
+            "g1",
+            "g2",
+            "calstate",
+            "bragg_directions",
+            "bragg_vectors_indexed",
+            "g1g2_map",
+            "strainmap_g1g2",
+            "strainmap_rotated",
+        ):
+            if hasattr(self, attr):
+                setattr(strainmap_copy, attr, getattr(self, attr))
 
         for k in self.metadata.keys():
             strainmap_copy.metadata = self.metadata[k].copy()
         return strainmap_copy
 
-    # def index_bragg_directions(x0, y0, gx, gy, g1, g2):
-    #     """
-    #     From an origin (x0,y0), a set of reciprocal lattice vectors gx,gy, and an pair of
-    #     lattice vectors g1=(g1x,g1y), g2=(g2x,g2y), find the indices (h,k) of all the
-    #     reciprocal lattice directions.
-
-    #     The approach is to solve the matrix equation
-    #             ``alpha = beta * M``
-    #     where alpha is the 2xN array of the (x,y) coordinates of N measured bragg directions,
-    #     beta is the 2x2 array of the two lattice vectors u,v, and M is the 2xN array of the
-    #     h,k indices.
-
-    #     Args:
-    #         x0 (float): x-coord of origin
-    #         y0 (float): y-coord of origin
-    #         gx (1d array): x-coord of the reciprocal lattice vectors
-    #         gy (1d array): y-coord of the reciprocal lattice vectors
-    #         g1 (2-tuple of floats): g1x,g1y
-    #         g2 (2-tuple of floats): g2x,g2y
-
-    #     Returns:
-    #         (3-tuple) A 3-tuple containing:
-
-    #             * **h**: *(ndarray of ints)* first index of the bragg directions
-    #             * **k**: *(ndarray of ints)* second index of the bragg directions
-    #             * **bragg_directions**: *(PointList)* a 4-coordinate PointList with the
-    #               indexed bragg directions; coords 'qx' and 'qy' contain bragg_x and bragg_y
-    #               coords 'h' and 'k' contain h and k.
-    #     """
-    #     # Get beta, the matrix of lattice vectors
-    #     beta = np.array([[g1[0],g2[0]],[g1[1],g2[1]]])
-
-    #     # Get alpha, the matrix of measured bragg angles
-    #     alpha = np.vstack([gx-x0,gy-y0])
-
-    #     # Calculate M, the matrix of peak positions
-    #     M = lstsq(beta, alpha, rcond=None)[0].T
-    #     M = np.round(M).astype(int)
-
-    #     # Get h,k
-    #     h = M[:,0]
-    #     k = M[:,1]
-
-    #     # Store in a PointList
-    #     coords = [('qx',float),('qy',float),('h',int),('k',int)]
-    #     temp_array = np.zeros([], dtype = coords)
-    #     bragg_directions = PointList(data = temp_array)
-    #     bragg_directions.add_data_by_field((gx,gy,h,k))
-
-    #     return h,k, bragg_directions
-
-    # def add_indices_to_braggvectors(
-    #     braggpeaks, lattice, maxPeakSpacing, qx_shift=0, qy_shift=0, mask=None
-    # ):
-    #     """
-    #     Using the peak positions (qx,qy) and indices (h,k) in the PointList lattice,
-    #     identify the indices for each peak in the PointListArray braggpeaks.
-    #     Return a new braggpeaks_indexed PointListArray, containing a copy of braggpeaks plus
-    #     three additional data columns -- 'h','k', and 'index_mask' -- specifying the peak
-    #     indices with the ints (h,k) and indicating whether the peak was successfully indexed
-    #     or not with the bool index_mask. If `mask` is specified, only the locations where
-    #     mask is True are indexed.
-
-    #     Args:
-    #         braggpeaks (PointListArray): the braggpeaks to index. Must contain
-    #             the coordinates 'qx', 'qy', and 'intensity'
-    #         lattice (PointList): the positions (qx,qy) of the (h,k) lattice points.
-    #             Must contain the coordinates 'qx', 'qy', 'h', and 'k'
-    #         maxPeakSpacing (float): Maximum distance from the ideal lattice points
-    #             to include a peak for indexing
-    #         qx_shift,qy_shift (number): the shift of the origin in the `lattice` PointList
-    #             relative to the `braggpeaks` PointListArray
-    #         mask (bool): Boolean mask, same shape as the pointlistarray, indicating which
-    #             locations should be indexed. This can be used to index different regions of
-    #             the scan with different lattices
-
-    #     Returns:
-    #         (PointListArray): The original braggpeaks pointlistarray, with new coordinates
-    #         'h', 'k', containing the indices of each indexable peak.
-    #     """
-
-    #     assert isinstance(braggpeaks, PointListArray)
-    #     assert np.all(
-    #         [name in braggpeaks.dtype.names for name in ("qx", "qy", "intensity")]
-    #     )
-    #     assert isinstance(lattice, PointList)
-    #     assert np.all([name in lattice.dtype.names for name in ("qx", "qy", "h", "k")])
-
-    #     if mask is None:
-    #         mask = np.ones(braggpeaks.shape, dtype=bool)
-
-    #     assert mask.shape == braggpeaks.shape, "mask must have same shape as pointlistarray"
-    #     assert mask.dtype == bool, "mask must be boolean"
-
-    #     indexed_braggpeaks = braggpeaks.copy()
-
-    #     # add the coordinates if they don't exist
-    #     if not ("h" in braggpeaks.dtype.names):
-    #         indexed_braggpeaks = indexed_braggpeaks.add_fields([("h", int)])
-    #     if not ("k" in braggpeaks.dtype.names):
-    #         indexed_braggpeaks = indexed_braggpeaks.add_fields([("k", int)])
-
-    #     # loop over all the scan positions
-    #     for Rx, Ry in tqdmnd(mask.shape[0], mask.shape[1]):
-    #         if mask[Rx, Ry]:
-    #             pl = indexed_braggpeaks.get_pointlist(Rx, Ry)
-    #             rm_peak_mask = np.zeros(pl.length, dtype=bool)
-
-    #             for i in range(pl.length):
-    #                 r2 = (pl.data["qx"][i] - lattice.data["qx"] + qx_shift) ** 2 + (
-    #                     pl.data["qy"][i] - lattice.data["qy"] + qy_shift
-    #                 ) ** 2
-    #                 ind = np.argmin(r2)
-    #                 if r2[ind] <= maxPeakSpacing**2:
-    #                     pl.data["h"][i] = lattice.data["h"][ind]
-    #                     pl.data["k"][i] = lattice.data["k"][ind]
-    #                 else:
-    #                     rm_peak_mask[i] = True
-    #             pl.remove(rm_peak_mask)
-
-    #     indexed_braggpeaks.name = braggpeaks.name + "_indexed"
-    #     return indexed_braggpeaks
-
     # IO methods
 
     # read
diff --git a/py4DSTEM/visualize/overlay.py b/py4DSTEM/visualize/overlay.py
index e0c87a427..7e7147a15 100644
--- a/py4DSTEM/visualize/overlay.py
+++ b/py4DSTEM/visualize/overlay.py
@@ -437,7 +437,7 @@ def add_bragg_index_labels(ax,d):
     Adds labels for indexed bragg directions to a plot, using the parameters in dict d.
 
     The dictionary d has required and optional parameters as follows:
-        braggdirections (req'd) (PointList) the Bragg directions. This PointList must have
+        bragg_directions (req'd) (PointList) the Bragg directions. This PointList must have
                         the fields 'qx','qy','h', and 'k', and may optionally have 'l'
         voffset         (number) vertical offset for the labels
         hoffset         (number) horizontal offset for the labels
@@ -450,12 +450,12 @@ def add_bragg_index_labels(ax,d):
     # handle inputs
     assert isinstance(ax,Axes)
     # bragg directions
-    assert('braggdirections' in d.keys())
-    braggdirections = d['braggdirections']
-    assert isinstance(braggdirections,PointList)
+    assert('bragg_directions' in d.keys())
+    bragg_directions = d['bragg_directions']
+    assert isinstance(bragg_directions,PointList)
     for k in ('qx','qy','h','k'):
-        assert k in braggdirections.data.dtype.fields
-    include_l = True if 'l' in braggdirections.data.dtype.fields else False
+        assert k in bragg_directions.data.dtype.fields
+    include_l = True if 'l' in bragg_directions.data.dtype.fields else False
     # offsets
     hoffset = d['hoffset'] if 'hoffset' in d.keys() else 0
     voffset = d['voffset'] if 'voffset' in d.keys() else 5
@@ -474,20 +474,20 @@ def add_bragg_index_labels(ax,d):
 
     # add the points
     if points:
-        ax.scatter(braggdirections.data['qy'],braggdirections.data['qx'],
+        ax.scatter(bragg_directions.data['qy'],bragg_directions.data['qx'],
                    color=pointcolor,s=pointsize)
 
     # add index labels
-    for i in range(braggdirections.length):
-        x,y = braggdirections.data['qx'][i],braggdirections.data['qy'][i]
+    for i in range(bragg_directions.length):
+        x,y = bragg_directions.data['qx'][i],bragg_directions.data['qy'][i]
         x -= voffset
         y += hoffset
-        h,k = braggdirections.data['h'][i],braggdirections.data['k'][i]
+        h,k = bragg_directions.data['h'][i],bragg_directions.data['k'][i]
         h = str(h) if h>=0 else r'$\overline{{{}}}$'.format(np.abs(h))
         k = str(k) if k>=0 else r'$\overline{{{}}}$'.format(np.abs(k))
         s = h+','+k
         if include_l:
-            l = braggdirections.data['l'][i]
+            l = bragg_directions.data['l'][i]
             l = str(l) if l>=0 else r'$\overline{{{}}}$'.format(np.abs(l))
             s += l
         ax.text(y,x,s,color=color,size=size,ha='center',va='bottom')

From b54fd47d63a0a9da136a03a96ee42ddb05977f34 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 14 Jul 2023 13:34:13 -0700
Subject: [PATCH 297/362] hot fix for fit origin

---
 py4DSTEM/process/calibration/origin.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/py4DSTEM/process/calibration/origin.py b/py4DSTEM/process/calibration/origin.py
index 8821b43d0..2b4138a74 100644
--- a/py4DSTEM/process/calibration/origin.py
+++ b/py4DSTEM/process/calibration/origin.py
@@ -134,14 +134,14 @@ def fit_origin(
 
         # Fit data
         if mask is None:
-            popt_x, pcov_x, qx0_fit = fit_2D(
+            popt_x, pcov_x, qx0_fit, _ = fit_2D(
                 f,
                 qx0_meas,
                 robust=robust,
                 robust_steps=robust_steps,
                 robust_thresh=robust_thresh,
             )
-            popt_y, pcov_y, qy0_fit = fit_2D(
+            popt_y, pcov_y, qy0_fit, _ = fit_2D(
                 f,
                 qy0_meas,
                 robust=robust,
@@ -150,7 +150,7 @@ def fit_origin(
             )
 
         else:
-            popt_x, pcov_x, qx0_fit = fit_2D(
+            popt_x, pcov_x, qx0_fit, _ = fit_2D(
                 f,
                 qx0_meas,
                 robust=robust,
@@ -158,7 +158,7 @@ def fit_origin(
                 robust_thresh=robust_thresh,
                 data_mask=mask == True,
             )
-            popt_y, pcov_y, qy0_fit = fit_2D(
+            popt_y, pcov_y, qy0_fit, _ = fit_2D(
                 f,
                 qy0_meas,
                 robust=robust,

From 145f1b08296a7a4279c9194f54f1144e89131be4 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 14 Jul 2023 14:43:06 -0700
Subject: [PATCH 298/362] flatfield correction

---
 py4DSTEM/io/filereaders/read_arina.py | 27 +++++++++++++++++++++++----
 1 file changed, 23 insertions(+), 4 deletions(-)

diff --git a/py4DSTEM/io/filereaders/read_arina.py b/py4DSTEM/io/filereaders/read_arina.py
index 2982d7f7f..323b5643f 100644
--- a/py4DSTEM/io/filereaders/read_arina.py
+++ b/py4DSTEM/io/filereaders/read_arina.py
@@ -11,6 +11,7 @@ def read_arina(
     mem="RAM",
     binfactor: int = 1,
     dtype_bin: float = None,
+    flatfield: np.ndarray = None,
 ):
 
     """
@@ -26,6 +27,8 @@ def read_arina(
         binfactor (int): Diffraction space binning factor for bin-on-load.
         dtype_bin(float): specify datatype for bin on load if need something
             other than uint16
+        flatfield (np.ndarray):
+            flatfield forcorrection factors
 
     Returns:
         DataCube
@@ -60,9 +63,20 @@ def read_arina(
 
     image_index = 0
 
+    if flatfield is None:
+        correction_factors = 1
+    else:
+        # Avoid div by 0 errors -> pixel with value 0 will be set to meadian
+        flatfield[flatfield == 0] = 1
+        correction_factors = np.median(flatfield) / flatfield
+
     for dset in f["entry"]["data"]:
         image_index = _processDataSet(
-            f["entry"]["data"][dset], image_index, array_3D, binfactor
+            f["entry"]["data"][dset],
+            image_index,
+            array_3D,
+            binfactor,
+            correction_factors,
         )
 
     if f.__bool__():
@@ -82,15 +96,20 @@ def read_arina(
     return datacube
 
 
-def _processDataSet(dset, start_index, array_3D, binfactor):
+def _processDataSet(dset, start_index, array_3D, binfactor, correction_factors):
     image_index = start_index
     nimages_dset = dset.shape[0]
 
     for i in range(nimages_dset):
         if binfactor == 1:
-            array_3D[image_index] = dset[i].astype(array_3D.dtype)
+            array_3D[image_index] = np.multiply(
+                dset[i].astype(array_3D.dtype), correction_factors
+            )
         else:
-            array_3D[image_index] = bin2D(dset[i].astype(array_3D.dtype), binfactor)
+            array_3D[image_index] = bin2D(
+                np.multiply(dset[i].astype(array_3D.dtype), correction_factors),
+                binfactor,
+            )
 
         image_index = image_index + 1
     return image_index

From b5a86fa07f1315188ad5f42b2c18ed6dd4aaa8ca Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Mon, 17 Jul 2023 09:45:37 -0400
Subject: [PATCH 299/362] bugfix for resampled pixel size

---
 py4DSTEM/preprocess/preprocess.py | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/py4DSTEM/preprocess/preprocess.py b/py4DSTEM/preprocess/preprocess.py
index c156c228e..6d35cbf5b 100644
--- a/py4DSTEM/preprocess/preprocess.py
+++ b/py4DSTEM/preprocess/preprocess.py
@@ -652,12 +652,7 @@ def resample_data_diffraction(
         if not resampling_factor:
             resampling_factor = old_size[2] / output_size[0]
         if datacube.calibration.get_Q_pixel_size() is not None:
-            datacube.calibration.set_Q_pixel_size(datacube.calibration.get_Q_pixel_size() / resampling_factor)
-
-        if not resampling_factor:
-            resampling_factor = old_size[2] / output_size[0]
-        if datacube.calibration.get_Q_pixel_size() is not None:
-            datacube.calibration.set_Q_pixel_size(datacube.calibration.get_Q_pixel_size() / resampling_factor)
+            datacube.calibration.set_Q_pixel_size(datacube.calibration.get_Q_pixel_size() * resampling_factor)
 
     elif method == "bilinear":
         from scipy.ndimage import zoom

From 2879ac7fdaa89c9f4878fdad1fabb2522af1d1de Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Mon, 17 Jul 2023 10:47:15 -0400
Subject: [PATCH 300/362] bugfixes

---
 py4DSTEM/datacube/datacube.py | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/datacube/datacube.py b/py4DSTEM/datacube/datacube.py
index f56836555..1246d96be 100644
--- a/py4DSTEM/datacube/datacube.py
+++ b/py4DSTEM/datacube/datacube.py
@@ -125,6 +125,9 @@ def calibrate(self):
         self._qxx,self._qyy = np.meshgrid( dim_qx,dim_qy )
         self._rxx,self._ryy = np.meshgrid( dim_rx,dim_ry )
 
+        self._qyy_raw,self._qxx_raw = np.meshgrid( np.arange(self.Q_Ny),np.arange(self.Q_Nx) )
+        self._ryy_raw,self._rxx_raw = np.meshgrid( np.arange(self.R_Ny),np.arange(self.R_Nx) )
+
 
 
     # coordinate meshgrids
@@ -140,6 +143,18 @@ def qxx(self):
     @property
     def qyy(self):
         return self._qyy
+    @property
+    def rxx_raw(self):
+        return self._rxx_raw
+    @property
+    def ryy_raw(self):
+        return self._ryy_raw
+    @property
+    def qxx_raw(self):
+        return self._qxx_raw
+    @property
+    def qyy_raw(self):
+        return self._qyy_raw
 
     # coordinate meshgrids with shifted origin
     def qxxs(self,rx,ry):
@@ -1171,7 +1186,7 @@ def get_radial_bkgrnd(
         # define the 2D cartesian coordinate system
         origin = self.calibration.get_origin()
         origin = origin[0][rx,ry],origin[1][rx,ry]
-        qxx,qyy = self.qxx-origin[0], self.qyy-origin[1]
+        qxx,qyy = self.qxx_raw-origin[0], self.qyy_raw-origin[1]
 
         # get distance qr in polar-elliptical coords
         ellipse = self.calibration.get_ellipse()
@@ -1456,7 +1471,7 @@ def get_braggmask(
         vects = braggvectors.raw[rx,ry]
         # loop
         for idx in range(len(vects.data)):
-            qr = np.hypot(self.qxx-vects.qx[idx], self.qyy-vects.qy[idx])
+            qr = np.hypot(self.qxx_raw-vects.qx[idx], self.qyy_raw-vects.qy[idx])
             mask = np.logical_and(mask, qr>radius)
         return mask
 

From 97719d78bd5de125c9d1d395ff4e7998fdad6e79 Mon Sep 17 00:00:00 2001
From: bsavitzky <bsavitzky@users.noreply.github.com>
Date: Mon, 17 Jul 2023 11:13:24 -0400
Subject: [PATCH 301/362] Revert "bugfix for resampled pixel size"

---
 py4DSTEM/preprocess/preprocess.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/py4DSTEM/preprocess/preprocess.py b/py4DSTEM/preprocess/preprocess.py
index c72240b4c..162b9a32d 100644
--- a/py4DSTEM/preprocess/preprocess.py
+++ b/py4DSTEM/preprocess/preprocess.py
@@ -649,7 +649,12 @@ def resample_data_diffraction(
         if not resampling_factor:
             resampling_factor = old_size[2] / output_size[0]
         if datacube.calibration.get_Q_pixel_size() is not None:
-            datacube.calibration.set_Q_pixel_size(datacube.calibration.get_Q_pixel_size() * resampling_factor)
+            datacube.calibration.set_Q_pixel_size(datacube.calibration.get_Q_pixel_size() / resampling_factor)
+
+        if not resampling_factor:
+            resampling_factor = old_size[2] / output_size[0]
+        if datacube.calibration.get_Q_pixel_size() is not None:
+            datacube.calibration.set_Q_pixel_size(datacube.calibration.get_Q_pixel_size() / resampling_factor)
 
     elif method == "bilinear":
         from scipy.ndimage import zoom

From adfc1bc60457084bc84c0f6402bd89981ae7fb96 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 14 Jul 2023 13:34:13 -0700
Subject: [PATCH 302/362] hot fix for fit origin

---
 py4DSTEM/process/calibration/origin.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/py4DSTEM/process/calibration/origin.py b/py4DSTEM/process/calibration/origin.py
index 8821b43d0..2b4138a74 100644
--- a/py4DSTEM/process/calibration/origin.py
+++ b/py4DSTEM/process/calibration/origin.py
@@ -134,14 +134,14 @@ def fit_origin(
 
         # Fit data
         if mask is None:
-            popt_x, pcov_x, qx0_fit = fit_2D(
+            popt_x, pcov_x, qx0_fit, _ = fit_2D(
                 f,
                 qx0_meas,
                 robust=robust,
                 robust_steps=robust_steps,
                 robust_thresh=robust_thresh,
             )
-            popt_y, pcov_y, qy0_fit = fit_2D(
+            popt_y, pcov_y, qy0_fit, _ = fit_2D(
                 f,
                 qy0_meas,
                 robust=robust,
@@ -150,7 +150,7 @@ def fit_origin(
             )
 
         else:
-            popt_x, pcov_x, qx0_fit = fit_2D(
+            popt_x, pcov_x, qx0_fit, _ = fit_2D(
                 f,
                 qx0_meas,
                 robust=robust,
@@ -158,7 +158,7 @@ def fit_origin(
                 robust_thresh=robust_thresh,
                 data_mask=mask == True,
             )
-            popt_y, pcov_y, qy0_fit = fit_2D(
+            popt_y, pcov_y, qy0_fit, _ = fit_2D(
                 f,
                 qy0_meas,
                 robust=robust,

From 9a053d4d09e540c23d39e193e691da252b8e6fdd Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Thu, 15 Jun 2023 13:19:12 -0700
Subject: [PATCH 303/362] read_arina start

---
 py4DSTEM/io/filereaders/__init__.py   |  2 +-
 py4DSTEM/io/filereaders/read_arina.py | 65 +++++++++++++++++++++++++++
 2 files changed, 66 insertions(+), 1 deletion(-)
 create mode 100644 py4DSTEM/io/filereaders/read_arina.py

diff --git a/py4DSTEM/io/filereaders/__init__.py b/py4DSTEM/io/filereaders/__init__.py
index d256334a8..44c083856 100644
--- a/py4DSTEM/io/filereaders/__init__.py
+++ b/py4DSTEM/io/filereaders/__init__.py
@@ -2,4 +2,4 @@
 from py4DSTEM.io.filereaders.read_K2 import read_gatan_K2_bin
 from py4DSTEM.io.filereaders.empad import read_empad
 from py4DSTEM.io.filereaders.read_mib import load_mib
-
+from py4DSTEM.io.filereaders.read_arina import read_arina
diff --git a/py4DSTEM/io/filereaders/read_arina.py b/py4DSTEM/io/filereaders/read_arina.py
new file mode 100644
index 000000000..86ed2ee9b
--- /dev/null
+++ b/py4DSTEM/io/filereaders/read_arina.py
@@ -0,0 +1,65 @@
+import h5py
+import numpy as np
+from py4DSTEM.classes import DataCube
+
+def read_arina(filename, scan_width):
+
+    """
+    Args:
+        filename: str or Path Path to the file
+        scan_width: x dimension of scan
+
+    Returns:
+            DataCube
+    """
+    f = h5py.File(filename, "r")
+    nimages = 0
+
+    # Count the number of images in all datasets
+    for dset in f["entry"]["data"]:
+        nimages = nimages + f["entry"]["data"][dset].shape[0]
+        height = f["entry"]["data"][dset].shape[1]
+        width = f["entry"]["data"][dset].shape[2]
+        dtype = f["entry"]["data"][dset].dtype
+
+    assert (
+        nimages % scan_width < 1e-6
+    ), "scan_width must be integer multiple of x*y size"
+
+    if dtype.type is np.uint32:
+        print("Dataset is uint32 but will be converted to uint16")
+        dtype = np.dtype(np.uint16)
+
+    array_3D = np.empty((nimages, width, height), dtype=dtype)
+
+    image_index = 0
+
+    for dset in f["entry"]["data"]:
+        image_index = _processDataSet(
+            f["entry"]["data"][dset], image_index, array_3D, scan_width
+        )
+
+    if f.__bool__():
+        f.close()
+
+    scan_height = int(nimages / scan_width)
+
+    datacube = DataCube(
+        array_3D.reshape(
+            scan_width, scan_height, array_3D.data.shape[1], array_3D.data.shape[2]
+        )
+    )
+
+    return datacube
+
+
+def _processDataSet(dset, start_index, array_3D, scan_width):
+    image_index = start_index
+    nimages_dset = dset.shape[0]
+
+    for i in range(nimages_dset):
+        array_3D[image_index] = dset[i].astype(array_3D.dtype)
+
+        image_index = image_index + 1
+
+    return image_index

From daf2fe7dac36868055b5e971215da2a9aec87b5f Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 16 Jun 2023 11:17:42 -0700
Subject: [PATCH 304/362] bug fixes and including in importfile

---
 py4DSTEM/io/filereaders/read_arina.py | 40 +++++++++++++++++++++------
 py4DSTEM/io/importfile.py             | 15 +++++-----
 2 files changed, 39 insertions(+), 16 deletions(-)

diff --git a/py4DSTEM/io/filereaders/read_arina.py b/py4DSTEM/io/filereaders/read_arina.py
index 86ed2ee9b..b52dc994e 100644
--- a/py4DSTEM/io/filereaders/read_arina.py
+++ b/py4DSTEM/io/filereaders/read_arina.py
@@ -1,17 +1,34 @@
 import h5py
+import hdf5plugin
 import numpy as np
 from py4DSTEM.classes import DataCube
+from py4DSTEM.preprocess.utils import bin2D
 
-def read_arina(filename, scan_width):
+
+def read_arina(
+    filename,
+    scan_width,
+    mem="RAM",
+    binfactor:int=1,
+):
 
     """
+    File reader for arina 4D-STEM datasets
     Args:
-        filename: str or Path Path to the file
+        filename: str with path to master file
         scan_width: x dimension of scan
+        mem (str):  Must be "RAM" or "MEMMAP". Specifies how the data is
+            loaded; "RAM" transfer the data from storage to RAM, while "MEMMAP"
+            leaves the data in storage and creates a memory map which points to
+            the diffraction patterns, allowing them to be retrieved individually
+            from storage.
+        binfactor (int): Diffraction space binning factor for bin-on-load.
 
     Returns:
-            DataCube
+        DataCube
     """
+    assert mem == "RAM", "ARNIA does not support memory mapping"
+
     f = h5py.File(filename, "r")
     nimages = 0
 
@@ -21,7 +38,10 @@ def read_arina(filename, scan_width):
         height = f["entry"]["data"][dset].shape[1]
         width = f["entry"]["data"][dset].shape[2]
         dtype = f["entry"]["data"][dset].dtype
-
+    
+    width = width//binfactor
+    height = height//binfactor
+    
     assert (
         nimages % scan_width < 1e-6
     ), "scan_width must be integer multiple of x*y size"
@@ -36,7 +56,7 @@ def read_arina(filename, scan_width):
 
     for dset in f["entry"]["data"]:
         image_index = _processDataSet(
-            f["entry"]["data"][dset], image_index, array_3D, scan_width
+            f["entry"]["data"][dset], image_index, array_3D, binfactor
         )
 
     if f.__bool__():
@@ -53,13 +73,15 @@ def read_arina(filename, scan_width):
     return datacube
 
 
-def _processDataSet(dset, start_index, array_3D, scan_width):
+def _processDataSet(dset, start_index, array_3D, binfactor):
     image_index = start_index
     nimages_dset = dset.shape[0]
 
     for i in range(nimages_dset):
-        array_3D[image_index] = dset[i].astype(array_3D.dtype)
-
+        if binfactor == 1:
+            array_3D[image_index] = dset[i].astype(array_3D.dtype)
+        else: 
+            array_3D[image_index] = bin2D(dset[i].astype(array_3D.dtype), binfactor)
+        
         image_index = image_index + 1
-
     return image_index
diff --git a/py4DSTEM/io/importfile.py b/py4DSTEM/io/importfile.py
index 17b052601..9048e0f7f 100644
--- a/py4DSTEM/io/importfile.py
+++ b/py4DSTEM/io/importfile.py
@@ -9,12 +9,11 @@
     read_empad,
     read_dm,
     read_gatan_K2_bin,
-    load_mib
+    load_mib,
+    read_arina
 )
 
 
-
-
 def import_file(
     filepath: Union[str, pathlib.Path],
     mem: Optional[str] = "RAM",
@@ -37,6 +36,7 @@ def import_file(
             from storage.
         binfactor (int): Diffraction space binning factor for bin-on-load.
         filetype (str): Used to override automatic filetype detection.
+            options include "dm", "empad", "gatan_K2_bin", "mib","arina"
         **kwargs: any additional kwargs are passed to the downstream reader -
             refer to the individual filetype reader function call signatures
             and docstrings for more details.
@@ -72,7 +72,8 @@ def import_file(
         "dm",
         "empad",
         "gatan_K2_bin",
-        "mib"
+        "mib",
+        "arina",
         # "kitware_counted",
     ], "Error: filetype not recognized"
 
@@ -85,10 +86,10 @@ def import_file(
     # elif filetype == "kitware_counted":
     #    data = read_kitware_counted(filepath, mem, binfactor, metadata=metadata, **kwargs)
     elif filetype == "mib":
-        data = load_mib(filepath, mem=mem, binfactor=binfactor,**kwargs)
+        data = load_mib(filepath, mem=mem, binfactor=binfactor, **kwargs)
+    elif filetype == "arina":
+        data = read_arina(filepath, mem=mem, binfactor=binfactor, **kwargs)
     else:
         raise Exception("Bad filetype!")
 
     return data
-
-

From 1d96f9195aeb8ca4e90a713cfe713e34878389a0 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 16 Jun 2023 12:55:43 -0700
Subject: [PATCH 305/362] hdf5plugin dependency

---
 setup.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/setup.py b/setup.py
index cb9da8169..b0c7fa081 100644
--- a/setup.py
+++ b/setup.py
@@ -26,6 +26,7 @@
         'numpy >= 1.19',
         'scipy >= 1.5.2',
         'h5py >= 3.2.0',
+        'hdf5plugin >= 4.1.3',
         'ncempy >= 1.8.1',
         'matplotlib >= 3.2.2',
         'scikit-image >= 0.17.2',

From e02d4110584027cd742174c0a2902b519134d24b Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Sat, 17 Jun 2023 08:29:09 -0700
Subject: [PATCH 306/362] updates for file parser and dtype

---
 py4DSTEM/io/filereaders/read_arina.py |  8 ++++++-
 py4DSTEM/io/parsefiletype.py          | 32 ++++++++++++++++++++++++---
 py4DSTEM/io/read.py                   |  6 ++---
 3 files changed, 39 insertions(+), 7 deletions(-)

diff --git a/py4DSTEM/io/filereaders/read_arina.py b/py4DSTEM/io/filereaders/read_arina.py
index b52dc994e..4d0b605fd 100644
--- a/py4DSTEM/io/filereaders/read_arina.py
+++ b/py4DSTEM/io/filereaders/read_arina.py
@@ -10,6 +10,7 @@ def read_arina(
     scan_width,
     mem="RAM",
     binfactor:int=1,
+    dtype_bin:float=None,
 ):
 
     """
@@ -23,6 +24,8 @@ def read_arina(
             the diffraction patterns, allowing them to be retrieved individually
             from storage.
         binfactor (int): Diffraction space binning factor for bin-on-load.
+        dtype_bin(float): specify datatype for bin on load if need something 
+            other than uint16
 
     Returns:
         DataCube
@@ -50,7 +53,10 @@ def read_arina(
         print("Dataset is uint32 but will be converted to uint16")
         dtype = np.dtype(np.uint16)
 
-    array_3D = np.empty((nimages, width, height), dtype=dtype)
+    if dtype_bin:
+        array_3D = np.empty((nimages, width, height), dtype=dtype_bin)
+    else:
+        array_3D = np.empty((nimages, width, height), dtype=dtype)
 
     image_index = 0
 
diff --git a/py4DSTEM/io/parsefiletype.py b/py4DSTEM/io/parsefiletype.py
index 5903ce814..b2889511a 100644
--- a/py4DSTEM/io/parsefiletype.py
+++ b/py4DSTEM/io/parsefiletype.py
@@ -1,9 +1,13 @@
 # File parser utility
 
 from os.path import splitext
+import py4DSTEM.io.legacy as legacy
+import emdfile as emd
+import h5py
 
 def _parse_filetype(fp):
-    """ Accepts a path to a data file, and returns the file type as a string.
+    """ 
+    Accepts a path to a data file, and returns the file type as a string.
     """
     _, fext = splitext(fp)
     fext = fext.lower()
@@ -13,7 +17,16 @@ def _parse_filetype(fp):
         ".py4dstem",
         ".emd",
     ]:
-        return "H5"
+        if emd._is_EMD_file(fp):
+            return "emd"
+
+        elif legacy.is_py4DSTEM_file(fp):
+            return "legacy"
+
+        elif _is_arina(fp):
+            return "arina"
+
+
     elif fext in [
         ".dm",
         ".dm3",
@@ -33,5 +46,18 @@ def _parse_filetype(fp):
     else:
         raise Exception(f"Unrecognized file extension {fext}.")
 
-
+def _is_arina(filepath):
+    """
+    Check if an h5 file is an Arina file.
+    """
+    with h5py.File(filepath,'r') as f:
+        try:
+            assert("entry" in f.keys())
+        except AssertionError:
+            return False
+        try:
+            assert("NX_class" in f["entry"].attrs.keys())
+        except AssertionError:
+            return False
+    return True
 
diff --git a/py4DSTEM/io/read.py b/py4DSTEM/io/read.py
index 79291fe86..f9290aac4 100644
--- a/py4DSTEM/io/read.py
+++ b/py4DSTEM/io/read.py
@@ -70,7 +70,7 @@ def read(
     assert(exists(filepath)), er2
 
     filetype = _parse_filetype(filepath)
-    assert filetype == "H5", f"`py4DSTEM.read` loads native HDF5 formatted files, but a file of type {filetype} was detected.  Try loading it using py4DSTEM.import_file"
+    assert filetype in ('emd', 'legacy'), f"`py4DSTEM.read` loads native HDF5 formatted files, but a file of type {filetype} was detected.  Try loading it using py4DSTEM.import_file"
 
     # support older `root` input
     if datapath is None:
@@ -78,7 +78,7 @@ def read(
             datapath = kwargs['root']
 
     # EMD 1.0 formatted files (py4DSTEM v0.14+)
-    if emd._is_EMD_file(filepath):
+    if filetype == "emd":
         version = emd._get_EMD_version(filepath)
         if verbose: print(f"EMD version {version[0]}.{version[1]}.{version[2]} detected. Reading...")
         assert emd._version_is_geq(version,(1,0,0)), f"EMD version {version} detected. Expected version >= 1.0.0"
@@ -127,7 +127,7 @@ def read(
 
     # legacy py4DSTEM files (v <= 0.13)
     else:
-        assert legacy.is_py4DSTEM_file(filepath), "path points to an H5 file which is neither an EMD 1.0+ file, nor a recognized legacy py4DSTEM file."
+        assert filetype == "legacy", "path points to an H5 file which is neither an EMD 1.0+ file, nor a recognized legacy py4DSTEM file."
 
 
         # read v13

From f64f926382487e2ebac8f58913228157d0c3c0df Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Sat, 17 Jun 2023 09:20:35 -0700
Subject: [PATCH 307/362] read abTEM

---
 py4DSTEM/io/filereaders/__init__.py   |  1 +
 py4DSTEM/io/filereaders/read_abTEM.py | 59 +++++++++++++++++++++++++++
 py4DSTEM/io/filereaders/read_arina.py | 20 ++++-----
 py4DSTEM/io/importfile.py             |  8 +++-
 py4DSTEM/io/parsefiletype.py          | 16 +++++++-
 5 files changed, 91 insertions(+), 13 deletions(-)
 create mode 100644 py4DSTEM/io/filereaders/read_abTEM.py

diff --git a/py4DSTEM/io/filereaders/__init__.py b/py4DSTEM/io/filereaders/__init__.py
index 44c083856..b6f4eb0a2 100644
--- a/py4DSTEM/io/filereaders/__init__.py
+++ b/py4DSTEM/io/filereaders/__init__.py
@@ -3,3 +3,4 @@
 from py4DSTEM.io.filereaders.empad import read_empad
 from py4DSTEM.io.filereaders.read_mib import load_mib
 from py4DSTEM.io.filereaders.read_arina import read_arina
+from py4DSTEM.io.filereaders.read_abTEM import read_abTEM
diff --git a/py4DSTEM/io/filereaders/read_abTEM.py b/py4DSTEM/io/filereaders/read_abTEM.py
new file mode 100644
index 000000000..3e60f5fee
--- /dev/null
+++ b/py4DSTEM/io/filereaders/read_abTEM.py
@@ -0,0 +1,59 @@
+import h5py
+from py4DSTEM.classes import DataCube
+
+
+def read_abTEM(
+    filename,
+    mem="RAM",
+    binfactor: int = 1,
+):
+    """
+    File reader for abTEM 4D-STEM datasets
+    Args:
+        filename: str with path to master file
+        scan_width: x dimension of scan
+        mem (str):  Must be "RAM" or "MEMMAP". Specifies how the data is
+            loaded; "RAM" transfer the data from storage to RAM, while "MEMMAP"
+            leaves the data in storage and creates a memory map which points to
+            the diffraction patterns, allowing them to be retrieved individually
+            from storage.
+        binfactor (int): Diffraction space binning factor for bin-on-load.
+
+    Returns:
+        DataCube
+    """
+    assert mem == "RAM", "read_abTEM does not support memory mapping"
+    assert binfactor == 1, "abTEM files can only be read at full resolution"
+
+    with h5py.File(filename, "r") as f:
+        datasets = {}
+        for key in f.keys():
+            datasets[key] = f.get(key)[()]
+
+    data = datasets["array"]
+    assert len(data.shape) == 4, "reader is for 4D-STEM datasets only"
+
+    datacube = DataCube(data=data)
+
+    sampling = datasets["sampling"]
+    units = datasets["units"]
+
+    datacube.calibration.set_R_pixel_size(sampling[0])
+    if sampling[0] != sampling[1]:
+        print(
+            "Warning: py4DSTEM currently only handles uniform x,y sampling. Setting sampling with x calibration"
+        )
+    datacube.calibration.set_Q_pixel_size(sampling[2])
+    if sampling[2] != sampling[3]:
+        print(
+            "Warning: py4DSTEM currently only handles uniform qx,qy sampling. Setting sampling with qx calibration"
+        )
+
+    if units[0] == b"\xc3\x85":
+        datacube.calibration.set_R_pixel_units("A")
+    else:
+        datacube.calibration.set_R_pixel_units(units[0].decode("utf-8"))
+
+    datacube.calibration.set_Q_pixel_units(units[2].decode("utf-8"))
+
+    return datacube
diff --git a/py4DSTEM/io/filereaders/read_arina.py b/py4DSTEM/io/filereaders/read_arina.py
index 4d0b605fd..0f334f52b 100644
--- a/py4DSTEM/io/filereaders/read_arina.py
+++ b/py4DSTEM/io/filereaders/read_arina.py
@@ -9,8 +9,8 @@ def read_arina(
     filename,
     scan_width,
     mem="RAM",
-    binfactor:int=1,
-    dtype_bin:float=None,
+    binfactor: int = 1,
+    dtype_bin: float = None,
 ):
 
     """
@@ -24,13 +24,13 @@ def read_arina(
             the diffraction patterns, allowing them to be retrieved individually
             from storage.
         binfactor (int): Diffraction space binning factor for bin-on-load.
-        dtype_bin(float): specify datatype for bin on load if need something 
+        dtype_bin(float): specify datatype for bin on load if need something
             other than uint16
 
     Returns:
         DataCube
     """
-    assert mem == "RAM", "ARNIA does not support memory mapping"
+    assert mem == "RAM", "read_arina does not support memory mapping"
 
     f = h5py.File(filename, "r")
     nimages = 0
@@ -41,10 +41,10 @@ def read_arina(
         height = f["entry"]["data"][dset].shape[1]
         width = f["entry"]["data"][dset].shape[2]
         dtype = f["entry"]["data"][dset].dtype
-    
-    width = width//binfactor
-    height = height//binfactor
-    
+
+    width = width // binfactor
+    height = height // binfactor
+
     assert (
         nimages % scan_width < 1e-6
     ), "scan_width must be integer multiple of x*y size"
@@ -86,8 +86,8 @@ def _processDataSet(dset, start_index, array_3D, binfactor):
     for i in range(nimages_dset):
         if binfactor == 1:
             array_3D[image_index] = dset[i].astype(array_3D.dtype)
-        else: 
+        else:
             array_3D[image_index] = bin2D(dset[i].astype(array_3D.dtype), binfactor)
-        
+
         image_index = image_index + 1
     return image_index
diff --git a/py4DSTEM/io/importfile.py b/py4DSTEM/io/importfile.py
index 9048e0f7f..9c3287642 100644
--- a/py4DSTEM/io/importfile.py
+++ b/py4DSTEM/io/importfile.py
@@ -10,7 +10,8 @@
     read_dm,
     read_gatan_K2_bin,
     load_mib,
-    read_arina
+    read_arina,
+    read_abTEM
 )
 
 
@@ -36,7 +37,7 @@ def import_file(
             from storage.
         binfactor (int): Diffraction space binning factor for bin-on-load.
         filetype (str): Used to override automatic filetype detection.
-            options include "dm", "empad", "gatan_K2_bin", "mib","arina"
+            options include "dm", "empad", "gatan_K2_bin", "mib", "arina", "abTEM"
         **kwargs: any additional kwargs are passed to the downstream reader -
             refer to the individual filetype reader function call signatures
             and docstrings for more details.
@@ -74,6 +75,7 @@ def import_file(
         "gatan_K2_bin",
         "mib",
         "arina",
+        "abTEM"
         # "kitware_counted",
     ], "Error: filetype not recognized"
 
@@ -89,6 +91,8 @@ def import_file(
         data = load_mib(filepath, mem=mem, binfactor=binfactor, **kwargs)
     elif filetype == "arina":
         data = read_arina(filepath, mem=mem, binfactor=binfactor, **kwargs)
+    elif filetype == "abTEM":
+        data = read_abTEM(filepath, mem=mem, binfactor=binfactor, **kwargs)
     else:
         raise Exception("Bad filetype!")
 
diff --git a/py4DSTEM/io/parsefiletype.py b/py4DSTEM/io/parsefiletype.py
index b2889511a..ab7529ec6 100644
--- a/py4DSTEM/io/parsefiletype.py
+++ b/py4DSTEM/io/parsefiletype.py
@@ -26,7 +26,9 @@ def _parse_filetype(fp):
         elif _is_arina(fp):
             return "arina"
 
-
+        elif _is_abTEM(fp):
+            return "abTEM"
+            
     elif fext in [
         ".dm",
         ".dm3",
@@ -61,3 +63,15 @@ def _is_arina(filepath):
             return False
     return True
 
+def _is_abTEM(filepath):
+    """
+    Check if an h5 file is an abTEM file. 
+    """
+    with h5py.File(filepath,'r') as f:
+        try:
+            assert("array" in f.keys())
+        except AssertionError:
+            return False
+    return True
+
+

From 5ca07285fd6ff99b493482b302ca2d170b077e16 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Sat, 17 Jun 2023 09:45:46 -0700
Subject: [PATCH 308/362] fix warning statement and doc strings

---
 py4DSTEM/io/filereaders/read_abTEM.py | 3 +--
 py4DSTEM/io/importfile.py             | 4 ++--
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/py4DSTEM/io/filereaders/read_abTEM.py b/py4DSTEM/io/filereaders/read_abTEM.py
index 3e60f5fee..1008bcc0e 100644
--- a/py4DSTEM/io/filereaders/read_abTEM.py
+++ b/py4DSTEM/io/filereaders/read_abTEM.py
@@ -10,8 +10,7 @@ def read_abTEM(
     """
     File reader for abTEM 4D-STEM datasets
     Args:
-        filename: str with path to master file
-        scan_width: x dimension of scan
+        filename: str with path to  file
         mem (str):  Must be "RAM" or "MEMMAP". Specifies how the data is
             loaded; "RAM" transfer the data from storage to RAM, while "MEMMAP"
             leaves the data in storage and creates a memory map which points to
diff --git a/py4DSTEM/io/importfile.py b/py4DSTEM/io/importfile.py
index 9c3287642..98ef05238 100644
--- a/py4DSTEM/io/importfile.py
+++ b/py4DSTEM/io/importfile.py
@@ -67,8 +67,8 @@ def import_file(
 
     filetype = _parse_filetype(filepath) if filetype is None else filetype
 
-    if filetype == 'EMD':
-        raise Exception("EMD file detected - use py4DSTEM.read, not py4DSTEM.import_file!")
+    if filetype in ('emd', 'legacy'):
+        raise Exception("EMD file or py4DSTEM detected - use py4DSTEM.read, not py4DSTEM.import_file!")
     assert filetype in [
         "dm",
         "empad",

From 065aa3cfeb8e201fb7fc575b51203c35cced9a94 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Mon, 3 Jul 2023 10:31:39 -0700
Subject: [PATCH 309/362] avoid transpose

---
 py4DSTEM/io/filereaders/read_arina.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/io/filereaders/read_arina.py b/py4DSTEM/io/filereaders/read_arina.py
index 0f334f52b..d5dbbedb9 100644
--- a/py4DSTEM/io/filereaders/read_arina.py
+++ b/py4DSTEM/io/filereaders/read_arina.py
@@ -71,8 +71,11 @@ def read_arina(
     scan_height = int(nimages / scan_width)
 
     datacube = DataCube(
-        array_3D.reshape(
-            scan_width, scan_height, array_3D.data.shape[1], array_3D.data.shape[2]
+        np.flip(
+            array_3D.reshape(
+                scan_width, scan_height, array_3D.data.shape[1], array_3D.data.shape[2]
+            ),
+            0,
         )
     )
 

From 8686770d7bac35d2780ef5616bce9bcdd62aa6f3 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 11 Jul 2023 10:58:38 -0400
Subject: [PATCH 310/362] more import fixes, all tests passing

---
 py4DSTEM/io/read.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/io/read.py b/py4DSTEM/io/read.py
index f9290aac4..6c693b534 100644
--- a/py4DSTEM/io/read.py
+++ b/py4DSTEM/io/read.py
@@ -95,7 +95,7 @@ def read(
             with warnings.catch_warnings():
                 warnings.simplefilter('ignore')
                 cal = data.calibration
-        elif isinstance(data,py4DSTEM.Root):
+        elif isinstance(data,emd.Root):
             try:
                 cal = data.metadata['calibration']
             except KeyError:

From cae6fa6832e440ec38cf466b8bfa8752d72b449e Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 11 Jul 2023 11:25:37 -0400
Subject: [PATCH 311/362] adds test_arina unit test

---
 test/test_nonnative_io/test_arina.py | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 test/test_nonnative_io/test_arina.py

diff --git a/test/test_nonnative_io/test_arina.py b/test/test_nonnative_io/test_arina.py
new file mode 100644
index 000000000..bf9bf8e73
--- /dev/null
+++ b/test/test_nonnative_io/test_arina.py
@@ -0,0 +1,19 @@
+import py4DSTEM
+import emdfile
+from os.path import join
+
+
+# Set filepaths
+filepath = join(py4DSTEM._TESTPATH, "test_arina/STO-STEM_bench_20us_master.h5")
+
+
+def test_read_arina():
+
+    # read
+    data = py4DSTEM.import_file( filepath )
+
+    # check imported data
+    assert isinstance(data, emdfile.Array)
+    assert isinstance(data, py4DSTEM.DataCube)
+
+

From a44fc6b6282ebe893896944d74a1668f771c74e2 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 14 Jul 2023 14:43:06 -0700
Subject: [PATCH 312/362] flatfield correction

---
 py4DSTEM/io/filereaders/read_arina.py | 27 +++++++++++++++++++++++----
 1 file changed, 23 insertions(+), 4 deletions(-)

diff --git a/py4DSTEM/io/filereaders/read_arina.py b/py4DSTEM/io/filereaders/read_arina.py
index d5dbbedb9..543d8db76 100644
--- a/py4DSTEM/io/filereaders/read_arina.py
+++ b/py4DSTEM/io/filereaders/read_arina.py
@@ -11,6 +11,7 @@ def read_arina(
     mem="RAM",
     binfactor: int = 1,
     dtype_bin: float = None,
+    flatfield: np.ndarray = None,
 ):
 
     """
@@ -26,6 +27,8 @@ def read_arina(
         binfactor (int): Diffraction space binning factor for bin-on-load.
         dtype_bin(float): specify datatype for bin on load if need something
             other than uint16
+        flatfield (np.ndarray):
+            flatfield forcorrection factors
 
     Returns:
         DataCube
@@ -60,9 +63,20 @@ def read_arina(
 
     image_index = 0
 
+    if flatfield is None:
+        correction_factors = 1
+    else:
+        # Avoid div by 0 errors -> pixel with value 0 will be set to meadian
+        flatfield[flatfield == 0] = 1
+        correction_factors = np.median(flatfield) / flatfield
+
     for dset in f["entry"]["data"]:
         image_index = _processDataSet(
-            f["entry"]["data"][dset], image_index, array_3D, binfactor
+            f["entry"]["data"][dset],
+            image_index,
+            array_3D,
+            binfactor,
+            correction_factors,
         )
 
     if f.__bool__():
@@ -82,15 +96,20 @@ def read_arina(
     return datacube
 
 
-def _processDataSet(dset, start_index, array_3D, binfactor):
+def _processDataSet(dset, start_index, array_3D, binfactor, correction_factors):
     image_index = start_index
     nimages_dset = dset.shape[0]
 
     for i in range(nimages_dset):
         if binfactor == 1:
-            array_3D[image_index] = dset[i].astype(array_3D.dtype)
+            array_3D[image_index] = np.multiply(
+                dset[i].astype(array_3D.dtype), correction_factors
+            )
         else:
-            array_3D[image_index] = bin2D(dset[i].astype(array_3D.dtype), binfactor)
+            array_3D[image_index] = bin2D(
+                np.multiply(dset[i].astype(array_3D.dtype), correction_factors),
+                binfactor,
+            )
 
         image_index = image_index + 1
     return image_index

From 641484c51b7aea32f80d138c0a7ea1aa5be3dced Mon Sep 17 00:00:00 2001
From: Steven Zeltmann <steven.zeltmann@cornell.edu>
Date: Mon, 17 Jul 2023 09:45:37 -0400
Subject: [PATCH 313/362] bugfix for resampled pixel size

---
 py4DSTEM/preprocess/preprocess.py | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/py4DSTEM/preprocess/preprocess.py b/py4DSTEM/preprocess/preprocess.py
index 162b9a32d..c72240b4c 100644
--- a/py4DSTEM/preprocess/preprocess.py
+++ b/py4DSTEM/preprocess/preprocess.py
@@ -649,12 +649,7 @@ def resample_data_diffraction(
         if not resampling_factor:
             resampling_factor = old_size[2] / output_size[0]
         if datacube.calibration.get_Q_pixel_size() is not None:
-            datacube.calibration.set_Q_pixel_size(datacube.calibration.get_Q_pixel_size() / resampling_factor)
-
-        if not resampling_factor:
-            resampling_factor = old_size[2] / output_size[0]
-        if datacube.calibration.get_Q_pixel_size() is not None:
-            datacube.calibration.set_Q_pixel_size(datacube.calibration.get_Q_pixel_size() / resampling_factor)
+            datacube.calibration.set_Q_pixel_size(datacube.calibration.get_Q_pixel_size() * resampling_factor)
 
     elif method == "bilinear":
         from scipy.ndimage import zoom

From 942715769e85870944e282bc59f93528baed9eb4 Mon Sep 17 00:00:00 2001
From: bsavitzky <bsavitzky@users.noreply.github.com>
Date: Mon, 17 Jul 2023 11:13:24 -0400
Subject: [PATCH 314/362] Revert "bugfix for resampled pixel size"

---
 py4DSTEM/preprocess/preprocess.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/py4DSTEM/preprocess/preprocess.py b/py4DSTEM/preprocess/preprocess.py
index c72240b4c..162b9a32d 100644
--- a/py4DSTEM/preprocess/preprocess.py
+++ b/py4DSTEM/preprocess/preprocess.py
@@ -649,7 +649,12 @@ def resample_data_diffraction(
         if not resampling_factor:
             resampling_factor = old_size[2] / output_size[0]
         if datacube.calibration.get_Q_pixel_size() is not None:
-            datacube.calibration.set_Q_pixel_size(datacube.calibration.get_Q_pixel_size() * resampling_factor)
+            datacube.calibration.set_Q_pixel_size(datacube.calibration.get_Q_pixel_size() / resampling_factor)
+
+        if not resampling_factor:
+            resampling_factor = old_size[2] / output_size[0]
+        if datacube.calibration.get_Q_pixel_size() is not None:
+            datacube.calibration.set_Q_pixel_size(datacube.calibration.get_Q_pixel_size() / resampling_factor)
 
     elif method == "bilinear":
         from scipy.ndimage import zoom

From 9f921fe564ff3220ffcb43317c599a0cdfc44a16 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Mon, 17 Jul 2023 12:05:56 -0400
Subject: [PATCH 315/362] fix

---
 py4DSTEM/preprocess/preprocess.py | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/py4DSTEM/preprocess/preprocess.py b/py4DSTEM/preprocess/preprocess.py
index 162b9a32d..196b84dcf 100644
--- a/py4DSTEM/preprocess/preprocess.py
+++ b/py4DSTEM/preprocess/preprocess.py
@@ -645,14 +645,9 @@ def resample_data_diffraction(
         datacube.data = fourier_resample(
             datacube.data, scale=resampling_factor, output_size=output_size
         )
-        
-        if not resampling_factor:
-            resampling_factor = old_size[2] / output_size[0]
-        if datacube.calibration.get_Q_pixel_size() is not None:
-            datacube.calibration.set_Q_pixel_size(datacube.calibration.get_Q_pixel_size() / resampling_factor)
 
         if not resampling_factor:
-            resampling_factor = old_size[2] / output_size[0]
+            resampling_factor = output_size[0] / old_size[2]
         if datacube.calibration.get_Q_pixel_size() is not None:
             datacube.calibration.set_Q_pixel_size(datacube.calibration.get_Q_pixel_size() / resampling_factor)
 

From b57094dfe890b5002cc5a84e08a1f0cb92ce5040 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Mon, 17 Jul 2023 12:14:55 -0400
Subject: [PATCH 316/362] bugfix

---
 py4DSTEM/process/strain.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index 247b60a06..c76b429fa 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -364,7 +364,7 @@ def fit_lattice_vectors(
 
         bragg_vectors_indexed = add_indices_to_braggvectors(
             self.braggvectors,
-            self.bragg_directions,
+            self.braggdirections,
             maxPeakSpacing=max_peak_spacing,
             qx_shift=self.braggvectors.Qshape[0] / 2,
             qy_shift=self.braggvectors.Qshape[1] / 2,

From ae802d9a67e799cd6a539621136f30b0c1e8a79c Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Mon, 17 Jul 2023 09:39:54 -0700
Subject: [PATCH 317/362] another origin fix

---
 py4DSTEM/process/calibration/origin.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/py4DSTEM/process/calibration/origin.py b/py4DSTEM/process/calibration/origin.py
index cd61b77be..0b27f5a85 100644
--- a/py4DSTEM/process/calibration/origin.py
+++ b/py4DSTEM/process/calibration/origin.py
@@ -133,14 +133,14 @@ def fit_origin(
 
         # Fit data
         if mask is None:
-            popt_x, pcov_x, qx0_fit, _ = fit_2D(
+            popt_x, pcov_x, qx0_fit = fit_2D(
                 f,
                 qx0_meas,
                 robust=robust,
                 robust_steps=robust_steps,
                 robust_thresh=robust_thresh,
             )
-            popt_y, pcov_y, qy0_fit, _ = fit_2D(
+            popt_y, pcov_y, qy0_fit = fit_2D(
                 f,
                 qy0_meas,
                 robust=robust,
@@ -149,7 +149,7 @@ def fit_origin(
             )
 
         else:
-            popt_x, pcov_x, qx0_fit, _ = fit_2D(
+            popt_x, pcov_x, qx0_fit = fit_2D(
                 f,
                 qx0_meas,
                 robust=robust,
@@ -157,7 +157,7 @@ def fit_origin(
                 robust_thresh=robust_thresh,
                 data_mask=mask == True,
             )
-            popt_y, pcov_y, qy0_fit, _ = fit_2D(
+            popt_y, pcov_y, qy0_fit = fit_2D(
                 f,
                 qy0_meas,
                 robust=robust,

From 478905c7b5552d2e47d0d769ea2e130ce402db38 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Mon, 17 Jul 2023 12:17:21 -0700
Subject: [PATCH 318/362] this bug is so confusing

---
 py4DSTEM/process/calibration/origin.py |  8 ++++----
 py4DSTEM/process/fit/fit.py            | 11 ++++-------
 2 files changed, 8 insertions(+), 11 deletions(-)

diff --git a/py4DSTEM/process/calibration/origin.py b/py4DSTEM/process/calibration/origin.py
index 0b27f5a85..cd61b77be 100644
--- a/py4DSTEM/process/calibration/origin.py
+++ b/py4DSTEM/process/calibration/origin.py
@@ -133,14 +133,14 @@ def fit_origin(
 
         # Fit data
         if mask is None:
-            popt_x, pcov_x, qx0_fit = fit_2D(
+            popt_x, pcov_x, qx0_fit, _ = fit_2D(
                 f,
                 qx0_meas,
                 robust=robust,
                 robust_steps=robust_steps,
                 robust_thresh=robust_thresh,
             )
-            popt_y, pcov_y, qy0_fit = fit_2D(
+            popt_y, pcov_y, qy0_fit, _ = fit_2D(
                 f,
                 qy0_meas,
                 robust=robust,
@@ -149,7 +149,7 @@ def fit_origin(
             )
 
         else:
-            popt_x, pcov_x, qx0_fit = fit_2D(
+            popt_x, pcov_x, qx0_fit, _ = fit_2D(
                 f,
                 qx0_meas,
                 robust=robust,
@@ -157,7 +157,7 @@ def fit_origin(
                 robust_thresh=robust_thresh,
                 data_mask=mask == True,
             )
-            popt_y, pcov_y, qy0_fit = fit_2D(
+            popt_y, pcov_y, qy0_fit, _ = fit_2D(
                 f,
                 qy0_meas,
                 robust=robust,
diff --git a/py4DSTEM/process/fit/fit.py b/py4DSTEM/process/fit/fit.py
index e3bb4d86e..4a75d5c68 100644
--- a/py4DSTEM/process/fit/fit.py
+++ b/py4DSTEM/process/fit/fit.py
@@ -58,12 +58,9 @@ def fit_2D(function, data, data_mask=None, popt=None,
             fitting.
 
     Returns:
-        (3-tuple) A 3-tuple containing:
-
-            * **popt**: optimal fit parameters to function
-            * **pcov**: the covariance matrix
-            * **fit_ar**: optional. If return_ar==True, fit_ar is returned, and is an
-              array of the same shape as data, containing the fit values
+    (popt,pcov,fit_at, mask) : 4-tuple
+        The optimal fit parameters, the fitting covariance matrix, the
+        the fit array with the returned `popt` params, and the mask
     """
     shape = data.shape
     shape1D = [1,np.prod(shape)]
@@ -101,7 +98,7 @@ def fit_2D(function, data, data_mask=None, popt=None,
             p0=popt)
 
     fit_ar = function(xy,*popt).reshape(shape)
-    return popt, pcov, fit_ar
+    return popt, pcov, fit_ar, mask
 
 
 # Functions for fitting

From 47216928c4bebfba6842eef317c0edc717e06293 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Mon, 17 Jul 2023 12:17:49 -0700
Subject: [PATCH 319/362] verbose should be False for braggvectors

---
 py4DSTEM/braggvectors/braggvectors.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/braggvectors/braggvectors.py b/py4DSTEM/braggvectors/braggvectors.py
index 14b89fd98..9a4400794 100644
--- a/py4DSTEM/braggvectors/braggvectors.py
+++ b/py4DSTEM/braggvectors/braggvectors.py
@@ -65,7 +65,7 @@ def __init__(
         Rshape,
         Qshape,
         name = 'braggvectors',
-        verbose = True,
+        verbose = False,
         calibration = None
         ):
         Custom.__init__(self,name=name)

From 97ee5dcc47411614382ef8c08102023693260d15 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Mon, 17 Jul 2023 12:55:59 -0700
Subject: [PATCH 320/362] flake fix

---
 py4DSTEM/process/strain.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index c76b429fa..db252f75b 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -380,7 +380,7 @@ def fit_lattice_vectors(
         self.g1g2_map = g1g2_map
 
         if returncalc:
-            bragg_directions, bragg_vectors_indexed, g1g2_map
+            braggdirections, bragg_vectors_indexed, g1g2_map
 
     def get_strain(
         self, mask=None, g_reference=None, flip_theta=False, returncalc=False, **kwargs

From 97d7e93f5775b91bcc033f1dcdc5dcf158fcd94b Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Mon, 17 Jul 2023 16:04:03 -0400
Subject: [PATCH 321/362] bvects.copy bugfix

---
 py4DSTEM/braggvectors/braggvectors.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/py4DSTEM/braggvectors/braggvectors.py b/py4DSTEM/braggvectors/braggvectors.py
index e3173e466..851579ea8 100644
--- a/py4DSTEM/braggvectors/braggvectors.py
+++ b/py4DSTEM/braggvectors/braggvectors.py
@@ -293,17 +293,17 @@ def get_vectors(
     def copy(self, name=None):
         name = name if name is not None else self.name+"_copy"
         braggvector_copy = BraggVectors(
-            self.Rshape, 
-            self.Qshape, 
-            name=name, 
+            self.Rshape,
+            self.Qshape,
+            name=name,
             calibration = self.calibration.copy()
         )
-        
-        braggvector_copy._v_uncal = self._v_uncal.copy()
+
+        braggvector_copy.set_raw_vectors( self._v_uncal.copy() )
         for k in self.metadata.keys():
             braggvector_copy.metadata = self.metadata[k].copy()
-        # TODO - fix this calibration line?
         braggvector_copy.calibration = self.calibration
+        braggvector_copy.setcal()
         return braggvector_copy
 
 

From e9e92634742879fa55628a3c1f89d2f4cf1dd866 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Mon, 17 Jul 2023 16:26:51 -0400
Subject: [PATCH 322/362] bvects.copy bugfix

---
 py4DSTEM/braggvectors/braggvectors.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/py4DSTEM/braggvectors/braggvectors.py b/py4DSTEM/braggvectors/braggvectors.py
index 851579ea8..5d03e40d1 100644
--- a/py4DSTEM/braggvectors/braggvectors.py
+++ b/py4DSTEM/braggvectors/braggvectors.py
@@ -302,8 +302,6 @@ def copy(self, name=None):
         braggvector_copy.set_raw_vectors( self._v_uncal.copy() )
         for k in self.metadata.keys():
             braggvector_copy.metadata = self.metadata[k].copy()
-        braggvector_copy.calibration = self.calibration
-        braggvector_copy.setcal()
         return braggvector_copy
 
 

From f9b0b6c531af598cd039361249bcd73d90fae011 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Mon, 17 Jul 2023 16:26:51 -0400
Subject: [PATCH 323/362] bvects.copy bugfix

---
 py4DSTEM/braggvectors/braggvectors.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/py4DSTEM/braggvectors/braggvectors.py b/py4DSTEM/braggvectors/braggvectors.py
index 851579ea8..5d03e40d1 100644
--- a/py4DSTEM/braggvectors/braggvectors.py
+++ b/py4DSTEM/braggvectors/braggvectors.py
@@ -302,8 +302,6 @@ def copy(self, name=None):
         braggvector_copy.set_raw_vectors( self._v_uncal.copy() )
         for k in self.metadata.keys():
             braggvector_copy.metadata = self.metadata[k].copy()
-        braggvector_copy.calibration = self.calibration
-        braggvector_copy.setcal()
         return braggvector_copy
 
 

From 36bcf8d46ffc47be24c198bc5acbf913824a1e2c Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Mon, 17 Jul 2023 13:30:53 -0700
Subject: [PATCH 324/362] Update defaults in polar peaks, docstrings

---
 py4DSTEM/process/polar/polar_peaks.py | 40 ++++++++++++++++++++++++---
 1 file changed, 36 insertions(+), 4 deletions(-)

diff --git a/py4DSTEM/process/polar/polar_peaks.py b/py4DSTEM/process/polar/polar_peaks.py
index 3f367b398..c88b8d231 100644
--- a/py4DSTEM/process/polar/polar_peaks.py
+++ b/py4DSTEM/process/polar/polar_peaks.py
@@ -34,7 +34,8 @@ def find_peaks_single_pattern(
     return_background = False,
     plot_result = True,
     plot_power_scale = 1.0,
-    plot_scale_size = 100.0,
+    plot_scale_size = 10.0,
+    figsize = (6,6),
     returnfig = False,
     ):
     """
@@ -62,10 +63,41 @@ def find_peaks_single_pattern(
     radial_background_thresh: float
         Relative order of sorted values to use as background estimate.
         Setting to 0.5 is equivalent to median, 0.0 is min value.
-    
+    num_peaks_max = 100
+        Max number of peaks to return.
+    threshold_abs: float
+        Absolute image intensity threshold for peaks.
+    threshold_prom_annular: float
+        Threshold for prominance, along annular direction.
+    threshold_prom_radial: float
+        Threshold for prominance, along radial direction.
+    remove_masked_peaks: bool
+        Delete peaks that are in the region masked by "mask"
+    scale_sigma_annular: float
+        Scaling of the estimated annular standard deviation.
+    scale_sigma_radial: float
+        Scaling of the estimated radial standard deviation.
+    return_background: bool
+        Return the background signal.
+    plot_result:
+        Plot the detector peaks
+    plot_power_scale: float
+        Image intensity power law scaling.
+    plot_scale_size: float
+        Marker scaling in the plot.
+    figsize: 2-tuple
+        Size of the result plotting figure.
+    returnfig: bool
+        Return the figure and axes handles.
+
     Returns
     --------
 
+    peaks_polar : pointlist
+        The detected peaks
+    fig, ax : (optional)
+        Figure and axes handles 
+
     """
 
     # if needed, generate mask from Bragg peaks
@@ -151,7 +183,7 @@ def find_peaks_single_pattern(
             trace_annular, 
             annular_ind_center,
             )
-        sigma_annular = scale_sigma_annular * np.maximum(
+        sigma_annular = scale_sigma_annular * np.minimum(
             annular_ind_center - p_annular[1],
             p_annular[2] - annular_ind_center)
 
@@ -161,7 +193,7 @@ def find_peaks_single_pattern(
             trace_radial, 
             np.atleast_1d(peaks[a0,1]),
             )
-        sigma_radial = scale_sigma_radial * np.maximum(
+        sigma_radial = scale_sigma_radial * np.minimum(
             peaks[a0,1] - p_radial[1],
             p_radial[2] - peaks[a0,1])
 

From 6659d5f2d778323fb8aa7592428441fce988d3c0 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Mon, 17 Jul 2023 16:40:30 -0400
Subject: [PATCH 325/362] bvects autocal fix

---
 py4DSTEM/data/calibration.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/data/calibration.py b/py4DSTEM/data/calibration.py
index b5ef200d8..50ec8f6f9 100644
--- a/py4DSTEM/data/calibration.py
+++ b/py4DSTEM/data/calibration.py
@@ -610,6 +610,7 @@ def set_QR_flip(self,x):
     def get_QR_flip(self):
         return self._get_value('QR_flip')
 
+    @call_calibrate
     def set_QR_rotflip(self, rot_flip):
         """
         Args:
@@ -618,8 +619,8 @@ def set_QR_rotflip(self, rot_flip):
                 flip (bool): True indicates a Q/R axes flip
         """
         rot,flip = rot_flip
-        self.set_QR_rotation_degrees(rot)
-        self.set_QR_flip(flip)
+        self._params['QR_rotation_degrees'] = rot
+        self._params['QR_flip'] = flip
     def get_QR_rotflip(self):
         rot = self.get_QR_rotation_degrees()
         flip = self.get_QR_flip()

From 12d6e114eae7775f93c20a79804231bf0f6283ea Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Mon, 17 Jul 2023 16:50:16 -0400
Subject: [PATCH 326/362] polar datacube instantiation bugfix

---
 py4DSTEM/process/polar/polar_datacube.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/process/polar/polar_datacube.py b/py4DSTEM/process/polar/polar_datacube.py
index 3f3db0eca..652debb23 100644
--- a/py4DSTEM/process/polar/polar_datacube.py
+++ b/py4DSTEM/process/polar/polar_datacube.py
@@ -127,9 +127,9 @@ def set_radial_bins(
             self._qmax,
             self._qstep
         )
-        self.qscale = self._qscale
         self._radial_step = self._datacube.calibration.get_Q_pixel_size() * self._qstep
         self.set_polar_shape()
+        self.qscale = self._qscale
 
     @property
     def qmin(self):

From af475e847fdb3647e302969e86201232e2dbe722 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Mon, 17 Jul 2023 20:06:14 -0400
Subject: [PATCH 327/362] fixes

---
 py4DSTEM/datacube/virtualimage.py | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/py4DSTEM/datacube/virtualimage.py b/py4DSTEM/datacube/virtualimage.py
index 6731c0fd0..ad6344c7d 100644
--- a/py4DSTEM/datacube/virtualimage.py
+++ b/py4DSTEM/datacube/virtualimage.py
@@ -10,7 +10,7 @@
 import inspect
 
 from emdfile import tqdmnd,Metadata
-from py4DSTEM.data import Calibration, RealSlice, Data
+from py4DSTEM.data import Calibration, RealSlice, Data, DiffractionSlice
 from py4DSTEM.visualize.show import show
 
 
@@ -322,7 +322,7 @@ def position_detector(
         data = None,
         centered = None,
         calibrated = None,
-        shift_center = None,
+        shift_center = False,
         scan_position = None,
         invert = False,
         color = 'r',
@@ -381,18 +381,22 @@ def position_detector(
 
         # data
         if data is None:
+            image = None
             keys = ['dp_mean','dp_max','dp_median']
             for k in keys:
-                image = None
                 try:
-                    image = data.tree(k)
+                    image = self.tree(k)
                     break
                 except:
                     pass
-                if image is None:
-                    image = self[0,0]
+            if image is None:
+                image = self[0,0]
         elif isinstance(data, np.ndarray):
             assert(data.shape == self.Qshape), f"Can't position a detector over an image with a shape that is different from diffraction space.  Diffraction space in this dataset has shape {self.Qshape} but the image passed has shape {data.shape}"
+            image = data
+        elif isinstance(data, DiffractionSlice):
+            assert(data.shape == self.Qshape), f"Can't position a detector over an image with a shape that is different from diffraction space.  Diffraction space in this dataset has shape {self.Qshape} but the image passed has shape {data.shape}"
+            image = data.data
         elif isinstance(data,tuple):
             rx,ry = data[:2]
             image = self[rx,ry]
@@ -401,10 +405,7 @@ def position_detector(
 
         # shift center
         if shift_center is None:
-            if isinstance(data,tuple):
-                shift_center = True
-            else:
-                shift_center = False
+            shift_center = False
         elif shift_center == True:
             assert(isinstance(data,tuple)), "If shift_center is set to True, `data` should be a 2-tuple (rx,ry). To shift the detector mask while using some other input for `data`, set `shift_center` to a 2-tuple (rx,ry)"
         elif isinstance(shift_center,tuple):

From a87a908df23b0c1cf8b9458b189d5b3c495033d8 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Mon, 17 Jul 2023 22:24:07 -0400
Subject: [PATCH 328/362] let Crystal.plot_scattering work w/out all cals

---
 py4DSTEM/process/diffraction/crystal_viz.py | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/process/diffraction/crystal_viz.py b/py4DSTEM/process/diffraction/crystal_viz.py
index 9395682a0..c6e9e1a33 100644
--- a/py4DSTEM/process/diffraction/crystal_viz.py
+++ b/py4DSTEM/process/diffraction/crystal_viz.py
@@ -360,6 +360,12 @@ def plot_scattering_intensity(
     # If Bragg peaks are passed in, compute 1D integral
     if bragg_peaks is not None:
 
+        # set rotate and ellipse based on their availability
+        rotate = bragg_peaks.calibration.get_QR_rotation_degrees()
+        ellipse = bragg_peaks.calibration.get_ellipse()
+        rotate = False if rotate is None else True
+        ellipse = False if ellipse is None else True
+
         # concatenate all peaks
         bigpl = np.concatenate(
             [
@@ -367,9 +373,9 @@ def plot_scattering_intensity(
                     rx,
                     ry,
                     center = True,
-                    ellipse = True,
+                    ellipse = ellipse,
                     pixel = True,
-                    rotate = True,
+                    rotate = rotate,
                 ).data
                 for rx in range(bragg_peaks.shape[0])
                 for ry in range(bragg_peaks.shape[1])

From 6ea124b6c1b6124fcc1cce4fa0ce60b1269bd2eb Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Mon, 17 Jul 2023 22:40:35 -0400
Subject: [PATCH 329/362] let Crystal.cal_pix_size work w/out all cals

---
 py4DSTEM/process/diffraction/crystal.py | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/process/diffraction/crystal.py b/py4DSTEM/process/diffraction/crystal.py
index 3be87eb25..1c4ac9073 100644
--- a/py4DSTEM/process/diffraction/crystal.py
+++ b/py4DSTEM/process/diffraction/crystal.py
@@ -898,6 +898,12 @@ def calculate_bragg_peak_histogram(
         k = np.arange(k_min, k_max + k_step, k_step)
         k_num = k.shape[0]
 
+        # set rotate and ellipse based on their availability
+        rotate = bragg_peaks.calibration.get_QR_rotation_degrees()
+        ellipse = bragg_peaks.calibration.get_ellipse()
+        rotate = False if rotate is None else True
+        ellipse = False if ellipse is None else True
+
         # concatenate all peaks
         bigpl = np.concatenate(
             [
@@ -905,9 +911,9 @@ def calculate_bragg_peak_histogram(
                     rx,
                     ry,
                     center = True,
-                    ellipse = True,
+                    ellipse = ellipse,
                     pixel = True,
-                    rotate = True,
+                    rotate = rotate,
                 ).data
                 for rx in range(bragg_peaks.shape[0])
                 for ry in range(bragg_peaks.shape[1])

From de92f647020728f91126c1b45ff5c2a6810cb850 Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Mon, 17 Jul 2023 19:53:24 -0700
Subject: [PATCH 330/362] Slight updates to polardata

---
 py4DSTEM/process/polar/polar_datacube.py | 10 ++--
 py4DSTEM/process/polar/polar_peaks.py    | 69 ++++++++++++++++++------
 2 files changed, 61 insertions(+), 18 deletions(-)

diff --git a/py4DSTEM/process/polar/polar_datacube.py b/py4DSTEM/process/polar/polar_datacube.py
index 652debb23..9de3da249 100644
--- a/py4DSTEM/process/polar/polar_datacube.py
+++ b/py4DSTEM/process/polar/polar_datacube.py
@@ -19,7 +19,7 @@ def __init__(
         n_annular = 180,
         qscale = None,
         mask = None,
-        mask_thresh = 0.25,
+        mask_thresh = 0.1,
         ellipse = True,
         two_fold_symmetry = False,
         ):
@@ -241,7 +241,11 @@ def qscale(self):
     def qscale(self,x):
         self._qscale = x
         if x is not None:
-            self._qscale_ar = np.arange(self.polar_shape[1])**x
+            self._qscale_ar = (self.qq / self.qq[-1])**x
+            # self._qscale_ar = np.arange(self.polar_shape[1])**x
+            # print(self.qq)
+            # self._qscale_ar = (np.arange(self._qmin, self.polar_shape[1] + self._qmin) \
+            #     / (self.polar_shape[1] - - self._qmin))**x
 
 
     # expose raw data
@@ -453,7 +457,7 @@ def _transform(
         )
 
         # scale the normalization array by the bin density
-        norm_array = ans_norm*self._polarcube._annular_bin_step[np.newaxis]
+        norm_array = ans_norm * self._polarcube._annular_bin_step[np.newaxis]
         mask_bool = norm_array < mask_thresh
 
         # apply normalization
diff --git a/py4DSTEM/process/polar/polar_peaks.py b/py4DSTEM/process/polar/polar_peaks.py
index c88b8d231..c04a7fab8 100644
--- a/py4DSTEM/process/polar/polar_peaks.py
+++ b/py4DSTEM/process/polar/polar_peaks.py
@@ -5,7 +5,7 @@
 from scipy.ndimage import gaussian_filter, gaussian_filter1d
 from scipy.signal import peak_prominences
 from skimage.feature import peak_local_max
-from scipy.optimize import curve_fit
+from scipy.optimize import curve_fit, leastsq
 import warnings
 
 # from emdfile import tqdmnd, PointList, PointListArray
@@ -35,7 +35,7 @@ def find_peaks_single_pattern(
     plot_result = True,
     plot_power_scale = 1.0,
     plot_scale_size = 10.0,
-    figsize = (6,6),
+    figsize = (12,6),
     returnfig = False,
     ):
     """
@@ -298,7 +298,7 @@ def find_peaks_single_pattern(
         st = np.sin(t)
 
 
-        fig,ax = plt.subplots(figsize=(12,6))
+        fig,ax = plt.subplots(figsize=figsize)
 
         ax.imshow(
             im_plot,
@@ -783,6 +783,8 @@ def model_radial_background(
         self.background_coefs[3*a0+3] = ring_int[a0]
         self.background_coefs[3*a0+4] = ring_sigma[a0]
         self.background_coefs[3*a0+5] = ring_position[a0]
+    lb = np.zeros_like(self.background_coefs)
+    ub = np.ones_like(self.background_coefs) * np.inf
 
     # Create background model
     def background_model(q, *coefs):
@@ -808,7 +810,7 @@ def background_model(q, *coefs):
             self.background_radial_mean[self.background_mask], 
             p0 = self.background_coefs,
             xtol = 1e-12,
-            # bounds = (lb,ub),
+            bounds = (lb,ub),
         )[0]
 
     # plotting
@@ -826,6 +828,7 @@ def refine_peaks(
     # reset_fits_to_init_positions = False,
     scale_sigma_estimate = 0.5,
     min_num_pixels_fit = 10,
+    maxfev = None,
     progress_bar = True,
     ):
     """
@@ -848,6 +851,8 @@ def refine_peaks(
         Factor to reduce sigma of peaks by, to prevent fit from running away.
     min_num_pixels_fit: int
         Minimum number of pixels to perform fitting
+    maxfev: int
+        Maximum number of iterations in fit.  Set to a low number for a fast fit.
     progress_bar: bool
         Enable progress bar
 
@@ -928,6 +933,11 @@ def refine_peaks(
             s_radial * scale_sigma_estimate,
             ))
 
+        # bounds
+        lb = np.zeros_like(coefs_all)
+        ub = np.ones_like(coefs_all) * np.inf
+
+
         # Construct fitting model
         def fit_image(basis, *coefs):
             coefs = np.squeeze(np.array(coefs))
@@ -960,14 +970,25 @@ def fit_image(basis, *coefs):
         try:
             with warnings.catch_warnings():
                 warnings.simplefilter('ignore')
-                coefs_all = curve_fit(
-                    fit_image, 
-                    basis[mask_bool.ravel(),:], 
-                    im_polar[mask_bool], 
-                    p0 = coefs_all,
-                    xtol = 1e-12,
-                    # bounds = (lb,ub),
-                )[0]
+                if maxfev is None:
+                    coefs_all = curve_fit(
+                        fit_image, 
+                        basis[mask_bool.ravel(),:], 
+                        im_polar[mask_bool], 
+                        p0 = coefs_all,
+                        xtol = 1e-12,
+                        bounds = (lb,ub),
+                    )[0]
+                else:
+                    coefs_all = curve_fit(
+                        fit_image, 
+                        basis[mask_bool.ravel(),:], 
+                        im_polar[mask_bool], 
+                        p0 = coefs_all,
+                        xtol = 1e-12,
+                        maxfev = maxfev,
+                        bounds = (lb,ub),
+                    )[0]
 
             # Output refined peak parameters
             coefs_peaks = np.reshape(
@@ -983,9 +1004,24 @@ def fit_image(basis, *coefs):
                 ]),
                 name = 'peaks_polar')
         except:
-            # if fitting has failed, we will output the mean background signal,
-            # but none of the peaks.
-            pass
+            # if fitting has failed, we will still output the last iteration
+            # TODO - add a flag for unconverged fits
+            coefs_peaks = np.reshape(
+                coefs_all[(3*num_rings+3):],
+                (5,num_peaks)).T
+            self.peaks_refine[rx,ry] = PointList(
+                coefs_peaks.ravel().view([
+                    ('qt', float),
+                    ('qr', float),
+                    ('intensity', float),
+                    ('sigma_annular', float),
+                    ('sigma_radial', float),
+                ]),
+                name = 'peaks_polar')
+
+            #  mean background signal,
+            # # but none of the peaks.
+            # pass
 
         # Output refined parameters for background
         coefs_bg = coefs_all[:(3*num_rings+3)]
@@ -1186,6 +1222,9 @@ def make_orientation_histogram(
         v_sigma = np.linspace(-2,2,2*peak_sigma_samples+1)
         w_sigma = np.exp(-v_sigma**2/2)
 
+    if use_refined_peaks is False:
+        warnings.warn("Orientation histogram is using non-refined peak positions")
+
     # Loop over all probe positions
     for a0 in range(num_radii):
         t = "Generating histogram " + str(a0)

From b9a03b63243961af082138234d298fe0ff271e49 Mon Sep 17 00:00:00 2001
From: cophus <cophus@gmail.com>
Date: Mon, 17 Jul 2023 20:11:55 -0700
Subject: [PATCH 331/362] fix for non-refined peaks in polar peaks

---
 py4DSTEM/process/polar/polar_peaks.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/py4DSTEM/process/polar/polar_peaks.py b/py4DSTEM/process/polar/polar_peaks.py
index c04a7fab8..b05434233 100644
--- a/py4DSTEM/process/polar/polar_peaks.py
+++ b/py4DSTEM/process/polar/polar_peaks.py
@@ -1270,7 +1270,10 @@ def make_orientation_histogram(
 
                 # If needed, expand signal using peak sigma to write into multiple bins
                 if use_peak_sigma:
-                    theta_std = self.peaks_refine[rx,ry]['sigma_annular'][sub] / dtheta
+                    if use_refined_peaks:
+                        theta_std = self.peaks_refine[rx,ry]['sigma_annular'][sub] / dtheta
+                    else:
+                        theta_std = self.peaks[rx,ry]['sigma_annular'][sub] / dtheta                        
                     t = (t[:,None] + theta_std[:,None]*v_sigma[None,:]).ravel()
                     intensity = (intensity[:,None] * w_sigma[None,:]).ravel()
 

From a34d97e2ad62e8d214a06467baa36fb707e41f22 Mon Sep 17 00:00:00 2001
From: bsavitzky <bsavitzky@users.noreply.github.com>
Date: Mon, 17 Jul 2023 23:18:32 -0400
Subject: [PATCH 332/362] Update polar_datacube.py

---
 py4DSTEM/process/polar/polar_datacube.py | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/py4DSTEM/process/polar/polar_datacube.py b/py4DSTEM/process/polar/polar_datacube.py
index 9de3da249..24e6aaf40 100644
--- a/py4DSTEM/process/polar/polar_datacube.py
+++ b/py4DSTEM/process/polar/polar_datacube.py
@@ -242,10 +242,6 @@ def qscale(self,x):
         self._qscale = x
         if x is not None:
             self._qscale_ar = (self.qq / self.qq[-1])**x
-            # self._qscale_ar = np.arange(self.polar_shape[1])**x
-            # print(self.qq)
-            # self._qscale_ar = (np.arange(self._qmin, self.polar_shape[1] + self._qmin) \
-            #     / (self.polar_shape[1] - - self._qmin))**x
 
 
     # expose raw data

From 03baa807c81ae9b9e32fa2b2f93ea42ff52aaa71 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Tue, 18 Jul 2023 08:23:43 -0700
Subject: [PATCH 333/362] fix for fit

---
 py4DSTEM/process/fit/fit.py | 211 ++++++++++++++++++++++++++++++------
 1 file changed, 177 insertions(+), 34 deletions(-)

diff --git a/py4DSTEM/process/fit/fit.py b/py4DSTEM/process/fit/fit.py
index 4a75d5c68..32809ddb1 100644
--- a/py4DSTEM/process/fit/fit.py
+++ b/py4DSTEM/process/fit/fit.py
@@ -29,41 +29,49 @@ def fit_1D_gaussian(xdata,ydata,xmin,xmax):
     A,mu,sigma = scale*popt[0],popt[1],popt[2]
     return A,mu,sigma
 
-def fit_2D(function, data, data_mask=None, popt=None,
-    robust=False, robust_steps=3, robust_thresh=2):
+def fit_2D(
+    function,
+    data,
+    data_mask=None,
+    popt=None,
+    robust=False,
+    robust_steps=3,
+    robust_thresh=2,
+    ):
     """
-    Performs a 2D fit, where the fit function takes its first input in the form of a
-    length 2 vector (ndarray) of (x,y) positions, followed by the remaining parameters,
-    and the data to fit takes the form of an (n,m) shaped array. Robust fitting can be
-    enabled to iteratively reject outlier data points, which have a root-mean-square
-    error beyond the user-specified threshold.
-
-    Args:
-        function: First input should be a length 2 array xy, where (xy[0],xy[1]) are the
-            (x,y) coordinates
-        data: Data to fit, in an (n,m) shaped ndarray
-        data_mask:  Optional parameter. If specified, must be a boolean array of the same
-            shape as data, specifying which elements of data to use in the fit
-        return_ar: Optional parameter. If False, only the fit parameters and covariance
-            matrix are returned. If True, return an array  of the same shape as data with
-            the fit values. Defaults to True
-        popt: Optional parameter for input. If specified, should be a tuple of initial
-            guesses for the fit parameters.
-        robust: Optional parameter. If set to True, fit will be repeated with outliers
-            removed.
-        robust_steps: Optional parameter. Number of robust iterations performed after
-            initial fit.
-        robust_thresh: Optional parameter. Threshold for including points, in units of
-            root-mean-square (standard deviations) error of the predicted values after
-            fitting.
+    Performs a 2D fit.
+
+    TODO: make returning the mask optional
+
+    Parameters
+    ----------
+    function : callable
+        Some `function( xy, **p)` where `xy` is a length 2 vector (1D np array)
+        specifying the pixel position (x,y), and `p` is the function parameters
+    data : ndarray
+        Some 2D array of any shape (n,m)
+    data_mask : None or boolean array of shape (n,m), optional
+        If specified, fits only the pixels in `data` where this array is True
+    popt : dict
+        Initial guess at the parameters `p` of `function`. Note that positions
+        in pixels (i.e. the xy positions) are linearly scaled to the space [0,1]
+    robust : bool
+        Toggles robust fitting, which iteratively rejects outlier data points
+        which have a root-mean-square error beyond `robust_thresh`
+    robust_steps : int
+        The number of robust fitting iterations to perform
+    robust_thresh : int
+        The robust fitting cutoff
 
     Returns:
     (popt,pcov,fit_at, mask) : 4-tuple
         The optimal fit parameters, the fitting covariance matrix, the
         the fit array with the returned `popt` params, and the mask
     """
+    # get shape
     shape = data.shape
     shape1D = [1,np.prod(shape)]
+
     # x and y coordinates normalized from 0 to 1
     x,y = np.linspace(0, 1, shape[0]),np.linspace(0, 1, shape[1])
     ry,rx = np.meshgrid(y,x)
@@ -75,8 +83,10 @@ def fit_2D(function, data, data_mask=None, popt=None,
     if robust==False:
         robust_steps=0
 
-    # least squares fitting - 1st iteration 
+    # least squares fitting
     for k in range(robust_steps+1):
+
+        # in 1st iteration, set up params and mask
         if k == 0:
             if popt is None:
                 popt = np.zeros((1,len(signature(function).parameters)-1))
@@ -84,16 +94,21 @@ def fit_2D(function, data, data_mask=None, popt=None,
                 mask = data_mask
             else:
                 mask = np.ones(shape,dtype=bool)
+
+        # otherwise, get fitting error and add high error pixels to mask
         else:
-            fit_mean_square_error = (function(xy,*popt).reshape(shape) - data)**2
-            mask = fit_mean_square_error <= np.mean(fit_mean_square_error) * robust_thresh**2
-            # include user-specified mask if provided
-            if data_mask is not None:
-                mask[data_mask==False] = False
+            fit_mean_square_error = (
+                function(xy,*popt).reshape(shape) - data)**2
+            _mask = fit_mean_square_error > np.mean(
+                fit_mean_square_error) * robust_thresh**2
+            mask[_mask] == False
 
         # perform fitting
-        popt, pcov = curve_fit(function,
-            np.vstack((rx_1D[mask.reshape(shape1D)],ry_1D[mask.reshape(shape1D)])),
+        popt, pcov = curve_fit(
+            function,
+            np.vstack((
+                rx_1D[mask.reshape(shape1D)],
+                ry_1D[mask.reshape(shape1D)])),
             data[mask],
             p0=popt)
 
@@ -124,5 +139,133 @@ def bezier_two(xy, c00, c01, c02, c10, c11, c12, c20, c21, c22):
         c12*2*(1-xy[0])*xy[0] * (xy[1]**2) + \
         c22  *(xy[0]**2)      * (xy[1]**2)
 
+def polar_gaussian_2D(
+    tq,
+    I0,
+    mu_t,
+    mu_q,
+    sigma_t,
+    sigma_q,
+    C,
+    ):
+    # unpack position
+    t,q = tq
+    # set theta value to its closest periodic reflection to mu_t
+    #t = np.square(t-mu_t)
+    #t2 = np.min(np.vstack([t,1-t]))
+    t2 = np.square(t-mu_t)
+    return \
+        I0 * np.exp(
+            - ( t2/(2*sigma_t**2) + \
+                (q-mu_q)**2/(2*sigma_q**2) ) ) + C
+
+
+def polar_twofold_gaussian_2D(
+    tq,
+    I0,
+    mu_t,
+    mu_q,
+    sigma_t,
+    sigma_q,
+    ):
+    
+    # unpack position
+    t,q = tq
+
+    # theta periodicity
+    dt = np.mod(t - mu_t + np.pi/2, np.pi) - np.pi/2
+
+    # output intensity
+    return I0 * np.exp(
+        (dt**2 / (-2.0*sigma_t**2)) + \
+        ((q - mu_q)**2 / (-2.0*sigma_q**2)) )
+
+def polar_twofold_gaussian_2D_background(
+    tq,
+    I0,
+    mu_t,
+    mu_q,
+    sigma_t,
+    sigma_q,
+    C,
+    ):
+    
+    # unpack position
+    t,q = tq
 
+    # theta periodicity
+    dt = np.mod(t - mu_t + np.pi/2, np.pi) - np.pi/2
+
+    # output intensity
+    return C + I0 * np.exp(
+        (dt**2 / (-2.0*sigma_t**2)) + \
+        ((q - mu_q)**2 / (-2.0*sigma_q**2)) )
+
+
+def fit_2D_polar_gaussian(
+    data,
+    mask = None,
+    p0 = None,
+    robust = False,
+    robust_steps = 3,
+    robust_thresh = 2,
+    constant_background = False,
+    ):
+    """
+
+    NOTE - this cannot work without using pixel coordinates - something is wrong in the workflow.
+
+
+    Fits a 2D gaussian to the pixels in `data` which are set to True in `mask`.
+
+    The gaussian is anisotropic and oriented along (t,q), centered at
+    (mu_t,mu_q), has standard deviations (sigma_t,sigma_q), maximum of I0,
+    and an optional constant offset of C, and is periodic in t.
+
+        f(x,y) = I0 * exp( - (x-mu_x)^2/(2sig_x^2) + (y-mu_y)^2/(2sig_y^2) )
+        or
+        f(x,y) = I0 * exp( - (x-mu_x)^2/(2sig_x^2) + (y-mu_y)^2/(2sig_y^2) ) + C
+
+    Parameters
+    ----------
+    data : 2d array
+        the data to fit
+    p0 : 6-tuple
+        initial guess at fit parameters, (I0,mu_x,mu_y,sigma_x_sigma_y,C)
+    mask : 2d boolean array
+        ignore pixels where mask is False
+    robust : bool
+        toggle robust fitting
+    robust_steps : int
+        number of robust fit iterations
+    robust_thresh : number
+        the robust fitting threshold
+    constant_background : bool
+        whether or not to include constant background
+
+    Returns
+    -------
+    (popt,pcov,fit_ar) : 3-tuple
+        the optimal fit parameters, the covariance matrix, and the fit array
+    """
 
+    if constant_background:
+        return fit_2D(
+            polar_twofold_gaussian_2D_background,
+            data = data,
+            data_mask = mask,
+            popt = p0,
+            robust = robust,
+            robust_steps = robust_steps,
+            robust_thresh = robust_thresh
+        )
+    else:
+        return fit_2D(
+            polar_twofold_gaussian_2D,
+            data = data,
+            data_mask = mask,
+            popt = p0,
+            robust = robust,
+            robust_steps = robust_steps,
+            robust_thresh = robust_thresh
+        )

From 24e6c256ac1a9abeaebddbfd7731406673e7a488 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Thu, 13 Jul 2023 21:48:25 -0400
Subject: [PATCH 334/362] updates

---
 py4DSTEM/process/strain.py        | 402 ++++++++++++++++++++++++++----
 py4DSTEM/visualize/vis_special.py |  96 -------
 test/test_strain.py               |   2 +
 3 files changed, 351 insertions(+), 149 deletions(-)

diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index e999c02d1..3088afa51 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -1,10 +1,12 @@
 # Defines the Strain class
 
 import numpy as np
+import matplotlib.pyplot as plt
 from typing import Optional
 from py4DSTEM.data import RealSlice, Data
 from py4DSTEM.braggvectors import BraggVectors
-
+from py4DSTEM.preprocess.utils import get_maxima_2D
+from py4DSTEM.visualize import show,add_pointlabels,add_vector
 
 
 class StrainMap(RealSlice,Data):
@@ -45,19 +47,26 @@ def __init__(
         )
 
         # set up braggvectors
+        # this assigns the bvs, ensures the origin is calibrated,
+        # and adds the strainmap to the bvs' tree
         self.braggvectors = braggvectors
-        # TODO - how to handle changes to braggvectors
-        #   option: register with calibrations and add a .calibrate method
-        #   which {{does something}} when origin changes
-        # TODO - include ellipse cal or no?
-
-        assert(self.root is not None)
 
         # initialize as Data
-        Data.__init__(
-            self,
-            calibration = self.braggvectors.calibration
-        )
+        Data.__init__(self)
+
+        # set calstate
+        # this property is used only to check to make sure that
+        # the braggvectors being used throughout a workflow are
+        # the same. The state of calibration of the vectors is noted
+        # here, and then checked each time the vectors are used -
+        # if they differ, an error message and instructions for
+        # re-calibration are issued
+        self.calstate = self.braggvectors.calstate
+
+        # get the BVM
+        # a new BVM using the current calstate is computed
+        self.bvm = self.braggvectors.histogram()
+
 
 
     # braggvector properties
@@ -73,6 +82,20 @@ def braggvectors(self,x):
         self._braggvectors.tree(self,force=True)
 
 
+    def reset_calstate(self):
+        """
+        Resets the calibration state. This recomputes the BVM, and removes any computations
+        this StrainMap instance has stored, which will need to be recomputed.
+        """
+        del(
+            self.g0,
+            self.g1,
+            self.g2,
+        )
+        self.calstate = self.braggvectors.calstate
+        pass
+
+
 
     # Class methods
 
@@ -81,8 +104,6 @@ def choose_lattice_vectors(
         index_g0,
         index_g1,
         index_g2,
-        mode = 'centered',
-        plot = True,
         subpixel = 'multicorr',
         upsample_factor = 16,
         sigma=0,
@@ -92,39 +113,94 @@ def choose_lattice_vectors(
         minSpacing=0,
         edgeBoundary=1,
         maxNumPeaks=10,
-        bvm_vis_params = {},
+        figsize=(12,6),
+        c_indices='lightblue',
+        c0='g',
+        c1='r',
+        c2='r',
+        c_vectors='r',
+        c_vectorlabels='w',
+        size_indices=20,
+        width_vectors=1,
+        size_vectorlabels=20,
+        vis_params = {},
         returncalc = False,
+        returnfig=False,
         ):
         """
         Choose which lattice vectors to use for strain mapping.
 
-        Args:
-            index_g0 (int): origin
-            index_g1 (int): second point of vector 1
-            index_g2 (int): second point of vector 2
-            mode (str): centered or raw bragg map
-            plot (bool): plot bragg vector maps and vectors
-            subpixel (str): specifies the subpixel resolution algorithm to use.
-                must be in ('pixel','poly','multicorr'), which correspond
-                to pixel resolution, subpixel resolution by fitting a
-                parabola, and subpixel resultion by Fourier upsampling.
-            upsample_factor: the upsampling factor for the 'multicorr'
-                algorithm
-            sigma: if >0, applies a gaussian filter
-            maxNumPeaks: the maximum number of maxima to return
-            minAbsoluteIntensity, minRelativeIntensity, relativeToPeak,
-                minSpacing, edgeBoundary, maxNumPeaks: filtering applied
-                after maximum detection and before subpixel refinement
+        Overlays the bvm with the points detected via local 2D
+        maxima detection, plus an index for each point. User selects
+        3 points using the overlaid indices, which are identified as
+        the origin and the termini of the lattice vectors g1 and g2.
+
+        Parameters
+        ----------
+        index_g0 : int
+            selected index for the origin
+        index_g1 : int
+            selected index for g1
+        index_g2 :int
+            selected index for g2
+        subpixel : str in ('pixel','poly','multicorr')
+            See the docstring for py4DSTEM.preprocess.get_maxima_2D
+        upsample_factor : int
+            See the py4DSTEM.preprocess.get_maxima_2D docstring
+        sigma : number
+            See the py4DSTEM.preprocess.get_maxima_2D docstring
+        minAbsoluteIntensity : number
+            See the py4DSTEM.preprocess.get_maxima_2D docstring
+        minRelativeIntensity : number
+            See the py4DSTEM.preprocess.get_maxima_2D docstring
+        relativeToPeak : int
+            See the py4DSTEM.preprocess.get_maxima_2D docstring
+        minSpacing : number
+            See the py4DSTEM.preprocess.get_maxima_2D docstring
+        edgeBoundary : number
+            See the py4DSTEM.preprocess.get_maxima_2D docstring
+        maxNumPeaks : int
+            See the py4DSTEM.preprocess.get_maxima_2D docstring
+        figsize : 2-tuple
+            the size of the figure
+        c_indices : color
+            color of the maxima
+        c0 : color
+            color of the origin
+        c1 : color
+            color of g1 point
+        c2 : color
+            color of g2 point
+        c_vectors : color
+            color of the g1/g2 vectors
+        c_vectorlabels : color
+            color of the vector labels
+        size_indices : number
+            size of the indices
+        width_vectors : number
+            width of the vectors
+        size_vectorlabels : number
+            size of the vector labels
+        vis_params : dict
+            additional visualization parameters passed to `show`
+        returncalc : bool
+            toggles returning the answer
+        returnfig : bool
+            toggles returning the figure
+
+        Returns
+        -------
+        (optional) : None or (g0,g1,g2) or (fig,(ax1,ax2)) or both of the latter
         """
-        from py4DSTEM.process.utils import get_maxima_2D
-
-        if mode == "centered":
-            bvm = self.bvm_centered
-        else:
-            bvm = self.bvm_raw
+        # validate inputs
+        for i in (index_g0,index_g1,index_g2):
+            assert isinstance(i,(int,np.integer)), "indices must be integers!"
+        # check the calstate
+        assert(self.calstate == self.braggvectors.calstate), "The calibration state has changed! To resync the calibration state, use `.reset_calstate`."
 
+        # find the maxima
         g = get_maxima_2D(
-            bvm,
+            self.bvm.data,
             subpixel = subpixel,
             upsample_factor = upsample_factor,
             sigma = sigma,
@@ -136,26 +212,246 @@ def choose_lattice_vectors(
             maxNumPeaks = maxNumPeaks,
         )
 
-        self.g = g
-
-        from py4DSTEM.visualize import select_lattice_vectors
-        g1,g2 = select_lattice_vectors(
-            bvm,
-            gx = g['x'],
-            gy = g['y'],
-            i0 = index_g0,
-            i1 = index_g1,
-            i2 = index_g2,
-            **bvm_vis_params,
-        )
-
+        # get the lattice vectors
+        gx,gy = g['x'],g['y']
+        g0 = gx[index_g0],gy[index_g0]
+        g1x = gx[index_g1] - g0[0]
+        g1y = gy[index_g1] - g0[1]
+        g2x = gx[index_g2] - g0[0]
+        g2y = gy[index_g2] - g0[1]
+        g1,g2 = (g1x,g1y),(g2x,g2y)
+
+        # make the figure
+        fig,(ax1,ax2) = plt.subplots(1,2,figsize=figsize)
+        show(self.bvm.data,figax=(fig,ax1),**vis_params)
+        show(self.bvm.data,figax=(fig,ax2),**vis_params)
+
+        # Add indices to left panel
+        d = {'x':gx,'y':gy,'size':size_indices,'color':c_indices}
+        d0 = {'x':gx[index_g0],'y':gy[index_g0],'size':size_indices,
+              'color':c0,'fontweight':'bold','labels':[str(index_g0)]}
+        d1 = {'x':gx[index_g1],'y':gy[index_g1],'size':size_indices,
+              'color':c1,'fontweight':'bold','labels':[str(index_g1)]}
+        d2 = {'x':gx[index_g2],'y':gy[index_g2],'size':size_indices,
+              'color':c2,'fontweight':'bold','labels':[str(index_g2)]}
+        add_pointlabels(ax1,d)
+        add_pointlabels(ax1,d0)
+        add_pointlabels(ax1,d1)
+        add_pointlabels(ax1,d2)
+
+        # Add vectors to right panel
+        dg1 = {'x0':gx[index_g0],'y0':gy[index_g0],'vx':g1[0],'vy':g1[1],'width':width_vectors,
+               'color':c_vectors,'label':r'$g_1$','labelsize':size_vectorlabels,'labelcolor':c_vectorlabels}
+        dg2 = {'x0':gx[index_g0],'y0':gy[index_g0],'vx':g2[0],'vy':g2[1],'width':width_vectors,
+               'color':c_vectors,'label':r'$g_2$','labelsize':size_vectorlabels,'labelcolor':c_vectorlabels}
+        add_vector(ax2,dg1)
+        add_vector(ax2,dg2)
+
+        # store vectors
+        self.g0 = g0
         self.g1 = g1
         self.g2 = g2
 
-        if returncalc:
-            return g1, g2
+        # return
+        if returncalc and returnfig:
+            return (g0,g1,g2),(fig,(ax1,ax2))
+        elif returncalc:
+            return (g0,g1,g2)
+        elif returnfig:
+            return (fig,(ax1,ax2))
+        else:
+            return
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+def index_bragg_directions(x0, y0, gx, gy, g1, g2):
+    """
+    From an origin (x0,y0), a set of reciprocal lattice vectors gx,gy, and an pair of
+    lattice vectors g1=(g1x,g1y), g2=(g2x,g2y), find the indices (h,k) of all the
+    reciprocal lattice directions.
+
+    The approach is to solve the matrix equation
+            ``alpha = beta * M``
+    where alpha is the 2xN array of the (x,y) coordinates of N measured bragg directions,
+    beta is the 2x2 array of the two lattice vectors u,v, and M is the 2xN array of the
+    h,k indices.
+
+    Args:
+        x0 (float): x-coord of origin
+        y0 (float): y-coord of origin
+        gx (1d array): x-coord of the reciprocal lattice vectors
+        gy (1d array): y-coord of the reciprocal lattice vectors
+        g1 (2-tuple of floats): g1x,g1y
+        g2 (2-tuple of floats): g2x,g2y
+
+    Returns:
+        (3-tuple) A 3-tuple containing:
+
+            * **h**: *(ndarray of ints)* first index of the bragg directions
+            * **k**: *(ndarray of ints)* second index of the bragg directions
+            * **bragg_directions**: *(PointList)* a 4-coordinate PointList with the
+              indexed bragg directions; coords 'qx' and 'qy' contain bragg_x and bragg_y
+              coords 'h' and 'k' contain h and k.
+    """
+    # Get beta, the matrix of lattice vectors
+    beta = np.array([[g1[0],g2[0]],[g1[1],g2[1]]])
+
+    # Get alpha, the matrix of measured bragg angles
+    alpha = np.vstack([gx-x0,gy-y0])
+
+    # Calculate M, the matrix of peak positions
+    M = lstsq(beta, alpha, rcond=None)[0].T
+    M = np.round(M).astype(int)
 
+    # Get h,k
+    h = M[:,0]
+    k = M[:,1]
 
+    # Store in a PointList
+    coords = [('qx',float),('qy',float),('h',int),('k',int)]
+    temp_array = np.zeros([], dtype = coords)
+    bragg_directions = PointList(data = temp_array)
+    bragg_directions.add_data_by_field((gx,gy,h,k))
+
+    return h,k, bragg_directions
+
+
+
+def add_indices_to_braggpeaks(braggpeaks, lattice, maxPeakSpacing, qx_shift=0,
+                              qy_shift=0, mask=None):
+    """
+    Using the peak positions (qx,qy) and indices (h,k) in the PointList lattice,
+    identify the indices for each peak in the PointListArray braggpeaks.
+    Return a new braggpeaks_indexed PointListArray, containing a copy of braggpeaks plus
+    three additional data columns -- 'h','k', and 'index_mask' -- specifying the peak
+    indices with the ints (h,k) and indicating whether the peak was successfully indexed
+    or not with the bool index_mask. If `mask` is specified, only the locations where
+    mask is True are indexed.
+
+    Args:
+        braggpeaks (PointListArray): the braggpeaks to index. Must contain
+            the coordinates 'qx', 'qy', and 'intensity'
+        lattice (PointList): the positions (qx,qy) of the (h,k) lattice points.
+            Must contain the coordinates 'qx', 'qy', 'h', and 'k'
+        maxPeakSpacing (float): Maximum distance from the ideal lattice points
+            to include a peak for indexing
+        qx_shift,qy_shift (number): the shift of the origin in the `lattice` PointList
+            relative to the `braggpeaks` PointListArray
+        mask (bool): Boolean mask, same shape as the pointlistarray, indicating which
+            locations should be indexed. This can be used to index different regions of
+            the scan with different lattices
+
+    Returns:
+        (PointListArray): The original braggpeaks pointlistarray, with new coordinates
+        'h', 'k', containing the indices of each indexable peak.
+    """
+
+    assert isinstance(braggpeaks,PointListArray)
+    assert np.all([name in braggpeaks.dtype.names for name in ('qx','qy','intensity')])
+    assert isinstance(lattice, PointList)
+    assert np.all([name in lattice.dtype.names for name in ('qx','qy','h','k')])
+
+    if mask is None:
+        mask = np.ones(braggpeaks.shape,dtype=bool)
+
+    assert mask.shape == braggpeaks.shape, 'mask must have same shape as pointlistarray'
+    assert mask.dtype == bool, 'mask must be boolean'
+
+    indexed_braggpeaks = braggpeaks.copy()
+
+    # add the coordinates if they don't exist
+    if not ('h' in braggpeaks.dtype.names):
+        indexed_braggpeaks = indexed_braggpeaks.add_fields([('h',int)])
+    if not ('k' in braggpeaks.dtype.names):
+        indexed_braggpeaks = indexed_braggpeaks.add_fields([('k',int)])
+
+    # loop over all the scan positions
+    for Rx, Ry in tqdmnd(mask.shape[0],mask.shape[1]):
+        if mask[Rx,Ry]:
+            pl = indexed_braggpeaks.get_pointlist(Rx,Ry)
+            rm_peak_mask = np.zeros(pl.length,dtype=bool)
+
+            for i in range(pl.length):
+                r2 = (pl.data['qx'][i]-lattice.data['qx'] + qx_shift)**2 + \
+                     (pl.data['qy'][i]-lattice.data['qy'] + qy_shift)**2
+                ind = np.argmin(r2)
+                if r2[ind] <= maxPeakSpacing**2:
+                    pl.data['h'][i] = lattice.data['h'][ind]
+                    pl.data['k'][i] = lattice.data['k'][ind]
+                else:
+                    rm_peak_mask[i] = True
+            pl.remove(rm_peak_mask)
+
+    indexed_braggpeaks.name = braggpeaks.name + "_indexed"
+    return indexed_braggpeaks
+
+
+
+
+
+
+
+
+
+
+
+
+    def show_lattice_vectors(ar,x0,y0,g1,g2,color='r',width=1,labelsize=20,labelcolor='w',returnfig=False,**kwargs):
+        """ Adds the vectors g1,g2 to an image, with tail positions at (x0,y0).  g1 and g2 are 2-tuples (gx,gy).
+        """
+        fig,ax = show(ar,returnfig=True,**kwargs)
+
+        # Add vectors
+        dg1 = {'x0':x0,'y0':y0,'vx':g1[0],'vy':g1[1],'width':width,
+               'color':color,'label':r'$g_1$','labelsize':labelsize,'labelcolor':labelcolor}
+        dg2 = {'x0':x0,'y0':y0,'vx':g2[0],'vy':g2[1],'width':width,
+               'color':color,'label':r'$g_2$','labelsize':labelsize,'labelcolor':labelcolor}
+        add_vector(ax,dg1)
+        add_vector(ax,dg2)
+
+        if returnfig:
+            return fig,ax
+        else:
+            plt.show()
+            return
+
+
+    def show_bragg_indexing(ar,braggdirections,voffset=5,hoffset=0,color='w',size=20,
+                            points=True,pointcolor='r',pointsize=50,returnfig=False,**kwargs):
+        """
+        Shows an array with an overlay describing the Bragg directions
+
+        Accepts:
+            ar                  (arrray) the image
+            bragg_directions    (PointList) the bragg scattering directions; must have coordinates
+                                'qx','qy','h', and 'k'. Optionally may also have 'l'.
+        """
+        assert isinstance(braggdirections,PointList)
+        for k in ('qx','qy','h','k'):
+            assert k in braggdirections.data.dtype.fields
+
+        fig,ax = show(ar,returnfig=True,**kwargs)
+        d = {'braggdirections':braggdirections,'voffset':voffset,'hoffset':hoffset,'color':color,
+             'size':size,'points':points,'pointsize':pointsize,'pointcolor':pointcolor}
+        add_bragg_index_labels(ax,d)
+
+        if returnfig:
+            return fig,ax
+        else:
+            plt.show()
+            return
 
 
 
diff --git a/py4DSTEM/visualize/vis_special.py b/py4DSTEM/visualize/vis_special.py
index b487048e2..43cf7fff8 100644
--- a/py4DSTEM/visualize/vis_special.py
+++ b/py4DSTEM/visualize/vis_special.py
@@ -590,102 +590,6 @@ def select_point(ar,x,y,i,color='lightblue',color_selected='r',size=20,returnfig
         return
 
 
-def select_lattice_vectors(ar,gx,gy,i0,i1,i2,
-               c_indices='lightblue',c0='g',c1='r',c2='r',c_vectors='r',c_vectorlabels='w',
-               size_indices=20,width_vectors=1,size_vectorlabels=20,
-               figsize=(12,6),returnfig=False,**kwargs):
-    """
-    This function accepts a set of reciprocal lattice points (gx,gy) and three indices
-    (i0,i1,i2).  Using those indices as, respectively, the origin, the endpoint of g1, and
-    the endpoint of g2, this function computes the basis lattice vectors g1,g2, visualizes
-    them, and returns them.  To compute these vectors without visualizing, use
-    latticevectors.get_selected_lattice_vectors().
-
-    Returns:
-        if returnfig==False:    g1,g2
-        if returnfig==True      g1,g2,fig,ax
-    """
-    from py4DSTEM.process.latticevectors import get_selected_lattice_vectors
-
-    # Make the figure
-    fig,(ax1,ax2) = plt.subplots(1,2,figsize=figsize)
-    show(ar,figax=(fig,ax1),**kwargs)
-    show(ar,figax=(fig,ax2),**kwargs)
-
-    # Add indices to left panel
-    d = {'x':gx,'y':gy,'size':size_indices,'color':c_indices}
-    d0 = {'x':gx[i0],'y':gy[i0],'size':size_indices,'color':c0,'fontweight':'bold','labels':[str(i0)]}
-    d1 = {'x':gx[i1],'y':gy[i1],'size':size_indices,'color':c1,'fontweight':'bold','labels':[str(i1)]}
-    d2 = {'x':gx[i2],'y':gy[i2],'size':size_indices,'color':c2,'fontweight':'bold','labels':[str(i2)]}
-    add_pointlabels(ax1,d)
-    add_pointlabels(ax1,d0)
-    add_pointlabels(ax1,d1)
-    add_pointlabels(ax1,d2)
-
-    # Compute vectors
-    g1,g2 = get_selected_lattice_vectors(gx,gy,i0,i1,i2)
-
-    # Add vectors to right panel
-    dg1 = {'x0':gx[i0],'y0':gy[i0],'vx':g1[0],'vy':g1[1],'width':width_vectors,
-           'color':c_vectors,'label':r'$g_1$','labelsize':size_vectorlabels,'labelcolor':c_vectorlabels}
-    dg2 = {'x0':gx[i0],'y0':gy[i0],'vx':g2[0],'vy':g2[1],'width':width_vectors,
-           'color':c_vectors,'label':r'$g_2$','labelsize':size_vectorlabels,'labelcolor':c_vectorlabels}
-    add_vector(ax2,dg1)
-    add_vector(ax2,dg2)
-
-    if returnfig:
-        return g1,g2,fig,(ax1,ax2)
-    else:
-        plt.show()
-        return g1,g2
-
-
-def show_lattice_vectors(ar,x0,y0,g1,g2,color='r',width=1,labelsize=20,labelcolor='w',returnfig=False,**kwargs):
-    """ Adds the vectors g1,g2 to an image, with tail positions at (x0,y0).  g1 and g2 are 2-tuples (gx,gy).
-    """
-    fig,ax = show(ar,returnfig=True,**kwargs)
-
-    # Add vectors
-    dg1 = {'x0':x0,'y0':y0,'vx':g1[0],'vy':g1[1],'width':width,
-           'color':color,'label':r'$g_1$','labelsize':labelsize,'labelcolor':labelcolor}
-    dg2 = {'x0':x0,'y0':y0,'vx':g2[0],'vy':g2[1],'width':width,
-           'color':color,'label':r'$g_2$','labelsize':labelsize,'labelcolor':labelcolor}
-    add_vector(ax,dg1)
-    add_vector(ax,dg2)
-
-    if returnfig:
-        return fig,ax
-    else:
-        plt.show()
-        return
-
-
-def show_bragg_indexing(ar,braggdirections,voffset=5,hoffset=0,color='w',size=20,
-                        points=True,pointcolor='r',pointsize=50,returnfig=False,**kwargs):
-    """
-    Shows an array with an overlay describing the Bragg directions
-
-    Accepts:
-        ar                  (arrray) the image
-        bragg_directions    (PointList) the bragg scattering directions; must have coordinates
-                            'qx','qy','h', and 'k'. Optionally may also have 'l'.
-    """
-    assert isinstance(braggdirections,PointList)
-    for k in ('qx','qy','h','k'):
-        assert k in braggdirections.data.dtype.fields
-
-    fig,ax = show(ar,returnfig=True,**kwargs)
-    d = {'braggdirections':braggdirections,'voffset':voffset,'hoffset':hoffset,'color':color,
-         'size':size,'points':points,'pointsize':pointsize,'pointcolor':pointcolor}
-    add_bragg_index_labels(ax,d)
-
-    if returnfig:
-        return fig,ax
-    else:
-        plt.show()
-        return
-
-
 def show_max_peak_spacing(ar,spacing,braggdirections,color='g',lw=2,returnfig=False,**kwargs):
     """ Show a circle of radius `spacing` about each Bragg direction
     """
diff --git a/test/test_strain.py b/test/test_strain.py
index 5bfa0efd3..bc9b8b58c 100644
--- a/test/test_strain.py
+++ b/test/test_strain.py
@@ -27,5 +27,7 @@ def test_strainmap_instantiation(self):
         )
 
         assert(isinstance(strainmap, StrainMap))
+        assert(strainmap.calibration is not None)
+        assert(strainmap.calibration is strainmap.braggvectors.calibration)
 
 

From 5b0ad3e9eeebebfbd5be59752ff83d7a846eabdb Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Thu, 13 Jul 2023 22:49:42 -0400
Subject: [PATCH 335/362] fix

---
 py4DSTEM/process/strain.py | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index 3088afa51..07dcb91bd 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -87,11 +87,13 @@ def reset_calstate(self):
         Resets the calibration state. This recomputes the BVM, and removes any computations
         this StrainMap instance has stored, which will need to be recomputed.
         """
-        del(
-            self.g0,
-            self.g1,
-            self.g2,
-        )
+        for attr in )
+            'g0',
+            'g1',
+            'g2',
+        ):
+            if hasattr(self,attr):
+                delattr(self,attr)
         self.calstate = self.braggvectors.calstate
         pass
 

From 33a6ca3e2cece946d75b8fc928723366b23fd211 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 14 Jul 2023 06:18:46 -0700
Subject: [PATCH 336/362] fit lattice vectors

---
 py4DSTEM/process/latticevectors/fit.py   |  15 +-
 py4DSTEM/process/latticevectors/index.py |  65 ++++--
 py4DSTEM/process/strain.py               | 284 +++++++++++++++--------
 3 files changed, 244 insertions(+), 120 deletions(-)

diff --git a/py4DSTEM/process/latticevectors/fit.py b/py4DSTEM/process/latticevectors/fit.py
index 822ffdea5..fef72aca3 100644
--- a/py4DSTEM/process/latticevectors/fit.py
+++ b/py4DSTEM/process/latticevectors/fit.py
@@ -104,13 +104,22 @@ def fit_lattice_vectors_all_DPs(braggpeaks, x0=0, y0=0, minNumPeaks=5):
 
     # Make RealSlice to contain outputs
     slicelabels = ('x0','y0','g1x','g1y','g2x','g2y','error','mask')
-    g1g2_map = RealSlice(data=np.zeros((braggpeaks.shape[0],braggpeaks.shape[1],8)),
-                       slicelabels=slicelabels, name='g1g2_map')
+    g1g2_map = RealSlice(
+        data=np.zeros(
+            (8, braggpeaks.shape[0],braggpeaks.shape[1])
+            ),
+            slicelabels=slicelabels, name='g1g2_map'
+    )
 
     # Fit lattice vectors
     for (Rx, Ry) in tqdmnd(braggpeaks.shape[0],braggpeaks.shape[1]):
         braggpeaks_curr = braggpeaks.get_pointlist(Rx,Ry)
-        qx0,qy0,g1x,g1y,g2x,g2y,error = fit_lattice_vectors(braggpeaks_curr, x0, y0, minNumPeaks)
+        qx0,qy0,g1x,g1y,g2x,g2y,error = fit_lattice_vectors(
+            braggpeaks_curr, 
+            x0, 
+            y0, 
+            minNumPeaks
+        )
         # Store data
         if g1x is not None:
             g1g2_map.get_slice('x0').data[Rx,Ry] = qx0
diff --git a/py4DSTEM/process/latticevectors/index.py b/py4DSTEM/process/latticevectors/index.py
index cdf6b00fd..13d41d54c 100644
--- a/py4DSTEM/process/latticevectors/index.py
+++ b/py4DSTEM/process/latticevectors/index.py
@@ -80,6 +80,9 @@ def index_bragg_directions(x0, y0, gx, gy, g1, g2):
     temp_array = np.zeros([], dtype = coords)
     bragg_directions = PointList(data = temp_array)
     bragg_directions.add_data_by_field((gx,gy,h,k))
+    mask = np.zeros(bragg_directions['qx'].shape[0])
+    mask[0] = 1
+    bragg_directions.remove(mask)
 
     return h,k, bragg_directions
 
@@ -152,8 +155,14 @@ def generate_lattice(ux,uy,vx,vy,x0,y0,Q_Nx,Q_Ny,h_max=None,k_max=None):
 
     return ideal_lattice
 
-def add_indices_to_braggpeaks(braggpeaks, lattice, maxPeakSpacing, qx_shift=0,
-                              qy_shift=0, mask=None):
+def add_indices_to_braggvectors(
+    braggpeaks, 
+    lattice, 
+    maxPeakSpacing, 
+    qx_shift=0,
+    qy_shift=0, 
+    mask=None
+    ):
     """
     Using the peak positions (qx,qy) and indices (h,k) in the PointList lattice,
     identify the indices for each peak in the PointListArray braggpeaks.
@@ -181,43 +190,51 @@ def add_indices_to_braggpeaks(braggpeaks, lattice, maxPeakSpacing, qx_shift=0,
         'h', 'k', containing the indices of each indexable peak.
     """
 
-    assert isinstance(braggpeaks,PointListArray)
-    assert np.all([name in braggpeaks.dtype.names for name in ('qx','qy','intensity')])
-    assert isinstance(lattice, PointList)
-    assert np.all([name in lattice.dtype.names for name in ('qx','qy','h','k')])
+    # assert isinstance(braggpeaks,BraggVectors)
+    # assert isinstance(lattice, PointList)
+    # assert np.all([name in lattice.dtype.names for name in ('qx','qy','h','k')])
 
     if mask is None:
-        mask = np.ones(braggpeaks.shape,dtype=bool)
+        mask = np.ones(braggpeaks.Rshape,dtype=bool)
 
-    assert mask.shape == braggpeaks.shape, 'mask must have same shape as pointlistarray'
+    assert mask.shape == braggpeaks.Rshape, 'mask must have same shape as pointlistarray'
     assert mask.dtype == bool, 'mask must be boolean'
 
-    indexed_braggpeaks = braggpeaks.copy()
 
-    # add the coordinates if they don't exist
-    if not ('h' in braggpeaks.dtype.names):
-        indexed_braggpeaks = indexed_braggpeaks.add_fields([('h',int)])
-    if not ('k' in braggpeaks.dtype.names):
-        indexed_braggpeaks = indexed_braggpeaks.add_fields([('k',int)])
+    coords = [('qx',float),('qy',float),('intensity',float),('h',int),('k',int)]
+
+    indexed_braggpeaks = PointListArray(    
+        dtype = coords,
+        shape = braggpeaks.Rshape,
+    )
+
+    ellipse = braggpeaks.calstate["ellipse"]
 
     # loop over all the scan positions
     for Rx, Ry in tqdmnd(mask.shape[0],mask.shape[1]):
         if mask[Rx,Ry]:
-            pl = indexed_braggpeaks.get_pointlist(Rx,Ry)
-            rm_peak_mask = np.zeros(pl.length,dtype=bool)
-
-            for i in range(pl.length):
+            pl = braggpeaks.get_vectors(
+                scan_x=Rx,
+                scan_y=Ry,
+                center=True,
+                ellipse=ellipse,
+                pixel=False,
+                rotate=False
+            )
+            
+            for i in range(pl.data.shape[0]):
                 r2 = (pl.data['qx'][i]-lattice.data['qx'] + qx_shift)**2 + \
                      (pl.data['qy'][i]-lattice.data['qy'] + qy_shift)**2
                 ind = np.argmin(r2)
                 if r2[ind] <= maxPeakSpacing**2:
-                    pl.data['h'][i] = lattice.data['h'][ind]
-                    pl.data['k'][i] = lattice.data['k'][ind]
-                else:
-                    rm_peak_mask[i] = True
-            pl.remove(rm_peak_mask)
+                    indexed_braggpeaks[Rx,Ry].add_data_by_field((
+                        pl.data['qx'],
+                        pl.data['qy'],
+                        pl.data['intensity'],
+                        lattice.data['h'][ind],
+                        lattice.data['k'][ind]
+                        ))
 
-    indexed_braggpeaks.name = braggpeaks.name + "_indexed"
     return indexed_braggpeaks
 
 
diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index 07dcb91bd..ec10fe5f9 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -6,8 +6,8 @@
 from py4DSTEM.data import RealSlice, Data
 from py4DSTEM.braggvectors import BraggVectors
 from py4DSTEM.preprocess.utils import get_maxima_2D
-from py4DSTEM.visualize import show,add_pointlabels,add_vector
-
+from py4DSTEM.visualize import show,add_pointlabels,add_vector, add_bragg_index_labels
+from py4DSTEM import PointList
 
 class StrainMap(RealSlice,Data):
     """
@@ -62,7 +62,7 @@ def __init__(
         # if they differ, an error message and instructions for
         # re-calibration are issued
         self.calstate = self.braggvectors.calstate
-
+        assert self.calstate["center"], "braggvectors must be centered"
         # get the BVM
         # a new BVM using the current calstate is computed
         self.bvm = self.braggvectors.histogram()
@@ -87,7 +87,7 @@ def reset_calstate(self):
         Resets the calibration state. This recomputes the BVM, and removes any computations
         this StrainMap instance has stored, which will need to be recomputed.
         """
-        for attr in )
+        for attr in (
             'g0',
             'g1',
             'g2',
@@ -250,6 +250,7 @@ def choose_lattice_vectors(
         add_vector(ax2,dg2)
 
         # store vectors
+        self.g = g
         self.g0 = g0
         self.g1 = g1
         self.g2 = g2
@@ -263,75 +264,218 @@ def choose_lattice_vectors(
             return (fig,(ax1,ax2))
         else:
             return
+    
+    def fit_lattice_vectors(
+        self,
+        x0 = None,
+        y0 = None,
+        max_peak_spacing = 2,
+        mask = None,
+        plot = True,
+        vis_params = {},
+        returncalc = False,
+        ):
+        """
+        From an origin (x0,y0), a set of reciprocal lattice vectors gx,gy, and an pair of
+        lattice vectors g1=(g1x,g1y), g2=(g2x,g2y), find the indices (h,k) of all the
+        reciprocal lattice directions.
+
+        Args:
+            x0 : floagt
+                x-coord of origin
+            y0 : float
+                y-coord of origin
+            max_peak_spacing: float
+                Maximum distance from the ideal lattice points
+                to include a peak for indexing
+            mask: bool
+                Boolean mask, same shape as the pointlistarray, indicating which
+                locations should be indexed. This can be used to index different regions of
+                the scan with different lattices
+            plot:bool
+                plot results if tru
+            vis_params : dict
+                additional visualization parameters passed to `show`
+            returncalc : bool
+                if True, returns braggdirections, bragg_vectors_indexed, g1g2_map
+        """
+        # check the calstate
+        assert(self.calstate == self.braggvectors.calstate), "The calibration state has changed! To resync the calibration state, use `.reset_calstate`."
 
+        if x0 is None:
+            x0 = self.braggvectors.Qshape[0]/2
+        if y0 is None:
+            y0 = self.braggvectors.Qshape[0]/2
+
+        #index braggvectors
+        from py4DSTEM.process.latticevectors import index_bragg_directions
+        _, _, braggdirections = index_bragg_directions(
+            x0,
+            y0,
+            self.g['x'],
+            self.g['y'],
+            self.g1,
+            self.g2
+        )
 
+        self.braggdirections = braggdirections
+
+        if plot:
+            self.show_bragg_indexing(
+                self.bvm,
+                braggdirections = braggdirections,
+                points = True,
+                **vis_params,
+            )
+
+        #add indicies to braggvectors
+        from py4DSTEM.process.latticevectors import add_indices_to_braggvectors
+
+        bragg_vectors_indexed = add_indices_to_braggvectors(
+            self.braggvectors,
+            self.braggdirections,
+            maxPeakSpacing = max_peak_spacing,
+            qx_shift = self.braggvectors.Qshape[0]/2,
+            qy_shift = self.braggvectors.Qshape[1]/2,
+            mask = mask
+        )
 
+        self.bragg_vectors_indexed = bragg_vectors_indexed
 
+        #fit bragg vectors
+        from py4DSTEM.process.latticevectors import fit_lattice_vectors_all_DPs
+        g1g2_map = fit_lattice_vectors_all_DPs(
+            self.bragg_vectors_indexed
+        )
+        self.g1g2_map = g1g2_map
 
+        if returncalc:
+            braggdirections, bragg_vectors_indexed, g1g2_map
+    
+    def show_lattice_vectors(ar,x0,y0,g1,g2,color='r',width=1,labelsize=20,labelcolor='w',returnfig=False,**kwargs):
+        """ Adds the vectors g1,g2 to an image, with tail positions at (x0,y0).  g1 and g2 are 2-tuples (gx,gy).
+        """
+        fig,ax = show(ar,returnfig=True,**kwargs)
 
+        # Add vectors
+        dg1 = {'x0':x0,'y0':y0,'vx':g1[0],'vy':g1[1],'width':width,
+               'color':color,'label':r'$g_1$','labelsize':labelsize,'labelcolor':labelcolor}
+        dg2 = {'x0':x0,'y0':y0,'vx':g2[0],'vy':g2[1],'width':width,
+               'color':color,'label':r'$g_2$','labelsize':labelsize,'labelcolor':labelcolor}
+        add_vector(ax,dg1)
+        add_vector(ax,dg2)
+
+        if returnfig:
+            return fig,ax
+        else:
+            plt.show()
+            return
 
 
 
+    
 
+    def show_bragg_indexing(
+        self, 
+        ar,
+        braggdirections,
+        voffset=5,
+        hoffset=0,
+        color='w',
+        size=20,
+        points=True,
+        pointcolor='r',
+        pointsize=50,
+        returnfig=False,
+        **kwargs
+    ):
+        """
+        Shows an array with an overlay describing the Bragg directions
 
+        Accepts:
+            ar                  (arrray) the image
+            bragg_directions    (PointList) the bragg scattering directions; must have coordinates
+                                'qx','qy','h', and 'k'. Optionally may also have 'l'.
+        """
+        assert isinstance(braggdirections,PointList)
+        for k in ('qx','qy','h','k'):
+            assert k in braggdirections.data.dtype.fields
 
+        fig,ax = show(ar,returnfig=True,**kwargs)
+        d = {'braggdirections':braggdirections,'voffset':voffset,'hoffset':hoffset,'color':color,
+             'size':size,'points':points,'pointsize':pointsize,'pointcolor':pointcolor}
+        add_bragg_index_labels(ax,d)
 
+        if returnfig:
+            return fig,ax
+        else:
+            plt.show()
+            return
 
 
-def index_bragg_directions(x0, y0, gx, gy, g1, g2):
-    """
-    From an origin (x0,y0), a set of reciprocal lattice vectors gx,gy, and an pair of
-    lattice vectors g1=(g1x,g1y), g2=(g2x,g2y), find the indices (h,k) of all the
-    reciprocal lattice directions.
 
-    The approach is to solve the matrix equation
-            ``alpha = beta * M``
-    where alpha is the 2xN array of the (x,y) coordinates of N measured bragg directions,
-    beta is the 2x2 array of the two lattice vectors u,v, and M is the 2xN array of the
-    h,k indices.
 
-    Args:
-        x0 (float): x-coord of origin
-        y0 (float): y-coord of origin
-        gx (1d array): x-coord of the reciprocal lattice vectors
-        gy (1d array): y-coord of the reciprocal lattice vectors
-        g1 (2-tuple of floats): g1x,g1y
-        g2 (2-tuple of floats): g2x,g2y
 
-    Returns:
-        (3-tuple) A 3-tuple containing:
 
-            * **h**: *(ndarray of ints)* first index of the bragg directions
-            * **k**: *(ndarray of ints)* second index of the bragg directions
-            * **bragg_directions**: *(PointList)* a 4-coordinate PointList with the
-              indexed bragg directions; coords 'qx' and 'qy' contain bragg_x and bragg_y
-              coords 'h' and 'k' contain h and k.
-    """
-    # Get beta, the matrix of lattice vectors
-    beta = np.array([[g1[0],g2[0]],[g1[1],g2[1]]])
 
-    # Get alpha, the matrix of measured bragg angles
-    alpha = np.vstack([gx-x0,gy-y0])
 
-    # Calculate M, the matrix of peak positions
-    M = lstsq(beta, alpha, rcond=None)[0].T
-    M = np.round(M).astype(int)
 
-    # Get h,k
-    h = M[:,0]
-    k = M[:,1]
 
-    # Store in a PointList
-    coords = [('qx',float),('qy',float),('h',int),('k',int)]
-    temp_array = np.zeros([], dtype = coords)
-    bragg_directions = PointList(data = temp_array)
-    bragg_directions.add_data_by_field((gx,gy,h,k))
 
-    return h,k, bragg_directions
+# def index_bragg_directions(x0, y0, gx, gy, g1, g2):
+#     """
+#     From an origin (x0,y0), a set of reciprocal lattice vectors gx,gy, and an pair of
+#     lattice vectors g1=(g1x,g1y), g2=(g2x,g2y), find the indices (h,k) of all the
+#     reciprocal lattice directions.
 
+#     The approach is to solve the matrix equation
+#             ``alpha = beta * M``
+#     where alpha is the 2xN array of the (x,y) coordinates of N measured bragg directions,
+#     beta is the 2x2 array of the two lattice vectors u,v, and M is the 2xN array of the
+#     h,k indices.
 
+#     Args:
+#         x0 (float): x-coord of origin
+#         y0 (float): y-coord of origin
+#         gx (1d array): x-coord of the reciprocal lattice vectors
+#         gy (1d array): y-coord of the reciprocal lattice vectors
+#         g1 (2-tuple of floats): g1x,g1y
+#         g2 (2-tuple of floats): g2x,g2y
 
-def add_indices_to_braggpeaks(braggpeaks, lattice, maxPeakSpacing, qx_shift=0,
+#     Returns:
+#         (3-tuple) A 3-tuple containing:
+
+#             * **h**: *(ndarray of ints)* first index of the bragg directions
+#             * **k**: *(ndarray of ints)* second index of the bragg directions
+#             * **bragg_directions**: *(PointList)* a 4-coordinate PointList with the
+#               indexed bragg directions; coords 'qx' and 'qy' contain bragg_x and bragg_y
+#               coords 'h' and 'k' contain h and k.
+#     """
+#     # Get beta, the matrix of lattice vectors
+#     beta = np.array([[g1[0],g2[0]],[g1[1],g2[1]]])
+
+#     # Get alpha, the matrix of measured bragg angles
+#     alpha = np.vstack([gx-x0,gy-y0])
+
+#     # Calculate M, the matrix of peak positions
+#     M = lstsq(beta, alpha, rcond=None)[0].T
+#     M = np.round(M).astype(int)
+
+#     # Get h,k
+#     h = M[:,0]
+#     k = M[:,1]
+
+#     # Store in a PointList
+#     coords = [('qx',float),('qy',float),('h',int),('k',int)]
+#     temp_array = np.zeros([], dtype = coords)
+#     bragg_directions = PointList(data = temp_array)
+#     bragg_directions.add_data_by_field((gx,gy,h,k))
+
+#     return h,k, bragg_directions
+
+
+
+def add_indices_to_braggvectors(braggpeaks, lattice, maxPeakSpacing, qx_shift=0,
                               qy_shift=0, mask=None):
     """
     Using the peak positions (qx,qy) and indices (h,k) in the PointList lattice,
@@ -407,53 +551,7 @@ def add_indices_to_braggpeaks(braggpeaks, lattice, maxPeakSpacing, qx_shift=0,
 
 
 
-
-
-
-    def show_lattice_vectors(ar,x0,y0,g1,g2,color='r',width=1,labelsize=20,labelcolor='w',returnfig=False,**kwargs):
-        """ Adds the vectors g1,g2 to an image, with tail positions at (x0,y0).  g1 and g2 are 2-tuples (gx,gy).
-        """
-        fig,ax = show(ar,returnfig=True,**kwargs)
-
-        # Add vectors
-        dg1 = {'x0':x0,'y0':y0,'vx':g1[0],'vy':g1[1],'width':width,
-               'color':color,'label':r'$g_1$','labelsize':labelsize,'labelcolor':labelcolor}
-        dg2 = {'x0':x0,'y0':y0,'vx':g2[0],'vy':g2[1],'width':width,
-               'color':color,'label':r'$g_2$','labelsize':labelsize,'labelcolor':labelcolor}
-        add_vector(ax,dg1)
-        add_vector(ax,dg2)
-
-        if returnfig:
-            return fig,ax
-        else:
-            plt.show()
-            return
-
-
-    def show_bragg_indexing(ar,braggdirections,voffset=5,hoffset=0,color='w',size=20,
-                            points=True,pointcolor='r',pointsize=50,returnfig=False,**kwargs):
-        """
-        Shows an array with an overlay describing the Bragg directions
-
-        Accepts:
-            ar                  (arrray) the image
-            bragg_directions    (PointList) the bragg scattering directions; must have coordinates
-                                'qx','qy','h', and 'k'. Optionally may also have 'l'.
-        """
-        assert isinstance(braggdirections,PointList)
-        for k in ('qx','qy','h','k'):
-            assert k in braggdirections.data.dtype.fields
-
-        fig,ax = show(ar,returnfig=True,**kwargs)
-        d = {'braggdirections':braggdirections,'voffset':voffset,'hoffset':hoffset,'color':color,
-             'size':size,'points':points,'pointsize':pointsize,'pointcolor':pointcolor}
-        add_bragg_index_labels(ax,d)
-
-        if returnfig:
-            return fig,ax
-        else:
-            plt.show()
-            return
+    
 
 
 

From 0b21b46d87046f4c0104e523e9cd01f294c614cf Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 14 Jul 2023 06:38:29 -0700
Subject: [PATCH 337/362] small changes

---
 py4DSTEM/braggvectors/braggvector_methods.py | 6 +++---
 py4DSTEM/process/strain.py                   | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/py4DSTEM/braggvectors/braggvector_methods.py b/py4DSTEM/braggvectors/braggvector_methods.py
index 08ddbb0be..84bd72908 100644
--- a/py4DSTEM/braggvectors/braggvector_methods.py
+++ b/py4DSTEM/braggvectors/braggvector_methods.py
@@ -714,7 +714,7 @@ def index_bragg_directions(
 
 
 
-    def add_indices_to_braggpeaks(
+    def add_indices_to_braggvectors(
         self,
         maxPeakSpacing,
         mask = None,
@@ -738,9 +738,9 @@ def add_indices_to_braggpeaks(
                 locations should be indexed. This can be used to index different regions of
                 the scan with different lattices
         """
-        from py4DSTEM.process.latticevectors import add_indices_to_braggpeaks
+        from py4DSTEM.process.latticevectors import add_indices_to_braggvectors
 
-        bragg_peaks_indexed = add_indices_to_braggpeaks(
+        bragg_peaks_indexed = add_indices_to_braggvectors(
             self.vectors,
             self.braggdirections,
             maxPeakSpacing = maxPeakSpacing,
diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index ec10fe5f9..76dbbbfb8 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -65,7 +65,7 @@ def __init__(
         assert self.calstate["center"], "braggvectors must be centered"
         # get the BVM
         # a new BVM using the current calstate is computed
-        self.bvm = self.braggvectors.histogram()
+        self.bvm = self.braggvectors.histogram( mode = 'cal')
 
 
 

From 0c7887bb93cf3f7b1afa7fee97cc2c02e2df027f Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 14 Jul 2023 08:38:11 -0700
Subject: [PATCH 338/362] fix calibration for bragg vectors

---
 py4DSTEM/process/latticevectors/index.py | 14 ++------------
 1 file changed, 2 insertions(+), 12 deletions(-)

diff --git a/py4DSTEM/process/latticevectors/index.py b/py4DSTEM/process/latticevectors/index.py
index 13d41d54c..e75ee09e1 100644
--- a/py4DSTEM/process/latticevectors/index.py
+++ b/py4DSTEM/process/latticevectors/index.py
@@ -208,20 +208,10 @@ def add_indices_to_braggvectors(
         shape = braggpeaks.Rshape,
     )
 
-    ellipse = braggpeaks.calstate["ellipse"]
-
     # loop over all the scan positions
     for Rx, Ry in tqdmnd(mask.shape[0],mask.shape[1]):
-        if mask[Rx,Ry]:
-            pl = braggpeaks.get_vectors(
-                scan_x=Rx,
-                scan_y=Ry,
-                center=True,
-                ellipse=ellipse,
-                pixel=False,
-                rotate=False
-            )
-            
+        if mask[Rx,Ry]: 
+            pl = braggpeaks.cal[Rx,Ry]
             for i in range(pl.data.shape[0]):
                 r2 = (pl.data['qx'][i]-lattice.data['qx'] + qx_shift)**2 + \
                      (pl.data['qy'][i]-lattice.data['qy'] + qy_shift)**2

From 9ba71e4e84838847165eb24526792c9c811e9353 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 14 Jul 2023 09:17:24 -0700
Subject: [PATCH 339/362] strain!!!

---
 py4DSTEM/process/latticevectors/index.py  |  6 ++---
 py4DSTEM/process/latticevectors/strain.py | 11 +++++---
 py4DSTEM/process/strain.py                | 33 +++++++++++++++++++++++
 3 files changed, 43 insertions(+), 7 deletions(-)

diff --git a/py4DSTEM/process/latticevectors/index.py b/py4DSTEM/process/latticevectors/index.py
index e75ee09e1..189e7f10f 100644
--- a/py4DSTEM/process/latticevectors/index.py
+++ b/py4DSTEM/process/latticevectors/index.py
@@ -218,9 +218,9 @@ def add_indices_to_braggvectors(
                 ind = np.argmin(r2)
                 if r2[ind] <= maxPeakSpacing**2:
                     indexed_braggpeaks[Rx,Ry].add_data_by_field((
-                        pl.data['qx'],
-                        pl.data['qy'],
-                        pl.data['intensity'],
+                        pl.data['qx'][i],
+                        pl.data['qy'][i],
+                        pl.data['intensity'][i],
                         lattice.data['h'][ind],
                         lattice.data['k'][ind]
                         ))
diff --git a/py4DSTEM/process/latticevectors/strain.py b/py4DSTEM/process/latticevectors/strain.py
index 50b9bddc9..518f38885 100644
--- a/py4DSTEM/process/latticevectors/strain.py
+++ b/py4DSTEM/process/latticevectors/strain.py
@@ -71,9 +71,11 @@ def get_strain_from_reference_g1g2(g1g2_map, g1, g2):
 
     # Get RealSlice for output storage
     R_Nx,R_Ny = g1g2_map.get_slice('g1x').shape
-    strain_map = RealSlice(data=np.zeros((R_Nx,R_Ny,5)),
-                           slicelabels=('e_xx','e_yy','e_xy','theta','mask'),
-                           name='strain_map')
+    strain_map = RealSlice(
+        data=np.zeros((5, R_Nx, R_Ny)),
+        slicelabels=('e_xx','e_yy','e_xy','theta','mask'),
+        name='strain_map'
+    )
 
     # Get reference lattice matrix
     g1x,g1y = g1
@@ -130,7 +132,8 @@ def get_strain_from_reference_region(g1g2_map, mask):
         Note 1: the strain matrix has been symmetrized, so e_xy and e_yx are identical
     """
     assert isinstance(g1g2_map, RealSlice)
-    assert np.all([name in g1g2_map.slicelabels for name in ('g1x','g1y','g2x','g2y','mask')])
+    assert np.all(
+        [name in g1g2_map.slicelabels for name in ('g1x','g1y','g2x','g2y','mask')])
     assert mask.dtype == bool
 
     g1,g2 = get_reference_g1g2(g1g2_map,mask)
diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index 76dbbbfb8..c6a8fe88e 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -352,6 +352,39 @@ def fit_lattice_vectors(
         if returncalc:
             braggdirections, bragg_vectors_indexed, g1g2_map
     
+    def get_strain(
+        self,
+        mask = None,
+        returncalc = True
+        ):
+        """
+
+        """
+        if mask is None: 
+            mask = np.ones(self.g1g2_map.shape, dtype = "bool")
+
+        from py4DSTEM.process.latticevectors import get_strain_from_reference_region
+
+        strainmap_median_g1g2 = get_strain_from_reference_region(
+            self.g1g2_map,
+            mask = mask,
+        )
+
+        self.strainmap_median_g1g2 = strainmap_median_g1g2
+        from py4DSTEM.visualize import show_strain
+        show_strain(
+            strainmap_median_g1g2,
+            vrange_exx = [-2.0, 2.0],
+            vrange_theta = [-2.0, 2.0],
+            ticknumber = 3,
+            axes_plots = (),
+            bkgrd = False,
+            figsize = (14,4)
+        )
+        if returncalc:
+            return strainmap_median_g1g2
+
+    
     def show_lattice_vectors(ar,x0,y0,g1,g2,color='r',width=1,labelsize=20,labelcolor='w',returnfig=False,**kwargs):
         """ Adds the vectors g1,g2 to an image, with tail positions at (x0,y0).  g1 and g2 are 2-tuples (gx,gy).
         """

From 0647c73dd2ec933b9382e6b29c960382f055857b Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 14 Jul 2023 09:28:21 -0700
Subject: [PATCH 340/362] cleaning up formatting

---
 py4DSTEM/process/strain.py | 468 ++++++++++++++++++++-----------------
 1 file changed, 249 insertions(+), 219 deletions(-)

diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index c6a8fe88e..afe00dba4 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -1,15 +1,17 @@
 # Defines the Strain class
 
-import numpy as np
-import matplotlib.pyplot as plt
 from typing import Optional
-from py4DSTEM.data import RealSlice, Data
+
+import matplotlib.pyplot as plt
+import numpy as np
+from py4DSTEM import PointList
 from py4DSTEM.braggvectors import BraggVectors
+from py4DSTEM.data import Data, RealSlice
 from py4DSTEM.preprocess.utils import get_maxima_2D
-from py4DSTEM.visualize import show,add_pointlabels,add_vector, add_bragg_index_labels
-from py4DSTEM import PointList
+from py4DSTEM.visualize import add_bragg_index_labels, add_pointlabels, add_vector, show
+
 
-class StrainMap(RealSlice,Data):
+class StrainMap(RealSlice, Data):
     """
     Stores strain map.
 
@@ -17,33 +19,26 @@ class StrainMap(RealSlice,Data):
 
     """
 
-    def __init__(
-        self,
-        braggvectors: BraggVectors,
-        name: Optional[str] = 'strainmap'
-        ):
+    def __init__(self, braggvectors: BraggVectors, name: Optional[str] = "strainmap"):
         """
         TODO
         """
-        assert(isinstance(braggvectors,BraggVectors)), f"braggvectors myst be BraggVectors, not type {type(braggvectors)}"
+        assert isinstance(
+            braggvectors, BraggVectors
+        ), f"braggvectors myst be BraggVectors, not type {type(braggvectors)}"
 
         # initialize as a RealSlice
         RealSlice.__init__(
             self,
-            name = name,
-            data = np.empty((
-                6,
-                braggvectors.Rshape[0],
-                braggvectors.Rshape[1],
-            )),
-            slicelabels = [
-                'exx',
-                'eyy',
-                'exy',
-                'theta',
-                'mask',
-                'error'
-            ]
+            name=name,
+            data=np.empty(
+                (
+                    6,
+                    braggvectors.Rshape[0],
+                    braggvectors.Rshape[1],
+                )
+            ),
+            slicelabels=["exx", "eyy", "exy", "theta", "mask", "error"],
         )
 
         # set up braggvectors
@@ -65,22 +60,24 @@ def __init__(
         assert self.calstate["center"], "braggvectors must be centered"
         # get the BVM
         # a new BVM using the current calstate is computed
-        self.bvm = self.braggvectors.histogram( mode = 'cal')
-
-
+        self.bvm = self.braggvectors.histogram(mode="cal")
 
     # braggvector properties
 
     @property
     def braggvectors(self):
         return self._braggvectors
+
     @braggvectors.setter
-    def braggvectors(self,x):
-        assert(isinstance(x,BraggVectors)), f".braggvectors must be BraggVectors, not type {type(x)}"
-        assert(x.calibration.origin is not None), f"braggvectors must have a calibrated origin"
+    def braggvectors(self, x):
+        assert isinstance(
+            x, BraggVectors
+        ), f".braggvectors must be BraggVectors, not type {type(x)}"
+        assert (
+            x.calibration.origin is not None
+        ), f"braggvectors must have a calibrated origin"
         self._braggvectors = x
-        self._braggvectors.tree(self,force=True)
-
+        self._braggvectors.tree(self, force=True)
 
     def reset_calstate(self):
         """
@@ -88,17 +85,15 @@ def reset_calstate(self):
         this StrainMap instance has stored, which will need to be recomputed.
         """
         for attr in (
-            'g0',
-            'g1',
-            'g2',
+            "g0",
+            "g1",
+            "g2",
         ):
-            if hasattr(self,attr):
-                delattr(self,attr)
+            if hasattr(self, attr):
+                delattr(self, attr)
         self.calstate = self.braggvectors.calstate
         pass
 
-
-
     # Class methods
 
     def choose_lattice_vectors(
@@ -106,8 +101,8 @@ def choose_lattice_vectors(
         index_g0,
         index_g1,
         index_g2,
-        subpixel = 'multicorr',
-        upsample_factor = 16,
+        subpixel="multicorr",
+        upsample_factor=16,
         sigma=0,
         minAbsoluteIntensity=0,
         minRelativeIntensity=0,
@@ -115,20 +110,20 @@ def choose_lattice_vectors(
         minSpacing=0,
         edgeBoundary=1,
         maxNumPeaks=10,
-        figsize=(12,6),
-        c_indices='lightblue',
-        c0='g',
-        c1='r',
-        c2='r',
-        c_vectors='r',
-        c_vectorlabels='w',
+        figsize=(12, 6),
+        c_indices="lightblue",
+        c0="g",
+        c1="r",
+        c2="r",
+        c_vectors="r",
+        c_vectorlabels="w",
         size_indices=20,
         width_vectors=1,
         size_vectorlabels=20,
-        vis_params = {},
-        returncalc = False,
+        vis_params={},
+        returncalc=False,
         returnfig=False,
-        ):
+    ):
         """
         Choose which lattice vectors to use for strain mapping.
 
@@ -195,59 +190,97 @@ def choose_lattice_vectors(
         (optional) : None or (g0,g1,g2) or (fig,(ax1,ax2)) or both of the latter
         """
         # validate inputs
-        for i in (index_g0,index_g1,index_g2):
-            assert isinstance(i,(int,np.integer)), "indices must be integers!"
+        for i in (index_g0, index_g1, index_g2):
+            assert isinstance(i, (int, np.integer)), "indices must be integers!"
         # check the calstate
-        assert(self.calstate == self.braggvectors.calstate), "The calibration state has changed! To resync the calibration state, use `.reset_calstate`."
+        assert (
+            self.calstate == self.braggvectors.calstate
+        ), "The calibration state has changed! To resync the calibration state, use `.reset_calstate`."
 
         # find the maxima
         g = get_maxima_2D(
             self.bvm.data,
-            subpixel = subpixel,
-            upsample_factor = upsample_factor,
-            sigma = sigma,
-            minAbsoluteIntensity = minAbsoluteIntensity,
-            minRelativeIntensity = minRelativeIntensity,
-            relativeToPeak = relativeToPeak,
-            minSpacing = minSpacing,
-            edgeBoundary = edgeBoundary,
-            maxNumPeaks = maxNumPeaks,
+            subpixel=subpixel,
+            upsample_factor=upsample_factor,
+            sigma=sigma,
+            minAbsoluteIntensity=minAbsoluteIntensity,
+            minRelativeIntensity=minRelativeIntensity,
+            relativeToPeak=relativeToPeak,
+            minSpacing=minSpacing,
+            edgeBoundary=edgeBoundary,
+            maxNumPeaks=maxNumPeaks,
         )
 
         # get the lattice vectors
-        gx,gy = g['x'],g['y']
-        g0 = gx[index_g0],gy[index_g0]
+        gx, gy = g["x"], g["y"]
+        g0 = gx[index_g0], gy[index_g0]
         g1x = gx[index_g1] - g0[0]
         g1y = gy[index_g1] - g0[1]
         g2x = gx[index_g2] - g0[0]
         g2y = gy[index_g2] - g0[1]
-        g1,g2 = (g1x,g1y),(g2x,g2y)
+        g1, g2 = (g1x, g1y), (g2x, g2y)
 
         # make the figure
-        fig,(ax1,ax2) = plt.subplots(1,2,figsize=figsize)
-        show(self.bvm.data,figax=(fig,ax1),**vis_params)
-        show(self.bvm.data,figax=(fig,ax2),**vis_params)
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=figsize)
+        show(self.bvm.data, figax=(fig, ax1), **vis_params)
+        show(self.bvm.data, figax=(fig, ax2), **vis_params)
 
         # Add indices to left panel
-        d = {'x':gx,'y':gy,'size':size_indices,'color':c_indices}
-        d0 = {'x':gx[index_g0],'y':gy[index_g0],'size':size_indices,
-              'color':c0,'fontweight':'bold','labels':[str(index_g0)]}
-        d1 = {'x':gx[index_g1],'y':gy[index_g1],'size':size_indices,
-              'color':c1,'fontweight':'bold','labels':[str(index_g1)]}
-        d2 = {'x':gx[index_g2],'y':gy[index_g2],'size':size_indices,
-              'color':c2,'fontweight':'bold','labels':[str(index_g2)]}
-        add_pointlabels(ax1,d)
-        add_pointlabels(ax1,d0)
-        add_pointlabels(ax1,d1)
-        add_pointlabels(ax1,d2)
+        d = {"x": gx, "y": gy, "size": size_indices, "color": c_indices}
+        d0 = {
+            "x": gx[index_g0],
+            "y": gy[index_g0],
+            "size": size_indices,
+            "color": c0,
+            "fontweight": "bold",
+            "labels": [str(index_g0)],
+        }
+        d1 = {
+            "x": gx[index_g1],
+            "y": gy[index_g1],
+            "size": size_indices,
+            "color": c1,
+            "fontweight": "bold",
+            "labels": [str(index_g1)],
+        }
+        d2 = {
+            "x": gx[index_g2],
+            "y": gy[index_g2],
+            "size": size_indices,
+            "color": c2,
+            "fontweight": "bold",
+            "labels": [str(index_g2)],
+        }
+        add_pointlabels(ax1, d)
+        add_pointlabels(ax1, d0)
+        add_pointlabels(ax1, d1)
+        add_pointlabels(ax1, d2)
 
         # Add vectors to right panel
-        dg1 = {'x0':gx[index_g0],'y0':gy[index_g0],'vx':g1[0],'vy':g1[1],'width':width_vectors,
-               'color':c_vectors,'label':r'$g_1$','labelsize':size_vectorlabels,'labelcolor':c_vectorlabels}
-        dg2 = {'x0':gx[index_g0],'y0':gy[index_g0],'vx':g2[0],'vy':g2[1],'width':width_vectors,
-               'color':c_vectors,'label':r'$g_2$','labelsize':size_vectorlabels,'labelcolor':c_vectorlabels}
-        add_vector(ax2,dg1)
-        add_vector(ax2,dg2)
+        dg1 = {
+            "x0": gx[index_g0],
+            "y0": gy[index_g0],
+            "vx": g1[0],
+            "vy": g1[1],
+            "width": width_vectors,
+            "color": c_vectors,
+            "label": r"$g_1$",
+            "labelsize": size_vectorlabels,
+            "labelcolor": c_vectorlabels,
+        }
+        dg2 = {
+            "x0": gx[index_g0],
+            "y0": gy[index_g0],
+            "vx": g2[0],
+            "vy": g2[1],
+            "width": width_vectors,
+            "color": c_vectors,
+            "label": r"$g_2$",
+            "labelsize": size_vectorlabels,
+            "labelcolor": c_vectorlabels,
+        }
+        add_vector(ax2, dg1)
+        add_vector(ax2, dg2)
 
         # store vectors
         self.g = g
@@ -257,24 +290,24 @@ def choose_lattice_vectors(
 
         # return
         if returncalc and returnfig:
-            return (g0,g1,g2),(fig,(ax1,ax2))
+            return (g0, g1, g2), (fig, (ax1, ax2))
         elif returncalc:
-            return (g0,g1,g2)
+            return (g0, g1, g2)
         elif returnfig:
-            return (fig,(ax1,ax2))
+            return (fig, (ax1, ax2))
         else:
             return
-    
+
     def fit_lattice_vectors(
         self,
-        x0 = None,
-        y0 = None,
-        max_peak_spacing = 2,
-        mask = None,
-        plot = True,
-        vis_params = {},
-        returncalc = False,
-        ):
+        x0=None,
+        y0=None,
+        max_peak_spacing=2,
+        mask=None,
+        plot=True,
+        vis_params={},
+        returncalc=False,
+    ):
         """
         From an origin (x0,y0), a set of reciprocal lattice vectors gx,gy, and an pair of
         lattice vectors g1=(g1x,g1y), g2=(g2x,g2y), find the indices (h,k) of all the
@@ -300,22 +333,20 @@ def fit_lattice_vectors(
                 if True, returns braggdirections, bragg_vectors_indexed, g1g2_map
         """
         # check the calstate
-        assert(self.calstate == self.braggvectors.calstate), "The calibration state has changed! To resync the calibration state, use `.reset_calstate`."
+        assert (
+            self.calstate == self.braggvectors.calstate
+        ), "The calibration state has changed! To resync the calibration state, use `.reset_calstate`."
 
         if x0 is None:
-            x0 = self.braggvectors.Qshape[0]/2
+            x0 = self.braggvectors.Qshape[0] / 2
         if y0 is None:
-            y0 = self.braggvectors.Qshape[0]/2
+            y0 = self.braggvectors.Qshape[0] / 2
 
-        #index braggvectors
+        # index braggvectors
         from py4DSTEM.process.latticevectors import index_bragg_directions
+
         _, _, braggdirections = index_bragg_directions(
-            x0,
-            y0,
-            self.g['x'],
-            self.g['y'],
-            self.g1,
-            self.g2
+            x0, y0, self.g["x"], self.g["y"], self.g1, self.g2
         )
 
         self.braggdirections = braggdirections
@@ -323,104 +354,122 @@ def fit_lattice_vectors(
         if plot:
             self.show_bragg_indexing(
                 self.bvm,
-                braggdirections = braggdirections,
-                points = True,
+                braggdirections=braggdirections,
+                points=True,
                 **vis_params,
             )
 
-        #add indicies to braggvectors
+        # add indicies to braggvectors
         from py4DSTEM.process.latticevectors import add_indices_to_braggvectors
 
         bragg_vectors_indexed = add_indices_to_braggvectors(
             self.braggvectors,
             self.braggdirections,
-            maxPeakSpacing = max_peak_spacing,
-            qx_shift = self.braggvectors.Qshape[0]/2,
-            qy_shift = self.braggvectors.Qshape[1]/2,
-            mask = mask
+            maxPeakSpacing=max_peak_spacing,
+            qx_shift=self.braggvectors.Qshape[0] / 2,
+            qy_shift=self.braggvectors.Qshape[1] / 2,
+            mask=mask,
         )
 
         self.bragg_vectors_indexed = bragg_vectors_indexed
 
-        #fit bragg vectors
+        # fit bragg vectors
         from py4DSTEM.process.latticevectors import fit_lattice_vectors_all_DPs
-        g1g2_map = fit_lattice_vectors_all_DPs(
-            self.bragg_vectors_indexed
-        )
+
+        g1g2_map = fit_lattice_vectors_all_DPs(self.bragg_vectors_indexed)
         self.g1g2_map = g1g2_map
 
         if returncalc:
             braggdirections, bragg_vectors_indexed, g1g2_map
-    
-    def get_strain(
-        self,
-        mask = None,
-        returncalc = True
-        ):
-        """
 
-        """
-        if mask is None: 
-            mask = np.ones(self.g1g2_map.shape, dtype = "bool")
+    def get_strain(self, mask=None, returncalc=True):
+        """ """
+        if mask is None:
+            mask = np.ones(self.g1g2_map.shape, dtype="bool")
 
         from py4DSTEM.process.latticevectors import get_strain_from_reference_region
 
         strainmap_median_g1g2 = get_strain_from_reference_region(
             self.g1g2_map,
-            mask = mask,
+            mask=mask,
         )
 
         self.strainmap_median_g1g2 = strainmap_median_g1g2
         from py4DSTEM.visualize import show_strain
+
         show_strain(
             strainmap_median_g1g2,
-            vrange_exx = [-2.0, 2.0],
-            vrange_theta = [-2.0, 2.0],
-            ticknumber = 3,
-            axes_plots = (),
-            bkgrd = False,
-            figsize = (14,4)
+            vrange_exx=[-2.0, 2.0],
+            vrange_theta=[-2.0, 2.0],
+            ticknumber=3,
+            axes_plots=(),
+            bkgrd=False,
+            figsize=(14, 4),
         )
         if returncalc:
             return strainmap_median_g1g2
 
-    
-    def show_lattice_vectors(ar,x0,y0,g1,g2,color='r',width=1,labelsize=20,labelcolor='w',returnfig=False,**kwargs):
-        """ Adds the vectors g1,g2 to an image, with tail positions at (x0,y0).  g1 and g2 are 2-tuples (gx,gy).
-        """
-        fig,ax = show(ar,returnfig=True,**kwargs)
+    def show_lattice_vectors(
+        ar,
+        x0,
+        y0,
+        g1,
+        g2,
+        color="r",
+        width=1,
+        labelsize=20,
+        labelcolor="w",
+        returnfig=False,
+        **kwargs,
+    ):
+        """Adds the vectors g1,g2 to an image, with tail positions at (x0,y0).  g1 and g2 are 2-tuples (gx,gy)."""
+        fig, ax = show(ar, returnfig=True, **kwargs)
 
         # Add vectors
-        dg1 = {'x0':x0,'y0':y0,'vx':g1[0],'vy':g1[1],'width':width,
-               'color':color,'label':r'$g_1$','labelsize':labelsize,'labelcolor':labelcolor}
-        dg2 = {'x0':x0,'y0':y0,'vx':g2[0],'vy':g2[1],'width':width,
-               'color':color,'label':r'$g_2$','labelsize':labelsize,'labelcolor':labelcolor}
-        add_vector(ax,dg1)
-        add_vector(ax,dg2)
+        dg1 = {
+            "x0": x0,
+            "y0": y0,
+            "vx": g1[0],
+            "vy": g1[1],
+            "width": width,
+            "color": color,
+            "label": r"$g_1$",
+            "labelsize": labelsize,
+            "labelcolor": labelcolor,
+        }
+        dg2 = {
+            "x0": x0,
+            "y0": y0,
+            "vx": g2[0],
+            "vy": g2[1],
+            "width": width,
+            "color": color,
+            "label": r"$g_2$",
+            "labelsize": labelsize,
+            "labelcolor": labelcolor,
+        }
+        add_vector(ax, dg1)
+        add_vector(ax, dg2)
 
         if returnfig:
-            return fig,ax
+            return fig, ax
         else:
             plt.show()
             return
 
-
-
-    
-
     def show_bragg_indexing(
-        self, 
+        self,
         ar,
         braggdirections,
         voffset=5,
         hoffset=0,
-        color='w',
+        color="w",
         size=20,
         points=True,
-        pointcolor='r',
+        pointcolor="r",
         pointsize=50,
         returnfig=False,
-        **kwargs
+        **kwargs,
     ):
         """
         Shows an array with an overlay describing the Bragg directions
@@ -430,31 +479,30 @@ def show_bragg_indexing(
             bragg_directions    (PointList) the bragg scattering directions; must have coordinates
                                 'qx','qy','h', and 'k'. Optionally may also have 'l'.
         """
-        assert isinstance(braggdirections,PointList)
-        for k in ('qx','qy','h','k'):
+        assert isinstance(braggdirections, PointList)
+        for k in ("qx", "qy", "h", "k"):
             assert k in braggdirections.data.dtype.fields
 
-        fig,ax = show(ar,returnfig=True,**kwargs)
-        d = {'braggdirections':braggdirections,'voffset':voffset,'hoffset':hoffset,'color':color,
-             'size':size,'points':points,'pointsize':pointsize,'pointcolor':pointcolor}
-        add_bragg_index_labels(ax,d)
+        fig, ax = show(ar, returnfig=True, **kwargs)
+        d = {
+            "braggdirections": braggdirections,
+            "voffset": voffset,
+            "hoffset": hoffset,
+            "color": color,
+            "size": size,
+            "points": points,
+            "pointsize": pointsize,
+            "pointcolor": pointcolor,
+        }
+        add_bragg_index_labels(ax, d)
 
         if returnfig:
-            return fig,ax
+            return fig, ax
         else:
             plt.show()
             return
 
 
-
-
-
-
-
-
-
-
-
 # def index_bragg_directions(x0, y0, gx, gy, g1, g2):
 #     """
 #     From an origin (x0,y0), a set of reciprocal lattice vectors gx,gy, and an pair of
@@ -507,9 +555,9 @@ def show_bragg_indexing(
 #     return h,k, bragg_directions
 
 
-
-def add_indices_to_braggvectors(braggpeaks, lattice, maxPeakSpacing, qx_shift=0,
-                              qy_shift=0, mask=None):
+def add_indices_to_braggvectors(
+    braggpeaks, lattice, maxPeakSpacing, qx_shift=0, qy_shift=0, mask=None
+):
     """
     Using the peak positions (qx,qy) and indices (h,k) in the PointList lattice,
     identify the indices for each peak in the PointListArray braggpeaks.
@@ -537,38 +585,41 @@ def add_indices_to_braggvectors(braggpeaks, lattice, maxPeakSpacing, qx_shift=0,
         'h', 'k', containing the indices of each indexable peak.
     """
 
-    assert isinstance(braggpeaks,PointListArray)
-    assert np.all([name in braggpeaks.dtype.names for name in ('qx','qy','intensity')])
+    assert isinstance(braggpeaks, PointListArray)
+    assert np.all(
+        [name in braggpeaks.dtype.names for name in ("qx", "qy", "intensity")]
+    )
     assert isinstance(lattice, PointList)
-    assert np.all([name in lattice.dtype.names for name in ('qx','qy','h','k')])
+    assert np.all([name in lattice.dtype.names for name in ("qx", "qy", "h", "k")])
 
     if mask is None:
-        mask = np.ones(braggpeaks.shape,dtype=bool)
+        mask = np.ones(braggpeaks.shape, dtype=bool)
 
-    assert mask.shape == braggpeaks.shape, 'mask must have same shape as pointlistarray'
-    assert mask.dtype == bool, 'mask must be boolean'
+    assert mask.shape == braggpeaks.shape, "mask must have same shape as pointlistarray"
+    assert mask.dtype == bool, "mask must be boolean"
 
     indexed_braggpeaks = braggpeaks.copy()
 
     # add the coordinates if they don't exist
-    if not ('h' in braggpeaks.dtype.names):
-        indexed_braggpeaks = indexed_braggpeaks.add_fields([('h',int)])
-    if not ('k' in braggpeaks.dtype.names):
-        indexed_braggpeaks = indexed_braggpeaks.add_fields([('k',int)])
+    if not ("h" in braggpeaks.dtype.names):
+        indexed_braggpeaks = indexed_braggpeaks.add_fields([("h", int)])
+    if not ("k" in braggpeaks.dtype.names):
+        indexed_braggpeaks = indexed_braggpeaks.add_fields([("k", int)])
 
     # loop over all the scan positions
-    for Rx, Ry in tqdmnd(mask.shape[0],mask.shape[1]):
-        if mask[Rx,Ry]:
-            pl = indexed_braggpeaks.get_pointlist(Rx,Ry)
-            rm_peak_mask = np.zeros(pl.length,dtype=bool)
+    for Rx, Ry in tqdmnd(mask.shape[0], mask.shape[1]):
+        if mask[Rx, Ry]:
+            pl = indexed_braggpeaks.get_pointlist(Rx, Ry)
+            rm_peak_mask = np.zeros(pl.length, dtype=bool)
 
             for i in range(pl.length):
-                r2 = (pl.data['qx'][i]-lattice.data['qx'] + qx_shift)**2 + \
-                     (pl.data['qy'][i]-lattice.data['qy'] + qy_shift)**2
+                r2 = (pl.data["qx"][i] - lattice.data["qx"] + qx_shift) ** 2 + (
+                    pl.data["qy"][i] - lattice.data["qy"] + qy_shift
+                ) ** 2
                 ind = np.argmin(r2)
                 if r2[ind] <= maxPeakSpacing**2:
-                    pl.data['h'][i] = lattice.data['h'][ind]
-                    pl.data['k'][i] = lattice.data['k'][ind]
+                    pl.data["h"][i] = lattice.data["h"][ind]
+                    pl.data["k"][i] = lattice.data["k"][ind]
                 else:
                     rm_peak_mask[i] = True
             pl.remove(rm_peak_mask)
@@ -576,40 +627,19 @@ def add_indices_to_braggvectors(braggpeaks, lattice, maxPeakSpacing, qx_shift=0,
     indexed_braggpeaks.name = braggpeaks.name + "_indexed"
     return indexed_braggpeaks
 
-
-
-
-
-
-
-
-
-    
-
-
-
-
-
-
-
-
-
     # IO methods
 
     # TODO - copy method
 
     # read
     @classmethod
-    def _get_constructor_args(cls,group):
+    def _get_constructor_args(cls, group):
         """
         Returns a dictionary of args/values to pass to the class constructor
         """
         ar_constr_args = RealSlice._get_constructor_args(group)
         args = {
-            'data' : ar_constr_args['data'],
-            'name' : ar_constr_args['name'],
+            "data": ar_constr_args["data"],
+            "name": ar_constr_args["name"],
         }
         return args
-
-
-

From b5aff3029f7376621c51c25092185831340b77ee Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 14 Jul 2023 10:11:38 -0700
Subject: [PATCH 341/362] working on strain plotting

---
 py4DSTEM/process/strain.py | 36 +++++++++++++++++++++++++++---------
 1 file changed, 27 insertions(+), 9 deletions(-)

diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index afe00dba4..a275f9e6b 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -382,7 +382,12 @@ def fit_lattice_vectors(
         if returncalc:
             braggdirections, bragg_vectors_indexed, g1g2_map
 
-    def get_strain(self, mask=None, returncalc=True):
+    def get_strain(
+        self, 
+        mask=None,
+        returncalc=False,
+        **kwargs
+    ):
         """ """
         if mask is None:
             mask = np.ones(self.g1g2_map.shape, dtype="bool")
@@ -395,17 +400,30 @@ def get_strain(self, mask=None, returncalc=True):
         )
 
         self.strainmap_median_g1g2 = strainmap_median_g1g2
+        
         from py4DSTEM.visualize import show_strain
-
-        show_strain(
+        figsize = kwargs.pop("figsize", (14, 4))
+        vrange_exx = kwargs.pop("vrange_exx", [-2.0, 2.0])
+        vrange_theta = kwargs.pop("vrange_theta", [-2.0, 2.0])
+        ticknumber = kwargs.pop("ticknumber", 3)
+        bkgrd = kwargs.pop("bkgrd", False) 
+        axes_plots = kwargs.pop("axes_plots",())
+
+        fig, ax = show_strain(
             strainmap_median_g1g2,
-            vrange_exx=[-2.0, 2.0],
-            vrange_theta=[-2.0, 2.0],
-            ticknumber=3,
-            axes_plots=(),
-            bkgrd=False,
-            figsize=(14, 4),
+            vrange_exx=vrange_exx,
+            vrange_theta=vrange_theta,
+            ticknumber=ticknumber,
+            axes_plots=axes_plots,
+            bkgrd=bkgrd,
+            figsize=figsize,
+            **kwargs,
+            returnfig = True,
         )
+
+        if not np.all(mask == True): 
+            for axs in ax.flatten():
+                axs.imshow(mask, alpha = 0.2, cmap = "binary")
         if returncalc:
             return strainmap_median_g1g2
 

From fa7168b7a9021c473232ca27185547762d21dd93 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 14 Jul 2023 11:39:16 -0700
Subject: [PATCH 342/362] strain mapping functions

---
 py4DSTEM/braggvectors/braggvector_methods.py | 350 +++++++++----------
 py4DSTEM/process/latticevectors/strain.py    |  20 +-
 py4DSTEM/process/strain.py                   | 205 ++++++-----
 3 files changed, 309 insertions(+), 266 deletions(-)

diff --git a/py4DSTEM/braggvectors/braggvector_methods.py b/py4DSTEM/braggvectors/braggvector_methods.py
index 84bd72908..597c7b166 100644
--- a/py4DSTEM/braggvectors/braggvector_methods.py
+++ b/py4DSTEM/braggvectors/braggvector_methods.py
@@ -664,187 +664,187 @@ def fit_p_ellipse(
 
     # Deprecated??
 
-    def index_bragg_directions(
-        self,
-        x0 = None,
-        y0 = None,
-        plot = True,
-        bvm_vis_params = {},
-        returncalc = False,
-        ):
-        """
-        From an origin (x0,y0), a set of reciprocal lattice vectors gx,gy, and an pair of
-        lattice vectors g1=(g1x,g1y), g2=(g2x,g2y), find the indices (h,k) of all the
-        reciprocal lattice directions.
-
-        Args:
-            x0 (float): x-coord of origin
-            y0 (float): y-coord of origin
-            Plot (bool): plot results
-        """
-
-        if x0 is None:
-            x0 = self.Qshape[0]/2
-        if y0 is None:
-            y0 = self.Qshape[0]/2
-
-        from py4DSTEM.process.latticevectors import index_bragg_directions
-        _, _, braggdirections = index_bragg_directions(
-            x0,
-            y0,
-            self.g['x'],
-            self.g['y'],
-            self.g1,
-            self.g2
-        )
-
-        self.braggdirections = braggdirections
-
-        if plot:
-            from py4DSTEM.visualize import show_bragg_indexing
-            show_bragg_indexing(
-                self.bvm_centered,
-                **bvm_vis_params,
-                braggdirections = braggdirections,
-                points = True
-            )
-
-        if returncalc:
-            return braggdirections
-
-
-
-    def add_indices_to_braggvectors(
-        self,
-        maxPeakSpacing,
-        mask = None,
-        returncalc = False,
-        ):
-        """
-        Using the peak positions (qx,qy) and indices (h,k) in the PointList lattice,
-        identify the indices for each peak in the PointListArray braggpeaks.
-        Return a new braggpeaks_indexed PointListArray, containing a copy of braggpeaks plus
-        three additional data columns -- 'h','k', and 'index_mask' -- specifying the peak
-        indices with the ints (h,k) and indicating whether the peak was successfully indexed
-        or not with the bool index_mask. If `mask` is specified, only the locations where
-        mask is True are indexed.
-
-        Args:
-            maxPeakSpacing (float): Maximum distance from the ideal lattice points
-                to include a peak for indexing
-            qx_shift,qy_shift (number): the shift of the origin in the `lattice` PointList
-                relative to the `braggpeaks` PointListArray
-            mask (bool): Boolean mask, same shape as the pointlistarray, indicating which
-                locations should be indexed. This can be used to index different regions of
-                the scan with different lattices
-        """
-        from py4DSTEM.process.latticevectors import add_indices_to_braggvectors
-
-        bragg_peaks_indexed = add_indices_to_braggvectors(
-            self.vectors,
-            self.braggdirections,
-            maxPeakSpacing = maxPeakSpacing,
-            qx_shift = self.Qshape[0]/2,
-            qy_shift = self.Qshape[1]/2,
-        )
-
-        self.bragg_peaks_indexed = bragg_peaks_indexed
-
-        if returncalc:
-            return bragg_peaks_indexed
-
-
-    def fit_lattice_vectors_all_DPs(self, returncalc = False):
-        """
-        Fits lattice vectors g1,g2 to each diffraction pattern in braggpeaks, given some
-        known (h,k) indexing.
-
+    # def index_bragg_directions(
+    #     self,
+    #     x0 = None,
+    #     y0 = None,
+    #     plot = True,
+    #     bvm_vis_params = {},
+    #     returncalc = False,
+    #     ):
+    #     """
+    #     From an origin (x0,y0), a set of reciprocal lattice vectors gx,gy, and an pair of
+    #     lattice vectors g1=(g1x,g1y), g2=(g2x,g2y), find the indices (h,k) of all the
+    #     reciprocal lattice directions.
+
+    #     Args:
+    #         x0 (float): x-coord of origin
+    #         y0 (float): y-coord of origin
+    #         Plot (bool): plot results
+    #     """
+
+    #     if x0 is None:
+    #         x0 = self.Qshape[0]/2
+    #     if y0 is None:
+    #         y0 = self.Qshape[0]/2
+
+    #     from py4DSTEM.process.latticevectors import index_bragg_directions
+    #     _, _, braggdirections = index_bragg_directions(
+    #         x0,
+    #         y0,
+    #         self.g['x'],
+    #         self.g['y'],
+    #         self.g1,
+    #         self.g2
+    #     )
+
+    #     self.braggdirections = braggdirections
+
+    #     if plot:
+    #         from py4DSTEM.visualize import show_bragg_indexing
+    #         show_bragg_indexing(
+    #             self.bvm_centered,
+    #             **bvm_vis_params,
+    #             braggdirections = braggdirections,
+    #             points = True
+    #         )
+
+    #     if returncalc:
+    #         return braggdirections
+
+
+
+    # def add_indices_to_braggvectors(
+    #     self,
+    #     maxPeakSpacing,
+    #     mask = None,
+    #     returncalc = False,
+    #     ):
+    #     """
+    #     Using the peak positions (qx,qy) and indices (h,k) in the PointList lattice,
+    #     identify the indices for each peak in the PointListArray braggpeaks.
+    #     Return a new braggpeaks_indexed PointListArray, containing a copy of braggpeaks plus
+    #     three additional data columns -- 'h','k', and 'index_mask' -- specifying the peak
+    #     indices with the ints (h,k) and indicating whether the peak was successfully indexed
+    #     or not with the bool index_mask. If `mask` is specified, only the locations where
+    #     mask is True are indexed.
+
+    #     Args:
+    #         maxPeakSpacing (float): Maximum distance from the ideal lattice points
+    #             to include a peak for indexing
+    #         qx_shift,qy_shift (number): the shift of the origin in the `lattice` PointList
+    #             relative to the `braggpeaks` PointListArray
+    #         mask (bool): Boolean mask, same shape as the pointlistarray, indicating which
+    #             locations should be indexed. This can be used to index different regions of
+    #             the scan with different lattices
+    #     """
+    #     from py4DSTEM.process.latticevectors import add_indices_to_braggvectors
+
+    #     bragg_peaks_indexed = add_indices_to_braggvectors(
+    #         self.vectors,
+    #         self.braggdirections,
+    #         maxPeakSpacing = maxPeakSpacing,
+    #         qx_shift = self.Qshape[0]/2,
+    #         qy_shift = self.Qshape[1]/2,
+    #     )
+
+    #     self.bragg_peaks_indexed = bragg_peaks_indexed
+
+    #     if returncalc:
+    #         return bragg_peaks_indexed
+
+
+    # def fit_lattice_vectors_all_DPs(self, returncalc = False):
+    #     """
+    #     Fits lattice vectors g1,g2 to each diffraction pattern in braggpeaks, given some
+    #     known (h,k) indexing.
+
+
+    #     """
+
+    #     from py4DSTEM.process.latticevectors import fit_lattice_vectors_all_DPs
+    #     g1g2_map = fit_lattice_vectors_all_DPs(self.bragg_peaks_indexed)
+    #     self.g1g2_map = g1g2_map
+    #     if returncalc:
+    #         return g1g2_map
+
+    # def get_strain_from_reference_region(self, mask, returncalc = False):
+    #     """
+    #     Gets a strain map from the reference region of real space specified by mask and the
+    #     lattice vector map g1g2_map.
+
+    #     Args:
+    #         mask (ndarray of bools): use lattice vectors from g1g2_map scan positions
+    #             wherever mask==True
+
+    #     """
+    #     from py4DSTEM.process.latticevectors import get_strain_from_reference_region
+
+    #     strainmap_median_g1g2 = get_strain_from_reference_region(
+    #         self.g1g2_map,
+    #         mask = mask,
+    #     )
+
+    #     self.strainmap_median_g1g2 = strainmap_median_g1g2
+
+    #     if returncalc:
+    #         return strainmap_median_g1g2
+
+
+    # def get_strain_from_reference_g1g2(self, mask, returncalc = False):
+    #     """
+    #     Gets a strain map from the reference lattice vectors g1,g2 and lattice vector map
+    #     g1g2_map.
+
+
+    #     Args:
+    #         mask (ndarray of bools): use lattice vectors from g1g2_map scan positions
+    #             wherever mask==True
+
+    #     """
+    #     from py4DSTEM.process.latticevectors import get_reference_g1g2
+    #     g1_ref,g2_ref = get_reference_g1g2(self.g1g2_map, mask)
+
+    #     from py4DSTEM.process.latticevectors import get_strain_from_reference_g1g2
+    #     strainmap_reference_g1g2 = get_strain_from_reference_g1g2(self.g1g2_map, g1_ref, g2_ref)
 
-        """
-
-        from py4DSTEM.process.latticevectors import fit_lattice_vectors_all_DPs
-        g1g2_map = fit_lattice_vectors_all_DPs(self.bragg_peaks_indexed)
-        self.g1g2_map = g1g2_map
-        if returncalc:
-            return g1g2_map
-
-    def get_strain_from_reference_region(self, mask, returncalc = False):
-        """
-        Gets a strain map from the reference region of real space specified by mask and the
-        lattice vector map g1g2_map.
-
-        Args:
-            mask (ndarray of bools): use lattice vectors from g1g2_map scan positions
-                wherever mask==True
-
-        """
-        from py4DSTEM.process.latticevectors import get_strain_from_reference_region
-
-        strainmap_median_g1g2 = get_strain_from_reference_region(
-            self.g1g2_map,
-            mask = mask,
-        )
-
-        self.strainmap_median_g1g2 = strainmap_median_g1g2
-
-        if returncalc:
-            return strainmap_median_g1g2
-
-
-    def get_strain_from_reference_g1g2(self, mask, returncalc = False):
-        """
-        Gets a strain map from the reference lattice vectors g1,g2 and lattice vector map
-        g1g2_map.
+    #     self.strainmap_reference_g1g2 = strainmap_reference_g1g2
+
+    #     if returncalc:
+    #         return strainmap_reference_g1g2
+
+    # def get_rotated_strain_map(self, mode, g_reference = None, returncalc = True, flip_theta = False):
+    #     """
+    #     Starting from a strain map defined with respect to the xy coordinate system of
+    #     diffraction space, i.e. where exx and eyy are the compression/tension along the Qx
+    #     and Qy directions, respectively, get a strain map defined with respect to some other
+    #     right-handed coordinate system, in which the x-axis is oriented along (xaxis_x,
+    #     xaxis_y).
+
+    #     Args:
+    #         g_referencce (tupe): reference coordinate system for xaxis_x and xaxis_y
+    #     """
 
+    #     assert mode in ("median","reference")
+    #     if g_reference is None:
+    #         g_reference = np.subtract(self.g1, self.g2)
 
-        Args:
-            mask (ndarray of bools): use lattice vectors from g1g2_map scan positions
-                wherever mask==True
+    #     from py4DSTEM.process.latticevectors import get_rotated_strain_map
 
-        """
-        from py4DSTEM.process.latticevectors import get_reference_g1g2
-        g1_ref,g2_ref = get_reference_g1g2(self.g1g2_map, mask)
+    #     if mode == "median":
+    #         strainmap_raw = self.strainmap_median_g1g2
+    #     elif mode == "reference":
+    #         strainmap_raw = self.strainmap_reference_g1g2
 
-        from py4DSTEM.process.latticevectors import get_strain_from_reference_g1g2
-        strainmap_reference_g1g2 = get_strain_from_reference_g1g2(self.g1g2_map, g1_ref, g2_ref)
+    #     strainmap = get_rotated_strain_map(
+    #         strainmap_raw,
+    #         xaxis_x = g_reference[0],
+    #         xaxis_y = g_reference[1],
+    #         flip_theta = flip_theta
+    #     )
 
-        self.strainmap_reference_g1g2 = strainmap_reference_g1g2
-
-        if returncalc:
-            return strainmap_reference_g1g2
-
-    def get_rotated_strain_map(self, mode, g_reference = None, returncalc = True, flip_theta = False):
-        """
-        Starting from a strain map defined with respect to the xy coordinate system of
-        diffraction space, i.e. where exx and eyy are the compression/tension along the Qx
-        and Qy directions, respectively, get a strain map defined with respect to some other
-        right-handed coordinate system, in which the x-axis is oriented along (xaxis_x,
-        xaxis_y).
-
-        Args:
-            g_referencce (tupe): reference coordinate system for xaxis_x and xaxis_y
-        """
-
-        assert mode in ("median","reference")
-        if g_reference is None:
-            g_reference = np.subtract(self.g1, self.g2)
-
-        from py4DSTEM.process.latticevectors import get_rotated_strain_map
-
-        if mode == "median":
-            strainmap_raw = self.strainmap_median_g1g2
-        elif mode == "reference":
-            strainmap_raw = self.strainmap_reference_g1g2
-
-        strainmap = get_rotated_strain_map(
-            strainmap_raw,
-            xaxis_x = g_reference[0],
-            xaxis_y = g_reference[1],
-            flip_theta = flip_theta
-        )
-
-        if returncalc:
-            return strainmap
+    #     if returncalc:
+    #         return strainmap
 
 
     def mask_in_Q(
diff --git a/py4DSTEM/process/latticevectors/strain.py b/py4DSTEM/process/latticevectors/strain.py
index 518f38885..7a586bd69 100644
--- a/py4DSTEM/process/latticevectors/strain.py
+++ b/py4DSTEM/process/latticevectors/strain.py
@@ -172,18 +172,20 @@ def get_rotated_strain_map(unrotated_strain_map, xaxis_x, xaxis_y, flip_theta):
     sint2 = sint**2
 
     Rx,Ry = unrotated_strain_map.get_slice('e_xx').data.shape
-    rotated_strain_map = RealSlice(data=np.zeros((Rx,Ry,5)),
-                                   slicelabels=['e_xx','e_xy','e_yy','theta','mask'],
-                                   name=unrotated_strain_map.name+"_rotated".format(np.degrees(theta)))
+    rotated_strain_map = RealSlice(
+        data=np.zeros((5, Rx,Ry)),
+        slicelabels=['e_xx','e_xy','e_yy','theta','mask'],
+        name=unrotated_strain_map.name+"_rotated".format(np.degrees(theta))
+    )
 
-    rotated_strain_map.data[:,:,0] = cost2*unrotated_strain_map.get_slice('e_xx').data - 2*cost*sint*unrotated_strain_map.get_slice('e_xy').data + sint2*unrotated_strain_map.get_slice('e_yy').data
-    rotated_strain_map.data[:,:,1] = cost*sint*(unrotated_strain_map.get_slice('e_xx').data-unrotated_strain_map.get_slice('e_yy').data) + (cost2-sint2)*unrotated_strain_map.get_slice('e_xy').data
-    rotated_strain_map.data[:,:,2] = sint2*unrotated_strain_map.get_slice('e_xx').data + 2*cost*sint*unrotated_strain_map.get_slice('e_xy').data + cost2*unrotated_strain_map.get_slice('e_yy').data
+    rotated_strain_map.data[0,:,:] = cost2*unrotated_strain_map.get_slice('e_xx').data - 2*cost*sint*unrotated_strain_map.get_slice('e_xy').data + sint2*unrotated_strain_map.get_slice('e_yy').data
+    rotated_strain_map.data[1,:,:] = cost*sint*(unrotated_strain_map.get_slice('e_xx').data-unrotated_strain_map.get_slice('e_yy').data) + (cost2-sint2)*unrotated_strain_map.get_slice('e_xy').data
+    rotated_strain_map.data[2,:,:] = sint2*unrotated_strain_map.get_slice('e_xx').data + 2*cost*sint*unrotated_strain_map.get_slice('e_xy').data + cost2*unrotated_strain_map.get_slice('e_yy').data
     if flip_theta == True:
-        rotated_strain_map.data[:,:,3] = -unrotated_strain_map.get_slice('theta').data
+        rotated_strain_map.data[3,:,:] = -unrotated_strain_map.get_slice('theta').data
     else: 
-        rotated_strain_map.data[:,:,3] = unrotated_strain_map.get_slice('theta').data
-    rotated_strain_map.data[:,:,4] = unrotated_strain_map.get_slice('mask').data
+        rotated_strain_map.data[3,:,:] = unrotated_strain_map.get_slice('theta').data
+    rotated_strain_map.data[4,:,:] = unrotated_strain_map.get_slice('mask').data
     return rotated_strain_map
 
 
diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index a275f9e6b..0424e92e0 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -385,21 +385,57 @@ def fit_lattice_vectors(
     def get_strain(
         self, 
         mask=None,
+        g_reference=None,
+        flip_theta=False,
         returncalc=False,
         **kwargs
     ):
-        """ """
+        """ 
+        mask: nd.array (bool) 
+            Use lattice vectors from g1g2_map scan positions
+            wherever mask==True. If mask is None gets median strain
+            map from entire field of view. If mask is not None, gets 
+            reference g1 and g2 from region and then calculates strain.
+        g_reference: nd.array of form [x,y]
+            G_reference (tupe): reference coordinate system for 
+            xaxis_x and xaxis_y
+        flip_theta: bool
+            If True, flips rotation coordinate system
+        returncal: bool
+            It True, returns rotated map
+        """
         if mask is None:
             mask = np.ones(self.g1g2_map.shape, dtype="bool")
 
-        from py4DSTEM.process.latticevectors import get_strain_from_reference_region
+            from py4DSTEM.process.latticevectors import get_strain_from_reference_region
 
-        strainmap_median_g1g2 = get_strain_from_reference_region(
-            self.g1g2_map,
-            mask=mask,
+            strainmap_g1g2 = get_strain_from_reference_region(
+                self.g1g2_map,
+                mask=mask,
+            )
+        else:
+            from py4DSTEM.process.latticevectors import get_reference_g1g2
+            g1_ref,g2_ref = get_reference_g1g2(self.g1g2_map, mask)
+            
+            from py4DSTEM.process.latticevectors import get_strain_from_reference_g1g2
+            strainmap_g1g2 = get_strain_from_reference_g1g2(self.g1g2_map, g1_ref, g2_ref)
+
+        self.strainmap_g1g2 = strainmap_g1g2
+
+        if g_reference is None:
+            g_reference = np.subtract(self.g1, self.g2)
+
+        print(g_reference)
+        from py4DSTEM.process.latticevectors import get_rotated_strain_map
+
+        strainmap_rotated = get_rotated_strain_map(
+            self.strainmap_g1g2,
+            xaxis_x = g_reference[0],
+            xaxis_y = g_reference[1],
+            flip_theta = flip_theta
         )
 
-        self.strainmap_median_g1g2 = strainmap_median_g1g2
+        self.strainmap_rotated = strainmap_rotated
         
         from py4DSTEM.visualize import show_strain
         figsize = kwargs.pop("figsize", (14, 4))
@@ -410,7 +446,7 @@ def get_strain(
         axes_plots = kwargs.pop("axes_plots",())
 
         fig, ax = show_strain(
-            strainmap_median_g1g2,
+            self.strainmap_rotated,
             vrange_exx=vrange_exx,
             vrange_theta=vrange_theta,
             ticknumber=ticknumber,
@@ -422,10 +458,13 @@ def get_strain(
         )
 
         if not np.all(mask == True): 
-            for axs in ax.flatten():
-                axs.imshow(mask, alpha = 0.2, cmap = "binary")
+           ax[0][0].imshow(mask, alpha = 0.2, cmap = "binary")
+           ax[0][1].imshow(mask, alpha = 0.2, cmap = "binary")
+           ax[1][0].imshow(mask, alpha = 0.2, cmap = "binary")
+           ax[1][1].imshow(mask, alpha = 0.2, cmap = "binary")
+        
         if returncalc:
-            return strainmap_median_g1g2
+            return self.strainmap_rotated
 
     def show_lattice_vectors(
         ar,
@@ -519,7 +558,9 @@ def show_bragg_indexing(
         else:
             plt.show()
             return
-
+    
+    # def copy():
+    #     # TODO - copy method
 
 # def index_bragg_directions(x0, y0, gx, gy, g1, g2):
 #     """
@@ -573,81 +614,81 @@ def show_bragg_indexing(
 #     return h,k, bragg_directions
 
 
-def add_indices_to_braggvectors(
-    braggpeaks, lattice, maxPeakSpacing, qx_shift=0, qy_shift=0, mask=None
-):
-    """
-    Using the peak positions (qx,qy) and indices (h,k) in the PointList lattice,
-    identify the indices for each peak in the PointListArray braggpeaks.
-    Return a new braggpeaks_indexed PointListArray, containing a copy of braggpeaks plus
-    three additional data columns -- 'h','k', and 'index_mask' -- specifying the peak
-    indices with the ints (h,k) and indicating whether the peak was successfully indexed
-    or not with the bool index_mask. If `mask` is specified, only the locations where
-    mask is True are indexed.
-
-    Args:
-        braggpeaks (PointListArray): the braggpeaks to index. Must contain
-            the coordinates 'qx', 'qy', and 'intensity'
-        lattice (PointList): the positions (qx,qy) of the (h,k) lattice points.
-            Must contain the coordinates 'qx', 'qy', 'h', and 'k'
-        maxPeakSpacing (float): Maximum distance from the ideal lattice points
-            to include a peak for indexing
-        qx_shift,qy_shift (number): the shift of the origin in the `lattice` PointList
-            relative to the `braggpeaks` PointListArray
-        mask (bool): Boolean mask, same shape as the pointlistarray, indicating which
-            locations should be indexed. This can be used to index different regions of
-            the scan with different lattices
-
-    Returns:
-        (PointListArray): The original braggpeaks pointlistarray, with new coordinates
-        'h', 'k', containing the indices of each indexable peak.
-    """
+# def add_indices_to_braggvectors(
+#     braggpeaks, lattice, maxPeakSpacing, qx_shift=0, qy_shift=0, mask=None
+# ):
+#     """
+#     Using the peak positions (qx,qy) and indices (h,k) in the PointList lattice,
+#     identify the indices for each peak in the PointListArray braggpeaks.
+#     Return a new braggpeaks_indexed PointListArray, containing a copy of braggpeaks plus
+#     three additional data columns -- 'h','k', and 'index_mask' -- specifying the peak
+#     indices with the ints (h,k) and indicating whether the peak was successfully indexed
+#     or not with the bool index_mask. If `mask` is specified, only the locations where
+#     mask is True are indexed.
+
+#     Args:
+#         braggpeaks (PointListArray): the braggpeaks to index. Must contain
+#             the coordinates 'qx', 'qy', and 'intensity'
+#         lattice (PointList): the positions (qx,qy) of the (h,k) lattice points.
+#             Must contain the coordinates 'qx', 'qy', 'h', and 'k'
+#         maxPeakSpacing (float): Maximum distance from the ideal lattice points
+#             to include a peak for indexing
+#         qx_shift,qy_shift (number): the shift of the origin in the `lattice` PointList
+#             relative to the `braggpeaks` PointListArray
+#         mask (bool): Boolean mask, same shape as the pointlistarray, indicating which
+#             locations should be indexed. This can be used to index different regions of
+#             the scan with different lattices
+
+#     Returns:
+#         (PointListArray): The original braggpeaks pointlistarray, with new coordinates
+#         'h', 'k', containing the indices of each indexable peak.
+#     """
 
-    assert isinstance(braggpeaks, PointListArray)
-    assert np.all(
-        [name in braggpeaks.dtype.names for name in ("qx", "qy", "intensity")]
-    )
-    assert isinstance(lattice, PointList)
-    assert np.all([name in lattice.dtype.names for name in ("qx", "qy", "h", "k")])
-
-    if mask is None:
-        mask = np.ones(braggpeaks.shape, dtype=bool)
-
-    assert mask.shape == braggpeaks.shape, "mask must have same shape as pointlistarray"
-    assert mask.dtype == bool, "mask must be boolean"
-
-    indexed_braggpeaks = braggpeaks.copy()
-
-    # add the coordinates if they don't exist
-    if not ("h" in braggpeaks.dtype.names):
-        indexed_braggpeaks = indexed_braggpeaks.add_fields([("h", int)])
-    if not ("k" in braggpeaks.dtype.names):
-        indexed_braggpeaks = indexed_braggpeaks.add_fields([("k", int)])
-
-    # loop over all the scan positions
-    for Rx, Ry in tqdmnd(mask.shape[0], mask.shape[1]):
-        if mask[Rx, Ry]:
-            pl = indexed_braggpeaks.get_pointlist(Rx, Ry)
-            rm_peak_mask = np.zeros(pl.length, dtype=bool)
-
-            for i in range(pl.length):
-                r2 = (pl.data["qx"][i] - lattice.data["qx"] + qx_shift) ** 2 + (
-                    pl.data["qy"][i] - lattice.data["qy"] + qy_shift
-                ) ** 2
-                ind = np.argmin(r2)
-                if r2[ind] <= maxPeakSpacing**2:
-                    pl.data["h"][i] = lattice.data["h"][ind]
-                    pl.data["k"][i] = lattice.data["k"][ind]
-                else:
-                    rm_peak_mask[i] = True
-            pl.remove(rm_peak_mask)
-
-    indexed_braggpeaks.name = braggpeaks.name + "_indexed"
-    return indexed_braggpeaks
+#     assert isinstance(braggpeaks, PointListArray)
+#     assert np.all(
+#         [name in braggpeaks.dtype.names for name in ("qx", "qy", "intensity")]
+#     )
+#     assert isinstance(lattice, PointList)
+#     assert np.all([name in lattice.dtype.names for name in ("qx", "qy", "h", "k")])
+
+#     if mask is None:
+#         mask = np.ones(braggpeaks.shape, dtype=bool)
+
+#     assert mask.shape == braggpeaks.shape, "mask must have same shape as pointlistarray"
+#     assert mask.dtype == bool, "mask must be boolean"
+
+#     indexed_braggpeaks = braggpeaks.copy()
+
+#     # add the coordinates if they don't exist
+#     if not ("h" in braggpeaks.dtype.names):
+#         indexed_braggpeaks = indexed_braggpeaks.add_fields([("h", int)])
+#     if not ("k" in braggpeaks.dtype.names):
+#         indexed_braggpeaks = indexed_braggpeaks.add_fields([("k", int)])
+
+#     # loop over all the scan positions
+#     for Rx, Ry in tqdmnd(mask.shape[0], mask.shape[1]):
+#         if mask[Rx, Ry]:
+#             pl = indexed_braggpeaks.get_pointlist(Rx, Ry)
+#             rm_peak_mask = np.zeros(pl.length, dtype=bool)
+
+#             for i in range(pl.length):
+#                 r2 = (pl.data["qx"][i] - lattice.data["qx"] + qx_shift) ** 2 + (
+#                     pl.data["qy"][i] - lattice.data["qy"] + qy_shift
+#                 ) ** 2
+#                 ind = np.argmin(r2)
+#                 if r2[ind] <= maxPeakSpacing**2:
+#                     pl.data["h"][i] = lattice.data["h"][ind]
+#                     pl.data["k"][i] = lattice.data["k"][ind]
+#                 else:
+#                     rm_peak_mask[i] = True
+#             pl.remove(rm_peak_mask)
+
+#     indexed_braggpeaks.name = braggpeaks.name + "_indexed"
+#     return indexed_braggpeaks
 
     # IO methods
 
-    # TODO - copy method
+    
 
     # read
     @classmethod

From e5b9a8b5b0a9daf21f9133d6fa76f6a52cd5dffa Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 14 Jul 2023 11:47:35 -0700
Subject: [PATCH 343/362] strain copy

---
 py4DSTEM/process/strain.py | 324 +++++++++++++++++++------------------
 1 file changed, 165 insertions(+), 159 deletions(-)

diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index 0424e92e0..3ce202e4b 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -25,7 +25,7 @@ def __init__(self, braggvectors: BraggVectors, name: Optional[str] = "strainmap"
         """
         assert isinstance(
             braggvectors, BraggVectors
-        ), f"braggvectors myst be BraggVectors, not type {type(braggvectors)}"
+        ), f"braggvectors must be BraggVectors, not type {type(braggvectors)}"
 
         # initialize as a RealSlice
         RealSlice.__init__(
@@ -383,27 +383,27 @@ def fit_lattice_vectors(
             braggdirections, bragg_vectors_indexed, g1g2_map
 
     def get_strain(
-        self, 
-        mask=None,
-        g_reference=None,
-        flip_theta=False,
-        returncalc=False,
-        **kwargs
+        self, mask=None, g_reference=None, flip_theta=False, returncalc=False, **kwargs
     ):
-        """ 
-        mask: nd.array (bool) 
+        """
+        mask: nd.array (bool)
             Use lattice vectors from g1g2_map scan positions
             wherever mask==True. If mask is None gets median strain
-            map from entire field of view. If mask is not None, gets 
+            map from entire field of view. If mask is not None, gets
             reference g1 and g2 from region and then calculates strain.
         g_reference: nd.array of form [x,y]
-            G_reference (tupe): reference coordinate system for 
+            G_reference (tupe): reference coordinate system for
             xaxis_x and xaxis_y
         flip_theta: bool
             If True, flips rotation coordinate system
         returncal: bool
             It True, returns rotated map
         """
+        # check the calstate
+        assert (
+            self.calstate == self.braggvectors.calstate
+        ), "The calibration state has changed! To resync the calibration state, use `.reset_calstate`."
+
         if mask is None:
             mask = np.ones(self.g1g2_map.shape, dtype="bool")
 
@@ -415,38 +415,42 @@ def get_strain(
             )
         else:
             from py4DSTEM.process.latticevectors import get_reference_g1g2
-            g1_ref,g2_ref = get_reference_g1g2(self.g1g2_map, mask)
-            
+
+            g1_ref, g2_ref = get_reference_g1g2(self.g1g2_map, mask)
+
             from py4DSTEM.process.latticevectors import get_strain_from_reference_g1g2
-            strainmap_g1g2 = get_strain_from_reference_g1g2(self.g1g2_map, g1_ref, g2_ref)
+
+            strainmap_g1g2 = get_strain_from_reference_g1g2(
+                self.g1g2_map, g1_ref, g2_ref
+            )
 
         self.strainmap_g1g2 = strainmap_g1g2
 
         if g_reference is None:
             g_reference = np.subtract(self.g1, self.g2)
 
-        print(g_reference)
         from py4DSTEM.process.latticevectors import get_rotated_strain_map
 
         strainmap_rotated = get_rotated_strain_map(
             self.strainmap_g1g2,
-            xaxis_x = g_reference[0],
-            xaxis_y = g_reference[1],
-            flip_theta = flip_theta
+            xaxis_x=g_reference[0],
+            xaxis_y=g_reference[1],
+            flip_theta=flip_theta,
         )
 
-        self.strainmap_rotated = strainmap_rotated
-        
+        self.data = strainmap_rotated
+
         from py4DSTEM.visualize import show_strain
+
         figsize = kwargs.pop("figsize", (14, 4))
         vrange_exx = kwargs.pop("vrange_exx", [-2.0, 2.0])
         vrange_theta = kwargs.pop("vrange_theta", [-2.0, 2.0])
         ticknumber = kwargs.pop("ticknumber", 3)
-        bkgrd = kwargs.pop("bkgrd", False) 
-        axes_plots = kwargs.pop("axes_plots",())
+        bkgrd = kwargs.pop("bkgrd", False)
+        axes_plots = kwargs.pop("axes_plots", ())
 
         fig, ax = show_strain(
-            self.strainmap_rotated,
+            self.data,
             vrange_exx=vrange_exx,
             vrange_theta=vrange_theta,
             ticknumber=ticknumber,
@@ -454,15 +458,15 @@ def get_strain(
             bkgrd=bkgrd,
             figsize=figsize,
             **kwargs,
-            returnfig = True,
+            returnfig=True,
         )
 
-        if not np.all(mask == True): 
-           ax[0][0].imshow(mask, alpha = 0.2, cmap = "binary")
-           ax[0][1].imshow(mask, alpha = 0.2, cmap = "binary")
-           ax[1][0].imshow(mask, alpha = 0.2, cmap = "binary")
-           ax[1][1].imshow(mask, alpha = 0.2, cmap = "binary")
-        
+        if not np.all(mask == True):
+            ax[0][0].imshow(mask, alpha=0.2, cmap="binary")
+            ax[0][1].imshow(mask, alpha=0.2, cmap="binary")
+            ax[1][0].imshow(mask, alpha=0.2, cmap="binary")
+            ax[1][1].imshow(mask, alpha=0.2, cmap="binary")
+
         if returncalc:
             return self.strainmap_rotated
 
@@ -558,137 +562,139 @@ def show_bragg_indexing(
         else:
             plt.show()
             return
-    
-    # def copy():
-    #     # TODO - copy method
-
-# def index_bragg_directions(x0, y0, gx, gy, g1, g2):
-#     """
-#     From an origin (x0,y0), a set of reciprocal lattice vectors gx,gy, and an pair of
-#     lattice vectors g1=(g1x,g1y), g2=(g2x,g2y), find the indices (h,k) of all the
-#     reciprocal lattice directions.
-
-#     The approach is to solve the matrix equation
-#             ``alpha = beta * M``
-#     where alpha is the 2xN array of the (x,y) coordinates of N measured bragg directions,
-#     beta is the 2x2 array of the two lattice vectors u,v, and M is the 2xN array of the
-#     h,k indices.
-
-#     Args:
-#         x0 (float): x-coord of origin
-#         y0 (float): y-coord of origin
-#         gx (1d array): x-coord of the reciprocal lattice vectors
-#         gy (1d array): y-coord of the reciprocal lattice vectors
-#         g1 (2-tuple of floats): g1x,g1y
-#         g2 (2-tuple of floats): g2x,g2y
-
-#     Returns:
-#         (3-tuple) A 3-tuple containing:
-
-#             * **h**: *(ndarray of ints)* first index of the bragg directions
-#             * **k**: *(ndarray of ints)* second index of the bragg directions
-#             * **bragg_directions**: *(PointList)* a 4-coordinate PointList with the
-#               indexed bragg directions; coords 'qx' and 'qy' contain bragg_x and bragg_y
-#               coords 'h' and 'k' contain h and k.
-#     """
-#     # Get beta, the matrix of lattice vectors
-#     beta = np.array([[g1[0],g2[0]],[g1[1],g2[1]]])
-
-#     # Get alpha, the matrix of measured bragg angles
-#     alpha = np.vstack([gx-x0,gy-y0])
-
-#     # Calculate M, the matrix of peak positions
-#     M = lstsq(beta, alpha, rcond=None)[0].T
-#     M = np.round(M).astype(int)
-
-#     # Get h,k
-#     h = M[:,0]
-#     k = M[:,1]
-
-#     # Store in a PointList
-#     coords = [('qx',float),('qy',float),('h',int),('k',int)]
-#     temp_array = np.zeros([], dtype = coords)
-#     bragg_directions = PointList(data = temp_array)
-#     bragg_directions.add_data_by_field((gx,gy,h,k))
-
-#     return h,k, bragg_directions
-
-
-# def add_indices_to_braggvectors(
-#     braggpeaks, lattice, maxPeakSpacing, qx_shift=0, qy_shift=0, mask=None
-# ):
-#     """
-#     Using the peak positions (qx,qy) and indices (h,k) in the PointList lattice,
-#     identify the indices for each peak in the PointListArray braggpeaks.
-#     Return a new braggpeaks_indexed PointListArray, containing a copy of braggpeaks plus
-#     three additional data columns -- 'h','k', and 'index_mask' -- specifying the peak
-#     indices with the ints (h,k) and indicating whether the peak was successfully indexed
-#     or not with the bool index_mask. If `mask` is specified, only the locations where
-#     mask is True are indexed.
-
-#     Args:
-#         braggpeaks (PointListArray): the braggpeaks to index. Must contain
-#             the coordinates 'qx', 'qy', and 'intensity'
-#         lattice (PointList): the positions (qx,qy) of the (h,k) lattice points.
-#             Must contain the coordinates 'qx', 'qy', 'h', and 'k'
-#         maxPeakSpacing (float): Maximum distance from the ideal lattice points
-#             to include a peak for indexing
-#         qx_shift,qy_shift (number): the shift of the origin in the `lattice` PointList
-#             relative to the `braggpeaks` PointListArray
-#         mask (bool): Boolean mask, same shape as the pointlistarray, indicating which
-#             locations should be indexed. This can be used to index different regions of
-#             the scan with different lattices
-
-#     Returns:
-#         (PointListArray): The original braggpeaks pointlistarray, with new coordinates
-#         'h', 'k', containing the indices of each indexable peak.
-#     """
-
-#     assert isinstance(braggpeaks, PointListArray)
-#     assert np.all(
-#         [name in braggpeaks.dtype.names for name in ("qx", "qy", "intensity")]
-#     )
-#     assert isinstance(lattice, PointList)
-#     assert np.all([name in lattice.dtype.names for name in ("qx", "qy", "h", "k")])
-
-#     if mask is None:
-#         mask = np.ones(braggpeaks.shape, dtype=bool)
-
-#     assert mask.shape == braggpeaks.shape, "mask must have same shape as pointlistarray"
-#     assert mask.dtype == bool, "mask must be boolean"
-
-#     indexed_braggpeaks = braggpeaks.copy()
-
-#     # add the coordinates if they don't exist
-#     if not ("h" in braggpeaks.dtype.names):
-#         indexed_braggpeaks = indexed_braggpeaks.add_fields([("h", int)])
-#     if not ("k" in braggpeaks.dtype.names):
-#         indexed_braggpeaks = indexed_braggpeaks.add_fields([("k", int)])
-
-#     # loop over all the scan positions
-#     for Rx, Ry in tqdmnd(mask.shape[0], mask.shape[1]):
-#         if mask[Rx, Ry]:
-#             pl = indexed_braggpeaks.get_pointlist(Rx, Ry)
-#             rm_peak_mask = np.zeros(pl.length, dtype=bool)
-
-#             for i in range(pl.length):
-#                 r2 = (pl.data["qx"][i] - lattice.data["qx"] + qx_shift) ** 2 + (
-#                     pl.data["qy"][i] - lattice.data["qy"] + qy_shift
-#                 ) ** 2
-#                 ind = np.argmin(r2)
-#                 if r2[ind] <= maxPeakSpacing**2:
-#                     pl.data["h"][i] = lattice.data["h"][ind]
-#                     pl.data["k"][i] = lattice.data["k"][ind]
-#                 else:
-#                     rm_peak_mask[i] = True
-#             pl.remove(rm_peak_mask)
-
-#     indexed_braggpeaks.name = braggpeaks.name + "_indexed"
-#     return indexed_braggpeaks
 
-    # IO methods
+    def copy(self, name=None):
+        name = name if name is not None else self.name + "_copy"
+        strainmap_copy = StrainMap(self.braggvectors)
+
+        for k in self.metadata.keys():
+            strainmap_copy.metadata = self.metadata[k].copy()
+        return strainmap_copy
+
+    # def index_bragg_directions(x0, y0, gx, gy, g1, g2):
+    #     """
+    #     From an origin (x0,y0), a set of reciprocal lattice vectors gx,gy, and an pair of
+    #     lattice vectors g1=(g1x,g1y), g2=(g2x,g2y), find the indices (h,k) of all the
+    #     reciprocal lattice directions.
+
+    #     The approach is to solve the matrix equation
+    #             ``alpha = beta * M``
+    #     where alpha is the 2xN array of the (x,y) coordinates of N measured bragg directions,
+    #     beta is the 2x2 array of the two lattice vectors u,v, and M is the 2xN array of the
+    #     h,k indices.
+
+    #     Args:
+    #         x0 (float): x-coord of origin
+    #         y0 (float): y-coord of origin
+    #         gx (1d array): x-coord of the reciprocal lattice vectors
+    #         gy (1d array): y-coord of the reciprocal lattice vectors
+    #         g1 (2-tuple of floats): g1x,g1y
+    #         g2 (2-tuple of floats): g2x,g2y
+
+    #     Returns:
+    #         (3-tuple) A 3-tuple containing:
+
+    #             * **h**: *(ndarray of ints)* first index of the bragg directions
+    #             * **k**: *(ndarray of ints)* second index of the bragg directions
+    #             * **bragg_directions**: *(PointList)* a 4-coordinate PointList with the
+    #               indexed bragg directions; coords 'qx' and 'qy' contain bragg_x and bragg_y
+    #               coords 'h' and 'k' contain h and k.
+    #     """
+    #     # Get beta, the matrix of lattice vectors
+    #     beta = np.array([[g1[0],g2[0]],[g1[1],g2[1]]])
+
+    #     # Get alpha, the matrix of measured bragg angles
+    #     alpha = np.vstack([gx-x0,gy-y0])
+
+    #     # Calculate M, the matrix of peak positions
+    #     M = lstsq(beta, alpha, rcond=None)[0].T
+    #     M = np.round(M).astype(int)
+
+    #     # Get h,k
+    #     h = M[:,0]
+    #     k = M[:,1]
+
+    #     # Store in a PointList
+    #     coords = [('qx',float),('qy',float),('h',int),('k',int)]
+    #     temp_array = np.zeros([], dtype = coords)
+    #     bragg_directions = PointList(data = temp_array)
+    #     bragg_directions.add_data_by_field((gx,gy,h,k))
+
+    #     return h,k, bragg_directions
+
+    # def add_indices_to_braggvectors(
+    #     braggpeaks, lattice, maxPeakSpacing, qx_shift=0, qy_shift=0, mask=None
+    # ):
+    #     """
+    #     Using the peak positions (qx,qy) and indices (h,k) in the PointList lattice,
+    #     identify the indices for each peak in the PointListArray braggpeaks.
+    #     Return a new braggpeaks_indexed PointListArray, containing a copy of braggpeaks plus
+    #     three additional data columns -- 'h','k', and 'index_mask' -- specifying the peak
+    #     indices with the ints (h,k) and indicating whether the peak was successfully indexed
+    #     or not with the bool index_mask. If `mask` is specified, only the locations where
+    #     mask is True are indexed.
+
+    #     Args:
+    #         braggpeaks (PointListArray): the braggpeaks to index. Must contain
+    #             the coordinates 'qx', 'qy', and 'intensity'
+    #         lattice (PointList): the positions (qx,qy) of the (h,k) lattice points.
+    #             Must contain the coordinates 'qx', 'qy', 'h', and 'k'
+    #         maxPeakSpacing (float): Maximum distance from the ideal lattice points
+    #             to include a peak for indexing
+    #         qx_shift,qy_shift (number): the shift of the origin in the `lattice` PointList
+    #             relative to the `braggpeaks` PointListArray
+    #         mask (bool): Boolean mask, same shape as the pointlistarray, indicating which
+    #             locations should be indexed. This can be used to index different regions of
+    #             the scan with different lattices
+
+    #     Returns:
+    #         (PointListArray): The original braggpeaks pointlistarray, with new coordinates
+    #         'h', 'k', containing the indices of each indexable peak.
+    #     """
+
+    #     assert isinstance(braggpeaks, PointListArray)
+    #     assert np.all(
+    #         [name in braggpeaks.dtype.names for name in ("qx", "qy", "intensity")]
+    #     )
+    #     assert isinstance(lattice, PointList)
+    #     assert np.all([name in lattice.dtype.names for name in ("qx", "qy", "h", "k")])
+
+    #     if mask is None:
+    #         mask = np.ones(braggpeaks.shape, dtype=bool)
+
+    #     assert mask.shape == braggpeaks.shape, "mask must have same shape as pointlistarray"
+    #     assert mask.dtype == bool, "mask must be boolean"
+
+    #     indexed_braggpeaks = braggpeaks.copy()
+
+    #     # add the coordinates if they don't exist
+    #     if not ("h" in braggpeaks.dtype.names):
+    #         indexed_braggpeaks = indexed_braggpeaks.add_fields([("h", int)])
+    #     if not ("k" in braggpeaks.dtype.names):
+    #         indexed_braggpeaks = indexed_braggpeaks.add_fields([("k", int)])
+
+    #     # loop over all the scan positions
+    #     for Rx, Ry in tqdmnd(mask.shape[0], mask.shape[1]):
+    #         if mask[Rx, Ry]:
+    #             pl = indexed_braggpeaks.get_pointlist(Rx, Ry)
+    #             rm_peak_mask = np.zeros(pl.length, dtype=bool)
+
+    #             for i in range(pl.length):
+    #                 r2 = (pl.data["qx"][i] - lattice.data["qx"] + qx_shift) ** 2 + (
+    #                     pl.data["qy"][i] - lattice.data["qy"] + qy_shift
+    #                 ) ** 2
+    #                 ind = np.argmin(r2)
+    #                 if r2[ind] <= maxPeakSpacing**2:
+    #                     pl.data["h"][i] = lattice.data["h"][ind]
+    #                     pl.data["k"][i] = lattice.data["k"][ind]
+    #                 else:
+    #                     rm_peak_mask[i] = True
+    #             pl.remove(rm_peak_mask)
+
+    #     indexed_braggpeaks.name = braggpeaks.name + "_indexed"
+    #     return indexed_braggpeaks
 
-    
+    # IO methods
 
     # read
     @classmethod

From 7149d58135abc9d2ab9ad20670e5941a60c9d600 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 14 Jul 2023 12:01:40 -0700
Subject: [PATCH 344/362] rotated

---
 py4DSTEM/process/strain.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index 3ce202e4b..372ae7397 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -438,7 +438,7 @@ def get_strain(
             flip_theta=flip_theta,
         )
 
-        self.data = strainmap_rotated
+        self.strainmap_rotated = strainmap_rotated
 
         from py4DSTEM.visualize import show_strain
 
@@ -450,7 +450,7 @@ def get_strain(
         axes_plots = kwargs.pop("axes_plots", ())
 
         fig, ax = show_strain(
-            self.data,
+            self.strainmap_rotated,
             vrange_exx=vrange_exx,
             vrange_theta=vrange_theta,
             ticknumber=ticknumber,

From 80e80b9cfde9473d75f5540b49e2b17ad55d69aa Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Fri, 14 Jul 2023 13:21:24 -0700
Subject: [PATCH 345/362] fix copy method

---
 py4DSTEM/process/strain.py    | 153 +++++-----------------------------
 py4DSTEM/visualize/overlay.py |  22 ++---
 2 files changed, 33 insertions(+), 142 deletions(-)

diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index 372ae7397..247b60a06 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -330,7 +330,7 @@ def fit_lattice_vectors(
             vis_params : dict
                 additional visualization parameters passed to `show`
             returncalc : bool
-                if True, returns braggdirections, bragg_vectors_indexed, g1g2_map
+                if True, returns bragg_directions, bragg_vectors_indexed, g1g2_map
         """
         # check the calstate
         assert (
@@ -354,7 +354,7 @@ def fit_lattice_vectors(
         if plot:
             self.show_bragg_indexing(
                 self.bvm,
-                braggdirections=braggdirections,
+                bragg_directions=braggdirections,
                 points=True,
                 **vis_params,
             )
@@ -364,7 +364,7 @@ def fit_lattice_vectors(
 
         bragg_vectors_indexed = add_indices_to_braggvectors(
             self.braggvectors,
-            self.braggdirections,
+            self.bragg_directions,
             maxPeakSpacing=max_peak_spacing,
             qx_shift=self.braggvectors.Qshape[0] / 2,
             qy_shift=self.braggvectors.Qshape[1] / 2,
@@ -380,7 +380,7 @@ def fit_lattice_vectors(
         self.g1g2_map = g1g2_map
 
         if returncalc:
-            braggdirections, bragg_vectors_indexed, g1g2_map
+            bragg_directions, bragg_vectors_indexed, g1g2_map
 
     def get_strain(
         self, mask=None, g_reference=None, flip_theta=False, returncalc=False, **kwargs
@@ -521,7 +521,7 @@ def show_lattice_vectors(
     def show_bragg_indexing(
         self,
         ar,
-        braggdirections,
+        bragg_directions,
         voffset=5,
         hoffset=0,
         color="w",
@@ -540,13 +540,13 @@ def show_bragg_indexing(
             bragg_directions    (PointList) the bragg scattering directions; must have coordinates
                                 'qx','qy','h', and 'k'. Optionally may also have 'l'.
         """
-        assert isinstance(braggdirections, PointList)
+        assert isinstance(bragg_directions, PointList)
         for k in ("qx", "qy", "h", "k"):
-            assert k in braggdirections.data.dtype.fields
+            assert k in bragg_directions.data.dtype.fields
 
         fig, ax = show(ar, returnfig=True, **kwargs)
         d = {
-            "braggdirections": braggdirections,
+            "bragg_directions": bragg_directions,
             "voffset": voffset,
             "hoffset": hoffset,
             "color": color,
@@ -566,134 +566,25 @@ def show_bragg_indexing(
     def copy(self, name=None):
         name = name if name is not None else self.name + "_copy"
         strainmap_copy = StrainMap(self.braggvectors)
+        for attr in (
+            "g",
+            "g0",
+            "g1",
+            "g2",
+            "calstate",
+            "bragg_directions",
+            "bragg_vectors_indexed",
+            "g1g2_map",
+            "strainmap_g1g2",
+            "strainmap_rotated",
+        ):
+            if hasattr(self, attr):
+                setattr(strainmap_copy, attr, getattr(self, attr))
 
         for k in self.metadata.keys():
             strainmap_copy.metadata = self.metadata[k].copy()
         return strainmap_copy
 
-    # def index_bragg_directions(x0, y0, gx, gy, g1, g2):
-    #     """
-    #     From an origin (x0,y0), a set of reciprocal lattice vectors gx,gy, and an pair of
-    #     lattice vectors g1=(g1x,g1y), g2=(g2x,g2y), find the indices (h,k) of all the
-    #     reciprocal lattice directions.
-
-    #     The approach is to solve the matrix equation
-    #             ``alpha = beta * M``
-    #     where alpha is the 2xN array of the (x,y) coordinates of N measured bragg directions,
-    #     beta is the 2x2 array of the two lattice vectors u,v, and M is the 2xN array of the
-    #     h,k indices.
-
-    #     Args:
-    #         x0 (float): x-coord of origin
-    #         y0 (float): y-coord of origin
-    #         gx (1d array): x-coord of the reciprocal lattice vectors
-    #         gy (1d array): y-coord of the reciprocal lattice vectors
-    #         g1 (2-tuple of floats): g1x,g1y
-    #         g2 (2-tuple of floats): g2x,g2y
-
-    #     Returns:
-    #         (3-tuple) A 3-tuple containing:
-
-    #             * **h**: *(ndarray of ints)* first index of the bragg directions
-    #             * **k**: *(ndarray of ints)* second index of the bragg directions
-    #             * **bragg_directions**: *(PointList)* a 4-coordinate PointList with the
-    #               indexed bragg directions; coords 'qx' and 'qy' contain bragg_x and bragg_y
-    #               coords 'h' and 'k' contain h and k.
-    #     """
-    #     # Get beta, the matrix of lattice vectors
-    #     beta = np.array([[g1[0],g2[0]],[g1[1],g2[1]]])
-
-    #     # Get alpha, the matrix of measured bragg angles
-    #     alpha = np.vstack([gx-x0,gy-y0])
-
-    #     # Calculate M, the matrix of peak positions
-    #     M = lstsq(beta, alpha, rcond=None)[0].T
-    #     M = np.round(M).astype(int)
-
-    #     # Get h,k
-    #     h = M[:,0]
-    #     k = M[:,1]
-
-    #     # Store in a PointList
-    #     coords = [('qx',float),('qy',float),('h',int),('k',int)]
-    #     temp_array = np.zeros([], dtype = coords)
-    #     bragg_directions = PointList(data = temp_array)
-    #     bragg_directions.add_data_by_field((gx,gy,h,k))
-
-    #     return h,k, bragg_directions
-
-    # def add_indices_to_braggvectors(
-    #     braggpeaks, lattice, maxPeakSpacing, qx_shift=0, qy_shift=0, mask=None
-    # ):
-    #     """
-    #     Using the peak positions (qx,qy) and indices (h,k) in the PointList lattice,
-    #     identify the indices for each peak in the PointListArray braggpeaks.
-    #     Return a new braggpeaks_indexed PointListArray, containing a copy of braggpeaks plus
-    #     three additional data columns -- 'h','k', and 'index_mask' -- specifying the peak
-    #     indices with the ints (h,k) and indicating whether the peak was successfully indexed
-    #     or not with the bool index_mask. If `mask` is specified, only the locations where
-    #     mask is True are indexed.
-
-    #     Args:
-    #         braggpeaks (PointListArray): the braggpeaks to index. Must contain
-    #             the coordinates 'qx', 'qy', and 'intensity'
-    #         lattice (PointList): the positions (qx,qy) of the (h,k) lattice points.
-    #             Must contain the coordinates 'qx', 'qy', 'h', and 'k'
-    #         maxPeakSpacing (float): Maximum distance from the ideal lattice points
-    #             to include a peak for indexing
-    #         qx_shift,qy_shift (number): the shift of the origin in the `lattice` PointList
-    #             relative to the `braggpeaks` PointListArray
-    #         mask (bool): Boolean mask, same shape as the pointlistarray, indicating which
-    #             locations should be indexed. This can be used to index different regions of
-    #             the scan with different lattices
-
-    #     Returns:
-    #         (PointListArray): The original braggpeaks pointlistarray, with new coordinates
-    #         'h', 'k', containing the indices of each indexable peak.
-    #     """
-
-    #     assert isinstance(braggpeaks, PointListArray)
-    #     assert np.all(
-    #         [name in braggpeaks.dtype.names for name in ("qx", "qy", "intensity")]
-    #     )
-    #     assert isinstance(lattice, PointList)
-    #     assert np.all([name in lattice.dtype.names for name in ("qx", "qy", "h", "k")])
-
-    #     if mask is None:
-    #         mask = np.ones(braggpeaks.shape, dtype=bool)
-
-    #     assert mask.shape == braggpeaks.shape, "mask must have same shape as pointlistarray"
-    #     assert mask.dtype == bool, "mask must be boolean"
-
-    #     indexed_braggpeaks = braggpeaks.copy()
-
-    #     # add the coordinates if they don't exist
-    #     if not ("h" in braggpeaks.dtype.names):
-    #         indexed_braggpeaks = indexed_braggpeaks.add_fields([("h", int)])
-    #     if not ("k" in braggpeaks.dtype.names):
-    #         indexed_braggpeaks = indexed_braggpeaks.add_fields([("k", int)])
-
-    #     # loop over all the scan positions
-    #     for Rx, Ry in tqdmnd(mask.shape[0], mask.shape[1]):
-    #         if mask[Rx, Ry]:
-    #             pl = indexed_braggpeaks.get_pointlist(Rx, Ry)
-    #             rm_peak_mask = np.zeros(pl.length, dtype=bool)
-
-    #             for i in range(pl.length):
-    #                 r2 = (pl.data["qx"][i] - lattice.data["qx"] + qx_shift) ** 2 + (
-    #                     pl.data["qy"][i] - lattice.data["qy"] + qy_shift
-    #                 ) ** 2
-    #                 ind = np.argmin(r2)
-    #                 if r2[ind] <= maxPeakSpacing**2:
-    #                     pl.data["h"][i] = lattice.data["h"][ind]
-    #                     pl.data["k"][i] = lattice.data["k"][ind]
-    #                 else:
-    #                     rm_peak_mask[i] = True
-    #             pl.remove(rm_peak_mask)
-
-    #     indexed_braggpeaks.name = braggpeaks.name + "_indexed"
-    #     return indexed_braggpeaks
-
     # IO methods
 
     # read
diff --git a/py4DSTEM/visualize/overlay.py b/py4DSTEM/visualize/overlay.py
index e0c87a427..7e7147a15 100644
--- a/py4DSTEM/visualize/overlay.py
+++ b/py4DSTEM/visualize/overlay.py
@@ -437,7 +437,7 @@ def add_bragg_index_labels(ax,d):
     Adds labels for indexed bragg directions to a plot, using the parameters in dict d.
 
     The dictionary d has required and optional parameters as follows:
-        braggdirections (req'd) (PointList) the Bragg directions. This PointList must have
+        bragg_directions (req'd) (PointList) the Bragg directions. This PointList must have
                         the fields 'qx','qy','h', and 'k', and may optionally have 'l'
         voffset         (number) vertical offset for the labels
         hoffset         (number) horizontal offset for the labels
@@ -450,12 +450,12 @@ def add_bragg_index_labels(ax,d):
     # handle inputs
     assert isinstance(ax,Axes)
     # bragg directions
-    assert('braggdirections' in d.keys())
-    braggdirections = d['braggdirections']
-    assert isinstance(braggdirections,PointList)
+    assert('bragg_directions' in d.keys())
+    bragg_directions = d['bragg_directions']
+    assert isinstance(bragg_directions,PointList)
     for k in ('qx','qy','h','k'):
-        assert k in braggdirections.data.dtype.fields
-    include_l = True if 'l' in braggdirections.data.dtype.fields else False
+        assert k in bragg_directions.data.dtype.fields
+    include_l = True if 'l' in bragg_directions.data.dtype.fields else False
     # offsets
     hoffset = d['hoffset'] if 'hoffset' in d.keys() else 0
     voffset = d['voffset'] if 'voffset' in d.keys() else 5
@@ -474,20 +474,20 @@ def add_bragg_index_labels(ax,d):
 
     # add the points
     if points:
-        ax.scatter(braggdirections.data['qy'],braggdirections.data['qx'],
+        ax.scatter(bragg_directions.data['qy'],bragg_directions.data['qx'],
                    color=pointcolor,s=pointsize)
 
     # add index labels
-    for i in range(braggdirections.length):
-        x,y = braggdirections.data['qx'][i],braggdirections.data['qy'][i]
+    for i in range(bragg_directions.length):
+        x,y = bragg_directions.data['qx'][i],bragg_directions.data['qy'][i]
         x -= voffset
         y += hoffset
-        h,k = braggdirections.data['h'][i],braggdirections.data['k'][i]
+        h,k = bragg_directions.data['h'][i],bragg_directions.data['k'][i]
         h = str(h) if h>=0 else r'$\overline{{{}}}$'.format(np.abs(h))
         k = str(k) if k>=0 else r'$\overline{{{}}}$'.format(np.abs(k))
         s = h+','+k
         if include_l:
-            l = braggdirections.data['l'][i]
+            l = bragg_directions.data['l'][i]
             l = str(l) if l>=0 else r'$\overline{{{}}}$'.format(np.abs(l))
             s += l
         ax.text(y,x,s,color=color,size=size,ha='center',va='bottom')

From 8263e09a3127208c1a68c5c6fbae16e5a8a12569 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Mon, 17 Jul 2023 12:14:55 -0400
Subject: [PATCH 346/362] bugfix

---
 py4DSTEM/process/strain.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index 247b60a06..c76b429fa 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -364,7 +364,7 @@ def fit_lattice_vectors(
 
         bragg_vectors_indexed = add_indices_to_braggvectors(
             self.braggvectors,
-            self.bragg_directions,
+            self.braggdirections,
             maxPeakSpacing=max_peak_spacing,
             qx_shift=self.braggvectors.Qshape[0] / 2,
             qy_shift=self.braggvectors.Qshape[1] / 2,

From cc654863611c8152963cfef8042c57f4462e5cbb Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Mon, 17 Jul 2023 09:39:54 -0700
Subject: [PATCH 347/362] another origin fix

---
 py4DSTEM/process/calibration/origin.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/py4DSTEM/process/calibration/origin.py b/py4DSTEM/process/calibration/origin.py
index 2b4138a74..8821b43d0 100644
--- a/py4DSTEM/process/calibration/origin.py
+++ b/py4DSTEM/process/calibration/origin.py
@@ -134,14 +134,14 @@ def fit_origin(
 
         # Fit data
         if mask is None:
-            popt_x, pcov_x, qx0_fit, _ = fit_2D(
+            popt_x, pcov_x, qx0_fit = fit_2D(
                 f,
                 qx0_meas,
                 robust=robust,
                 robust_steps=robust_steps,
                 robust_thresh=robust_thresh,
             )
-            popt_y, pcov_y, qy0_fit, _ = fit_2D(
+            popt_y, pcov_y, qy0_fit = fit_2D(
                 f,
                 qy0_meas,
                 robust=robust,
@@ -150,7 +150,7 @@ def fit_origin(
             )
 
         else:
-            popt_x, pcov_x, qx0_fit, _ = fit_2D(
+            popt_x, pcov_x, qx0_fit = fit_2D(
                 f,
                 qx0_meas,
                 robust=robust,
@@ -158,7 +158,7 @@ def fit_origin(
                 robust_thresh=robust_thresh,
                 data_mask=mask == True,
             )
-            popt_y, pcov_y, qy0_fit, _ = fit_2D(
+            popt_y, pcov_y, qy0_fit = fit_2D(
                 f,
                 qy0_meas,
                 robust=robust,

From 999a5ab78e8b9e76e3b034134d10c9305e700966 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Mon, 17 Jul 2023 12:55:59 -0700
Subject: [PATCH 348/362] flake fix

---
 py4DSTEM/process/strain.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/process/strain.py b/py4DSTEM/process/strain.py
index c76b429fa..db252f75b 100644
--- a/py4DSTEM/process/strain.py
+++ b/py4DSTEM/process/strain.py
@@ -380,7 +380,7 @@ def fit_lattice_vectors(
         self.g1g2_map = g1g2_map
 
         if returncalc:
-            bragg_directions, bragg_vectors_indexed, g1g2_map
+            braggdirections, bragg_vectors_indexed, g1g2_map
 
     def get_strain(
         self, mask=None, g_reference=None, flip_theta=False, returncalc=False, **kwargs

From 8316bc05501d2095295495b949d84f6e2e1b3e7d Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 18 Jul 2023 12:26:09 -0400
Subject: [PATCH 349/362] attempt to resolve dev/strain conflicts

---
 py4DSTEM/process/polar/__init__.py       | 1 +
 py4DSTEM/process/polar/polar_datacube.py | 1 -
 py4DSTEM/process/polar/polar_fits.py     | 1 -
 3 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/py4DSTEM/process/polar/__init__.py b/py4DSTEM/process/polar/__init__.py
index ddf0a9e50..a63afff5e 100644
--- a/py4DSTEM/process/polar/__init__.py
+++ b/py4DSTEM/process/polar/__init__.py
@@ -1,3 +1,4 @@
 from py4DSTEM.process.polar.polar_datacube import PolarDatacube
 from py4DSTEM.process.polar.polar_fits import fit_amorphous_ring, plot_amorphous_ring
 from py4DSTEM.process.polar.polar_peaks import find_peaks_single_pattern, find_peaks, refine_peaks, plot_radial_peaks, plot_radial_background, make_orientation_histogram
+
diff --git a/py4DSTEM/process/polar/polar_datacube.py b/py4DSTEM/process/polar/polar_datacube.py
index 24e6aaf40..a4bfad383 100644
--- a/py4DSTEM/process/polar/polar_datacube.py
+++ b/py4DSTEM/process/polar/polar_datacube.py
@@ -3,7 +3,6 @@
 from scipy.ndimage import binary_opening,binary_closing, gaussian_filter1d
 
 
-
 class PolarDatacube:
 
     """
diff --git a/py4DSTEM/process/polar/polar_fits.py b/py4DSTEM/process/polar/polar_fits.py
index 9d7e50290..5802ff94a 100644
--- a/py4DSTEM/process/polar/polar_fits.py
+++ b/py4DSTEM/process/polar/polar_fits.py
@@ -1,4 +1,3 @@
-
 import numpy as np
 import matplotlib.pyplot as plt
 # from scipy.optimize import leastsq

From f8b7178dfc31e50c78cfc8f8ddb86a3a451b1f37 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Tue, 18 Jul 2023 09:30:33 -0700
Subject: [PATCH 350/362] test for crystal_ACOM

---
 py4DSTEM/process/diffraction/crystal_ACOM.py | 48 ++++++++++++++++++--
 1 file changed, 44 insertions(+), 4 deletions(-)

diff --git a/py4DSTEM/process/diffraction/crystal_ACOM.py b/py4DSTEM/process/diffraction/crystal_ACOM.py
index 4d02dcb0b..bffa5b620 100644
--- a/py4DSTEM/process/diffraction/crystal_ACOM.py
+++ b/py4DSTEM/process/diffraction/crystal_ACOM.py
@@ -8,6 +8,8 @@
 from py4DSTEM.process.diffraction.utils import Orientation, OrientationMap, axisEqual3D
 from py4DSTEM.process.utils import electron_wavelength_angstrom
 
+from warnings import warn
+
 from numpy.linalg import lstsq
 try:
     import cupy as cp
@@ -767,6 +769,18 @@ def match_orientations(
         num_x=bragg_peaks_array.shape[0],
         num_y=bragg_peaks_array.shape[1],
         num_matches=num_matches_return)
+    
+    #check cal state
+    if bragg_peaks_array.calstate['ellipse'] == False:
+        ellipse = False
+        warn('Warning: bragg peaks not elliptically calibrated')
+    else:
+        ellipse = True
+    if bragg_peaks_array.calstate['rotate'] == False:
+        rotate = False
+        warn('bragg peaks not rotationally calibrated')
+    else:
+        rotate = True
 
     for rx, ry in tqdmnd(
         *bragg_peaks_array.shape,
@@ -774,9 +788,17 @@ def match_orientations(
         unit=" PointList",
         disable=not progress_bar,
     ):
+        vectors = bragg_peaks_array.get_vectors(
+            scan_x=rx,
+            scan_y=ry,
+            center=True,
+            ellipse=ellipse,
+            pixel=True,
+            rotate=rotate
+        )
 
         orientation = self.match_single_pattern(
-            bragg_peaks_array.cal[rx, ry],
+            bragg_peaks=vectors,
             num_matches_return=num_matches_return,
             min_number_peaks=min_number_peaks,
             inversion_symmetry=inversion_symmetry,
@@ -1639,6 +1661,18 @@ def calculate_strain(
         corr_kernel_size = self.orientation_kernel_size
     radius_max_2 = corr_kernel_size**2
 
+    #check cal state
+    if bragg_peaks_array.calstate['ellipse'] == False:
+        ellipse = False
+        warn('bragg peaks not elliptically calibrated')
+    else:
+        ellipse = True
+    if bragg_peaks_array.calstate['rotate'] == False:
+        rotate = False
+        warn('bragg peaks not rotationally calibrated')
+    else:
+        rotate = True
+
     # Loop over all probe positions
     for rx, ry in tqdmnd(
         *bragg_peaks_array.shape,
@@ -1647,7 +1681,14 @@ def calculate_strain(
         disable=not progress_bar,
         ):
         # Get bragg peaks from experiment and reference
-        p = bragg_peaks_array.cal[rx,ry]
+        p = bragg_peaks_array.get_vectors(
+            scan_x=rx,
+            scan_y=ry,
+            center=True,
+            ellipse=ellipse,
+            pixel=True,
+            rotate=rotate
+        )
 
         if p.data.shape[0] >= min_num_peaks:
             p_ref = self.generate_diffraction_pattern(
@@ -2070,5 +2111,4 @@ def symmetry_reduce_directions(
 }
 
     # "-3m": ["fiber", [0, 0, 1], [90.0, 60.0]],
-    # "-3m": ["fiber", [0, 0, 1], [180.0, 30.0]],
-
+    # "-3m": ["fiber", [0, 0, 1], [180.0, 30.0]],
\ No newline at end of file

From 763ef479133ef6f919ed06512aaba6fe460393e3 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Tue, 18 Jul 2023 09:35:19 -0700
Subject: [PATCH 351/362] ACOM

---
 .../process/diffraction/crystal_calibrate.py  | 35 +++++++----
 py4DSTEM/process/diffraction/crystal_viz.py   | 61 +++++++++++++------
 py4DSTEM/process/diffraction/flowlines.py     |  4 +-
 3 files changed, 65 insertions(+), 35 deletions(-)

diff --git a/py4DSTEM/process/diffraction/crystal_calibrate.py b/py4DSTEM/process/diffraction/crystal_calibrate.py
index 2d08cd03c..1b65480f5 100644
--- a/py4DSTEM/process/diffraction/crystal_calibrate.py
+++ b/py4DSTEM/process/diffraction/crystal_calibrate.py
@@ -24,7 +24,7 @@ def calibrate_pixel_size(
         k_step = 0.002,
         k_broadening = 0.002,
         fit_all_intensities = True,
-        set_calibration = True,
+        set_calibration_in_place = False,
         verbose = True,
         plot_result = False,
         figsize: Union[list, tuple, np.ndarray] = (12, 6),
@@ -60,8 +60,13 @@ def calibrate_pixel_size(
         figsize (list, tuple, np.ndarray): Figure size of the plot.
         returnfig (bool): Return handles figure and axis
 
-    Returns:
-        fig, ax (handles): Optional figure and axis handles, if returnfig=True.
+    Returns
+    _______
+
+    
+
+    fig, ax: handles, optional 
+        Figure and axis handles, if returnfig=True.
 
     """
 
@@ -112,17 +117,21 @@ def fit_profile(k, *coefs):
 
     # Get the answer
     pix_size_prev = bragg_peaks.calibration.get_Q_pixel_size()
-    ans = pix_size_prev / scale_pixel_size
+    pixel_size_new = pix_size_prev / scale_pixel_size
 
-    # if requested, apply calibrations
-    if set_calibration:
-        bragg_peaks.calibration.set_Q_pixel_size( ans )
+    # if requested, apply calibrations in place
+    if set_calibration_in_place:
+        bragg_peaks.calibration.set_Q_pixel_size( pixel_size_new )
         bragg_peaks.calibration.set_Q_pixel_units('A^-1')
-        bragg_peaks.setcal()
 
-    # Output
+    # Output calibrated Bragg peaks
+    bragg_peaks_cali = bragg_peaks.copy()
+    bragg_peaks_cali.calibration.set_Q_pixel_size( pixel_size_new )
+    bragg_peaks_cali.calibration.set_Q_pixel_units('A^-1')
+
+    # Output pixel size
     if verbose:
-        print(f"Calibrated pixel size = {np.round(ans, decimals=8)} A^-1")
+        print(f"Calibrated pixel size = {np.round(pixel_size_new, decimals=8)} A^-1")
 
     # Plotting
     if plot_result:
@@ -163,9 +172,9 @@ def fit_profile(k, *coefs):
 
     # return
     if returnfig and plot_result:
-        return ans, (fig,ax)
+        return bragg_peaks_cali, (fig,ax)
     else:
-        return ans
+        return bragg_peaks_cali
 
 
 
@@ -463,4 +472,4 @@ def fitfun(self, k, *coefs_fit):
     "432": [[0, 0, 0, 3, 3, 3], [True, True, True, False, False, False]], #Cubic
     "-43m": [[0, 0, 0, 3, 3, 3], [True, True, True, False, False, False]], #Cubic
     "m-3m": [[0, 0, 0, 3, 3, 3], [True, True, True, False, False, False]], #Cubic
-    }
+    }
\ No newline at end of file
diff --git a/py4DSTEM/process/diffraction/crystal_viz.py b/py4DSTEM/process/diffraction/crystal_viz.py
index a6074e714..a9420fee4 100644
--- a/py4DSTEM/process/diffraction/crystal_viz.py
+++ b/py4DSTEM/process/diffraction/crystal_viz.py
@@ -296,30 +296,48 @@ def plot_scattering_intensity(
     bragg_k_power=0.0,
     bragg_intensity_power=1.0,
     bragg_k_broadening=0.005,
-    figsize: Union[list, tuple, np.ndarray] = (12, 6),
+    figsize: Union[list, tuple, np.ndarray] = (10, 4),
     returnfig: bool = False,
 ):
     """
     1D plot of the structure factors
 
-    Args:
-        k_min (float):                      min k value for profile range.
-        k_max (float):                      max k value for profile range.
-        k_step (float):                     step size of k in profile range.
-        k_broadening (float):               Broadening of simulated pattern.
-        k_power_scale (float):              Scale SF intensities by k**k_power_scale.
-        int_power_scale (float):            Scale SF intensities**int_power_scale.
-        int_scale (float):                  Scale output profile by this value.
-        remove_origin (bool):               Remove origin from plot.
-        bragg_peaks (BraggVectors):         Passed in bragg_peaks for comparison with simulated pattern.
-        bragg_k_power (float):              bragg_peaks scaled by k**bragg_k_power.
-        bragg_intensity_power (float):      bragg_peaks scaled by intensities**bragg_intensity_power.
-        bragg_k_broadening float):          Broadening applied to bragg_peaks.
-        figsize (list, tuple, np.ndarray):  Figure size for plot.
-        returnfig (bool):                   Return figure and axes handles if this is True.
-
-    Returns:
-        fig, ax                     (optional) figure and axes handles
+    Parameters
+    --------
+
+    k_min: float                      
+        min k value for profile range.
+    k_max: float                      
+        max k value for profile range.
+    k_step: float                     
+        Step size of k in profile range.
+    k_broadening: float               
+        Broadening of simulated pattern.
+    k_power_scale: float              
+        Scale SF intensities by k**k_power_scale.
+    int_power_scale: float            
+        Scale SF intensities**int_power_scale.
+    int_scale: float                  
+        Scale output profile by this value.
+    remove_origin: bool               
+        Remove origin from plot.
+    bragg_peaks: BraggVectors         
+        Passed in bragg_peaks for comparison with simulated pattern.
+    bragg_k_power: float              
+        bragg_peaks scaled by k**bragg_k_power.
+    bragg_intensity_power: float      
+        bragg_peaks scaled by intensities**bragg_intensity_power.
+    bragg_k_broadening: float  
+        Broadening applied to bragg_peaks.
+    figsize: list, tuple, np.ndarray
+        Figure size for plot.
+    returnfig (bool):                   
+        Return figure and axes handles if this is True.
+
+    Returns
+    --------
+    fig, ax (optional) 
+        figure and axes handles
     """
 
     # k coordinates
@@ -916,6 +934,9 @@ def plot_diffraction_pattern(
     ax.set_ylabel("$q_x$ [Å$^{-1}$]")
 
     if plot_range_kx_ky is not None:
+        plot_range_kx_ky = np.array(plot_range_kx_ky)
+        if plot_range_kx_ky.ndim == 0:
+            plot_range_kx_ky = np.array((plot_range_kx_ky,plot_range_kx_ky))
         ax.set_xlim((-plot_range_kx_ky[0], plot_range_kx_ky[0]))
         ax.set_ylim((-plot_range_kx_ky[1], plot_range_kx_ky[1]))
     else:
@@ -1859,4 +1880,4 @@ def plot_ring_pattern(
         plt.show()
 
     if returnfig:
-        return fig, ax
+        return fig, ax
\ No newline at end of file
diff --git a/py4DSTEM/process/diffraction/flowlines.py b/py4DSTEM/process/diffraction/flowlines.py
index c2fa224fa..a483740ff 100644
--- a/py4DSTEM/process/diffraction/flowlines.py
+++ b/py4DSTEM/process/diffraction/flowlines.py
@@ -15,7 +15,7 @@
 
 
 def make_orientation_histogram(
-    bragg_peaks: PointList = None,
+    bragg_peaks: PointListArray = None,
     radial_ranges: np.ndarray = None,
     orientation_map = None,
     orientation_ind: int = 0,
@@ -1143,4 +1143,4 @@ def set_intensity(orient,xy_t_int):
         mode=['clip','clip','wrap'])
     orient.ravel()[inds_1D] = orient.ravel()[inds_1D] + xy_t_int[:,3]*(  dx)*(  dy)*(  dt)
 
-    return orient
+    return orient
\ No newline at end of file

From 542470986f4a970bb3669bc9f2d3a64771208cb0 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Tue, 18 Jul 2023 09:39:43 -0700
Subject: [PATCH 352/362] polar

---
 py4DSTEM/process/polar/__init__.py       |  3 +-
 py4DSTEM/process/polar/polar_datacube.py | 89 +++++++++++++++---------
 py4DSTEM/process/polar/polar_fits.py     | 40 ++++++++---
 3 files changed, 88 insertions(+), 44 deletions(-)

diff --git a/py4DSTEM/process/polar/__init__.py b/py4DSTEM/process/polar/__init__.py
index a63afff5e..79e13a054 100644
--- a/py4DSTEM/process/polar/__init__.py
+++ b/py4DSTEM/process/polar/__init__.py
@@ -1,4 +1,3 @@
 from py4DSTEM.process.polar.polar_datacube import PolarDatacube
 from py4DSTEM.process.polar.polar_fits import fit_amorphous_ring, plot_amorphous_ring
-from py4DSTEM.process.polar.polar_peaks import find_peaks_single_pattern, find_peaks, refine_peaks, plot_radial_peaks, plot_radial_background, make_orientation_histogram
-
+from py4DSTEM.process.polar.polar_peaks import find_peaks_single_pattern, find_peaks, refine_peaks, plot_radial_peaks, plot_radial_background, make_orientation_histogram
\ No newline at end of file
diff --git a/py4DSTEM/process/polar/polar_datacube.py b/py4DSTEM/process/polar/polar_datacube.py
index 196d1e02d..cb206c961 100644
--- a/py4DSTEM/process/polar/polar_datacube.py
+++ b/py4DSTEM/process/polar/polar_datacube.py
@@ -3,6 +3,7 @@
 from scipy.ndimage import binary_opening,binary_closing, gaussian_filter1d
 
 
+
 class PolarDatacube:
 
     """
@@ -20,7 +21,7 @@ def __init__(
         mask = None,
         mask_thresh = 0.1,
         ellipse = True,
-        two_fold_rotation = False,
+        two_fold_symmetry = False,
         ):
         """
         Parameters
@@ -28,14 +29,15 @@ def __init__(
         datacube : DataCube
             The datacube in cartesian coordinates
         qmin : number
-            Minumum radius of the polar transformation
+            Minumum radius of the polar transformation, in pixels
         qmax : number or None
-            Maximum radius of the polar transformation
+            Maximum radius of the polar transformation, in pixels
         qstep : number
-            Width of radial bins
+            Width of radial bins, in pixels
         n_annular : integer
             Number of bins in the annular direction. Bins will each
-            have a width of 360/num_annular_bins, in degrees
+            have a width of 360/n_annular, or 180/n_annular if
+            two_fold_rotation is set to True, in degrees
         qscale : number or None
             Radial scaling power to apply to polar transform
         mask : boolean array
@@ -48,9 +50,10 @@ def __init__(
             performs an elliptic transform iff elliptic calibrations are
             available.
         two_fold_rotation : bool
-            Setting to True computes the transform mod(theta,pi), i.e. assumes all patterns
-            posess two-fold rotation (Friedel symmetry).  The output angular range in this case
-            becomes [0, pi) as opposed to the default of [0,2*pi).
+            Setting to True computes the transform mod(theta,pi), i.e. assumes
+            all patterns possess two-fold rotation (Friedel symmetry).  The
+            output angular range in this case becomes [0, pi) as opposed to the
+            default of [0,2*pi).
         """
 
         # attach datacube
@@ -67,17 +70,12 @@ def __init__(
 
         # setup sampling
 
-        # annular range, depending on if polar transform spans pi or 2*pi
-        if two_fold_rotation:
-            self._annular_range = np.pi
-        else:
-            self._annular_range = 2.0 * np.pi
-
         # polar
         self._qscale = qscale
         if qmax is None:
             qmax = np.min(self._datacube.Qshape) / np.sqrt(2)
-        self.set_annular_bins(n_annular)
+        self._n_annular = n_annular
+        self.two_fold_symmetry = two_fold_symmetry #implicitly calls set_annular_bins
         self.set_radial_bins(qmin,qmax,qstep)
 
         # cartesian
@@ -101,6 +99,16 @@ def __init__(
         plot_FEM_global,
         calculate_FEM_local,
     )
+    from py4DSTEM.process.polar.polar_peaks import (
+        find_peaks_single_pattern,
+        find_peaks,
+        refine_peaks_local,
+        refine_peaks,
+        plot_radial_peaks,
+        plot_radial_background,
+        model_radial_background,
+        make_orientation_histogram,
+    )
 
 
     # sampling methods + properties
@@ -176,6 +184,18 @@ def annular_bins(self):
     @property
     def annular_step(self):
         return self._annular_step
+    @property
+    def two_fold_symmetry(self):
+        return self._two_fold_symmetry
+    @two_fold_symmetry.setter
+    def two_fold_symmetry(self,x):
+        assert(isinstance(x,bool)), f"two_fold_symmetry must be boolean, not type {type(x)}"
+        self._two_fold_symmetry = x
+        if x:
+            self._annular_range = np.pi
+        else:
+            self._annular_range = 2 * np.pi
+        self.set_annular_bins(self._n_annular)
 
     @property
     def n_annular(self):
@@ -195,8 +215,22 @@ def set_polar_shape(self):
             # set KDE params
             self._annular_bin_step = 1 / (self._annular_step * (self.radial_bins + self.qstep * 0.5))
             self._sigma_KDE = self._annular_bin_step * 0.5
+            # set array indices
+            self._annular_indices = np.arange(self.polar_shape[0]).astype(int)
+            self._radial_indices = np.arange(self.polar_shape[1]).astype(int)
 
 
+    # coordinate grid properties
+    @property
+    def tt(self):
+        return self._annular_bins
+    @property
+    def tt_deg(self):
+        return self._annular_bins * 180/np.pi
+    @property
+    def qq(self):
+        return self.radial_bins * self.calibration.get_Q_pixel_size()
+
 
 
     # scaling property
@@ -442,6 +476,7 @@ def _transform(
             )
             return ans
         elif returnval == 'nan':
+            ans[mask_bool] = np.nan
             return ans
         elif returnval == 'all':
             return ans, ans_norm, norm_array, mask_bool
@@ -472,7 +507,7 @@ def _transform_array(
             # get polar coords
             rr = np.sqrt(x**2 + y**2)
             tt = np.mod(
-                np.arctan2(y, x) - np.pi/2,
+                np.arctan2(y, x),
                 self._polarcube._annular_range)
 
         # elliptical
@@ -480,21 +515,12 @@ def _transform_array(
             # unpack ellipse
             a,b,theta = ellipse
 
-            # transformation matrix (elliptic cartesian -> circular cartesian)
-            A = (a/b)*np.cos(theta)
-            B = -np.sin(theta)
-            C = (a/b)*np.sin(theta)
-            D = np.cos(theta)
-            det = 1 / (A*D - B*C)
-
-            # get circular cartesian coords
-            xc =  x*D - y*B
-            yc = -x*C + y*A
-
-            # get polar coords
-            rr = det * np.hypot(xc,yc)
+            # Get polar coords
+            xc = x*np.cos(theta) + y*np.sin(theta)
+            yc = (y*np.cos(theta) - x*np.sin(theta))*(a/b)
+            rr = (b/a) * np.hypot(xc,yc)
             tt = np.mod(
-                np.arctan2(yc,xc) - np.pi/2,
+                np.arctan2(yc,xc) + theta,
                 self._polarcube._annular_range)
 
         # transform to bin sampling
@@ -562,5 +588,4 @@ def __repr__(self):
         space = ' '*len(self.__class__.__name__)+'  '
         string = f"{self.__class__.__name__}( "
         string += "Retrieves the diffraction pattern at scan position (x,y) in polar coordinates when sliced with [x,y]."
-        return string
-
+        return string
\ No newline at end of file
diff --git a/py4DSTEM/process/polar/polar_fits.py b/py4DSTEM/process/polar/polar_fits.py
index a4fdaaa2b..b92b2b7ba 100644
--- a/py4DSTEM/process/polar/polar_fits.py
+++ b/py4DSTEM/process/polar/polar_fits.py
@@ -1,3 +1,4 @@
+
 import numpy as np
 import matplotlib.pyplot as plt
 # from scipy.optimize import leastsq
@@ -6,13 +7,14 @@
 
 def fit_amorphous_ring(
     im,
-    center,
-    radial_range,
+    center = None,
+    radial_range = None,
     coefs = None,
+    mask_dp = None,
     show_fit_mask = False,
     verbose = False,
     plot_result = True,
-    plot_log_scale = True,
+    plot_log_scale = False,
     plot_int_scale = (-3,3),
     figsize = (8,8),
     return_all_coefs = True,
@@ -26,9 +28,15 @@ def fit_amorphous_ring(
     im: np.array
         2D image array to perform fitting on
     center: np.array
-        (x,y) center coordinates for fitting mask
+        (x,y) center coordinates for fitting mask. If not specified 
+        by the user, we will assume the center coordinate is (im.shape-1)/2.
     radial_range: np.array
-        (radius_inner, radius_outer) radial range to perform fitting over
+        (radius_inner, radius_outer) radial range to perform fitting over.
+        If not specified by the user, we will assume (im.shape[0]/4,im.shape[0]/2).
+    coefs: np.array (optional)
+        Array containing initial fitting coefficients for the amorphous fit.
+    mask_dp: np.array
+        Dark field mask for fitting, in addition to the radial range specified above.
     show_fit_mask: bool
         Set to true to preview the fitting mask and initial guess for the ellipse params
     verbose: bool
@@ -52,6 +60,14 @@ def fit_amorphous_ring(
         11 parameter elliptic fit coefficients
     """
 
+    # Default values
+    if center is None:
+        center = np.array((
+            (im.shape[0]-1)/2,
+            (im.shape[1]-1)/2))
+    if radial_range is None:
+        radial_range = (im.shape[0]/4, im.shape[0]/2)
+
     # coordinates
     xa,ya = np.meshgrid(
         np.arange(im.shape[0]),
@@ -65,6 +81,9 @@ def fit_amorphous_ring(
         ra2 >= radial_range[0]**2,
         ra2 <= radial_range[1]**2,
         )
+    if mask_dp is not None:
+        # Logical AND the radial mask with the user-provided mask
+        mask = np.logical_and(mask, mask_dp)
     vals = im[mask]
     basis = np.vstack((xa[mask],ya[mask]))
 
@@ -117,9 +136,11 @@ def fit_amorphous_ring(
             int_range = (
                 int_med + plot_int_scale[0]*int_std, 
                 int_med + plot_int_scale[1]*int_std)
-            im_plot = np.tile(np.clip(
-                (np.log(im[:,:,None]) - int_range[0]) / (int_range[1] - int_range[0]),
-                0,1),(1,1,3))
+            im_plot = np.tile(
+                np.clip(
+                    (np.log(im[:,:,None]) - int_range[0]) / (int_range[1] - int_range[0]),
+                    0,1),
+                (1,1,3))
 
         else:
             int_med = np.median(vals)
@@ -345,5 +366,4 @@ def amorphous_model(basis, *coefs):
     sub = np.logical_not(sub)
     int_model[sub] += int12*np.exp(dr2[sub]/(-2*sigma2**2))
 
-    return int_model
-
+    return int_model
\ No newline at end of file

From fd7c50e6d218810ee3e5bd4bfe16d9844039e596 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Tue, 18 Jul 2023 09:40:18 -0700
Subject: [PATCH 353/362] multislice

---
 py4DSTEM/process/phase/iterative_multislice_ptychography.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/py4DSTEM/process/phase/iterative_multislice_ptychography.py b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
index 1e9bd2cbb..92f8c0bf3 100644
--- a/py4DSTEM/process/phase/iterative_multislice_ptychography.py
+++ b/py4DSTEM/process/phase/iterative_multislice_ptychography.py
@@ -974,7 +974,7 @@ def _gradient_descent_adjoint(
                 )
 
             # back-transmit
-            exit_waves *= xp.conj(obj) / xp.abs(obj) ** 2
+            exit_waves *= xp.conj(obj) #/ xp.abs(obj) ** 2
 
             if s > 0:
                 # back-propagate
@@ -1076,7 +1076,7 @@ def _projection_sets_adjoint(
                 )
 
             # back-transmit
-            exit_waves_copy *= xp.conj(obj) / xp.abs(obj) ** 2
+            exit_waves_copy *= xp.conj(obj) # / xp.abs(obj) ** 2
 
             if s > 0:
                 # back-propagate
@@ -3067,4 +3067,4 @@ def _return_object_fft(
             obj = np.angle(obj)
 
         obj = self._crop_rotate_object_fov(np.sum(obj, axis=0))
-        return np.abs(np.fft.fftshift(np.fft.fft2(np.fft.ifftshift(obj))))
+        return np.abs(np.fft.fftshift(np.fft.fft2(np.fft.ifftshift(obj))))
\ No newline at end of file

From 387a581a6afc9a93462e50611d4c5501a77ea6e5 Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Tue, 18 Jul 2023 09:43:36 -0700
Subject: [PATCH 354/362] datacube

---
 py4DSTEM/datacube/datacube.py | 61 ++++++++++++++++++++++++++---------
 1 file changed, 45 insertions(+), 16 deletions(-)

diff --git a/py4DSTEM/datacube/datacube.py b/py4DSTEM/datacube/datacube.py
index 159d822ea..ae3a82a36 100644
--- a/py4DSTEM/datacube/datacube.py
+++ b/py4DSTEM/datacube/datacube.py
@@ -3,7 +3,7 @@
 import numpy as np
 from scipy.interpolate import interp1d
 from scipy.ndimage import (binary_opening, binary_dilation,
-    distance_transform_edt, binary_fill_holes, gaussian_filter1d)
+    distance_transform_edt, binary_fill_holes, gaussian_filter1d, gaussian_filter)
 from typing import Optional,Union
 
 from emdfile import Array, Metadata, Node, Root, tqdmnd
@@ -1030,8 +1030,11 @@ def find_Bragg_disks(
     def get_beamstop_mask(
         self,
         threshold = 0.25,
-        distance_edge = 4.0,
+        distance_edge = 2.0,
         include_edges = True,
+        sigma = 0,
+        use_max_dp = False,
+        scale_radial = None,
         name = "mask_beamstop",
         returncalc = True,
         ):
@@ -1046,6 +1049,12 @@ def get_beamstop_mask(
             distance_edge (float): How many pixels to expand the mask.
             include_edges (bool): If set to True, edge pixels will be included
                 in the mask.
+            sigma (float):
+                Gaussain blur std to apply to image before thresholding.
+            use_max_dp (bool):
+                Use the max DP instead of the mean DP.
+            scale_radial (float):
+                Scale from center of image by this factor (can help with edge)
             name (string): Name of the output array.
             returncalc (bool): Set to true to return the result.
 
@@ -1054,19 +1063,42 @@ def get_beamstop_mask(
 
         """
 
-        # Calculate dp_mean if needed
-        if not "dp_mean" in self._branch.keys():
-            self.get_dp_mean();
-
-        # normalized dp_mean
-        int_sort = np.sort(self.tree("dp_mean").data.ravel())
+        if scale_radial is not None:
+            x = np.arange(self.data.shape[2]) * 2.0 / self.data.shape[2]
+            y = np.arange(self.data.shape[3]) * 2.0 / self.data.shape[3]
+            ya, xa = np.meshgrid(y - np.mean(y), x - np.mean(x))
+            im_scale = 1.0 + np.sqrt(xa**2 + ya**2)*scale_radial
+
+        # Get image for beamstop mask
+        if use_max_dp:
+            # if not "dp_mean" in self.tree.keys():
+            #     self.get_dp_max();
+            # im = self.tree["dp_max"].data.astype('float')
+            if not "dp_max" in self._branch.keys():
+                self.get_dp_max();
+            im = self.tree("dp_max").data.copy().astype('float')
+        else:
+            if not "dp_mean" in self._branch.keys():
+                self.get_dp_mean();
+            im = self.tree("dp_mean").data.copy()
+
+            # if not "dp_mean" in self.tree.keys():
+            #     self.get_dp_mean();
+            # im = self.tree["dp_mean"].data.astype('float')
+
+        # smooth and scale if needed
+        if sigma > 0.0:
+            im = gaussian_filter(im, sigma, mode='nearest')
+        if scale_radial is not None:
+            im *= im_scale
+
+        # Calculate beamstop mask
+        int_sort = np.sort(im.ravel())
         ind = np.round(np.clip(
                 int_sort.shape[0]*threshold,
                 0,int_sort.shape[0])).astype('int')
         intensity_threshold = int_sort[ind]
-
-        # Use threshold to calculate initial mask
-        mask_beamstop = self.tree("dp_mean").data >= intensity_threshold
+        mask_beamstop = im >= intensity_threshold
 
         # clean up mask
         mask_beamstop = np.logical_not(binary_fill_holes(np.logical_not(mask_beamstop)))
@@ -1103,7 +1135,7 @@ def get_beamstop_mask(
         )
 
         # Add to tree
-        self.attach( mask_beamstop )
+        self.tree(x)
 
         # return
         if returncalc:
@@ -1441,7 +1473,4 @@ def get_braggmask(
         for idx in range(len(vects.data)):
             qr = np.hypot(self.qxx_raw-vects.qx[idx], self.qyy_raw-vects.qy[idx])
             mask = np.logical_and(mask, qr>radius)
-        return mask
-
-
-
+        return mask
\ No newline at end of file

From 5014f0bb7c02291605c42266b4d53f6717a97517 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 18 Jul 2023 12:43:59 -0400
Subject: [PATCH 355/362] attempt to resolve dev/strain conflicts

---
 py4DSTEM/process/calibration/origin.py | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/py4DSTEM/process/calibration/origin.py b/py4DSTEM/process/calibration/origin.py
index 0b27f5a85..19d2f0c55 100644
--- a/py4DSTEM/process/calibration/origin.py
+++ b/py4DSTEM/process/calibration/origin.py
@@ -73,11 +73,12 @@ def fit_origin(
 ):
     """
     Fits the position of the origin of diffraction space to a plane or parabola,
-    given some 2D arrays (qx0_meas,qy0_meas) of measured center positions, optionally
-    masked by the Boolean array `mask`. The 2D data arrays may be passed directly as
-    a 2-tuple to the arg `data`, or, if `data` is either a DataCube or Calibration
-    instance, they will be retreived automatically. If a DataCube or Calibration are
-    passed, fitted origin and residuals are stored there directly.
+    given some 2D arrays (qx0_meas,qy0_meas) of measured center positions,
+    optionally masked by the Boolean array `mask`. The 2D data arrays may be
+    passed directly as a 2-tuple to the arg `data`, or, if `data` is either a
+    DataCube or Calibration instance, they will be retreived automatically. If a
+    DataCube or Calibration are passed, fitted origin and residuals are stored
+    there directly.
 
     Args:
         data (2-tuple of 2d arrays): the measured origin position (qx0,qy0)
@@ -133,14 +134,14 @@ def fit_origin(
 
         # Fit data
         if mask is None:
-            popt_x, pcov_x, qx0_fit = fit_2D(
+            popt_x, pcov_x, qx0_fit, _ = fit_2D(
                 f,
                 qx0_meas,
                 robust=robust,
                 robust_steps=robust_steps,
                 robust_thresh=robust_thresh,
             )
-            popt_y, pcov_y, qy0_fit = fit_2D(
+            popt_y, pcov_y, qy0_fit, _ = fit_2D(
                 f,
                 qy0_meas,
                 robust=robust,
@@ -149,7 +150,7 @@ def fit_origin(
             )
 
         else:
-            popt_x, pcov_x, qx0_fit = fit_2D(
+            popt_x, pcov_x, qx0_fit, _ = fit_2D(
                 f,
                 qx0_meas,
                 robust=robust,
@@ -157,7 +158,7 @@ def fit_origin(
                 robust_thresh=robust_thresh,
                 data_mask=mask == True,
             )
-            popt_y, pcov_y, qy0_fit = fit_2D(
+            popt_y, pcov_y, qy0_fit, _ = fit_2D(
                 f,
                 qy0_meas,
                 robust=robust,
@@ -358,4 +359,3 @@ def get_origin_beamstop(datacube: DataCube, mask: np.ndarray, **kwargs):
     return qx0, qy0
 
 
-

From 3c2229adeaf1d568ada57eb531dd1de00fb45488 Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Tue, 18 Jul 2023 12:46:09 -0400
Subject: [PATCH 356/362] attempt to resolve dev/strain conflicts

---
 py4DSTEM/data/calibration.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/py4DSTEM/data/calibration.py b/py4DSTEM/data/calibration.py
index 48acd503e..50ec8f6f9 100644
--- a/py4DSTEM/data/calibration.py
+++ b/py4DSTEM/data/calibration.py
@@ -64,8 +64,8 @@ class Calibration(Metadata):
         theta,                                        *
         p_ellipse,                                    *
         ellipse,                                      *
-        QR_rotation_degrees,
-        QR_flip,
+        QR_rotation_degrees,                          *
+        QR_flip,                                      *
         QR_rotflip,                                   *
         probe_semiangle,
         probe_param,
@@ -598,11 +598,13 @@ def ellipse(self,x):
 
     # Q/R-space rotation and flip
 
+    @call_calibrate
     def set_QR_rotation_degrees(self,x):
         self._params['QR_rotation_degrees'] = x
     def get_QR_rotation_degrees(self):
         return self._get_value('QR_rotation_degrees')
 
+    @call_calibrate
     def set_QR_flip(self,x):
         self._params['QR_flip'] = x
     def get_QR_flip(self):

From adc0c9bea50b57ba720094c3e8f41e06b802b3da Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Tue, 18 Jul 2023 09:47:47 -0700
Subject: [PATCH 357/362] bragg vectors

---
 py4DSTEM/braggvectors/braggvectors.py | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/py4DSTEM/braggvectors/braggvectors.py b/py4DSTEM/braggvectors/braggvectors.py
index 0f62d9501..f1ff406d0 100644
--- a/py4DSTEM/braggvectors/braggvectors.py
+++ b/py4DSTEM/braggvectors/braggvectors.py
@@ -236,9 +236,16 @@ def setcal(
             "rotate" : rotate,
         }
         if self.verbose:
-            print('current calstate: ', self.calstate)
+            print('current calibration state: ', self.calstate)
         pass
 
+    def calibrate(self):
+        """
+        Autoupdate the calstate when relevant calibrations are set
+        """
+        self.setcal()
+
+
 
     # vector getter method
 
@@ -250,7 +257,7 @@ def get_vectors(
         ellipse,
         pixel,
         rotate
-    ):
+        ):
         """
         Returns the bragg vectors at the specified scan position with
         the specified calibration state.
@@ -268,6 +275,7 @@ def get_vectors(
         -------
         vectors : BVects
         """
+
         ans = self._v_uncal[scan_x,scan_y].data
         ans = self.cal._transform(
             data = ans,
@@ -282,7 +290,6 @@ def get_vectors(
 
 
     # copy
-
     def copy(self, name=None):
         name = name if name is not None else self.name+"_copy"
         braggvector_copy = BraggVectors(
@@ -526,6 +533,4 @@ def _transform(
 
 
         # return
-        return ans
-
-
+        return ans
\ No newline at end of file

From cf2ea5a8a8876fe33eb920d2fe8292b3a3ff2cfa Mon Sep 17 00:00:00 2001
From: Stephanie Ribet <stephanie.ribet@gmail.com>
Date: Tue, 18 Jul 2023 09:52:39 -0700
Subject: [PATCH 358/362] bragg vectors methods

---
 py4DSTEM/braggvectors/braggvector_methods.py | 243 ++++---------------
 1 file changed, 42 insertions(+), 201 deletions(-)

diff --git a/py4DSTEM/braggvectors/braggvector_methods.py b/py4DSTEM/braggvectors/braggvector_methods.py
index 009f5a193..be766ad49 100644
--- a/py4DSTEM/braggvectors/braggvector_methods.py
+++ b/py4DSTEM/braggvectors/braggvector_methods.py
@@ -186,7 +186,11 @@ def get_virtual_image(
         mode = None,
         geometry = None,
         name = 'bragg_virtual_image',
-        returncalc = True
+        returncalc = True,
+        center = True,
+        ellipse = True,
+        pixel = True,
+        rotate = True,
         ):
         '''
         Calculates a virtual image based on the values of the Braggvectors
@@ -204,13 +208,22 @@ def get_virtual_image(
               - 'circle', 'circular': nested 2-tuple, ((qx,qy),radius)
               - 'annular' or 'annulus': nested 2-tuple,
                 ((qx,qy),(radius_i,radius_o))
-             All values are in pixels.  Note that (qx,qy) can be skipped, which
-             assumes peaks centered at (0,0)
+             Values can be in pixels or calibrated units. Note that (qx,qy) 
+             can be skipped, which assumes peaks centered at (0,0).
+        center: bool
+            Apply calibration - center coordinate.
+        ellipse: bool
+            Apply calibration - elliptical correction.
+        pixel: bool
+            Apply calibration - pixel size.
+        rotate: bool
+            Apply calibration - QR rotation.
 
         Returns
         -------
         virtual_im : VirtualImage
         '''
+
         # parse inputs
         circle_modes = ['circular','circle']
         annulus_modes = ['annular','annulus']
@@ -220,13 +233,13 @@ def get_virtual_image(
         # set geometry
         if mode is None:
             if geometry is None:
-                center = None
+                qxy_center = None
                 radial_range = np.array((0,np.inf))
             else:
                 if len(geometry[0]) == 0:
-                    center = None
+                    qxy_center = None
                 else:
-                    center = np.array(geometry[0])
+                    qxy_center = np.array(geometry[0])
                 if isinstance(geometry[1], int) or isinstance(geometry[1], float):
                     radial_range = np.array((0,geometry[1]))
                 elif len(geometry[1]) == 0:
@@ -236,30 +249,44 @@ def get_virtual_image(
         elif mode == 'circular' or mode == 'circle':
             radial_range = np.array((0,geometry[1]))
             if len(geometry[0]) == 0:
-                    center = None
+                    qxy_center = None
             else:
-                center = np.array(geometry[0])
+                qxy_center = np.array(geometry[0])
         elif mode == 'annular' or mode == 'annulus':
             radial_range = np.array(geometry[1])
             if len(geometry[0]) == 0:
-                    center = None
+                    qxy_center = None
             else:
-                center = np.array(geometry[0])
+                qxy_center = np.array(geometry[0])
 
         # allocate space
         im_virtual = np.zeros(self.shape)
 
         # generate image
-        for rx,ry in tqdmnd(self.shape[0],self.shape[1]):
-            p = self.raw[rx,ry]
+        for rx,ry in tqdmnd(
+            self.shape[0],
+            self.shape[1],
+            ):
+            # Get user-specified Bragg vectors
+            p = self.get_vectors(
+                rx,
+                ry,
+                center = center,
+                ellipse = ellipse,
+                pixel = pixel,
+                rotate = rotate,
+                )
+
             if p.data.shape[0] > 0:
                 if radial_range is None:
                     im_virtual[rx,ry] = np.sum(p.I)
                 else:
-                    if center is None:
+                    if qxy_center is None:
                         qr = np.hypot(p.qx,p.qy)
                     else:
-                        qr = np.hypot(p.qx - center[0],p.qy - center[1])
+                        qr = np.hypot(
+                            p.qx - qxy_center[0],
+                            p.qy - qxy_center[1])
                     sub = np.logical_and(
                         qr >= radial_range[0],
                         qr <  radial_range[1])
@@ -284,7 +311,7 @@ def get_virtual_image(
             }
         )
         # attach to the tree
-        self.attach( ans)
+        self.attach(ans)
 
         # return
         if returncalc:
@@ -634,192 +661,6 @@ def fit_p_ellipse(
         if returncalc:
             return p_ellipse
 
-
-    # Deprecated??
-
-    # def index_bragg_directions(
-    #     self,
-    #     x0 = None,
-    #     y0 = None,
-    #     plot = True,
-    #     bvm_vis_params = {},
-    #     returncalc = False,
-    #     ):
-    #     """
-    #     From an origin (x0,y0), a set of reciprocal lattice vectors gx,gy, and an pair of
-    #     lattice vectors g1=(g1x,g1y), g2=(g2x,g2y), find the indices (h,k) of all the
-    #     reciprocal lattice directions.
-
-    #     Args:
-    #         x0 (float): x-coord of origin
-    #         y0 (float): y-coord of origin
-    #         Plot (bool): plot results
-    #     """
-
-    #     if x0 is None:
-    #         x0 = self.Qshape[0]/2
-    #     if y0 is None:
-    #         y0 = self.Qshape[0]/2
-
-    #     from py4DSTEM.process.latticevectors import index_bragg_directions
-    #     _, _, braggdirections = index_bragg_directions(
-    #         x0,
-    #         y0,
-    #         self.g['x'],
-    #         self.g['y'],
-    #         self.g1,
-    #         self.g2
-    #     )
-
-    #     self.braggdirections = braggdirections
-
-    #     if plot:
-    #         from py4DSTEM.visualize import show_bragg_indexing
-    #         show_bragg_indexing(
-    #             self.bvm_centered,
-    #             **bvm_vis_params,
-    #             braggdirections = braggdirections,
-    #             points = True
-    #         )
-
-    #     if returncalc:
-    #         return braggdirections
-
-
-
-    # def add_indices_to_braggvectors(
-    #     self,
-    #     maxPeakSpacing,
-    #     mask = None,
-    #     returncalc = False,
-    #     ):
-    #     """
-    #     Using the peak positions (qx,qy) and indices (h,k) in the PointList lattice,
-    #     identify the indices for each peak in the PointListArray braggpeaks.
-    #     Return a new braggpeaks_indexed PointListArray, containing a copy of braggpeaks plus
-    #     three additional data columns -- 'h','k', and 'index_mask' -- specifying the peak
-    #     indices with the ints (h,k) and indicating whether the peak was successfully indexed
-    #     or not with the bool index_mask. If `mask` is specified, only the locations where
-    #     mask is True are indexed.
-
-    #     Args:
-    #         maxPeakSpacing (float): Maximum distance from the ideal lattice points
-    #             to include a peak for indexing
-    #         qx_shift,qy_shift (number): the shift of the origin in the `lattice` PointList
-    #             relative to the `braggpeaks` PointListArray
-    #         mask (bool): Boolean mask, same shape as the pointlistarray, indicating which
-    #             locations should be indexed. This can be used to index different regions of
-    #             the scan with different lattices
-    #     """
-    #     from py4DSTEM.process.latticevectors import add_indices_to_braggvectors
-
-    #     bragg_peaks_indexed = add_indices_to_braggvectors(
-    #         self.vectors,
-    #         self.braggdirections,
-    #         maxPeakSpacing = maxPeakSpacing,
-    #         qx_shift = self.Qshape[0]/2,
-    #         qy_shift = self.Qshape[1]/2,
-    #     )
-
-    #     self.bragg_peaks_indexed = bragg_peaks_indexed
-
-    #     if returncalc:
-    #         return bragg_peaks_indexed
-
-
-    # def fit_lattice_vectors_all_DPs(self, returncalc = False):
-    #     """
-    #     Fits lattice vectors g1,g2 to each diffraction pattern in braggpeaks, given some
-    #     known (h,k) indexing.
-
-
-    #     """
-
-    #     from py4DSTEM.process.latticevectors import fit_lattice_vectors_all_DPs
-    #     g1g2_map = fit_lattice_vectors_all_DPs(self.bragg_peaks_indexed)
-    #     self.g1g2_map = g1g2_map
-    #     if returncalc:
-    #         return g1g2_map
-
-    # def get_strain_from_reference_region(self, mask, returncalc = False):
-    #     """
-    #     Gets a strain map from the reference region of real space specified by mask and the
-    #     lattice vector map g1g2_map.
-
-    #     Args:
-    #         mask (ndarray of bools): use lattice vectors from g1g2_map scan positions
-    #             wherever mask==True
-
-    #     """
-    #     from py4DSTEM.process.latticevectors import get_strain_from_reference_region
-
-    #     strainmap_median_g1g2 = get_strain_from_reference_region(
-    #         self.g1g2_map,
-    #         mask = mask,
-    #     )
-
-    #     self.strainmap_median_g1g2 = strainmap_median_g1g2
-
-    #     if returncalc:
-    #         return strainmap_median_g1g2
-
-
-    # def get_strain_from_reference_g1g2(self, mask, returncalc = False):
-    #     """
-    #     Gets a strain map from the reference lattice vectors g1,g2 and lattice vector map
-    #     g1g2_map.
-
-
-    #     Args:
-    #         mask (ndarray of bools): use lattice vectors from g1g2_map scan positions
-    #             wherever mask==True
-
-    #     """
-    #     from py4DSTEM.process.latticevectors import get_reference_g1g2
-    #     g1_ref,g2_ref = get_reference_g1g2(self.g1g2_map, mask)
-
-    #     from py4DSTEM.process.latticevectors import get_strain_from_reference_g1g2
-    #     strainmap_reference_g1g2 = get_strain_from_reference_g1g2(self.g1g2_map, g1_ref, g2_ref)
-
-    #     self.strainmap_reference_g1g2 = strainmap_reference_g1g2
-
-    #     if returncalc:
-    #         return strainmap_reference_g1g2
-
-    # def get_rotated_strain_map(self, mode, g_reference = None, returncalc = True, flip_theta = False):
-    #     """
-    #     Starting from a strain map defined with respect to the xy coordinate system of
-    #     diffraction space, i.e. where exx and eyy are the compression/tension along the Qx
-    #     and Qy directions, respectively, get a strain map defined with respect to some other
-    #     right-handed coordinate system, in which the x-axis is oriented along (xaxis_x,
-    #     xaxis_y).
-
-    #     Args:
-    #         g_referencce (tupe): reference coordinate system for xaxis_x and xaxis_y
-    #     """
-
-    #     assert mode in ("median","reference")
-    #     if g_reference is None:
-    #         g_reference = np.subtract(self.g1, self.g2)
-
-    #     from py4DSTEM.process.latticevectors import get_rotated_strain_map
-
-    #     if mode == "median":
-    #         strainmap_raw = self.strainmap_median_g1g2
-    #     elif mode == "reference":
-    #         strainmap_raw = self.strainmap_reference_g1g2
-
-    #     strainmap = get_rotated_strain_map(
-    #         strainmap_raw,
-    #         xaxis_x = g_reference[0],
-    #         xaxis_y = g_reference[1],
-    #         flip_theta = flip_theta
-    #     )
-
-    #     if returncalc:
-    #         return strainmap
-
-
     def mask_in_Q(
         self,
         mask,

From 88adba34957b9afabdbb32112f5aa3c8f135463f Mon Sep 17 00:00:00 2001
From: Colin <cophus@gmail.com>
Date: Tue, 18 Jul 2023 14:40:13 -0700
Subject: [PATCH 359/362] Slight changes to fitting, plotting

---
 py4DSTEM/Untitled.ipynb                   |  6 +++++
 py4DSTEM/process/diffraction/flowlines.py | 22 ++++++++++++++--
 py4DSTEM/process/polar/polar_fits.py      | 31 +++++++++++++++++------
 py4DSTEM/process/polar/polar_peaks.py     |  2 ++
 4 files changed, 51 insertions(+), 10 deletions(-)
 create mode 100644 py4DSTEM/Untitled.ipynb

diff --git a/py4DSTEM/Untitled.ipynb b/py4DSTEM/Untitled.ipynb
new file mode 100644
index 000000000..363fcab7e
--- /dev/null
+++ b/py4DSTEM/Untitled.ipynb
@@ -0,0 +1,6 @@
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/py4DSTEM/process/diffraction/flowlines.py b/py4DSTEM/process/diffraction/flowlines.py
index a483740ff..cf84f69f5 100644
--- a/py4DSTEM/process/diffraction/flowlines.py
+++ b/py4DSTEM/process/diffraction/flowlines.py
@@ -519,6 +519,7 @@ def make_flowline_rainbow_image(
     power_scaling = 1.0,
     sum_radial_bins = False,
     plot_images = True,
+    figsize = None,
     ):
     """
     Generate RGB output images from the flowline arrays.
@@ -535,6 +536,7 @@ def make_flowline_rainbow_image(
         power_scaling (float):      Power law scaling for flowline intensity output.
         sum_radial_bins (bool):     Sum all radial bins (alternative is to output separate images).
         plot_images (bool):         Plot the outputs for quick visualization.
+        figsize (2-tuple):          Size of output figure.
 
     Returns:
         im_flowline (array):        3D or 4D array containing flowline images
@@ -613,7 +615,14 @@ def make_flowline_rainbow_image(
             im_flowline = np.min(im_flowline,axis=0)[None,:,:,:]
 
     if plot_images is True:
-        fig,ax = plt.subplots(im_flowline.shape[0],1,figsize=(10,im_flowline.shape[0]*10))
+        if figsize is None:
+            fig,ax = plt.subplots(
+                im_flowline.shape[0],1,
+                figsize=(10,im_flowline.shape[0]*10))
+        else:
+            fig,ax = plt.subplots(
+                im_flowline.shape[0],1,
+                figsize=figsize)
 
         if im_flowline.shape[0] > 1:
             for a0 in range(im_flowline.shape[0]):
@@ -729,6 +738,7 @@ def make_flowline_combined_image(
     power_scaling = 1.0,
     sum_radial_bins = True,
     plot_images = True,
+    figsize = None,
     ):
     """
     Generate RGB output images from the flowline arrays.
@@ -742,6 +752,7 @@ def make_flowline_combined_image(
         power_scaling (float):      Power law scaling for flowline intensities.
         sum_radial_bins (bool):     Sum outputs over radial bins.
         plot_images (bool):         Plot the output images for quick visualization.
+        figsize (2-tuple):          Size of output figure.
 
     Returns:
         im_flowline (array):        flowline images
@@ -787,7 +798,14 @@ def make_flowline_combined_image(
 
 
     if plot_images is True:
-        fig,ax = plt.subplots(im_flowline.shape[0],1,figsize=(10,im_flowline.shape[0]*10))
+        if figsize is None:
+            fig,ax = plt.subplots(
+                im_flowline.shape[0],1,
+                figsize=(10,im_flowline.shape[0]*10))
+        else:
+            fig,ax = plt.subplots(
+                im_flowline.shape[0],1,
+                figsize=figsize)
 
         if im_flowline.shape[0] > 1:
             for a0 in range(im_flowline.shape[0]):
diff --git a/py4DSTEM/process/polar/polar_fits.py b/py4DSTEM/process/polar/polar_fits.py
index b92b2b7ba..e231dda07 100644
--- a/py4DSTEM/process/polar/polar_fits.py
+++ b/py4DSTEM/process/polar/polar_fits.py
@@ -12,6 +12,7 @@ def fit_amorphous_ring(
     coefs = None,
     mask_dp = None,
     show_fit_mask = False,
+    maxfev = None,
     verbose = False,
     plot_result = True,
     plot_log_scale = False,
@@ -39,6 +40,8 @@ def fit_amorphous_ring(
         Dark field mask for fitting, in addition to the radial range specified above.
     show_fit_mask: bool
         Set to true to preview the fitting mask and initial guess for the ellipse params
+    maxfev: int
+        Max number of fitting evaluations for curve_fit.
     verbose: bool
         Print fit results
     plot_result: bool
@@ -159,14 +162,26 @@ def fit_amorphous_ring(
     else:
         # Perform elliptic fitting
         int_mean = np.mean(vals)
-        coefs = curve_fit(
-            amorphous_model, 
-            basis, 
-            vals / int_mean, 
-            p0=coefs,
-            xtol = 1e-12,
-            bounds = (lb,ub),
-        )[0]
+
+        if maxfev is None:
+            coefs = curve_fit(
+                amorphous_model, 
+                basis, 
+                vals / int_mean, 
+                p0=coefs,
+                xtol = 1e-8,
+                bounds = (lb,ub),
+            )[0]
+        else:
+            coefs = curve_fit(
+                amorphous_model, 
+                basis, 
+                vals / int_mean, 
+                p0=coefs,
+                xtol = 1e-8,
+                bounds = (lb,ub),
+                maxfev = maxfev,
+            )[0]
         coefs[4] = np.mod(coefs[4],2*np.pi)
         coefs[5:8] *= int_mean
         # bounds=bounds
diff --git a/py4DSTEM/process/polar/polar_peaks.py b/py4DSTEM/process/polar/polar_peaks.py
index b05434233..6a6e0860a 100644
--- a/py4DSTEM/process/polar/polar_peaks.py
+++ b/py4DSTEM/process/polar/polar_peaks.py
@@ -717,6 +717,7 @@ def model_radial_background(
     ring_int = None,
     refine_model = True,
     plot_result = True,
+    figsize = (8,4),
     ):
     """
     User provided radial background model, of the form:
@@ -818,6 +819,7 @@ def background_model(q, *coefs):
         self.plot_radial_background(
                 q_pixel_units = False,   
                 plot_background_model = True,
+                figsize = figsize,
             )
 
 

From 8e57e1c2c2abdccb28f1b8689fd20356ef5306ab Mon Sep 17 00:00:00 2001
From: Colin Ophus <cophus@gmail.com>
Date: Tue, 18 Jul 2023 15:17:25 -0700
Subject: [PATCH 360/362] Delete Untitled.ipynb

---
 py4DSTEM/Untitled.ipynb | 6 ------
 1 file changed, 6 deletions(-)
 delete mode 100644 py4DSTEM/Untitled.ipynb

diff --git a/py4DSTEM/Untitled.ipynb b/py4DSTEM/Untitled.ipynb
deleted file mode 100644
index 363fcab7e..000000000
--- a/py4DSTEM/Untitled.ipynb
+++ /dev/null
@@ -1,6 +0,0 @@
-{
- "cells": [],
- "metadata": {},
- "nbformat": 4,
- "nbformat_minor": 5
-}

From 41ee4cf9454476fdcbde36ff48c422836505651c Mon Sep 17 00:00:00 2001
From: bsavitzky <ben.savitzky@gmail.com>
Date: Wed, 19 Jul 2023 13:54:41 -0400
Subject: [PATCH 361/362] update get_cmap deprecations

---
 py4DSTEM/process/rdf/amorph.py  | 2 +-
 py4DSTEM/process/utils/utils.py | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/py4DSTEM/process/rdf/amorph.py b/py4DSTEM/process/rdf/amorph.py
index 9c80a2807..a537896b9 100644
--- a/py4DSTEM/process/rdf/amorph.py
+++ b/py4DSTEM/process/rdf/amorph.py
@@ -111,7 +111,7 @@ def plot_strains(strains, cmap="RdBu_r", vmin=None, vmax=None, mask=None):
         cmap, vmin, vmax: imshow parameters
         mask: real space mask of values not to show (black)
     """
-    cmap = matplotlib.cm.get_cmap(cmap)
+    cmap = plt.get_cmap(cmap)
     if vmin is None:
         vmin = np.min(strains)
     if vmax is None:
diff --git a/py4DSTEM/process/utils/utils.py b/py4DSTEM/process/utils/utils.py
index 1df4e78c5..86257b4dc 100644
--- a/py4DSTEM/process/utils/utils.py
+++ b/py4DSTEM/process/utils/utils.py
@@ -59,7 +59,7 @@ def radial_reduction(
 def plot(img, title='Image', savePath=None, cmap='inferno', show=True, vmax=None,
                                                         figsize=(10, 10), scale=None):
     fig, ax = plt.subplots(figsize=figsize)
-    im = ax.imshow(img, interpolation='nearest', cmap=plt.cm.get_cmap(cmap), vmax=vmax)
+    im = ax.imshow(img, interpolation='nearest', cmap=plt.get_cmap(cmap), vmax=vmax)
     divider = make_axes_locatable(ax)
     cax = divider.append_axes("right", size="5%", pad=0.05)
     plt.colorbar(im, cax=cax)
@@ -636,7 +636,7 @@ def fourier_resample(
 #def plot(img, title='Image', savePath=None, cmap='inferno', show=True, vmax=None,
 #                                                        figsize=(10, 10), scale=None):
 #    fig, ax = plt.subplots(figsize=figsize)
-#    im = ax.imshow(img, interpolation='nearest', cmap=plt.cm.get_cmap(cmap), vmax=vmax)
+#    im = ax.imshow(img, interpolation='nearest', cmap=plt.get_cmap(cmap), vmax=vmax)
 #    divider = make_axes_locatable(ax)
 #    cax = divider.append_axes("right", size="5%", pad=0.05)
 #    plt.colorbar(im, cax=cax)

From e00bab45a9c499585b968b8f276cc3eb7fe0356f Mon Sep 17 00:00:00 2001
From: bsavitzky <bsavitzky@users.noreply.github.com>
Date: Wed, 19 Jul 2023 18:25:51 -0400
Subject: [PATCH 362/362] Update version.py to 0.14.3

---
 py4DSTEM/version.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py4DSTEM/version.py b/py4DSTEM/version.py
index 4009e43c9..9df5075b8 100644
--- a/py4DSTEM/version.py
+++ b/py4DSTEM/version.py
@@ -1,2 +1,2 @@
-__version__='0.14.2'
+__version__='0.14.3'