#21 Add QCDict

Author: kwabenantim

pcpostprocess/hergQC.py

@@ -8,16 +8,67 @@
 import scipy.stats
 
 
-class hERGQC(object):
+class QCDict(object):
+
+    labels = [
+        "qc1.rseal",
+        "qc1.cm",
+        "qc1.rseries",
+        "qc2.raw",
+        "qc2.subtracted",
+        "qc3.raw",
+        "qc3.E4031",
+        "qc3.subtracted",
+        "qc4.rseal",
+        "qc4.cm",
+        "qc4.rseries",
+        "qc5.staircase",
+        "qc5.1.staircase",
+        "qc6.subtracted",
+        "qc6.1.subtracted",
+        "qc6.2.subtracted",
+    ]
+
+    def __init__(self):
+        self._dict = OrderedDict([(label, [(False, None)]) for label in QCDict.labels])
+
+    def __str__(self):
+        return self._dict.__str__()
+
+    def __repr__(self):
+        return self._dict.__repr__()
+
+    def __getitem__(self, key):
+        return self._dict.__getitem__(key)
+
+    def __setitem__(self, key, value):
+        if key not in QCDict.labels:
+            raise KeyError(f"Invalid QC key: {key}")
+        self._dict.__setitem__(key, value)
+
+    def keys(self):
+        return self._dict.keys()
+
+    def items(self):
+        return self._dict.items()
+
+    def values(self):
+        return self._dict.values()
+
+    def qc_passed(self, label):
+        """Return whether a single QC passed."""
+        return all([x for x, _ in self._dict[label]])
+
+    def passed_list(self):
+        """Return a list of booleans indicating whether each QC passed."""
+        return [self.qc_passed(label) for label in QCDict.labels]
+
+    def all_passed(self):
+        """Return whether all QC passed."""
+        return all(self.passed_list())
 
-    QCnames = ['qc1.rseal', 'qc1.cm', 'qc1.rseries',
-               'qc2.raw', 'qc2.subtracted',
-               'qc3.raw', 'qc3.E4031', 'qc3.subtracted',
-               'qc4.rseal', 'qc4.cm', 'qc4.rseries',
-               'qc5.staircase', 'qc5.1.staircase',
-               'qc6.subtracted', 'qc6.1.subtracted', 'qc6.2.subtracted']
 
-    no_QC = len(QCnames)
+class hERGQC(object):
 
     def __init__(self, sampling_rate=5, plot_dir=None, voltage=np.array([]),
                  n_sweeps=None, removal_time=5):
@@ -82,16 +133,6 @@ def __init__(self, sampling_rate=5, plot_dir=None, voltage=np.array([]),
 
         self._debug = True
 
-        self.qc_labels = ['qc1.rseal', 'qc1.cm', 'qc1.rseries', 'qc2.raw',
-                          'qc2.subtracted', 'qc3.raw', 'qc3.E4031',
-                          'qc3.subtracted', 'qc4.rseal', 'qc4.cm',
-                          'qc4.rseries', 'qc5.staircase', 'qc5.1.staircase',
-                          'qc6.subtracted', 'qc6.1.subtracted',
-                          'qc6.2.subtracted']
-
-    def get_qc_names(self):
-        return self.QCnames
-
     def set_trace(self, before, after, qc_vals_before,
                   qc_vals_after, n_sweeps):
         self._before = before
@@ -125,7 +166,7 @@ def run_qc(self, voltage_steps, times,
         before = self.filter_capacitive_spikes(before, times, voltage_steps)
         after = self.filter_capacitive_spikes(after, times, voltage_steps)
 
-        QC = OrderedDict([(label, [(False, None)]) for label in self.qc_labels])
+        QC = QCDict()
 
         if len(before) == 0 or len(after) == 0:
             return QC
@@ -223,10 +264,7 @@ def run_qc(self, voltage_steps, times,
             fig.savefig(os.path.join(self.plot_dir, 'qc_debug.png'))
             plt.close(fig)
 
-        # Check if all QC criteria passed
-        passed = all([x for qc in QC.values() for x, _ in qc])
-
-        return passed, QC
+        return QC
 
     def qc1(self, rseal, cm, rseries):
         # Check R_seal, C_m, R_series within desired range

pcpostprocess/scripts/run_herg_qc.py

@@ -922,16 +922,15 @@ def run_qc_for_protocol(readname, savename, time_strs, args):
                          voltage_protocol.get_all_sections() if vend == vstart]
 
         # Run QC with raw currents
-        _, QC = hergqc.run_qc(voltage_steps, times,
-                              before_currents_corrected,
-                              after_currents_corrected,
-                              np.array(qc_before[well])[0, :],
-                              np.array(qc_after[well])[0, :], nsweeps)
-        
-        passed_qc = [all([x for x, _ in qc]) for qc in QC.values()]
-        df_rows.append([well] + passed_qc)
-
-        selected = np.all(QC) and not no_cell
+        QC = hergqc.run_qc(voltage_steps, times,
+                           before_currents_corrected,
+                           after_currents_corrected,
+                           np.array(qc_before[well])[0, :],
+                           np.array(qc_after[well])[0, :], nsweeps)
+
+        df_rows.append([well] + QC.passed_list())
+
+        selected = QC.all_passed() and not no_cell
         if selected:
             selected_wells.append(well)
 

tests/test_herg_qc.py

@@ -148,15 +148,15 @@ def test_run_qc(self):
                                  for tstart, tend, vstart, vend in
                                  voltage_protocol.get_all_sections() if vend == vstart]
 
-                passed, qcs = hergqc.run_qc(voltage_steps,
-                                            self.times, before_well, after_well,
-                                            qc_vals_before_well,
-                                            qc_vals_after_well, n_sweeps=2)
+                QC = hergqc.run_qc(voltage_steps,
+                                   self.times, before_well, after_well,
+                                   qc_vals_before_well,
+                                   qc_vals_after_well, n_sweeps=2)
 
-                logging.debug(well, passed)
+                logging.debug(well, QC.all_passed())
 
                 trace = ""
-                for label, results in qcs.items():
-                    if any([x == False for x, _ in results]):
-                        trace += f"{label}: {results}\n"
-                self.assertTrue(passed, trace)
+                for label, result in QC.items():
+                    if not QC.qc_passed(label):
+                        trace += f"{label}: {result}\n"
+                self.assertTrue(QC.all_passed(), trace)