From 686df38f264374a5e7503ec4d1e81a03454b0826 Mon Sep 17 00:00:00 2001
From: G Adam Cox <gadamc@gmail.com>
Date: Fri, 31 Mar 2023 17:19:48 -0700
Subject: [PATCH 1/4] adds run_scan function and data access functions

---
 src/qt3utils/datagenerators/piezoscanner.py | 32 ++++++++++++++++++++-
 1 file changed, 31 insertions(+), 1 deletion(-)

diff --git a/src/qt3utils/datagenerators/piezoscanner.py b/src/qt3utils/datagenerators/piezoscanner.py
index a04ead2e..47b65d1a 100644
--- a/src/qt3utils/datagenerators/piezoscanner.py
+++ b/src/qt3utils/datagenerators/piezoscanner.py
@@ -133,7 +133,19 @@ def scan_axis(self, axis, min, max, step_size):
     def reset(self):
         self.scanned_raw_counts = []
         self.scanned_count_rate = []
-        
+
+    def get_raw_counts(self):
+        """
+        Returns a list of raw counts from the most resent scan
+        """
+        return self.scanned_raw_counts
+
+    def get_count_rate(self):
+        """
+        Returns a list of count rates from the most resent scan
+        """
+        return self.scanned_count_rate
+
     def optimize_position(self, axis, center_position, width = 2, step_size = 0.25):
         '''
         Performs a scan over a particular axis about `center_position`.
@@ -189,3 +201,21 @@ def optimize_position(self, axis, center_position, width = 2, step_size = 0.25):
 
         return count_rates, axis_vals, optimal_position, coeff
 
+
+    def run_scan(self, reset_starting_position=True):
+        """
+        Runs a scan of the sample.
+
+        To get the data, call get_raw_counts() or get_count_rate()
+        """
+
+        if reset_starting_position:
+            self.reset()
+            self.set_to_starting_position()
+
+        self.start()
+        while self.still_scanning():
+            self.scan_x()
+            self.move_y()
+        self.stop()
+

From 5af00972e1497925363e93935326b72d0ce19c3f Mon Sep 17 00:00:00 2001
From: G Adam Cox <gadamc@gmail.com>
Date: Sat, 1 Apr 2023 20:45:08 -0700
Subject: [PATCH 2/4] Adds hyper-data acquisition function to piezoscanner.

A number of changes have been made in this commit to support
the addition of a hyper-data acquisition callback function.

This function allows an external user to define a function
to be called at each position of the scan. This function
may also be executed in a separate thread if the 'in_parallel'
attribute of the funciton is set.

In support of this function, a number of other smaller changes
were made.

A run_scan function was added in order to facilitate use
of CounterAndScanner objects. A callback function for that
is also provided so the GUI application pizeoscan.py may
update it's display upon completion of a raster line.

Unnecessary checks for stage_controller != None were removed
since this object does not support instantiation without
a stage_controller. (Although, future updates should provide
proper type hinting.)

The position of the scan is no longer tracked by the CounterAndScan
object, but instead relies upon the last_write_values attribute
of the stage_controller object.
---
 src/applications/piezoscan.py               |  27 ++-
 src/qt3utils/datagenerators/piezoscanner.py | 188 +++++++++++++++-----
 2 files changed, 153 insertions(+), 62 deletions(-)

diff --git a/src/applications/piezoscan.py b/src/applications/piezoscan.py
index 95b17795..ba7c6e93 100644
--- a/src/applications/piezoscan.py
+++ b/src/applications/piezoscan.py
@@ -80,18 +80,18 @@ def __init__(self, mplcolormap = 'gray'):
         self.ax.set_ylabel('y position (um)')
         self.log_data = False
 
-    def update(self, model):
+    def update(self, scanner):
 
         if self.log_data:
-            data = np.log10(model.scanned_count_rate)
+            data = np.log10(scanner.get_count_rate())
             data[np.isinf(data)] = 0 #protect against +-inf
         else:
-            data = model.scanned_count_rate
+            data = scanner.get_count_rate()
 
-        self.artist = self.ax.imshow(data, cmap=self.cmap, extent=[model.xmin,
-                                                                   model.xmax + model.step_size,
-                                                                   model.current_y + model.step_size,
-                                                                   model.ymin])
+        self.artist = self.ax.imshow(data, cmap=self.cmap, extent=[scanner.xmin,
+                                                                   scanner.xmax + scanner.step_size,
+                                                                   scanner.get_current_position('y') + scanner.step_size,
+                                                                   scanner.ymin])
         if self.cbar is None:
             self.cbar = self.fig.colorbar(self.artist, ax=self.ax)
         else:
@@ -395,17 +395,12 @@ def scan_thread_function(self, xmin, xmax, ymin, ymax, step_size, N):
         self.counter_scanner.set_num_data_samples_per_batch(N)
 
         try:
-            self.counter_scanner.reset() #clears the data
-            self.counter_scanner.start() #starts the DAQ
-            self.counter_scanner.set_to_starting_position() #moves the stage to starting position
-
-            while self.counter_scanner.still_scanning():
-                self.counter_scanner.scan_x()
-                self.view.scan_view.update(self.counter_scanner)
+            def update_scan_view(counter_scanner):
+                self.view.scan_view.update(counter_scanner)
                 self.view.canvas.draw()
-                self.counter_scanner.move_y()
 
-            self.counter_scanner.stop()
+            self.counter_scanner.run_scan(reset_starting_position=True,
+                                          line_scan_callback=update_scan_view)
 
         except nidaqmx.errors.DaqError as e:
             logger.info(e)
diff --git a/src/qt3utils/datagenerators/piezoscanner.py b/src/qt3utils/datagenerators/piezoscanner.py
index 47b65d1a..a9353d0a 100644
--- a/src/qt3utils/datagenerators/piezoscanner.py
+++ b/src/qt3utils/datagenerators/piezoscanner.py
@@ -1,7 +1,10 @@
-import numpy as np
-import scipy.optimize
 import time
 import logging
+import threading
+from typing import Union, Callable
+
+import numpy as np
+import scipy.optimize
 
 logger = logging.getLogger(__name__)
 
@@ -11,10 +14,30 @@ def gauss(x, *p):
 
 
 class CounterAndScanner:
-    def __init__(self, rate_counter, stage_controller):
+    def __init__(self, rate_counter, stage_controller, hyper_data_acquisition_function: Callable = None):
+        """
+
+        :param rate_counter: a RateCounter object
+        :param stage_controller: a StageController object
+        :param hyper_data_acquisition_function: a function is called at each position of the scan
+
+        Notes on hyper_data_acquisition_function:
+
+        This function must have an attribute "in_parallel" that is True or False.
+        It must store its own data if generated
+
+        The function will be passed a copy of this CounterAndScanner object as the argument, from which the caller
+        can extract the current position and other information that may be desired.
+
+        If the function's "in_parallel" attribute is True, then the function will be called in a separate thread.
+        This is useful, for example, if the spectrometer is being used to acquire data at each position.
+        Both the spectrometer and the rate counter will acquire data simultaneously.
 
+        If the function uses NiDAQ or any of the other hardware also used during a scan, then "in_parallel" must be
+        False. Otherwise, both the scan and the function will be trying to use the same hardware simultaneously.
+
+        """
         self.running = False
-        self.current_y = 0
         self.ymin = 0.0
         self.ymax = 80.0
         self.xmin = 0.0
@@ -27,7 +50,36 @@ def __init__(self, rate_counter, stage_controller):
 
         self.stage_controller = stage_controller
         self.rate_counter = rate_counter
-        self.num_daq_batches = 1 # could change to 10 if want 10x more samples for each position
+        self.num_daq_batches = 1  # could change to 10 if want 10x more samples for each position
+
+        self.hyper_data_acquisition_function = None
+        self.set_hyper_data_acquisition_function(hyper_data_acquisition_function)
+
+    def set_hyper_data_acquisition_function(self, hyper_data_acquisition_function: Callable):
+        """
+        Sets the function that is called at each position of the scan
+
+        This function must have an attribute "in_parallel" that is True or False.
+        If no attribute is provided, then it is assumed to be False.
+
+        It must store its own data if generated
+
+        The function will be passed a copy of this CounterAndScanner object as the argument, from which the caller
+        can extract the current position and other information that may be desired.
+
+        If the function's "in_parallel" attribute is True, then the function will be called in a separate thread.
+        This is useful, for example, if the spectrometer is being used to acquire data at each position.
+        Both the spectrometer and the rate counter will acquire data simultaneously.
+
+        If the function uses NiDAQ or any of the other hardware also used during a scan, then "in_parallel" must be
+        False. Otherwise, both the scan and the function will be trying to use the same hardware simultaneously.
+        """
+        self.hyper_data_acquisition_function = hyper_data_acquisition_function
+        if self.hyper_data_acquisition_function is not None:
+            if hasattr(self.hyper_data_acquisition_function, 'in_parallel') is False:
+                logger.warning('hyper_data_acquisition_function does not have the attribute "in_parallel"')
+                logger.warning('setting hyper_data_acquisition_function.in_parallel = False')
+                self.hyper_data_acquisition_function.in_parallel = False
 
     def stop(self):
         self.rate_counter.stop()
@@ -38,9 +90,10 @@ def start(self):
         self.rate_counter.start()
 
     def set_to_starting_position(self):
-        self.current_y = self.ymin
-        if self.stage_controller:
-            self.stage_controller.go_to_position(x = self.xmin, y = self.ymin)
+        """
+        Move the stage to the starting position (xmin, ymin)
+        """
+        self.stage_controller.go_to_position(x=self.xmin, y=self.ymin)
 
     def close(self):
         self.rate_counter.close()
@@ -57,9 +110,11 @@ def sample_count_rate(self, data_counts=None):
         return self.rate_counter.sample_count_rate(data_counts)
 
     def set_scan_range(self, xmin, xmax, ymin, ymax):
-        if self.stage_controller:
-            self.stage_controller.check_allowed_position(xmin, ymin)
-            self.stage_controller.check_allowed_position(xmax, ymax)
+        """
+        Sets the scan range
+        """
+        self.stage_controller.check_allowed_position(xmin, ymin)
+        self.stage_controller.check_allowed_position(xmax, ymax)
 
         self.ymin = ymin
         self.ymax = ymax
@@ -73,60 +128,95 @@ def get_scan_range(self) -> tuple:
         """
         return self.xmin, self.xmax, self.ymin, self.ymax
 
+    def get_current_position(self, axis=None, use_last_write_values=True) -> Union[dict, float]:
+        """
+        Returns the last position written to the stage controller.
+
+        This is the CURRENT position of the stage.
+
+        :param axis: 'x', 'y', or 'z'. If None, returns a dict of all axes
+        :param use_last_write_values: if True, then the last position written to the stage controller is returned.
+            otherwise, the current position is returned as determined by the read voltages from the stage controller.
+
+        :return: dict of x, y, z positions or a single float of the position of the specified axis
+        """
+        if use_last_write_values:
+            position = dict(zip(['x', 'y', 'z'], self.stage_controller.last_write_values))
+        else:
+            position = dict(zip(['x', 'y', 'z'], self.stage_controller.get_position()))
+
+        if axis is None:
+            return position
+        else:
+            return position[axis]
+
     def get_completed_scan_range(self) -> tuple:
         """
         Returns a tuple of the scan range that has been completed
-        :return: xmin, xmax, ymin, current_y
+        :return: xmin, xmax, ymin, get_current_position('y')
         """
-        return self.xmin, self.xmax, self.ymin, self.current_y
+        return self.xmin, self.xmax, self.ymin, self.get_current_position('y')
 
-    def still_scanning(self):
-        if self.running == False: #this allows external process to stop scan
+    def _still_scanning(self):
+        if self.running == False:  # this allows external process to stop scan
             return False
 
-        if self.current_y <= self.ymax: #stops scan when reaches final position
+        if self.get_current_position('y') < self.ymax:  # stops scan when reaches final position
             return True
         else:
             self.running = False
             return False
 
-    def move_y(self):
-        self.current_y += self.step_size
-        if self.stage_controller and self.current_y <= self.ymax:
+    def _move_y(self):
+        if self.get_current_position('y') + self.step_size <= self.ymax:
             try:
-                self.stage_controller.go_to_position(y=self.current_y)
+                self.stage_controller.go_to_position(y=self.get_current_position('y') + self.step_size)
             except ValueError as e:
                 logger.info(f'out of range\n\n{e}')
 
-    def scan_x(self):
+    def _scan_x(self):
         """
         Scans the x axis from xmin to xmax in steps of step_size.
 
         Stores results in self.scanned_raw_counts and self.scanned_count_rate.
         """
-        raw_counts_for_axis = self.scan_axis('x', self.xmin, self.xmax, self.step_size)
+        raw_counts_for_axis = self._scan_axis('x', self.xmin, self.xmax, self.step_size,
+                                             hyper_data_acquisition_function=self.hyper_data_acquisition_function)
         self.scanned_raw_counts.append(raw_counts_for_axis)
         self.scanned_count_rate.append([self.sample_count_rate(raw_counts) for raw_counts in raw_counts_for_axis])
 
-    def scan_axis(self, axis, min, max, step_size):
+    def _scan_axis(self, axis, min, max, step_size, hyper_data_acquisition_function=None):
         """
         Moves the stage along the specified axis from min to max in steps of step_size.
         Returns a list of raw counts from the scan in the shape
         [[[counts, clock_samples]], [[counts, clock_samples]], ...] where each [[counts, clock_samples]] is the
         result of a single call to sample_counts at each scan position along the axis.
+
+        If hyper_data_acquisition_function is not None, it will be called at each scan position.
+        If hyper_data_acquisition_function.in_parallel is True, it will be called in a separate thread.
         """
         raw_counts = []
-        self.stage_controller.go_to_position(**{axis:min})
+        self.stage_controller.go_to_position(**{axis: min})
         time.sleep(self.raster_line_pause)
         for val in np.arange(min, max, step_size):
-            if self.stage_controller:
-                logger.info(f'go to position {axis}: {val:.2f}')
-                self.stage_controller.go_to_position(**{axis:val})
-            _raw_counts = self.sample_counts()
+            logger.info(f'go to position {axis}: {val:.2f}')
+            self.stage_controller.go_to_position(**{axis: val})
+
+            if hyper_data_acquisition_function is not None:
+                if hyper_data_acquisition_function.in_parallel:
+                    thread = threading.Thread(target=hyper_data_acquisition_function, args=(self,))
+                    thread.start()
+                    _raw_counts = self.sample_counts()
+                    thread.join()
+                else:
+                    hyper_data_acquisition_function(self)
+                    _raw_counts = self.sample_counts()
+            else:
+                _raw_counts = self.sample_counts()
+
             raw_counts.append(_raw_counts)
             logger.info(f'raw counts, total clock samples: {_raw_counts}')
-            if self.stage_controller:
-                logger.info(f'current position: {self.stage_controller.get_current_position()}')
+            logger.info(f'current stage position: {self.get_current_position()}')
 
         return raw_counts
 
@@ -147,7 +237,7 @@ def get_count_rate(self):
         return self.scanned_count_rate
 
     def optimize_position(self, axis, center_position, width = 2, step_size = 0.25):
-        '''
+        """
         Performs a scan over a particular axis about `center_position`.
 
         The scan ranges from center_position +- width and progresses with step_size.
@@ -170,18 +260,15 @@ def optimize_position(self, axis, center_position, width = 2, step_size = 0.25):
         and the fit_coeff is set to None.
         When the fit is successful, x_optimal = mu.
 
-        '''
+        This function does NOT call self.hyper_data_acquisition_function.
+        """
         min_val = center_position - width
         max_val = center_position + width
-        if self.stage_controller:
-            min_val = np.max([min_val, self.stage_controller.minimum_allowed_position])
-            max_val = np.min([max_val, self.stage_controller.maximum_allowed_position])
-        else:
-            min_val = np.max([min_val, 0.0])
-            max_val = np.min([max_val, 80.0])
+        min_val = np.max([min_val, self.stage_controller.minimum_allowed_position])
+        max_val = np.min([max_val, self.stage_controller.maximum_allowed_position])
 
         self.start()
-        raw_counts = self.scan_axis(axis, min_val, max_val, step_size)
+        raw_counts = self._scan_axis(axis, min_val, max_val, step_size)
         self.stop()
         axis_vals = np.arange(min_val, max_val, step_size)
         count_rates = [self.sample_count_rate(count) for count in raw_counts]
@@ -201,12 +288,19 @@ def optimize_position(self, axis, center_position, width = 2, step_size = 0.25):
 
         return count_rates, axis_vals, optimal_position, coeff
 
-
-    def run_scan(self, reset_starting_position=True):
+    def run_scan(self, reset_starting_position=True, line_scan_callback=None):
         """
-        Runs a scan of the sample.
+        Runs a scan across the range of set parameters: xmin, xmax, ymin, ymax, step_size
+
+        To get the data after the scan, call get_raw_counts() or get_count_rate(). You may also
+        provide a callback function that will be called after each line scan is completed.
+
+        :param reset_starting_position: if True, the stage will be reset to the starting position before the scan begins
+        :param line_scan_callback: a function that will be called after each line scan is completed. The function
+                                     should take a single argument, which will be an instance of this class.
+                                     i.e. line_scan_callback(obj: CounterAndScanner)
+        :return: None
 
-        To get the data, call get_raw_counts() or get_count_rate()
         """
 
         if reset_starting_position:
@@ -214,8 +308,10 @@ def run_scan(self, reset_starting_position=True):
             self.set_to_starting_position()
 
         self.start()
-        while self.still_scanning():
-            self.scan_x()
-            self.move_y()
+        while self._still_scanning():
+            self._scan_x()
+            self._move_y()
+            if line_scan_callback is not None:
+                line_scan_callback(self)
         self.stop()
 

From 71324d87aac24e867c674ad3c8fdc81569cd2de2 Mon Sep 17 00:00:00 2001
From: G Adam Cox <gadamc@gmail.com>
Date: Sun, 2 Apr 2023 14:37:23 -0700
Subject: [PATCH 3/4] Changes internal naming.

A misconception about the hardware led to incorrect variable
names and documentation. Initially, the piezo actuator
that controls the position of the laser light impinging upon
a sample was called a "stage" controller due to a misunderstanding
of the hardware setup. This labeling perpetuated until this change.
All usage of "stage" control has been replaced either with
"position" control or actuator, where appropriate.
Variable naming may still feel a bit off in places. Please fix
if you have better ways of describing functionality.
---
 README.md                                   |  2 +-
 pyproject.toml                              |  2 +-
 src/applications/piezoscan.py               | 31 ++++++------
 src/qt3utils/datagenerators/piezoscanner.py | 52 ++++++++++-----------
 4 files changed, 43 insertions(+), 44 deletions(-)

diff --git a/README.md b/README.md
index b860efa8..de8ff03d 100644
--- a/README.md
+++ b/README.md
@@ -11,7 +11,7 @@ various spin-control experiments on quantum systems, such as NV centers in diamo
    * Spin Core PulseBlaster
  * Excelitas SPCM for photon detection
  * NI-DAQ card (PCIx 6363) for data acquisition and control
- * Jena System's Piezo Actuator Stage Control Amplifier
+ * Jena System's Piezo Actuator Control Amplifier
  * [Future] spectrometer
 
 The code in this package facilitates usages of these devices to perform
diff --git a/pyproject.toml b/pyproject.toml
index 74157e39..87eeba69 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -10,7 +10,7 @@ description = "A package for performing experiments in the QT3 lab at UW."
 readme = "README.md"
 requires-python = ">=3.8"
 license = {file = "LICENSE"}
-keywords = ["qt3", "confocal scan", "nidaqmx", "piezo", "stage", "control", "electron spin control"]
+keywords = ["qt3", "confocal scan", "nidaqmx", "electron spin control", "quantum computing", "nitrogen-vacancy center"]
 
 authors = [
     {name = "G. Adam Cox", email = "gadamc@gmail.com" },
diff --git a/src/applications/piezoscan.py b/src/applications/piezoscan.py
index ba7c6e93..d5bc5692 100644
--- a/src/applications/piezoscan.py
+++ b/src/applications/piezoscan.py
@@ -294,8 +294,8 @@ class MainTkApplication():
     def __init__(self, counter_scanner):
         self.root = tk.Tk()
         self.counter_scanner = counter_scanner
-        scan_range = [counter_scanner.stage_controller.minimum_allowed_position,
-                      counter_scanner.stage_controller.maximum_allowed_position]
+        scan_range = [counter_scanner.actuator_controller.minimum_allowed_position,
+                      counter_scanner.actuator_controller.maximum_allowed_position]
         self.view = MainApplicationView(self.root, scan_range)
         self.view.sidepanel.startButton.bind("<Button>", self.start_scan)
         self.view.sidepanel.stopButton.bind("<Button>", self.stop_scan)
@@ -316,31 +316,31 @@ def __init__(self, counter_scanner):
         self.scan_thread = None
 
         self.optimized_position = {'x':0, 'y':0, 'z':-1}
-        if self.counter_scanner.stage_controller:
-            self.optimized_position['z'] = self.counter_scanner.stage_controller.get_current_position()[2]
+        if self.counter_scanner.actuator_controller:
+            self.optimized_position['z'] = self.counter_scanner.actuator_controller.get_current_position()[2]
         else:
             self.optimized_position['z'] = 20
         self.view.sidepanel.z_entry_text.set(np.round(self.optimized_position['z'],4))
 
 
     def run(self):
-        self.root.title("QT3Scan: Piezo Controlled NIDAQ Digital Count Rate Scanner")
+        self.root.title("QT3Scan: Piezo Control and NIDAQ Digital Signal Counter")
         self.root.deiconify()
         self.root.mainloop()
 
     def go_to_position(self, event = None):
-        if self.counter_scanner.stage_controller:
-            self.counter_scanner.stage_controller.go_to_position(x = self.view.sidepanel.go_to_x_position_text.get(), y = self.view.sidepanel.go_to_y_position_text.get())
+        if self.counter_scanner.actuator_controller:
+            self.counter_scanner.actuator_controller.go_to_position(x = self.view.sidepanel.go_to_x_position_text.get(), y = self.view.sidepanel.go_to_y_position_text.get())
         else:
-            print(f'stage_controller would have moved to x,y = {self.view.sidepanel.go_to_x_position_text.get():.2f}, {self.view.sidepanel.go_to_y_position_text.get():.2f}')
+            print(f'actuator_controller would have moved to x,y = {self.view.sidepanel.go_to_x_position_text.get():.2f}, {self.view.sidepanel.go_to_y_position_text.get():.2f}')
         self.optimized_position['x'] = self.view.sidepanel.go_to_x_position_text.get()
         self.optimized_position['y'] = self.view.sidepanel.go_to_y_position_text.get()
 
     def go_to_z(self, event = None):
-        if self.counter_scanner.stage_controller:
-            self.counter_scanner.stage_controller.go_to_position(z = self.view.sidepanel.z_entry_text.get())
+        if self.counter_scanner.actuator_controller:
+            self.counter_scanner.actuator_controller.go_to_position(z = self.view.sidepanel.z_entry_text.get())
         else:
-            print(f'stage_controller would have moved to z = {self.view.sidepanel.z_entry_text.get():.2f}')
+            print(f'actuator_controller would have moved to z = {self.view.sidepanel.z_entry_text.get():.2f}')
         self.optimized_position['z'] = self.view.sidepanel.z_entry_text.get()
 
     def set_color_map(self, event = None):
@@ -481,7 +481,7 @@ def optimize_thread_function(self, axis, central, range, step_size):
                                                                            range,
                                                                            step_size)
             self.optimized_position[axis] = opt_pos
-            self.counter_scanner.stage_controller.go_to_position(**{axis:opt_pos})
+            self.counter_scanner.actuator_controller.go_to_position(**{axis:opt_pos})
             self.view.show_optimization_plot(f'Optimize {axis}',
                                              central,
                                              self.optimized_position[axis],
@@ -494,7 +494,6 @@ def optimize_thread_function(self, axis, central, range, step_size):
             logger.info(e)
             logger.info('Check for other applications using resources. If not, you may need to restart the application.')
 
-
         self.view.sidepanel.startButton['state'] = 'normal'
         self.view.sidepanel.stopButton['state'] = 'normal'
         self.view.sidepanel.go_to_z_button['state'] = 'normal'
@@ -540,11 +539,11 @@ def on_closing(self):
 
 def build_data_scanner():
     if args.randomtest:
-        stage_controller = nipiezojenapy.BaseControl()
+        actuator_controller = nipiezojenapy.BaseControl()
         data_acq = datasources.RandomRateCounter(simulate_single_light_source=True,
                                                  num_data_samples_per_batch=args.num_data_samples_per_batch)
     else:
-        stage_controller = nipiezojenapy.PiezoControl(device_name = args.daq_name,
+        actuator_controller = nipiezojenapy.PiezoControl(device_name = args.daq_name,
                                   write_channels = args.piezo_write_channels.split(','),
                                   read_channels = args.piezo_read_channels.split(','))
 
@@ -556,7 +555,7 @@ def build_data_scanner():
                                                             args.rwtimeout,
                                                             args.signal_counter)
 
-    scanner = datasources.CounterAndScanner(data_acq, stage_controller)
+    scanner = datasources.CounterAndScanner(data_acq, actuator_controller)
 
     return scanner
 
diff --git a/src/qt3utils/datagenerators/piezoscanner.py b/src/qt3utils/datagenerators/piezoscanner.py
index a9353d0a..3f67ba27 100644
--- a/src/qt3utils/datagenerators/piezoscanner.py
+++ b/src/qt3utils/datagenerators/piezoscanner.py
@@ -14,11 +14,11 @@ def gauss(x, *p):
 
 
 class CounterAndScanner:
-    def __init__(self, rate_counter, stage_controller, hyper_data_acquisition_function: Callable = None):
+    def __init__(self, rate_counter, position_controller, hyper_data_acquisition_function: Callable = None):
         """
 
         :param rate_counter: a RateCounter object
-        :param stage_controller: a StageController object
+        :param position_controller: a position controller object such as nipiezojenapy.BaseControl or PiezoControl
         :param hyper_data_acquisition_function: a function is called at each position of the scan
 
         Notes on hyper_data_acquisition_function:
@@ -43,12 +43,12 @@ def __init__(self, rate_counter, stage_controller, hyper_data_acquisition_functi
         self.xmin = 0.0
         self.xmax = 80.0
         self.step_size = 0.5
-        self.raster_line_pause = 0.150  # wait 150ms for the piezo stage to settle before a line scan
+        self.raster_line_pause = 0.150  # wait 150ms for the piezo actuator to settle before a line scan
 
         self.scanned_raw_counts = []
         self.scanned_count_rate = []
 
-        self.stage_controller = stage_controller
+        self.position_controller = position_controller
         self.rate_counter = rate_counter
         self.num_daq_batches = 1  # could change to 10 if want 10x more samples for each position
 
@@ -91,9 +91,9 @@ def start(self):
 
     def set_to_starting_position(self):
         """
-        Move the stage to the starting position (xmin, ymin)
+        Move the actuator to the starting position (xmin, ymin)
         """
-        self.stage_controller.go_to_position(x=self.xmin, y=self.ymin)
+        self.position_controller.go_to_position(x=self.xmin, y=self.ymin)
 
     def close(self):
         self.rate_counter.close()
@@ -113,8 +113,8 @@ def set_scan_range(self, xmin, xmax, ymin, ymax):
         """
         Sets the scan range
         """
-        self.stage_controller.check_allowed_position(xmin, ymin)
-        self.stage_controller.check_allowed_position(xmax, ymax)
+        self.position_controller.check_allowed_position(xmin, ymin)
+        self.position_controller.check_allowed_position(xmax, ymax)
 
         self.ymin = ymin
         self.ymax = ymax
@@ -130,20 +130,20 @@ def get_scan_range(self) -> tuple:
 
     def get_current_position(self, axis=None, use_last_write_values=True) -> Union[dict, float]:
         """
-        Returns the last position written to the stage controller.
+        Returns the last position written to the actuator controller.
 
-        This is the CURRENT position of the stage.
+        This is the CURRENT position of the actuator.
 
         :param axis: 'x', 'y', or 'z'. If None, returns a dict of all axes
-        :param use_last_write_values: if True, then the last position written to the stage controller is returned.
-            otherwise, the current position is returned as determined by the read voltages from the stage controller.
+        :param use_last_write_values: if True, then the last position written to the actuator controller is returned.
+            otherwise, the current position is returned as determined by the read voltages from the actuator controller.
 
         :return: dict of x, y, z positions or a single float of the position of the specified axis
         """
         if use_last_write_values:
-            position = dict(zip(['x', 'y', 'z'], self.stage_controller.last_write_values))
+            position = dict(zip(['x', 'y', 'z'], self.position_controller.last_write_values))
         else:
-            position = dict(zip(['x', 'y', 'z'], self.stage_controller.get_position()))
+            position = dict(zip(['x', 'y', 'z'], self.position_controller.get_position()))
 
         if axis is None:
             return position
@@ -170,7 +170,7 @@ def _still_scanning(self):
     def _move_y(self):
         if self.get_current_position('y') + self.step_size <= self.ymax:
             try:
-                self.stage_controller.go_to_position(y=self.get_current_position('y') + self.step_size)
+                self.position_controller.go_to_position(y=self.get_current_position('y') + self.step_size)
             except ValueError as e:
                 logger.info(f'out of range\n\n{e}')
 
@@ -181,13 +181,13 @@ def _scan_x(self):
         Stores results in self.scanned_raw_counts and self.scanned_count_rate.
         """
         raw_counts_for_axis = self._scan_axis('x', self.xmin, self.xmax, self.step_size,
-                                             hyper_data_acquisition_function=self.hyper_data_acquisition_function)
+                                              hyper_data_acquisition_function=self.hyper_data_acquisition_function)
         self.scanned_raw_counts.append(raw_counts_for_axis)
         self.scanned_count_rate.append([self.sample_count_rate(raw_counts) for raw_counts in raw_counts_for_axis])
 
     def _scan_axis(self, axis, min, max, step_size, hyper_data_acquisition_function=None):
         """
-        Moves the stage along the specified axis from min to max in steps of step_size.
+        Moves the actuator along the specified axis from min to max in steps of step_size.
         Returns a list of raw counts from the scan in the shape
         [[[counts, clock_samples]], [[counts, clock_samples]], ...] where each [[counts, clock_samples]] is the
         result of a single call to sample_counts at each scan position along the axis.
@@ -196,11 +196,11 @@ def _scan_axis(self, axis, min, max, step_size, hyper_data_acquisition_function=
         If hyper_data_acquisition_function.in_parallel is True, it will be called in a separate thread.
         """
         raw_counts = []
-        self.stage_controller.go_to_position(**{axis: min})
+        self.position_controller.go_to_position(**{axis: min})
         time.sleep(self.raster_line_pause)
         for val in np.arange(min, max, step_size):
             logger.info(f'go to position {axis}: {val:.2f}')
-            self.stage_controller.go_to_position(**{axis: val})
+            self.position_controller.go_to_position(**{axis: val})
 
             if hyper_data_acquisition_function is not None:
                 if hyper_data_acquisition_function.in_parallel:
@@ -216,7 +216,7 @@ def _scan_axis(self, axis, min, max, step_size, hyper_data_acquisition_function=
 
             raw_counts.append(_raw_counts)
             logger.info(f'raw counts, total clock samples: {_raw_counts}')
-            logger.info(f'current stage position: {self.get_current_position()}')
+            logger.info(f'current actuator position: {self.get_current_position()}')
 
         return raw_counts
 
@@ -226,13 +226,13 @@ def reset(self):
 
     def get_raw_counts(self):
         """
-        Returns a list of raw counts from the most resent scan
+        Returns a list of raw counts from the most recent scan
         """
         return self.scanned_raw_counts
 
     def get_count_rate(self):
         """
-        Returns a list of count rates from the most resent scan
+        Returns a list of count rates from the most recent scan
         """
         return self.scanned_count_rate
 
@@ -264,8 +264,8 @@ def optimize_position(self, axis, center_position, width = 2, step_size = 0.25):
         """
         min_val = center_position - width
         max_val = center_position + width
-        min_val = np.max([min_val, self.stage_controller.minimum_allowed_position])
-        max_val = np.min([max_val, self.stage_controller.maximum_allowed_position])
+        min_val = np.max([min_val, self.position_controller.minimum_allowed_position])
+        max_val = np.min([max_val, self.position_controller.maximum_allowed_position])
 
         self.start()
         raw_counts = self._scan_axis(axis, min_val, max_val, step_size)
@@ -290,12 +290,12 @@ def optimize_position(self, axis, center_position, width = 2, step_size = 0.25):
 
     def run_scan(self, reset_starting_position=True, line_scan_callback=None):
         """
-        Runs a scan across the range of set parameters: xmin, xmax, ymin, ymax, step_size
+        Runs a scan across the range of set parameters: xmin, xmax, ymin, ymax, with increments of step_size.
 
         To get the data after the scan, call get_raw_counts() or get_count_rate(). You may also
         provide a callback function that will be called after each line scan is completed.
 
-        :param reset_starting_position: if True, the stage will be reset to the starting position before the scan begins
+        :param reset_starting_position: if True, the actuator will be reset to the starting position before the scan begins
         :param line_scan_callback: a function that will be called after each line scan is completed. The function
                                      should take a single argument, which will be an instance of this class.
                                      i.e. line_scan_callback(obj: CounterAndScanner)

From c43b13ca04386309a7104450d70887ce70d10352 Mon Sep 17 00:00:00 2001
From: G Adam Cox <gadamc@gmail.com>
Date: Sat, 1 Apr 2023 22:11:44 -0700
Subject: [PATCH 4/4] Adds example of using confocal scan.

In particular, shows how to run a test scan based on
a 'dummy' position controller and random data generator.
This is useful for testing purposes.

Also demonstrates how to use hyper data acquisition
callback function.
---
 .../confocal-scan-random-and-hyperdaq.ipynb   | 577 ++++++++++++++++++
 1 file changed, 577 insertions(+)
 create mode 100644 examples/confocal-scan-random-and-hyperdaq.ipynb

diff --git a/examples/confocal-scan-random-and-hyperdaq.ipynb b/examples/confocal-scan-random-and-hyperdaq.ipynb
new file mode 100644
index 00000000..f2de8e57
--- /dev/null
+++ b/examples/confocal-scan-random-and-hyperdaq.ipynb
@@ -0,0 +1,577 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "84edc1c2",
+   "metadata": {},
+   "source": [
+    "# Confocal Scan - Random Testing and Hyper DAQ\n",
+    "\n",
+    "This notebook demonstrates how to use the CounterAndScanner class (also called NiDaqPiezoScanner)\n",
+    "to generate a 2D image of a sample. This uses an actuator to move the location of \n",
+    "laser light impinging on a sample and an NiDAQ to count the photons emitted (via \n",
+    "digital TTL pulses generated from a photon detector) from the sample. When used with \n",
+    "an appropriate pinhole that restricts the in-focus depth of field, \n",
+    "the image is known as a confocal scan. \n",
+    "\n",
+    "In this example, dummy objects are used to demonstrate how to run without hardware, \n",
+    "which is useful for testing purposes. \n",
+    "\n",
+    "More importantly, usage of a 'hyper data acquisition' function is also demonstrated. \n",
+    "The hyper data acquisition function allows an experimenter to take extra data at \n",
+    "each position of 2D image, such as with a spectrometer to generate a \"hyperspectral image\". "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "4410fcd5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "815ca094",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import logging\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "7e06f7a3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import nipiezojenapy\n",
+    "import qt3utils.datagenerators as datasources\n",
+    "import qt3utils.datagenerators.piezoscanner"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "a7a370ec",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#logging.basicConfig(level = logging.INFO) #set to logging.WARNING to suppress logged information to cells\n",
+    "#qt3utils.datagenerators.piezoscanner.logger.setLevel(logging.INFO)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3e3f2ccc",
+   "metadata": {},
+   "source": [
+    "## Object Instantiation\n",
+    "\n",
+    "To generate a 2D image, three objects are used:\n",
+    "\n",
+    "  * an object to control the position of the light\n",
+    "  * an object to count the number of photons that reach our photon detector\n",
+    "  * an object that uses both the position controller and photon counter to generate the image. \n",
+    "  \n",
+    "  \n",
+    "In the QT3 lab, we  use the nipiezojenapy software package to control the \n",
+    "piezo actuator that positions the objective over a sample and the NIDAQ \n",
+    "card to count the number of TTL pulses from an SPCM. \n",
+    "\n",
+    "In this instance, for our demonstration purposes, we will use dummy \n",
+    "position control and DAQ objects, which mimic usage of real hardware objects.\n",
+    "\n",
+    "  * nipiezojenapy.BaseControl - dummy actuator controller\n",
+    "  * datasources.RandomRateCounter - random data generator\n",
+    "  * CounterAndScanner - perform the scans and generates the image\n",
+    "\n",
+    "See the [confocal_scan](confocal-scan.ipynb) notebook for example usage of real hardware."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "29a0511f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "position_controller = nipiezojenapy.BaseControl()\n",
+    "data_acq = datasources.RandomRateCounter(simulate_single_light_source=True, num_data_samples_per_batch=50)\n",
+    "scanner = datasources.CounterAndScanner(data_acq, position_controller)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "5b2cf4e1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scanner.set_scan_range(0, 20, 0, 20)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "d8b848c3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'x': 0, 'y': 0, 'z': 0}"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "scanner.get_current_position()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "15ff65d8-e99f-4493-879b-5e9b97561da8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# assume we wish to generate an image at some particular depth, z\n",
+    "\n",
+    "some_optimal_z = 15 \n",
+    "position_controller.go_to_position(z = some_optimal_z)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "c78a079c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[0, 0, 15]"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "position_controller.get_current_position()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6921fd3b",
+   "metadata": {},
+   "source": [
+    "### Run Scan\n",
+    "\n",
+    "The docstring for the `run_scan` function describes the actions it performs. \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "b1b0e47f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Help on method run_scan in module qt3utils.datagenerators.piezoscanner:\n",
+      "\n",
+      "run_scan(reset_starting_position=True, line_scan_callback=None) method of qt3utils.datagenerators.piezoscanner.CounterAndScanner instance\n",
+      "    Runs a scan across the range of set parameters: xmin, xmax, ymin, ymax, with increments of step_size.\n",
+      "    \n",
+      "    To get the data after the scan, call get_raw_counts() or get_count_rate(). You may also\n",
+      "    provide a callback function that will be called after each line scan is completed.\n",
+      "    \n",
+      "    :param reset_starting_position: if True, the actuator will be reset to the starting position before the scan begins\n",
+      "    :param line_scan_callback: a function that will be called after each line scan is completed. The function\n",
+      "                                 should take a single argument, which will be an instance of this class.\n",
+      "                                 i.e. line_scan_callback(obj: CounterAndScanner)\n",
+      "    :return: None\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "help(scanner.run_scan)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "3702c8ee",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scanner.run_scan() # user logger to display text during scan"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "b2d67812",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "count_rate = scanner.get_count_rate()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "82e5580f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.colorbar.Colorbar at 0x7fe01ec06370>"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots()\n",
+    "artist = ax.imshow(count_rate, cmap='gray', extent = scanner.get_completed_scan_range())\n",
+    "fig.colorbar(artist, ax=ax)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2833b2ae",
+   "metadata": {},
+   "source": [
+    "# Now, we add a Hyper DAQ function\n",
+    "\n",
+    "A \"Hyper DAQ\" function allows a researcher to take data at each position \n",
+    "during a scan. For example, one may wish to measure the energy spectrum\n",
+    "of photons at each postion, creating a hyperspectral image of a sample. \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "e2a64fc4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "my_functions_data = []\n",
+    "\n",
+    "def my_function(scanner_object):\n",
+    "    rand_data = np.random.random(100)\n",
+    "    my_functions_data.append([scanner_object.get_current_position(), rand_data])\n",
+    "    \n",
+    "\n",
+    "# Since this function does not touch any hardware\n",
+    "# used by the scanner, we can provide the attribute 'in_parallel' = True. \n",
+    "# With this setting, the scanner will run this function in a separate processing thread\n",
+    "# while it simultaneously acquires data from the RandomRateCounter\n",
+    "\n",
+    "# In real life, one can set the hyper DAQ function to 'in_parallel' if\n",
+    "# the function doesn't need to touch hardware used by the confocal scan\n",
+    "# For example, if a beamsplitter diverts light from a sample so that both\n",
+    "# a spectrometer and a photon counter receive signal, a spectrum and total\n",
+    "# count rate can be simultaneously generated.\n",
+    "\n",
+    "my_function.in_parallel = True"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "5fd0a110",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scanner.set_hyper_data_acquisition_function(my_function)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "387f330c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scanner.run_scan()\n",
+    "count_rate = scanner.get_count_rate()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "97721bf7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.colorbar.Colorbar at 0x7fe01f095c70>"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots()\n",
+    "artist = ax.imshow(count_rate, cmap='gray', extent = scanner.get_completed_scan_range())\n",
+    "fig.colorbar(artist, ax=ax)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "633002c8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1600\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[[{'x': 0.0, 'y': 0, 'z': 15},\n",
+       "  array([0.31452213, 0.35451581, 0.98887843, 0.72970574, 0.09544869,\n",
+       "         0.27399608, 0.50155377, 0.62806833, 0.47108881, 0.95060407,\n",
+       "         0.6806713 , 0.23337498, 0.4045021 , 0.3622902 , 0.41479225,\n",
+       "         0.5255417 , 0.87803697, 0.6299015 , 0.6965338 , 0.74122237,\n",
+       "         0.71905561, 0.21392037, 0.05950756, 0.36841156, 0.49753285,\n",
+       "         0.47952426, 0.6349023 , 0.82112918, 0.2256583 , 0.71479503,\n",
+       "         0.66250976, 0.72881137, 0.60264403, 0.56977916, 0.22136641,\n",
+       "         0.64898267, 0.469511  , 0.7731227 , 0.60596433, 0.03316667,\n",
+       "         0.03802478, 0.24201959, 0.07425821, 0.8163585 , 0.39698327,\n",
+       "         0.89983163, 0.36804661, 0.30183733, 0.03262771, 0.22796159,\n",
+       "         0.65103523, 0.01511088, 0.11394079, 0.6507492 , 0.33257084,\n",
+       "         0.76230229, 0.28549521, 0.04028606, 0.36139356, 0.889166  ,\n",
+       "         0.67783701, 0.17723507, 0.66518609, 0.86413806, 0.69168639,\n",
+       "         0.79187832, 0.91038901, 0.37228708, 0.48048336, 0.06371737,\n",
+       "         0.32302115, 0.90020679, 0.63158089, 0.52514972, 0.09317859,\n",
+       "         0.07671227, 0.63465768, 0.34138153, 0.0352425 , 0.79120745,\n",
+       "         0.24153934, 0.124083  , 0.23167348, 0.47569986, 0.56785272,\n",
+       "         0.03152147, 0.36377083, 0.93417836, 0.00308938, 0.41620902,\n",
+       "         0.96017147, 0.16941695, 0.49669156, 0.82004671, 0.80186092,\n",
+       "         0.34201109, 0.57538375, 0.04380919, 0.02887302, 0.83008538])],\n",
+       " [{'x': 0.5, 'y': 0, 'z': 15},\n",
+       "  array([0.10085373, 0.89020433, 0.5020103 , 0.53321429, 0.23884737,\n",
+       "         0.29960896, 0.31844161, 0.28619061, 0.96430294, 0.65094684,\n",
+       "         0.26603207, 0.16313636, 0.88537496, 0.11665349, 0.97364149,\n",
+       "         0.61723051, 0.9398117 , 0.35017829, 0.81622657, 0.8920931 ,\n",
+       "         0.55439331, 0.52459943, 0.39685363, 0.05270687, 0.03925469,\n",
+       "         0.43077531, 0.8768004 , 0.02316975, 0.9256348 , 0.59286166,\n",
+       "         0.47081801, 0.16402066, 0.62219207, 0.82273861, 0.32413582,\n",
+       "         0.58188467, 0.83825695, 0.42092253, 0.259126  , 0.28883077,\n",
+       "         0.81819112, 0.7315914 , 0.80605162, 0.8917003 , 0.36769154,\n",
+       "         0.17781673, 0.14508092, 0.17201237, 0.15932898, 0.1188686 ,\n",
+       "         0.08635844, 0.02356635, 0.73712502, 0.44723345, 0.18381022,\n",
+       "         0.34972678, 0.74042979, 0.1642673 , 0.83526595, 0.59526604,\n",
+       "         0.48132073, 0.3847834 , 0.44966642, 0.49666464, 0.4391638 ,\n",
+       "         0.82255819, 0.54240792, 0.60437853, 0.60956808, 0.01505983,\n",
+       "         0.37089889, 0.83891886, 0.63227209, 0.81763654, 0.74363278,\n",
+       "         0.36110181, 0.10065781, 0.43005997, 0.13131226, 0.33426462,\n",
+       "         0.0632574 , 0.90965429, 0.72017657, 0.72449606, 0.10897441,\n",
+       "         0.26284905, 0.02511043, 0.97425685, 0.59179729, 0.67818428,\n",
+       "         0.23210561, 0.00960374, 0.50120222, 0.63960781, 0.14938292,\n",
+       "         0.30390049, 0.33734481, 0.06716696, 0.11262085, 0.23542495])]]"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# During the scan, data was generated and stored into our array\n",
+    "print(len(my_functions_data))\n",
+    "my_functions_data[:2] #display the first two sets of data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "9b211e7f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# One could imagine extending the callback to an unlimited number of functions\n",
+    "# (Although, care should be taken to manage memory usage)\n",
+    "\n",
+    "other_data = []\n",
+    "shape, scale = 2., 2. # mean=4, std=2*sqrt(2)\n",
+    "\n",
+    "def my_other_function(scanner):\n",
+    "    s = np.random.gamma(shape, scale, 1000)\n",
+    "    other_data.append([scanner.get_current_position(), s])\n",
+    "    \n",
+    "\n",
+    "def both_hyper_functions(scanner):\n",
+    "    my_function(scanner)\n",
+    "    my_other_function(scanner)\n",
+    "    \n",
+    "both_hyper_functions.in_parallel = True"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "e8e5848c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scanner.set_hyper_data_acquisition_function(both_hyper_functions)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "9aa29ed2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scanner.run_scan()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "17324e75",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.colorbar.Colorbar at 0x7fe0203249d0>"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots()\n",
+    "artist = ax.imshow(scanner.get_count_rate(), cmap='gray', extent = scanner.get_completed_scan_range())\n",
+    "fig.colorbar(artist, ax=ax)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "03ff4c84",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import scipy.special as sps\n",
+    "\n",
+    "#randomly choose one of elements from other_data\n",
+    "\n",
+    "position, s = other_data[ np.random.choice(np.arange(len(other_data))) ]\n",
+    "\n",
+    "count, bins, ignored = plt.hist(s, 50, density=True)\n",
+    "y = bins**(shape-1)*(np.exp(-bins/scale) /\n",
+    "                     (sps.gamma(shape)*scale**shape))\n",
+    "plt.plot(bins, y, linewidth=2, color='r')\n",
+    "plt.title(position)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e221024a",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}