itkdb-gtk 0.10.9.dev4__py3-none-any.whl → 0.10.10__py3-none-any.whl

itkdb_gtk/WireBondGui.py

@@ -2,7 +2,11 @@
 """Wirebonding GUI for PSB."""
 
 import sys
+import re
 import json
+import copy
+from pathlib import Path
+from collections import namedtuple
 import gi
 
 gi.require_version("Gtk", "3.0")
@@ -12,7 +16,6 @@ try:
     import itkdb_gtk
 
 except ImportError:
-    from pathlib import Path
     cwd = Path(__file__).parent.parent
     sys.path.append(cwd.as_posix())
     import itkdb_gtk
@@ -22,6 +25,11 @@ __HELP_LINK__="https://itkdb-gtk.docs.cern.ch/wirebondTest.html"
 from itkdb_gtk import dbGtkUtils
 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]+]*")
+
+
 test_parameters = {
         "Repaired Row 1": "REPAIRED_FRONTEND_ROW1",
         "Failed Row 1": "FAILED_FRONTEND_ROW1",
@@ -84,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.
+
+        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 ichan
+    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."""
@@ -142,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
@@ -163,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:
@@ -177,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.
+        return mx_width, lst_holes
 
-        Each hybrid has 2 sensor segments corresponding to
-        rows (1,2) and (3, 4).
 
-        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)
@@ -286,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.
 
@@ -308,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.
 
@@ -348,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.
@@ -422,12 +516,14 @@ class WireBond(dbGtkUtils.ITkDBWindow):
         self.pdb = None
         self.models = {}
         self.holes = {}
-        self.institute = "IFIC"
+        self.institute = self.pdb_user["institutions"][0]["code"]
         self.inst_combo = None
         self.module_SN = None
         self.alternativeID = None
         self.combo = None
         self.tree = None
+        self.lut = {}
+        self.module_type = None
         self.init_window()
 
     def init_window(self):
@@ -464,15 +560,31 @@ class WireBond(dbGtkUtils.ITkDBWindow):
         grid = Gtk.Grid(column_spacing=5, row_spacing=1)
 
         # The shipment receiver
-        institute = self.create_institute_combo()
+        institute = self.create_institute_combo(True)
         institute.connect("changed", self.on_institute)
         institute.set_tooltip_text("Select the Institute.")
         dbGtkUtils.set_combo_iter(institute, self.institute)
-        grid.attach(Gtk.Label(label="Institute"), 0, 0, 1, 1)
+
+        lbl = Gtk.Label(label="Institute")
+        lbl.set_xalign(0)
+        grid.attach(lbl, 0, 0, 1, 1)
         grid.attach(institute, 1, 0, 1, 1)
         self.inst_combo = institute
 
 
+
+        # The lookup table
+        lbl = Gtk.Label(label="Lookup Table")
+        lbl.set_xalign(0)
+        grid.attach(lbl, 2, 0, 1, 1)
+
+        self.testF = Gtk.FileChooserButton()
+        self.testF.set_tooltip_text("Click to select Lookup table.")
+
+        grid.attach(self.testF, 3, 0, 1, 1)
+        self.testF.connect("file-set", self.on_lut)
+
+
         for i, tit in enumerate(["Operator", "Bond Machine", "Wire Batch", "SN", "Date"]):
             lbl = Gtk.Label(label=tit)
             lbl.set_xalign(0)
@@ -514,7 +626,7 @@ class WireBond(dbGtkUtils.ITkDBWindow):
         box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
         self.mainBox.pack_start(box, False, False, 0)
         dbGtkUtils.add_button_to_container(box, "Add Bond",
-                                           "Click to add a new bond.",
+                                           "Click to add a new bond or bond range.",
                                            self.add_item)
 
         dbGtkUtils.add_button_to_container(box, "Remove Bond",
@@ -527,6 +639,98 @@ class WireBond(dbGtkUtils.ITkDBWindow):
         self.mainBox.pack_start(self.message_panel.frame, True, True, 0)
         self.write_message("wirebond GUI\n")
 
+    def on_lut(self, fdlg):
+        """Get look-up table."""
+        fnam = Path(fdlg.get_filename())
+        if not fnam.exists():
+            dbGtkUtils.complain("Cannot open Luukup Table.",
+                                "File {} does not exist.".format(fnam))
+            return
+
+        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()
+
+                if len(line) == 0:
+                    continue
+
+                # Check for new section
+                ipos = line.find(':')
+                if ipos >= 0:
+                    section = line[:ipos].strip().upper()
+                    if section in module_map:
+                        dbGtkUtils.complain("Section {} already in map.".format(section), "Stop parsing bond Lookup table.")
+                        return
+
+                    lut = {}
+                    module_map[section] = lut
+                    continue
+
+                if section is None:
+                    continue
+
+                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[i_local])
+                v_std = range_to_list(values[i_std])
+
+                if len(v_local) != len(v_std):
+                    dbGtkUtils.complain("Wrong Lookup table.",
+                                        "Ranges have different length: {}".format(line))
+                    return
+
+                for L, S in zip(v_local, v_std):
+                    lut[L] = S
+
+        self.lut = module_map
+
+    def convert_channel(self, C):
+        """Convert channel according to LUT
+
+        Args:
+            C (str): channel number
+
+        """
+        try:
+            return self.lut[self.module_type][C]
+
+        except KeyError:
+            return C
+
     def on_institute(self, combo):
         """Institute changed."""
         name = self.get_institute_from_combo(combo)
@@ -536,13 +740,20 @@ class WireBond(dbGtkUtils.ITkDBWindow):
     def on_SN_changed(self, entry, value):
         """New SN given. Ask in PDB,"""
         if len(value) <= 0:
-            return None
-
+            return
 
         obj = itkdb_gtk.ITkDButils.get_DB_component(self.session, value)
-        if obj is not None:
+        if obj is not None and obj["serialNumber"] is not None:
             entry.set_text(obj["serialNumber"])
-            self.alternativeID = obj["alternativeIdentifier"]
+            alternativeID = obj["alternativeIdentifier"]
+            module_SN = obj["serialNumber"]
+            if len(module_SN) == 14 and module_SN.startswith("20USEM"):
+                self.module_SN = module_SN
+                self.alternativeID = alternativeID
+                self.module_type = module_SN[5:7]
+
+            else:
+                itkdb_gtk.dbGtkUtils.complain("Invalid SN: {}".format(module_SN), "Not a Ring module")
 
         else:
             itkdb_gtk.dbGtkUtils.complain("Invalid SN", value)
@@ -556,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."""
@@ -620,8 +831,9 @@ class WireBond(dbGtkUtils.ITkDBWindow):
     def channel_edited(self, widget, path, text):
         """Handles edition in channel number cell."""
         if not text.isnumeric():
-            dbGtkUtils.complain("Wrong channel number", "Invalid channel number: {}".format(text))
-            return
+            if valid_channel.match(text) is None:
+                dbGtkUtils.complain("Wrong channel number", "Invalid channel number: {}".format(text))
+                return
 
         self.text_edited(0, path, text)
 
@@ -699,16 +911,72 @@ 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))
+            for key in skeleton["results"]["FAILED_HYBRID_TO_PB"]:
+                defect = {
+                    "description": "Unbonded: Hybrid to PB",
+                    "name": "UNBODED",
+                    "properties": {
+                        "wire_number": range_to_list(key)
+                    }
+                }
+                skeleton["defects"].append(defect)
+
+
+    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))
+            for key in skeleton["results"]["FAILED_MODULE_TO_FRAME"]:
+                defect = {
+                    "description": "Unbonded: Module to Frame",
+                    "name": "UNBODED",
+                    "properties": {
+                        "wire_number": range_to_list(key)
+                    }
+                }
+                skeleton["defects"].append(defect)
+
+    def compute_unconnected(self, results):
         """Compute number of unconnected."""
         try:
             param = get_module_param(self.SN.get_text())
         except ValueError as E:
             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():
+        defects = []
+        for test, values in results.items():
             if test.find("FAILED") < 0:
                 continue
             if test.find("ROW") < 0:
@@ -717,56 +985,86 @@ 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:
                     H.add_channel(irow, out)
                     H.holes[irow] = find_holes(H.channels[irow])
 
+            # add defects
+            defects.append(
+                {
+                    "description": "Unbonded Channel",
+                    "name": "UNBONDED",
+                    "properties": {
+                        "front_end_row": irow,
+                        "wire_number": out
+                    }
+                }
+            )
 
         # 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"] = 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 mxW > 0:
-            self.write_message("Max width: {}". format(mxW))
+        if mx_sensor_width > 0:
+            self.write_message("Max width of consecutive unconnected strips: {}\n". format(mx_sensor_width))
+
+        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):
@@ -803,7 +1101,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"])
@@ -832,6 +1130,43 @@ class WireBond(dbGtkUtils.ITkDBWindow):
 
             data["results"][key] = out
 
+    def fix_list_of_channels(self, data):
+        """Expand ranges and, eventually, apply LUT.
+
+        Args:
+            data: The test payload.
+        """
+        for tit, section in data["results"].items():
+            if not isinstance(section, dict):
+                continue
+
+            range_items = []
+            added_items = []
+            for key, comment in section.items():
+                values = list(map(str.strip, key.split(',')))
+                if ',' in key or '-' in key:
+                    range_items.append(key)
+
+                else:
+                    continue
+
+                for V in values:
+                    for i in range_to_list(V):
+                        added_items.append((str(i), comment))
+
+            for key in range_items:
+                section.pop(key)
+
+            for key, comm in added_items:
+                section[key] = comm
+
+            if len(self.lut)>0 and len(section)>0:
+                tmp = copy.deepcopy(section)
+                section.clear()
+                for key, val in tmp.items():
+                    section[self.convert_channel(key)] = val
+
+
     def save_test(self, *args):
         """Save Test file."""
         dialog = Gtk.FileChooserDialog(
@@ -863,6 +1198,7 @@ class WireBond(dbGtkUtils.ITkDBWindow):
         data = {
             "institution": self.institute,
             "date": ITkDButils.get_db_date(),
+            "runNumber": "1",
             "properties": {},
             "results": {},
             "comments": [],
@@ -892,7 +1228,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
@@ -927,7 +1263,15 @@ class WireBond(dbGtkUtils.ITkDBWindow):
 
         self.get_test_header(skeleton)
         self.get_list_of_channels(skeleton)
-        self.get_unconnected(skeleton)
+        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
 
         uploadW = UploadTest.UploadTest(self.session, payload=skeleton)
         # uploadW.run()