itkdb-gtk 0.10.10.dev4__py3-none-any.whl → 0.10.10.dev6__py3-none-any.whl

itkdb_gtk/WireBondGui.py

@@ -6,6 +6,7 @@ import re
 import json
 import copy
 from pathlib import Path
+from collections import namedtuple
 import gi
 
 gi.require_version("Gtk", "3.0")
@@ -28,18 +29,6 @@ from itkdb_gtk import ITkDBlogin, ITkDButils, UploadTest
 #valid_channel = re.compile("(^[0-9]+)-([0-9]+)")
 valid_channel = re.compile("^[0-9]+[\\s*\\,\\s,-[0-9]+]*")
 
-def range_to_list(V):
-    """Convert a range (ch1-ch2) to a list."""
-    if '-' not in V:
-        return [V]
-
-    out = []
-    endpoints = list(map(int, V.split('-')))
-    endpoints.sort()
-    for i in range(endpoints[0], endpoints[1]+1):
-        out.append(str(i))
-
-    return out
 
 test_parameters = {
         "Repaired Row 1": "REPAIRED_FRONTEND_ROW1",
@@ -103,21 +92,75 @@ module_param = {
     ],
 }
 
-def wire2strip(mod_par, irow, iwire):
-    """Convert from wirebond index to strip_number."""
-    for sensor in mod_par:
-        for hyb in sensor:
-            rng = hyb[irow]
-            if iwire>= rng[0] and iwire<=rng[1]:
-                if irow % 2:
-                    ichan = 2*(iwire-rng[0]) + 1
-                else:
-                    ichan = 2*(iwire-rng[0])
+module_to_tf = {
+    0: [],
+    1: [],
+    2: [],
+    3: [],
+    4: [],
+    5: []
+}
+
+hyb_to_pb = {
+    0: [],
+    1: [],
+    2: [],
+    3: [],
+    4: [],
+    5: []
+}
+
+
+def range_to_list(V):
+    """Convert a range to a list.
 
-                return ichan
+        ch1-ch2 or ch1:ch2 -> [ch1, ch1+1, ch1+2, ..., ch2] or
+        ch1:step:ch2 -> [ch1, ch1+sep, ch1+2*step, ..., ch2]
+    """
+    nfound = 0
+    for c in "-:,":
+        if c in V:
+            nfound += 1
+            break
+
+    if nfound == 0:
+        return [V]
+
+    out = []
+    values = V.split(',')
+    for V in values:
+        if '-' in V:
+            endpoints = list(map(int, V.split('-')))
+            endpoints.sort()
+            for i in range(endpoints[0], endpoints[1]+1):
+                out.append(str(i))
+        elif ':' in V:
+            endpoints = list(map(int, V.split(':')))
+            if len(endpoints) == 2:
+                endpoints.sort()
+                for i in range(endpoints[0], endpoints[1]+1):
+                    out.append(str(i))
+
+            elif len(endpoints) == 3:
+                for i in range(endpoints[0], endpoints[2]+1, endpoints[1]):
+                    out.append(str(i))
+
+            else:
+                print("Wring range specification. {}".format(V))
+                continue
+
+        else:
+            out.append(V)
+
+    return out
 
-    return None
+def count_items(items):
+    """Count number of channels from results."""
+    nitems = 0
+    for key in items.keys():
+        nitems += len(range_to_list(key))
 
+    return nitems
 
 def find_holes(chan_list, min_chan=0, max_chan=999999):
     """Find groups of consecutive channels."""
@@ -161,19 +204,41 @@ def find_holes(chan_list, min_chan=0, max_chan=999999):
     return holes
 
 
+def wire2strip(iwire, irow, first_chan):
+    """From bond to strip number."""
+    if irow % 2:
+        istrip = 2*(iwire-first_chan) + 1
+    else:
+        istrip = 2*(iwire-first_chan)
+
+    return istrip
+
+
+class Hole:
+    """A range of consecutive unconnected channels."""
+    def __init__(self, *args):
+        for i, name in enumerate(['sensor', 'hybrid', 'row', 'chan', 'width']):
+            setattr(self, name, args[i])
+
+    def __repr__(self):
+        return "sensor: {} hyb: {} row: {} chan: {} width: {}".format(
+            self.sensor, self.hybrid, self.row, self.chan, self.width
+        )
+
 class HybridHoles:
-    """Holes in hybrid bomds.
+    """Holes in hybrid bonds.
 
     Holes are defined by a list [first_chan, n_chan].
     """
 
-    def __init__(self, param, hid=0):
+    def __init__(self, param, win=None, hid=0):
         """Initialization.
 
         Args:
             param: Hybrid wirebon parameters.
 
         """
+        self.win = win
         self.id = hid
         self.param = param
         self.nchan = 0
@@ -182,12 +247,25 @@ class HybridHoles:
 
         self.holes = [[] for irow in range(4)]
         self.channels = [[] for irow in range(4)]
+        # Sensor strips for each of the strip rows "served" by a hybrid.
+        self.sensor_channels = [[], []]
+        self.sensor_holes = [[], []]
+
+    def ready(self):
+        """Call when all channels are in."""
+        for irow, C in enumerate(self.channels):
+            C.sort()
+            self.holes[irow] = find_holes(C)
+
+        for irow, S in enumerate(self.sensor_channels):
+            S.sort()
+            self.sensor_holes[irow] = find_holes(S)
 
     def add_channel(self, irow, ichan)->bool:
         """Add a new channel in row.
 
         Args:
-            irow: rown number
+            irow: row number
             ichan: channel number
 
         Returns:
@@ -196,102 +274,93 @@ class HybridHoles:
         """
         first_chan = self.param[irow][0]
         last_chan = self.param[irow][1]
+        strip_row = int(irow/2)
+
+
         if isinstance(ichan, list) or isinstance(ichan, tuple):
             nadded = 0
             for ich in ichan:
-                if ich >= first_chan and ich <= last_chan:
+                if first_chan <= ich <= last_chan:
                     self.channels[irow].append(ich)
                     nadded += 1
 
             self.channels[irow] = sorted(self.channels[irow])
+            for iwire in self.channels[irow]:
+                istrip = wire2strip(iwire, irow, first_chan)
+                self.sensor_channels[strip_row].append(istrip)
+
             return nadded>0
-        else:
-            if ichan >= first_chan and ichan <= last_chan:
-                self.channels[irow].append(ichan)
-                return True
-            else:
-                return False
 
-    def get_n_unconnected(self):
+        if first_chan <= ichan <= last_chan:
+            self.channels[irow].append(ichan)
+            istrip = wire2strip(ichan, irow, first_chan)
+            self.sensor_channels[strip_row].append(istrip)
+            return True
+
+        return False
+
+    def get_n_unconnected(self) -> list:
         """Count number of unconnected channels.
 
         Return a list, one item per row.
         """
-        nchan = []
-        for row in self.holes:
-            nch = 0
-            for h in row:
-                nch += h[1]
-
-            nchan.append(nch)
-
+        nchan = [len(C) for C in self.channels]
         return nchan
 
-    def get_max_consecutive(self):
-        """Returns the largest 'hole'."""
+    def get_max_consecutive_from_list(self, holes):
+        """Return max widht of holes."""
         mx_width = []
+        lst_holes = []
+        for irow, row in enumerate(holes):
+            if len(row) == 0:
+                mxW = 0
 
-        for row in self.holes:
-            mxW = -1
-            for h in row:
-                if h[1] > mxW:
-                    mxW = h[1]
+            else:
+                mxW = -1
+                for h in row:
+                    lst_holes.append(Hole(0, self.id, irow, h[0], h[1]))
+                    mxW = max(mxW, h[1])
 
             mx_width.append(mxW)
 
-        return mx_width
-
-    def get_sensor_holes(self):
-        """Compute holes in 'sensor' strips.
-
-        Each hybrid has 2 sensor segments corresponding to
-        rows (1,2) and (3, 4).
+        return mx_width, lst_holes
 
-        Return a list of [sensor, hybrid, segment, ichan, width]
-        """
-        holes = []
-        channels = [[], []]
-        for irow, row in enumerate(self.channels):
-            isegment = int(irow/2)
-            for ich in row:
-                rng = self.param[irow]
-                if irow % 2:
-                    chan = 2*(ich-rng[0]) + 1
-                else:
-                    chan = 2*(ich-rng[0])
-
-                channels[isegment].append(chan)
 
-            channels[isegment] = sorted(channels[isegment])
-
-        for isegment, S in enumerate(channels):
-            H = find_holes(S)
-            if len(H)>0:
-                out = [ [0, self.id, isegment, chan, width] for chan, width in H ]
-                holes.extend(out)
-
-        return holes
+    def get_max_consecutive(self):
+        """Returns the largest 'hole'."""
+        mx_width, _ = self.get_max_consecutive_from_list(self.holes)
+        return mx_width
 
+    def get_max_sensor_consecutive(self):
+        """Return largest hole in sensor."""
+        mx_width, holes = self.get_max_consecutive_from_list(self.sensor_holes)
+        return mx_width, holes
 
 class SensorHoles:
     """Holes in sensor."""
 
-    def __init__(self, param, sid=0):
+    def __init__(self, param, win=None, sid=0):
         """Initialization.
 
         Args:
             param: sensor wirebon params
         """
+        self.win = win
         self.id = sid
         self.param = param
         self.nchan = 0
         self.nhybrid = len(param)
         self.hybrids = []
         for i, P in enumerate(param):
-            H = HybridHoles(P, hid=i)
+            H = HybridHoles(P, hid=i, win=win)
             self.hybrids.append(H)
             self.nchan += H.nchan
 
+    def ready(self):
+        """Call when all channels are in."""
+        for H in self.hybrids:
+            H.ready()
+
     def get_n_hyb(self):
         """Return number of hybrids."""
         return len(self.hybrids)
@@ -305,15 +374,29 @@ class SensorHoles:
 
         This is ordered by row.
         """
-        mx_width = [0, 0, 0, 0]
+        mx_width = [0 for x in range(4)]
         for hyb in self.hybrids:
             mxW = hyb.get_max_consecutive()
-            for j in range(4):
-                if mxW[j] > mx_width[j]:
-                    mx_width[j] = mxW[j]
+            for j, val in enumerate(mxW):
+                mx_width[j] = max(mx_width[j] , val)
 
         return mx_width
 
+    def get_max_sensor_consecutive(self):
+        """MAx widht of holes in sensor."""
+        mx_width = -1
+        holes = []
+        for hyb in self.hybrids:
+            mxW, hyb_holes = hyb.get_max_sensor_consecutive()
+            for H in hyb_holes:
+                H.sensor = self.id
+
+            holes.extend(hyb_holes)
+            for v in mxW:
+                mx_width = max(mx_width, v)
+
+        return mx_width, holes
+
     def get_n_unconnected(self):
         """Count number of unconnected channels.
 
@@ -327,37 +410,30 @@ class SensorHoles:
 
         return nchan
 
-    def get_sensor_holes(self):
-        """Return holes sensor.
-
-        Return a list of [sensor, hybrid, segment, ichan, width]
-        """
-        holes = []
-        for hyb in self.hybrids:
-            H = hyb.get_sensor_holes()
-            for _, ih, isegment, ichan, width in H:
-                holes.append([self.id, ih, isegment, ichan, width])
-
-        return holes
-
 
 class ModuleHoles:
     """Holes in Modules."""
 
-    def __init__(self, param):
+    def __init__(self, param, win=None):
         """Initialization.
 
         Args:
             param: module wirebond params
         """
+        self.win = win
         self.nsensor = len(param)
         self.nchan = 0
         self.sensors = []
         for i, P in enumerate(param):
-            S = SensorHoles(P, sid=i)
+            S = SensorHoles(P, sid=i, win=win)
             self.sensors.append(S)
             self.nchan += S.nchan
 
+    def ready(self):
+        """Call when all channels are in."""
+        for S in self.sensors:
+            S.ready()
+
     def get_max_consecutive(self):
         """Max number of consecutive unconnected channels.
 
@@ -367,22 +443,21 @@ class ModuleHoles:
         for S in self.sensors:
             mxW = S.get_max_consecutive()
             for j in range(4):
-                if mxW[j] > mx_width[j]:
-                    mx_width[j] = mxW[j]
+                mx_width[j] = max(mx_width[j], mxW[j])
 
         return mx_width
 
-    def get_sensor_holes(self) -> list:
-        """Return. holesin sensor strips.
-
-        Return a list of [sensor, hybrid, segment, ichan, width]
-        """
-        holes = []
+    def get_max_sensor_consecutive(self):
+        """The maximum number of consecutive channels per strip row."""
+        mx_width = -1
+        module_holes =  []
         for S in self.sensors:
-            for _, ihyb, isegment, ichan, width in S.get_sensor_holes():
-                holes.append([S.id, ihyb, isegment, ichan, width])
+            width, holes = S.get_max_sensor_consecutive()
+            module_holes.extend(holes)
+            mx_width = max(mx_width, width)
+
+        return mx_width, module_holes
 
-        return holes
 
     def get_n_unconnected(self) -> list:
         """Count number of unconnected channels.
@@ -575,12 +650,35 @@ class WireBond(dbGtkUtils.ITkDBWindow):
         lut = {}
         module_map = {}
         section = None
+        i_local = 0
+        i_std = 1
+        indx = ["local", "standard"]
+        found_format = False
         with open(fnam, 'r', encoding="UTF-8") as fin:
             for line in fin:
                 line = line.strip()
 
                 # Remove comments.
                 ipos = line.find('#')
+                jpos = line.find("#!")
+                if jpos>=0 and ipos==jpos:
+                    if found_format:
+                        dbGtkUtils.complain("A second format line was found.",
+                                            "Onely one is allowed. stopr map parsing.")
+                        return
+
+                    indx = [x.lower() for x in line[ipos+2:].split()]
+                    try:
+                        i_local = indx.index("local")
+                        i_std = indx.index("standard")
+                        found_format = True
+                    except ValueError:
+                        dbGtkUtils.complain("Wrong format desciption string.",
+                                            "The words 'local' and 'standard' should be there.\n{}".format(line))
+                        return
+
+                    continue
+
                 if ipos >= 0:
                     line = line[:ipos].strip()
 
@@ -602,13 +700,13 @@ class WireBond(dbGtkUtils.ITkDBWindow):
                 if section is None:
                     continue
 
-                values = list(map(str.strip, line.split(',')))
-                if len(values)!=2:
+                values = line.split()
+                if len(values)!=len(indx):
                     dbGtkUtils.complain("Cannot read Lookup table.", "Wrong line format: {}".format(line))
                     return
 
-                v_local = range_to_list(values[0])
-                v_std = range_to_list(values[1])
+                v_local = range_to_list(values[i_local])
+                v_std = range_to_list(values[i_std])
 
                 if len(v_local) != len(v_std):
                     dbGtkUtils.complain("Wrong Lookup table.",
@@ -669,7 +767,7 @@ class WireBond(dbGtkUtils.ITkDBWindow):
             view_model = self.models[param]
             self.tree.set_model(view_model)
         else:
-            self.write_message("Cannot find model for {}".format(param))
+            self.write_message("Cannot find model for {}\n".format(param))
 
     def create_combo(self):
         """Create the combo."""
@@ -813,7 +911,42 @@ class WireBond(dbGtkUtils.ITkDBWindow):
         self.hide()
         self.destroy()
 
-    def compute_unconnected(self):
+    def compute_repaired(self, skeleton):
+        """Compute number of repaired."""
+        nrepaired = 0
+        for key, values in skeleton["results"].items():
+            if key.find("REPAIRED")<0 or key.find("ROW")<0:
+                continue
+
+            nrepaired += len(values)
+
+        if nrepaired>0:
+            skeleton["problems"] = True
+            skeleton["comments"].append("Number of repaired FE bonds: {}".format(nrepaired))
+
+        return nrepaired
+
+    def compute_hybrid_to_pb(self, skeleton):
+        """Compute number of failures and repairs."""
+        n = count_items(skeleton["results"]["REPAIRED_HYBRID_TO_PB"])
+        n = count_items(skeleton["results"]["FAILED_HYBRID_TO_PB"])
+        if n:
+            msg = "Hybrid to PB: {} failing bonds.".format(n)
+            skeleton["comments"].append(msg)
+            skeleton["passed"] = False
+            self.write_message("{}\n".format(msg))
+
+    def compute_module_to_frame(self, skeleton):
+        """Compute number of failures and repairs."""
+        n = count_items(skeleton["results"]["REPAIRED_MODULE_TO_FRAME"])
+        n = count_items(skeleton["results"]["FAILED_MODULE_TO_FRAME"])
+        if n:
+            msg = "Module to test frame: {} failing bonds.".format(n)
+            skeleton["comments"].append(msg)
+            skeleton["passed"] = False
+            self.write_message("{}\n".format(msg))
+
+    def compute_unconnected(self, results):
         """Compute number of unconnected."""
         try:
             param = get_module_param(self.SN.get_text())
@@ -821,9 +954,9 @@ class WireBond(dbGtkUtils.ITkDBWindow):
             dbGtkUtils.complain("Wrong SN number", str(E))
             return None
 
-        M = ModuleHoles(param=param)
+        M = ModuleHoles(param=param, win=self)
 
-        for test in test_parameters.values():
+        for test, values in results.items():
             if test.find("FAILED") < 0:
                 continue
             if test.find("ROW") < 0:
@@ -832,16 +965,7 @@ class WireBond(dbGtkUtils.ITkDBWindow):
             irow = int(test[-1]) - 1
 
             # Get list of all channels with wirebond notation.
-            model = self.models[test]
-            it = model.get_iter_first()
-            out = []
-            while it:
-                chan, _ = model[it]
-                if len(chan) > 0:
-                    out.append(int(chan))
-
-                it = model.iter_next(it)
-
+            out = [int(x) for x in values.keys()]
             # Translate to sensor, hybrids, etc.
             for S in M.sensors:
                 for H in S.hybrids:
@@ -850,41 +974,66 @@ class WireBond(dbGtkUtils.ITkDBWindow):
 
 
         # Now get sensor strips.
+        M.ready()
         unconnected = M.get_n_unconnected()
         mx_consecutive = M.get_max_consecutive()
-        module_holes = M.get_sensor_holes()
+        mx_sensor_width, module_holes = M.get_max_sensor_consecutive()
 
         out = {}
+        out["comments"] = []
+        out["defects"] = []
         for irow in range(4):
             key = "MAX_CONT_UNCON_ROW{}".format(irow+1)
             out[key] = mx_consecutive[irow]
 
-        mxW = 0
         self.write_message("Found {} clusters of unconnected strips in sensor.\n".format(len(module_holes)))
         for H in module_holes:
-            self.write_message("{}\n".format(str(H)))
-            if H[-1] > mxW:
-                mxW = H[-1]
+            self.write_message("{}\n".format(H))
+
+        if mx_sensor_width > 0:
+            self.write_message("Max width of consecutive unconnected strips: {}\n". format(mx_sensor_width))
 
-        if mxW > 0:
-            self.write_message("Max width: {}". format(mxW))
+        out["MAX_UNCON_SENSOR_CHAN"] = mx_sensor_width
+        if mx_sensor_width > 8:
+            out["passed"] = False
+            out["comments"].append("Too many consecutive sensor strips unconnected: {}".format(mx_sensor_width))
 
-        out["MAX_UNCON_SENSOR_CHAN"] = mxW
         nstrips = 0
         for v in unconnected:
             nstrips += v
 
-        out["TOTAL_PERC_UNCON_SENSOR_CHAN"] = nstrips/M.nchan
+        percent = 100*nstrips/M.nchan
+        out["TOTAL_PERC_UNCON_SENSOR_CHAN"] = percent
+        if out["TOTAL_PERC_UNCON_SENSOR_CHAN"] > 1.0:
+            out["passed"] = False
+            out["comments"].append("More than 1%% of channels unconnected: {:.1f}%%".format(percent))
 
         return out
 
     def get_unconnected(self, skeleton):
         """Fill the test DTO with unconnected information."""
-        out = self.compute_unconnected()
+        out = self.compute_unconnected(skeleton["results"])
         if out is None:
             raise ValueError("Wrong SN")
 
         for key, val in out.items():
+            if key in ["passed", "problems"]:
+                skeleton[key] = out[key]
+                continue
+
+            if key == "comments":
+                for C in out[key]:
+                    skeleton[key].append(C)
+
+                continue
+
+            if key == "defects":
+                for D in out[key]:
+                    skeleton[key].append(D)
+
+                continue
+
+
             skeleton["results"][key] = val
 
     def read_file(self, *args):
@@ -921,7 +1070,7 @@ class WireBond(dbGtkUtils.ITkDBWindow):
         try:
             dbGtkUtils.set_combo_iter(self.inst_combo, data["institution"])
         except KeyError:
-            self.write_message("institution value is not in the loaded file.")
+            self.write_message("institution value is not in the loaded file\n.")
 
         self.operator.set_text(data["properties"]["OPERATOR"])
         self.machine.set_text(data["properties"]["BOND_MACHINE"])
@@ -971,12 +1120,8 @@ class WireBond(dbGtkUtils.ITkDBWindow):
                     continue
 
                 for V in values:
-                    if '-' in V:
-                        for i in range_to_list(V):
-                            added_items.append((str(i), comment))
-
-                    elif len(V)>0:
-                        added_items.append((V, comment))
+                    for i in range_to_list(V):
+                        added_items.append((str(i), comment))
 
             for key in range_items:
                 section.pop(key)
@@ -1052,7 +1197,7 @@ class WireBond(dbGtkUtils.ITkDBWindow):
             if len(values) == 4:
                 SN, operator, machine = values
             else:
-                self.write_message("Something went wrong while requesting missing information.")
+                self.write_message("Something went wrong while requesting missing information.\n")
 
         data["component"] = SN
         data["properties"]["OPERATOR"] = operator
@@ -1090,6 +1235,9 @@ class WireBond(dbGtkUtils.ITkDBWindow):
         self.fix_list_of_channels(skeleton)
         try:
             self.get_unconnected(skeleton)
+            self.compute_repaired(skeleton)
+            self.compute_hybrid_to_pb(skeleton)
+            self.compute_module_to_frame(skeleton)
 
         except ValueError:
             return