diff --git a/pyproject.toml b/pyproject.toml
index 592b4f59..924c3d2d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -47,6 +47,7 @@ dependencies = [
     "numpy>=1.21.2",
     "matplotlib>=3.4.3",
     "scipy>=1.7.1",
+    "h5py>=3.3.0",
     "qcsapphire>=1.0.1",
     "qt3rfsynthcontrol>=1.0.1",
     "nipiezojenapy>=1.0.1",
diff --git a/src/applications/piezoscan.py b/src/applications/piezoscan.py
index 1defffac..37417103 100644
--- a/src/applications/piezoscan.py
+++ b/src/applications/piezoscan.py
@@ -1,26 +1,23 @@
-import time
 import argparse
-import collections
 import tkinter as tk
-import tkinter.ttk as ttk
 import logging
 import datetime
 from threading import Thread
 
 import numpy as np
-import scipy.optimize
 import matplotlib.pyplot as plt
 from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
 import matplotlib
-matplotlib.use('Agg')
 import nidaqmx
+import h5py
 
 import qt3utils.nidaq
 import qt3utils.datagenerators as datasources
-import qt3utils.datagenerators.piezoscanner
 import qt3utils.pulsers.pulseblaster
 import nipiezojenapy
 
+matplotlib.use('Agg')
+
 
 parser = argparse.ArgumentParser(description='NI DAQ (PCIx 6363) / Jena Piezo Scanner',
                                  formatter_class=argparse.ArgumentDefaultsHelpFormatter)
@@ -86,10 +83,10 @@ def __init__(self, mplcolormap = 'Reds'):
     def update(self, model):
 
         if self.log_data:
-            data = np.log10(model.data)
+            data = np.log10(model.scanned_count_rate)
             data[np.isinf(data)] = 0 #protect against +-inf
         else:
-            data = model.data
+            data = model.scanned_count_rate
 
         self.artist = self.ax.imshow(data, cmap=self.cmap, extent=[model.xmin,
                                                                    model.xmax + model.step_size,
@@ -117,6 +114,7 @@ def onclick(self, event):
             #todo: draw a circle around clicked point? Maybe with a high alpha, so that its faint
             self.onclick_callback(event)
 
+
 class SidePanel():
     def __init__(self, root, scan_range):
         frame = tk.Frame(root)
@@ -231,7 +229,6 @@ def __init__(self, root, scan_range):
         self.log10Button = tk.Button(frame, text="Log10")
         self.log10Button.grid(row=row, column=2, pady=(2,15))
 
-
     def update_go_to_position(self, x = None, y = None, z = None):
         if x is not None:
             self.go_to_x_position_text.set(np.round(x,4))
@@ -294,11 +291,11 @@ def show_optimization_plot(self, title, old_opt_value,
 
 class MainTkApplication():
 
-    def __init__(self, data_model):
+    def __init__(self, counter_scanner):
         self.root = tk.Tk()
-        self.model = data_model
-        scan_range = [data_model.stage_controller.minimum_allowed_position,
-                      data_model.stage_controller.maximum_allowed_position]
+        self.counter_scanner = counter_scanner
+        scan_range = [counter_scanner.stage_controller.minimum_allowed_position,
+                      counter_scanner.stage_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)
@@ -319,8 +316,8 @@ def __init__(self, data_model):
         self.scan_thread = None
 
         self.optimized_position = {'x':0, 'y':0, 'z':-1}
-        if self.model.stage_controller:
-            self.optimized_position['z'] = self.model.stage_controller.get_current_position()[2]
+        if self.counter_scanner.stage_controller:
+            self.optimized_position['z'] = self.counter_scanner.stage_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))
@@ -332,16 +329,16 @@ def run(self):
         self.root.mainloop()
 
     def go_to_position(self, event = None):
-        if self.model.stage_controller:
-            self.model.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.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())
         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}')
         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.model.stage_controller:
-            self.model.stage_controller.go_to_position(z = self.view.sidepanel.z_entry_text.get())
+        if self.counter_scanner.stage_controller:
+            self.counter_scanner.stage_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}')
         self.optimized_position['z'] = self.view.sidepanel.z_entry_text.get()
@@ -349,15 +346,15 @@ def go_to_z(self, event = None):
     def set_color_map(self, event = None):
         #Is there a way for this function to exist entirely in the view code instead of here?
         self.view.scan_view.cmap = self.view.sidepanel.mpl_color_map_entry.get()
-        if len(self.model.data) > 0:
-            self.view.scan_view.update(self.model)
+        if len(self.counter_scanner.scanned_count_rate) > 0:
+            self.view.scan_view.update(self.counter_scanner)
             self.view.canvas.draw()
 
     def log_scan_image(self, event = None):
         #Is there a way for this function to exist entirely in the view code instead of here?
         self.view.scan_view.log_data = not self.view.scan_view.log_data
-        if len(self.model.data) > 0:
-            self.view.scan_view.update(self.model)
+        if len(self.counter_scanner.scanned_count_rate) > 0:
+            self.view.scan_view.update(self.counter_scanner)
             self.view.canvas.draw()
 
     def hold_aom_with_pulse_blaster(self, event = None):
@@ -367,7 +364,7 @@ def hold_aom_with_pulse_blaster(self, event = None):
         pb.start()
 
     def stop_scan(self, event = None):
-        self.model.stop()
+        self.counter_scanner.stop()
 
 
     def pop_out_scan(self, event = None):
@@ -393,22 +390,22 @@ def pop_out_scan(self, event = None):
 
     def scan_thread_function(self, xmin, xmax, ymin, ymax, step_size, N):
 
-        self.model.set_scan_range(xmin, xmax, ymin, ymax)
-        self.model.step_size = step_size
-        self.model.set_num_data_samples_per_batch(N)
+        self.counter_scanner.set_scan_range(xmin, xmax, ymin, ymax)
+        self.counter_scanner.step_size = step_size
+        self.counter_scanner.set_num_data_samples_per_batch(N)
 
         try:
-            self.model.reset() #clears the data
-            self.model.start() #starts the DAQ
-            self.model.set_to_starting_position() #moves the stage to starting position
+            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.model.still_scanning():
-                self.model.scan_x()
-                self.view.scan_view.update(self.model)
+            while self.counter_scanner.still_scanning():
+                self.counter_scanner.scan_x()
+                self.view.scan_view.update(self.counter_scanner)
                 self.view.canvas.draw()
-                self.model.move_y()
+                self.counter_scanner.move_y()
 
-            self.model.stop()
+            self.counter_scanner.stop()
 
         except nidaqmx.errors.DaqError as e:
             logger.info(e)
@@ -453,25 +450,43 @@ def start_scan(self, event = None):
         self.scan_thread.start()
 
     def save_scan(self, event = None):
-        myformats = [('Numpy Array', '*.npy')]
-        afile = tk.filedialog.asksaveasfilename(filetypes = myformats, defaultextension = '.npy')
+        myformats = [('Compressed Numpy MultiArray', '*.npz'), ('Numpy Array (count rate only)', '*.npy'), ('HDF5', '*.h5')]
+        afile = tk.filedialog.asksaveasfilename(filetypes=myformats, defaultextension='.npz')
         logger.info(afile)
+        file_type = afile.split('.')[-1]
         if afile is None or afile == '':
-           return #selection was canceled.
-        with open(afile, 'wb') as f_object:
-          np.save(f_object, self.model.data)
+            return # selection was canceled.
+
+        data = dict(
+                    raw_counts=self.counter_scanner.scanned_raw_counts,
+                    count_rate=self.counter_scanner.scanned_count_rate,
+                    scan_range=self.counter_scanner.get_completed_scan_range(),
+                    step_size=self.counter_scanner.step_size,
+                    daq_clock_rate=self.counter_scanner.rate_counter.clock_rate,
+                    )
+
+        if file_type == 'npy':
+            np.save(afile, data['count_rate'])
+
+        if file_type == 'npz':
+            np.savez_compressed(afile, **data)
+
+        elif file_type == 'h5':
+            h5file = h5py.File(afile, 'w')
+            for key, value in data.items():
+                h5file.create_dataset(key, data=value)
+            h5file.close()
 
-        self.view.sidepanel.saveScanButton['state'] = 'normal'
 
     def optimize_thread_function(self, axis, central, range, step_size):
 
         try:
-            data, axis_vals, opt_pos, coeff = self.model.optimize_position(axis,
+            data, axis_vals, opt_pos, coeff = self.counter_scanner.optimize_position(axis,
                                                                            central,
                                                                            range,
                                                                            step_size)
             self.optimized_position[axis] = opt_pos
-            self.model.stage_controller.go_to_position(**{axis:opt_pos})
+            self.counter_scanner.stage_controller.go_to_position(**{axis:opt_pos})
             self.view.show_optimization_plot(f'Optimize {axis}',
                                              central,
                                              self.optimized_position[axis],
@@ -502,7 +517,7 @@ def optimize(self, axis):
         opt_step_size = float(self.view.sidepanel.optimize_step_size_entry.get())
         old_optimized_value = self.optimized_position[axis]
 
-        self.model.set_num_data_samples_per_batch(self.view.sidepanel.n_sample_size_value.get())
+        self.counter_scanner.set_num_data_samples_per_batch(self.view.sidepanel.n_sample_size_value.get())
 
         self.view.sidepanel.startButton['state'] = 'disabled'
         self.view.sidepanel.stopButton['state'] = 'disabled'
@@ -531,7 +546,8 @@ def on_closing(self):
 def build_data_scanner():
     if args.randomtest:
         stage_controller = nipiezojenapy.BaseControl()
-        scanner = datasources.RandomPiezoScanner(stage_controller=stage_controller)
+        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,
                                   write_channels = args.piezo_write_channels.split(','),
@@ -545,7 +561,7 @@ def build_data_scanner():
                                                             args.rwtimeout,
                                                             args.signal_counter)
 
-        scanner = datasources.NiDaqPiezoScanner(data_acq, stage_controller)
+    scanner = datasources.CounterAndScanner(data_acq, stage_controller)
 
     return scanner
 
@@ -554,5 +570,6 @@ def main():
     tkapp = MainTkApplication(build_data_scanner())
     tkapp.run()
 
+
 if __name__ == '__main__':
     main()
diff --git a/src/qt3utils/datagenerators/__init__.py b/src/qt3utils/datagenerators/__init__.py
index 62977f18..eb0bbd4c 100644
--- a/src/qt3utils/datagenerators/__init__.py
+++ b/src/qt3utils/datagenerators/__init__.py
@@ -1,3 +1,5 @@
 from .daqsamplers import RandomRateCounter
 from .daqsamplers import NiDaqDigitalInputRateCounter
-from .piezoscanner import NiDaqPiezoScanner, RandomPiezoScanner
+from .piezoscanner import CounterAndScanner
+from .piezoscanner import CounterAndScanner as NiDaqPiezoScanner
+from .piezoscanner import CounterAndScanner as RandomPiezoScanner
diff --git a/src/qt3utils/datagenerators/daqsamplers.py b/src/qt3utils/datagenerators/daqsamplers.py
index ef23dc85..1a36d72e 100644
--- a/src/qt3utils/datagenerators/daqsamplers.py
+++ b/src/qt3utils/datagenerators/daqsamplers.py
@@ -1,5 +1,6 @@
 import time
 import logging
+import abc
 
 import numpy as np
 import nidaqmx
@@ -8,68 +9,181 @@
 
 logger = logging.getLogger(__name__)
 
-class RateCounterInterface:
+class RateCounterBase(abc.ABC):
+    """
+    Subclasses must implement a clock_rate attribute or property.
+    """
+    def __init__(self):
+        self.running = False
+        self.clock_rate = 0
     def stop(self):
-        pass
+        """
+        subclasses may override this for custom behavior
+        """
+        self.running = False
 
     def start(self):
-        pass
+        """
+        subclasses may override this for custom behavior
+        """
+        self.running = True
 
     def close(self):
+        """
+        subclasses may override this for custom behavior
+        """
         pass
 
-    def sample_count_rate(self, n_samples = None):
-        pass
+    @abc.abstractmethod
+    def _read_samples(self):
+        """
+        subclasses must implement this method
 
-    def yield_count_rate(self):
-        #this should be a generator function
-        #yield np.mean(self.sample_count_rate())
+        Should return total_counts, num_clock_samples
+        """
         pass
 
+    def sample_counts(self, n_batches=1, sum_counts=True):
+        """
+        Performs n_batches of batch reads from _read_samples method.
 
-class RandomRateCounter(RateCounterInterface):
+        This is useful when hardware (such as NIDAQ) is pre-configured to acquire a fixed number of samples
+        and the caller wishes to read more data than the number of samples acquired.
+        For example, if the NiDAQ is configured to acquire 1000 clock samples, but the caller
+        wishes to read 10000 samples, then this function may be called with n_batches=10.
 
-    '''
+        For each batch read (of size `num_data_samples_per_batch`), the
+        total counts are summed. Because it's possible (though unlikely)
+        for the hardware to return fewer than `num_data_samples_per_batch` measurements,
+        the actual number of data samples per batch are also recorded.
+
+        If sum_counts is False, a numpy array of shape (n_batches, 2) is returned, where
+        the first element is the sum of the counts, and the second element is
+        the actual number of clock samples per batch. This may be useful for the caller if
+        they wish to perform their own averaging or other statistical analysis that may be time dependent.
+
+        For example, if `num_data_samples_per_batch` is 5 and n_batches is 3,
+        (typical values are 100 and 10, 100 and 1, 1000 and 1, etc)
+
+        reading counts from the NiDAQ may return
+
+        #sample 1
+        raw_counts_1 = [3,5,4,6,4]
+        sum_counts_1 = 22
+        size_counts_1 = 5
+           (22, 5)
+        #sample 2
+        raw_counts_2 = [5,5,7,3,4]
+        sum_counts_2 = 24
+        size_counts_2 = 5
+           (24, 5)
+        #sample 3
+        raw_counts_3 = [5,3,5,7]
+        sum_counts_3 = 20
+        size_counts_2 = 4
+           (20, 4)
+
+        In this example, the numpy array is of shape (3, 2) and will be
+        data = [
+                [22, 5],
+                [24, 5],
+                [20, 4]
+               ]
+
+        If sum_counts is True, then will the total number of counts and total number of
+        clock samples read will be returned.
+
+        np.sum(data, axis=0, keepdims=True).
+
+        In the example above, this would be [[66, 14]].
+
+        With these data, and knowing the clock_rate, one can easily compute
+        the count rate. See sample_count_rate.
+        """
+
+        data = np.zeros((n_batches, 2))
+        for i in range(n_batches):
+            data_sample, samples_read = self._read_samples()
+            if samples_read > 0:
+                data[i][0] = np.sum(data_sample[:samples_read])
+            data[i][1] = samples_read
+            logger.info(f'batch data (sum counts, num clock cycles per batch): {data[i]}')
+
+        if sum_counts:
+            return np.sum(data, axis=0, keepdims=True)
+        else:
+            return data
+
+    def sample_count_rate(self, data_counts: np.ndarray):
+        """
+        Converts the output of sample_counts to a count rate. Expects data_counts to be a 2d numpy array
+        of [[counts, clock_samples], [counts, clock_samples], ...] or a 2d array with one row: [[counts, clock_samples]]
+        as is returned by sample_counts.
+
+        Returns the count rate in counts/second = clock_rate * total counts/ total clock_samples)
+
+        If the sum of all clock_samples is 0, will return np.nan.
+        """
+        _data = np.sum(data_counts, axis=0)
+        if _data[1] > 0:
+            return self.clock_rate * _data[0]/_data[1]
+        else:
+            return np.nan
+
+    def yield_count_rate(self):
+        while self.running:
+            count_data = self.sample_counts()
+            yield self.sample_count_rate(count_data)
+
+
+class RandomRateCounter(RateCounterBase):
+    """
     This random source acts like a light source with variable intensity.
 
     This is similar to a PL source moving in and out of focus.
-    '''
-    def __init__(self):
+
+    When 'simulated_single_light_source' is True at instantiation,
+    this will simulate a sample with isolated bright spots, like NV centers in diamond and
+    is used when testing the CounterAndScanner class in piezoscanner.py module.
+    """
+    def __init__(self, simulate_single_light_source=False, num_data_samples_per_batch=10):
+        super().__init__()
         self.default_offset = 100
-        self.signal_noise_amp  = 0.2
-        self.possible_offset_values = np.arange(0, 1000, 50)
+        self.signal_noise_amp = 0.2
 
         self.current_offset = self.default_offset
         self.current_direction = 1
-        self.running = False
-
-    def stop(self):
-        self.running = False
-
-    def start(self):
-        self.running = True
+        self.clock_rate = 0.9302010 # a totally random number :P
+        self.simulate_single_light_source = simulate_single_light_source
+        self.possible_offset_values = np.arange(5000, 100000, 1000)  # these create the "bright" positions
+        self.num_data_samples_per_batch = num_data_samples_per_batch
 
-    def close(self):
-        pass
+    def _read_samples(self):
+        """
+        Returns a random number of counts
+        """
+        if self.simulate_single_light_source:
+            if np.random.random(1)[0] < 0.005:
+                self.current_offset = np.random.choice(self.possible_offset_values)
+            else:
+                self.current_offset = self.default_offset
 
-    def sample_count_rate(self, n_samples = 1):
-        if np.random.random(1)[0] < 0.05:
-            if np.random.random(1)[0] < 0.1:
-                self.current_direction = -1 * self.current_direction
-            self.current_offset += self.current_direction*np.random.choice(self.possible_offset_values)
+        else:
+            if np.random.random(1)[0] < 0.05:
+                if np.random.random(1)[0] < 0.1:
+                    self.current_direction = -1 * self.current_direction
+                self.current_offset += self.current_direction*np.random.choice(self.possible_offset_values)
 
-        if self.current_offset < self.default_offset:
-            self.current_offset = self.default_offset
-            self.current_direction = 1
+            if self.current_offset < self.default_offset:
+                self.current_offset = self.default_offset
+                self.current_direction = 1
 
-        return self.signal_noise_amp*self.current_offset*np.random.random(n_samples) + self.current_offset
+        counts = self.signal_noise_amp * self.current_offset * np.random.random(self.num_data_samples_per_batch) + self.current_offset
 
-    def yield_count_rate(self):
-        while self.running:
-            yield np.mean(self.sample_count_rate())
+        return counts, self.num_data_samples_per_batch
 
 
-class NiDaqDigitalInputRateCounter(RateCounterInterface):
+class NiDaqDigitalInputRateCounter(RateCounterBase):
 
     def __init__(self, daq_name = 'Dev1',
                        signal_terminal = 'PFI0',
@@ -80,7 +194,7 @@ def __init__(self, daq_name = 'Dev1',
                        signal_counter = 'ctr2',
                        trigger_terminal = None,
                        ):
-
+        super().__init__()
         self.daq_name = daq_name
         self.signal_terminal = signal_terminal
         self.clock_rate = clock_rate
@@ -89,7 +203,6 @@ def __init__(self, daq_name = 'Dev1',
         self.read_write_timeout = read_write_timeout
         self.num_data_samples_per_batch = num_data_samples_per_batch
         self.trigger_terminal = trigger_terminal
-        self.running = False
 
         self.read_lock = False
 
@@ -151,7 +264,6 @@ def _read_samples(self):
             self.read_lock = False
             return data_buffer, samples_read
 
-
     def start(self):
         if self.running:
             self.stop()
@@ -171,12 +283,12 @@ def _burn_and_log_exception(self, f):
     def stop(self):
         if self.running:
             while self.read_lock:
-                time.sleep(0.1) #wait for current read to complete
+                time.sleep(0.1) # wait for current read to complete
 
             if self.nidaq_config.clock_task:
                 self._burn_and_log_exception(self.nidaq_config.clock_task.stop)
-                self._burn_and_log_exception(self.nidaq_config.clock_task.close) #close the task to free resource on NIDAQ
-            #self._burn_and_log_exception(self.nidaq_config.counter_task.stop) #will need to stop task if we move to continuous buffered acquisition
+                self._burn_and_log_exception(self.nidaq_config.clock_task.close) # close the task to free resource on NIDAQ
+            # self._burn_and_log_exception(self.nidaq_config.counter_task.stop) # will need to stop task if we move to continuous buffered acquisition
             self._burn_and_log_exception(self.nidaq_config.counter_task.close)
 
         self.running = False
@@ -184,90 +296,6 @@ def stop(self):
     def close(self):
         self.stop()
 
-    def sample_counts(self, n_samples = 1):
-        '''
-        Performs n_samples of batch reads from the NiDAQ.
 
-        For each batch read (of size `num_data_samples_per_batch`), the
-        total counts are summed. Additionally, because it's possible (though unlikely)
-        for the NiDAQ to return fewer than `num_data_samples_per_batch` measurements,
-        the actual number of data samples per batch are also recorded.
-
-        Finally, a numpy array of shape (n_samples, 2) is returned, where
-        the first element is the sum of the counts, and the second element is
-        the actual number of data samples per batch.
-
-        For example, if `num_data_samples_per_batch` is 5 and n_samples is 3,
-        (typical values are 100 and 10, 100 and 1, 1000 and 1, etc)
 
-        reading counts from the NiDAQ may return
 
-        #sample 1
-        raw_counts_1 = [3,5,4,6,4]
-        sum_counts_1 = 22
-        size_counts_1 = 5
-           (22, 5)
-        #sample 2
-        raw_counts_2 = [5,5,7,3,4]
-        sum_counts_2 = 24
-        size_counts_2 = 5
-           (24, 5)
-        #sample 3
-        raw_counts_3 = [5,3,5,7]
-        sum_counts_3 = 20
-        size_counts_2 = 4
-           (20, 4)
-
-        In this example, the numpy array is of shape (3, 2) and will be
-        data = [
-                [22, 5],
-                [24, 5],
-                [20, 4]
-               ]
-
-        With these data, and knowing the clock_rate, one can easily compute
-        the count rate
-
-        #removes rows where num samples per batch were zero (which would be a bug in the code)
-        data = data[np.where(data[:,1] > 0)]
-
-        #count rate is the mean counts per clock cycle multiplied by the clock rate.
-        count_rate = clock_rate * data[:,0]/data[:,1]
-        '''
-
-        data =np.zeros((n_samples, 2))
-        for i in range(n_samples):
-            data_sample, samples_read = self._read_samples()
-            if samples_read > 0:
-                data[i][0] = np.sum(data_sample[:samples_read])
-            data[i][1] = samples_read
-            logger.info(f'batch data (sum counts, num clock cycles per batch): {data[i]}')
-        return data
-
-    def sample_count_rate(self, n_samples = 1):
-        '''
-        Utilizes sample_counts method above and compute the count rate as described
-        in that method's docstring.
-
-        Under normal conditions, will return a numpy array of size n_samples, with values
-        equal to the estimated count rate.
-
-        However, there are two possible outcomes if there are errors reading the NiDAQ.
-
-        1. return a numpy array of count rate measurements of size 0 < N < n_samples (if there's partial error)
-        2. return a numpy array of size N = n_samples with value of np.nan if no data are returned
-
-        If the NiDAQ is configured properly and sufficient time is allowed for data to be
-        acquired per batch, it's very unlikely that any errors will occur.
-        '''
-
-        data = self.sample_counts(n_samples)
-        data = data[np.where(data[:,1] > 0)]
-        if data.shape[0] > 0:
-            return self.clock_rate * data[:,0]/data[:,1]
-        else:
-            return np.nan*np.ones(n_samples)
-
-    def yield_count_rate(self):
-        while self.running:
-            yield np.mean(self.sample_count_rate())
diff --git a/src/qt3utils/datagenerators/piezoscanner.py b/src/qt3utils/datagenerators/piezoscanner.py
index 16f84293..a04ead2e 100644
--- a/src/qt3utils/datagenerators/piezoscanner.py
+++ b/src/qt3utils/datagenerators/piezoscanner.py
@@ -1,4 +1,3 @@
-import abc
 import numpy as np
 import scipy.optimize
 import time
@@ -10,29 +9,33 @@ def gauss(x, *p):
     C, mu, sigma, offset = p
     return C*np.exp(-(x-mu)**2/(2.*sigma**2)) + offset
 
-class BasePiezoScanner(abc.ABC):
-    def __init__(self, stage_controller = None):
 
-        self.running = False
+class CounterAndScanner:
+    def __init__(self, rate_counter, stage_controller):
 
+        self.running = False
         self.current_y = 0
         self.ymin = 0.0
         self.ymax = 80.0
         self.xmin = 0.0
         self.xmax = 80.0
         self.step_size = 0.5
-        self.raster_line_pause = 0.0
+        self.raster_line_pause = 0.150  # wait 150ms for the piezo stage to settle before a line scan
 
-        self.data = []
-        self.stage_controller = stage_controller
+        self.scanned_raw_counts = []
+        self.scanned_count_rate = []
 
-        self.num_daq_batches = 1 #could change to 10 if want 10x more samples for each position
+        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
 
     def stop(self):
+        self.rate_counter.stop()
         self.running = False
 
     def start(self):
         self.running = True
+        self.rate_counter.start()
 
     def set_to_starting_position(self):
         self.current_y = self.ymin
@@ -40,7 +43,18 @@ def set_to_starting_position(self):
             self.stage_controller.go_to_position(x = self.xmin, y = self.ymin)
 
     def close(self):
-        return
+        self.rate_counter.close()
+
+    def set_num_data_samples_per_batch(self, N):
+        self.rate_counter.num_data_samples_per_batch = N
+
+    def sample_counts(self):
+        return self.rate_counter.sample_counts(self.num_daq_batches)
+
+    def sample_count_rate(self, data_counts=None):
+        if data_counts is None:
+            data_counts = self.sample_counts()
+        return self.rate_counter.sample_count_rate(data_counts)
 
     def set_scan_range(self, xmin, xmax, ymin, ymax):
         if self.stage_controller:
@@ -52,6 +66,20 @@ def set_scan_range(self, xmin, xmax, ymin, ymax):
         self.xmin = xmin
         self.xmax = xmax
 
+    def get_scan_range(self) -> tuple:
+        """
+        Returns a tuple of the full scan range
+        :return: xmin, xmax, ymin, ymax
+        """
+        return self.xmin, self.xmax, self.ymin, self.ymax
+
+    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 self.xmin, self.xmax, self.ymin, self.current_y
+
     def still_scanning(self):
         if self.running == False: #this allows external process to stop scan
             return False
@@ -70,41 +98,42 @@ def move_y(self):
             except ValueError as e:
                 logger.info(f'out of range\n\n{e}')
 
-    @abc.abstractmethod
-    def sample_count_rate(self):
-        '''
-        must return an array-like object
-        '''
-        pass
-
-    @abc.abstractmethod
-    def set_num_data_samples_per_batch(self, N):
-        pass
-
     def scan_x(self):
+        """
+        Scans the x axis from xmin to xmax in steps of step_size.
 
-        scan = self.scan_axis('x', self.xmin, self.xmax, self.step_size)
-        self.data.append(scan)
+        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)
+        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):
-        scan = []
+        """
+        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.
+        """
+        raw_counts = []
         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})
-            cr = np.mean(self.sample_count_rate())
-            scan.append(cr)
-            logger.info(f'count rate: {cr}')
+            _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()}')
 
-        return scan
+        return raw_counts
 
     def reset(self):
-        self.data = []
-
+        self.scanned_raw_counts = []
+        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`.
@@ -124,10 +153,10 @@ def optimize_position(self, axis, center_position, width = 2, step_size = 0.25):
         example:
            ([r0, r1, ...], [x0, x1, ...], x_optimal, [C, mu, sigma])
 
-        In cases where the data cannot be succesfully fit to a gaussian function,
-        the optimial_position returned is the absolute brightest position in the scan,
+        In cases where the data cannot be successfully fit to a gaussian function,
+        the optimal_position returned is the absolute brightest position in the scan,
         and the fit_coeff is set to None.
-        When the fit is sucessful, x_optimal = mu.
+        When the fit is successful, x_optimal = mu.
 
         '''
         min_val = center_position - width
@@ -140,72 +169,23 @@ def optimize_position(self, axis, center_position, width = 2, step_size = 0.25):
             max_val = np.min([max_val, 80.0])
 
         self.start()
-        data = 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]
 
-        optimal_position = axis_vals[np.argmax(data)]
+        optimal_position = axis_vals[np.argmax(count_rates)]
         coeff = None
-        params = [np.max(data), optimal_position, 1.0, np.min(data)]
+        params = [np.max(count_rates), optimal_position, 1.0, np.min(count_rates)]
+        bounds = (len(params)*tuple((0,)), len(params)*tuple((np.inf,)))
         try:
-            coeff, var_matrix = scipy.optimize.curve_fit(gauss, axis_vals, data, p0=params)
+            coeff, var_matrix = scipy.optimize.curve_fit(gauss, axis_vals, count_rates, p0=params, bounds=bounds)
             optimal_position = coeff[1]
             # ensure that the optimal position is within the scan range
             optimal_position = np.max([min_val, optimal_position])
             optimal_position = np.min([max_val, optimal_position])
         except RuntimeError as e:
-            print(e)
-
-        return data, axis_vals, optimal_position, coeff
-
-class NiDaqPiezoScanner(BasePiezoScanner):
-    def __init__(self, nidaqratecounter, stage_controller, num_data_samples_per_batch = 50):
-        super().__init__(stage_controller)
-        self.nidaqratecounter = nidaqratecounter
-        self.raster_line_pause = 0.150  #wait 150ms for the piezo stage to settle before a line scan
-        self.set_num_data_samples_per_batch(num_data_samples_per_batch)
-
-    def set_num_data_samples_per_batch(self, N):
-        self.nidaqratecounter.num_data_samples_per_batch = N
-
-    def sample_count_rate(self):
-        return self.nidaqratecounter.sample_count_rate(self.num_daq_batches)
-
-    def stop(self):
-        self.nidaqratecounter.stop()
-        super().stop()
-
-    def start(self):
-        super().start()
-        self.nidaqratecounter.start()
+            logger.warning(e)
 
-    def close(self):
-        super().close()
-        self.nidaqratecounter.close()
-
-class RandomPiezoScanner(BasePiezoScanner):
-    '''
-    This random scanner acts like it finds bright light sources
-    at random positions across a scan.
-    '''
-    def __init__(self, stage_controller = None):
-        super().__init__(stage_controller)
-        self.default_offset = 350
-        self.signal_noise_amp  = 0.2
-        self.possible_offset_values = np.arange(5000, 100000, 1000)
-
-        self.current_offset = self.default_offset
-
-    def set_num_data_samples_per_batch(self, N):
-        #for the random sampler, there is only one sample per batch. So, we set
-        #number of batches here
-        self.num_daq_batches = N
-
-    def sample_count_rate(self):
-        #time.sleep(.25) #simulate time for data acquisition
-        if np.random.random(1)[0] < 0.005:
-            self.current_offset = np.random.choice(self.possible_offset_values)
-        else:
-            self.current_offset = self.default_offset
+        return count_rates, axis_vals, optimal_position, coeff
 
-        return self.signal_noise_amp*self.current_offset*np.random.random(self.num_daq_batches) + self.current_offset