Draft: WIP Positive/negative standard deviation refinement

I have changed the function find_transition in refine.py look at threshold crossings above and below the channel's mean by a given standard deviation. This makes the refinement more accurate by around 25ms in some cases (see images below) and does not effect the refinement in others. The tuple returned by find_transition is threshold, refined_gps from the first threshold crossing (or only threshold crossing or None if no crossings exist).

The number of standard deviations is still taken from config.py but now the sign doesn't matter, only the magnitude. Signs have been removed and comments added too config.py to indicate that.

find_transition now creates a list dictionary containing a list of first ind where threshold crosses and threshold, sorts that list so the first ind (crossing) comes first and then outputs ind and threshold from the beginning of the list. This list only contains entries if the ind exists.

eg: thresh_crossing_list = [[ind_that_comes_first, associated_threshold],[ind_that_comes_second, associated_threshold]]

eg: thresh_crossing_dict = {'thresh': {'lower': lower_threshold, 'upper': upper_threshold}, 'ind': {'lower': lower_ind, 'upper': upper_ind} }

The key of the minimum ind is retuned as first_crossing and will be upper, lower or None if no crossings exist. The threshold and refined_gps is then retuned using the first_crossing key.

I have removed the logic that was: if no threshold crossing exists, choose the max/min channel value for use in plotting the threshold. Do we think that is okay to do?

Closes #158

Old version, refined gps = .0688

New version, refined gps = .0429 (i.e. 25.9ms sooner)

Additionally, I have changed to input params of plot_indicators from taking the dictionary params to just taking channel. Previously the plotting looked at whether the upper or lower threshold was used in order to place the annotation "threshold" above or below the plotted line. This seemed tricky to do with the variable thresholds so I removed the dependence and put the annotation always below. This doesn't always look as smart if anyone can think of a better way of doing this Plotting will still look at whether threshold is above or below mean and plot "threshold" annotation in the correct place.

locklost/plugins/refine.py

@@ -65,14 +65,20 @@ def plot_indicators(event, channel, refined_gps, threshold):
                 linestyle='--',
                 linewidth=2,
             )
+            if y_ind[0] < threshold:
+                xyoffset = (8, 10)
+                valign = 'bottom'
+            else:
+                xyoffset = (8, -10)
+                valign = 'top'
             ax1.annotate(
                 "threshold",
                 xy=(ax1.get_xlim()[0], threshold),
                 xycoords='data',
-                xytext=(8, -10),
+                xytext=xyoffset,
                 textcoords='offset points',
                 horizontalalignment='left',
-                verticalalignment='top',
+                verticalalignment=valign,
                 bbox=dict(
                     boxstyle="round", fc="w", ec="green", alpha=0.95),
                 )
@@ -153,8 +159,8 @@ def find_transition(channel, segment, std_threshold, minimum=None):
     returns `threshold`, `refined_gps` tuple
 
     """
-    refined_gps = None
     threshold = None
+    refined_gps = None
     buf = data.fetch(channel, segment)[0]
 
     # calculate mean and std using first 5 seconds of window
@@ -173,25 +179,35 @@ def find_transition(channel, segment, std_threshold, minimum=None):
     if minimum and lock_mean < minimum:
         logging.info("channel mean below minimum, unable to resolve time")
 
-    # look for positive and negative threshold crossings, add them to a list,
-    # then choose the first crossing if one exists
+    # look for positive and negative threshold crossings, add them to a
+    # dictionary, then choose the first crossing if one exists
     else:
         inds_above = np.where(buf.data > upper_threshold)[0]
         inds_below = np.where(buf.data < lower_threshold)[0]
-        thresh_crossing_list = []
+        thresh_crossing_dict = defaultdict(lambda: defaultdict(int))
         if inds_above.any():
-            thresh_crossing_list.append([np.min(inds_above), upper_threshold])
+            thresh_crossing_dict['ind']['upper'] = np.min(inds_above)
+            thresh_crossing_dict['thresh']['upper'] = upper_threshold
         if inds_below.any():
-            thresh_crossing_list.append([np.min(inds_below), lower_threshold])
-        if len(thresh_crossing_list) > 0:
-            thresh_crossing_list.sort()
-            ind = thresh_crossing_list[0][0]
-            threshold = thresh_crossing_list[0][1]
+            thresh_crossing_dict['ind']['lower'] = np.min(inds_below)
+            thresh_crossing_dict['thresh']['lower'] = lower_threshold
+        first_crossing = min(
+                thresh_crossing_dict['ind'],
+                key = lambda k: thresh_crossing_dict['ind'][k],
+                default = None
+                )
+        if first_crossing is None:
+            logging.info("no threshold crossings, unable to resolve time")
+        else:
+            threshold = thresh_crossing_dict['thresh'][first_crossing]
+            ind = thresh_crossing_dict['ind'][first_crossing]
             refined_gps = buf.tarray[ind]
             logging.info("threshold: {}".format(threshold))
             logging.info("refined time: {}".format(refined_gps))
-        else:
-            logging.info("no threshold crossings, unable to resolve time")
+
+    # add a threshold to be diplayed on graphs if refinement failed
+    if threshold is None:
+        threshold = lower_threshold
 
     return threshold, refined_gps