Continuous measurement (#214)

* core(in-progress): saving a checkmark of work towards implementing a continuous expt feature. Much of the heavy lifting has been done, but changes still need to be verified, validated, and added to our automatic testing if possible. File changes to abstract expt include new continuous preallocate, reallocate, and continuous save point methods; to runinfo include a new continuous_expt boolean attribute, and to experiment.py allow for continuous expt runs.

* most minor change to new naming convention.

* feat(core): adding ability for continuous measurement expts. Now by setting runinfo.continuous_expt to True, experimentalists can run their experiment designs continuously, and continue to extend their datasets indefinitely. This needs to be tested for how long/what number of continuous experiments can be run before the reallocation resizing bogs down, if ever. Also may want to consider changing the continuous_count var in experiment.py to a runinfo attribute to keep track of the number of repetitions without have to infer it through extraction of dataset size. I will likely find a solution for this where it will only added to continuous expts to not include it unnecessarily in the metadata of other experiments. Furthermore, not all data types/sizes have been tested with our new continuous_save_point function, and so one could still encounter bugs using this feature as we continue to flush it out. If so, please report them along with the circumstance you encountered it with in addition to the error message.

* chore(core): fixed minor issues, naming convention, and added runinfo.run_count attribute for continuous experiments.

* chore(core): fixed one more layer of continuous_preallocate; however, the lower layers likely still need updating. Furthermore, modifying experiment to be able to test the increasing lag times between experiments. Pushing to test on cint-transport overnight, hopefully this will provide a consistent testing environment since my computer was lagging out and artificially increasing runtimes temporarily.

* fix(measurement): updated continuous experiment to account for desired data formatting protocols.

* feat(core): implemented continuous measurement ability which works at all scan levels. Still need to ensure that it is the highest level scan; however, despite needing this check the continuous scan works well when set up properly.

* fix(core): Now continuous scan must be the highest level scan and not have empty scans below it. --Make sure this is what we want!

* chore(core): fix runinfo flake8 issue.

* refactor(core): feat continuous measurement scan now implemented with minimal changes to experiment.py. Furthermore, new data points are now not just saved to the hdf5 file, but captured by local arrays.

* fix(measurement): updated continuous scan to append values to attributes, write to proper locations in hdf5 of 1 value at a time, and allow for continuous experiments to have a pre-selected stop_at value for testing and/or increased experimental control.

* test(measurement)(scans): adding notebook for testing continuous scans timing over long runs (out to 100,000) with different kinds of experiment set ups, as well as plotting their deltas.

* chore(test): removing continuous_scan_time_test.ipynb notebook since it is not something we want to pull to the main branch and was simply for us to evaluate the efficacy of continuous scan as a method.

* test(refactor): updated tests to reflect expected behavior of saving protocols in abstract expt.

* fix(refactor)(measurement)(tests): fixed bug in save_point where average experiments would be treated as generic experiments.

* fixed sparse sweep but restoring old working condition of continuous scan saving.

* chore(measurement): updating continuous scan to use n_max instead of stop at. Adding runinfo attributes for replacing commonly used continuous scan required functions. Also refactoring check for empty property scan between continuous scans.

* chore(core): updated runinfo to match bug fix pr.

* refactor(core)(measurement): refactored abstract experiments save point, and runinfo to streamline code calls and partition functionalities into a more organized architecture.

* fix(core): fixed errors with abstract and runinfo changes causes test cases to fail.

* refactor(measurement): continuing to refactor for continuous scan and measurement changes. Removed continuous_dims and continuous ndims from runinfo for a work around. Still determining if scan.n can be incremented.

* feat(core)(measurement): average experiment can now be run continuously by implementing a continuous scan.

* fix(measurement): fixing runinfo attribute to no longer fail sparse expt test.

* refactor(measurement)(docs): refactored continuous scan iterator to return incrementing integers (0, 1, 2, 3...) instead of endless 0s. Furthermore added a doc string for ContinuousScan and its iterator method. Also updated doc strings to have improved formatting and added one for AbstractScans iterator method as well.

* refactor(measurement): updating continuous scan and measurement to use i and n attributes rather than run_count. Both are incrementing infinitely in the iterate function. Updated the docstring for this.

* fix(plotting)(docs): added continuous measurement scan demo nb with liveplotting. Updated basic_plots.py to support this. Renamed advanced demo notebooks numbering sequence to begin with an a.

* chore: renaming advanced demo notebook to account for advanced demo nb 02 that jasmine already added.

* chore: renaming a03 notebook in file title to match file name.

---------

Co-authored-by: i-am-mounce <[email protected]>
Co-authored-by: [email protected] <[email protected]>

Author: 3 people

.flake8

@@ -16,7 +16,7 @@ ignore=E266,E722,W503,C901
 ; exclude=
 
 # F401: module imported but unused
-#F403 unable to detect undefined names
+# F403 unable to detect undefined names
 per-file-ignores =
     pyscan/__init__.py:F401,F403
     pyscan/measurement/__init__.py:F401,F403

…books/advanced/01-custom_live_plot.ipynb …ooks/advanced/a01-custom_live_plot.ipynbdemo_notebooks/advanced/01-custom_live_plot.ipynb renamed to demo_notebooks/advanced/a01-custom_live_plot.ipynb demo_notebooks/advanced/01-custom_live_plot.ipynb renamed to demo_notebooks/advanced/a01-custom_live_plot.ipynb

@@ -10,7 +10,7 @@
 from .fast_stage_experiment import FastStageSweep, FastStageExperiment
 from .fast_galvo_experiment import FastGalvoSweep, FastGalvoExperiment
 
-from .scans import PropertyScan, RepeatScan, FunctionScan, AverageScan
+from .scans import PropertyScan, RepeatScan, ContinuousScan, FunctionScan, AverageScan
 
 # Other objects
 from .run_info import RunInfo

demo_notebooks/advanced/a03-example_continuous_scan.ipynb

@@ -42,6 +42,7 @@ def generic_experiment(self):
                 self.runinfo['t{}'.format(i)] = np.zeros(self.runinfo.dims)
 
         t0 = (datetime.now()).timestamp()
+
         # Use for scan, but break if self.runinfo.running=False
         for m in self.runinfo.scan3.iterator():
             self.runinfo.scan3.i = m
@@ -81,20 +82,12 @@ def generic_experiment(self):
                             self.runinfo.t3[indicies] = (datetime.now()).timestamp()
 
                         if np.all(np.array(self.runinfo.indicies) == 0):
-                            self.runinfo.measured = []
-                            for key, value in data.items():
-                                self.runinfo.measured.append(key)
                             self.preallocate(data)
 
-                        for key, value in data.items():
-                            if is_list_type(self[key]):
-                                self[key][self.runinfo.indicies] = value
-                            else:
-                                self[key] = value
                         if self.runinfo.time:
                             self.runinfo.t4[indicies] = (datetime.now()).timestamp()
 
-                        self.save_point()
+                        self.save_point(data)
 
                         if self.runinfo.time:
                             self.runinfo.t5[indicies] = (datetime.now()).timestamp()
@@ -103,21 +96,33 @@ def generic_experiment(self):
                             self.runinfo.complete = 'stopped'
                             break
 
+                        if isinstance(self.runinfo.scan0, ps.ContinuousScan):
+                            self.reallocate()
+
                     # Check if complete, stopped early
                     if self.runinfo.running is False:
                         self.runinfo.complete = 'stopped'
                         break
 
+                    if isinstance(self.runinfo.scan1, ps.ContinuousScan):
+                        self.reallocate()
+
                 if self.runinfo.running is False:
                     self.runinfo.complete = 'stopped'
                     break
 
+                if isinstance(self.runinfo.scan2, ps.ContinuousScan):
+                    self.reallocate()
+
             if self.runinfo.verbose:
                 print('Scan {}/{} Complete'.format(m + 1, self.runinfo.scan3.n))
             if self.runinfo.running is False:
                 self.runinfo.complete = 'stopped'
                 break
 
+            if isinstance(self.runinfo.scan3, ps.ContinuousScan):
+                self.reallocate()
+
         self.runinfo.complete = True
         self.runinfo.running = False
 
@@ -148,22 +153,22 @@ def average_experiment(self):
                 return
 
         # Use for scan, but break if self.runinfo.running=False
-        for m in range(self.runinfo.scan3.n):
+        for m in self.runinfo.scan3.iterator():
             self.runinfo.scan3.i = m
             self.runinfo.scan3.iterate(m, self.devices)
             sleep(self.runinfo.scan3.dt)
 
-            for k in range(self.runinfo.scan2.n):
+            for k in self.runinfo.scan2.iterator():
                 self.runinfo.scan2.i = k
                 self.runinfo.scan2.iterate(k, self.devices)
                 sleep(self.runinfo.scan2.dt)
 
-                for j in range(self.runinfo.scan1.n):
+                for j in self.runinfo.scan1.iterator():
                     self.runinfo.scan1.i = j
                     self.runinfo.scan1.iterate(j, self.devices)
                     sleep(self.runinfo.scan1.dt)
 
-                    for i in range(self.runinfo.scan0.n):
+                    for i in self.runinfo.scan0.iterator():
                         self.runinfo.scan0.i = i
                         self.runinfo.scan0.iterate(i, self.devices)
                         sleep(self.runinfo.scan0.dt)
@@ -172,9 +177,6 @@ def average_experiment(self):
 
                         # if on the first row of data, log the data names in self.runinfo.measured
                         if np.all(np.array(self.runinfo.indicies) == 0):
-                            self.runinfo.measured = []
-                            for key, value in data.items():
-                                self.runinfo.measured.append(key)
                             self.preallocate(data)
 
                         self.rolling_average(data)
@@ -183,24 +185,36 @@ def average_experiment(self):
                             self.runinfo.complete = 'stopped'
                             break
 
-                        self.save_point()
+                        self.save_point(data)
+
+                        if isinstance(self.runinfo.scan0, ps.ContinuousScan):
+                            self.reallocate()
 
-                    # self.save_row()
+                    # self.save_row(data)
 
                     # Check if complete, stopped early
                     if self.runinfo.running is False:
                         self.runinfo.complete = 'stopped'
                         break
 
+                    if isinstance(self.runinfo.scan1, ps.ContinuousScan):
+                        self.reallocate()
+
                 if self.runinfo.running is False:
                     self.runinfo.complete = 'stopped'
                     break
 
+                if isinstance(self.runinfo.scan2, ps.ContinuousScan):
+                    self.reallocate()
+
             print('Scan {}/{} Complete'.format(m + 1, self.runinfo.scan3.n))
             if self.runinfo.running is False:
                 self.runinfo.complete = 'stopped'
                 break
 
+            if isinstance(self.runinfo.scan3, ps.ContinuousScan):
+                self.reallocate()
+
         self.runinfo.complete = True
         self.runinfo.running = False
 

pyscan/measurement/__init__.py

@@ -2,6 +2,7 @@
 from pyscan.general.item_attribute import ItemAttribute
 from pyscan.general.get_pyscan_version import get_pyscan_version
 from .scans import PropertyScan, AverageScan
+import pyscan as ps
 
 
 class RunInfo(ItemAttribute):
@@ -62,6 +63,9 @@ def __init__(self):
         self.initial_pause = 0.1
         self.average_d = -1
 
+        # Assumed not a continuous expt. If there is a continuous scan this will be set to true in self.check()
+        self.continuous = False
+
         self.verbose = False
         self._pyscan_version = get_pyscan_version()
 
@@ -102,6 +106,32 @@ def check(self):
                     (f"Found empty PropertyScan (scan{count_down}) below used scan (scan{used_scan_index}).\n"
                      + "Scans must be populated in sequential order.")
 
+        # find the scan set to continuous scan (if any) and determine the index
+        for i, scan in enumerate(self.scans):
+            if isinstance(scan, ps.ContinuousScan):
+                self.continuous = True
+                self.continuous_scan_index = i
+
+        # If there is a ContinuousScan, ensure it is the highest level scan
+        if self.continuous:
+            for i in range(self.continuous_scan_index + 1, len(self.scans)):
+                assert isinstance(self.scans[i], PropertyScan) and len(self.scans[i].input_dict) == 0, \
+                    f"ContinuousScan found at scan{self.continuous_scan_index} but is not the highest level scan."
+
+    def stop_continuous(self, plus_one=False):
+        stop = False
+        if self.continuous:
+            continuous_scan = self.scans[self.continuous_scan_index]
+            if hasattr(continuous_scan, 'n_max'):
+                if plus_one is False:
+                    if continuous_scan.n_max <= continuous_scan.i:
+                        stop = True
+                elif plus_one is True:
+                    if continuous_scan.n_max <= continuous_scan.i + 1:
+                        stop = True
+
+        return stop
+
     @property
     def scans(self):
         ''' Returns array of all scans
@@ -117,6 +147,10 @@ def dims(self):
                 self.scan2.n,
                 self.scan3.n)
         dims = [n for n in dims if n != 1]
+        if self.continuous:
+            if len(dims) - 1 == self.continuous_scan_index:
+                dims = dims[:-1]
+            dims.append(1)
         self._dims = tuple(dims)
         return self._dims
 
@@ -132,7 +166,7 @@ def average_dims(self):
     def ndim(self):
         ''' Returns number of non 1 sized scans
         '''
-        self._ndim = len(self.dims)  # why is this stored as a property? It is never used
+        self._ndim = len(self.dims)
         return self._ndim
 
     @property
@@ -152,6 +186,8 @@ def indicies(self):
                           self.scan2.i,
                           self.scan3.i)
         self._indicies = self._indicies[:self.ndim]
+        if self.continuous:
+            self._indicies = self._indicies[:-1]
         return tuple(self._indicies)
 
     @property

pyscan/measurement/abstract_experiment.py

@@ -11,16 +11,21 @@ class AbstractScan(ItemAttribute):
 
     def iterate(self, index, devices):
         '''
-        A function to be implemented by inheriting Scan classes
+        A function to be implemented by inheriting Scan classes.
         '''
         pass
 
     def check_same_length(self):
-        '''A function to be implemented by inheriting Scan classes'''
+        '''
+        A function to be implemented by inheriting Scan classes.
+        '''
         pass
 
     # This must be a method and not an attribute as iterators can only be used once
     def iterator(self):
+        '''
+        Returns an iterator for the scan over its n range.
+        '''
         return iter(range(self.n))
 
 
@@ -72,7 +77,8 @@ def iterate(self, index, devices):
                 continue
 
     def check_same_length(self):
-        '''Check that the input_dict has values that are arrays of the same length
+        '''
+        Check that the input_dict has values that are arrays of the same length.
         '''
 
         if len(list(self.scan_dict.keys())) > 0:
@@ -85,7 +91,8 @@ def check_same_length(self):
 
 
 class FunctionScan(AbstractScan):
-    '''Class for iterating a function with input values inside an
+    '''
+    Class for iterating a function with input values inside an
     experimental loop. Inherits from `pyscan.measurement.scans.AbstractScan`.
 
     Parameters
@@ -141,10 +148,11 @@ class RepeatScan(AbstractScan):
     '''
 
     def __init__(self, nrepeat, dt=0):
-        '''Constructor method
+        '''
+        Constructor method.
         '''
         assert nrepeat > 0, "nrepeat must be > 0"
-        assert nrepeat != np.inf, "nrepeat is np.inf"
+        assert nrepeat != np.inf, "nrepeat is np.inf, make a continuous scan instead."
         self.scan_dict = {}
         self.scan_dict['repeat'] = list(range(nrepeat))
 
@@ -156,7 +164,8 @@ def __init__(self, nrepeat, dt=0):
         self.i = 0
 
     def iterate(self, index, devices):
-        '''Iterates repeat loop
+        '''
+        Iterates repeat loop.
         '''
 
         # Need a method here to iterate infinitely/continuously.
@@ -170,8 +179,62 @@ def check_same_length(self):
         return 1
 
 
+class ContinuousScan(AbstractScan):
+    '''
+    Class for performing a continuous scan, which runs indefinitely or until a specified maximum number of iterations.
+    Inherits from `pyscan.measurement.scans.AbstractScan`.
+
+    Parameters
+    ----------
+    dt : float, optional
+        Wait time in seconds after each iteration. Used by experiment classes, defaults to 0.
+    n_max : int, optional
+        Maximum number of iterations to run. If not specified, the scan will run indefinitely.
+    '''
+
+    def __init__(self, dt=0, n_max=None):
+        self.scan_dict = {}
+        self.scan_dict['continuous'] = []
+
+        self.device_names = ['continuous']
+        self.dt = dt
+
+        self.run_count = 0
+        # essentially run_count
+        self.n = 1
+        # current experiment number index
+        self.i = 0
+        if n_max is not None:
+            self.n_max = n_max
+
+    def iterate(self, index, devices):
+        self.run_count += 1
+
+        if hasattr(self, "stop_at"):
+            if not self.n_max <= self.i:
+                self.scan_dict['continuous'].append(self.i)
+        else:
+            self.scan_dict['continuous'].append(self.i)
+
+    def iterator(self):
+        '''
+        The following iterator increments continuous scan i and n by one each time continuously.
+        '''
+        def incrementing_n():
+            while True:
+                yield self.i
+                self.i += 1
+                self.n += 1
+
+        iterator = iter(incrementing_n())
+
+        # returns an infinite iterator, overwriting Abstract scans default iterator
+        return iterator
+
+
 class AverageScan(AbstractScan):
-    '''Class for averaging inner loops.
+    '''
+    Class for averaging inner loops.
 
     Parameters
     ----------

pyscan/measurement/experiment.py

@@ -84,7 +84,7 @@ def run(self):
                                     else:
                                         self[key] = value
 
-                                self.save_point()
+                                self.save_point(data)
 
                         if self.runinfo.running is False:
                             self.runinfo.complete = 'stopped'