petal-qc 0.0.0__tar.gz

petal_qc-0.0.0/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.1
+Name: petal_qc
+Version: 0.0.0
+Summary: A collection of scripts for Petal CORE QC.
+Author-email: Carlos Lacasta <carlos.lacasta@cern.ch>
+Project-URL: Homepage, https://gitlab.cern.ch/atlas-itk/sw/db/itk-pdb-gtk-gui-utils
+Project-URL: Bug Tracker, https://gitlab.cern.ch/atlas-itk/sw/db/itk-pdb-gtk-gui-utils/-/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: itkdb
+Requires-Dist: itkdb_gtk
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: lmfit
+Requires-Dist: openpyxl
+Requires-Dist: pandas
+Requires-Dist: python_dateutil
+Requires-Dist: python_docx
+Requires-Dist: scipy
+Requires-Dist: scikit-image
+
+# Petal QC
+
+The folder contains a collections of scripts to make the analysis of the Petal
+QC metrology and thermal tests.
+
+They will also upload the tests to the DB if required.

petal_qc-0.0.0/README.md

@@ -0,0 +1,6 @@
+# Petal QC
+
+The folder contains a collections of scripts to make the analysis of the Petal
+QC metrology and thermal tests.
+
+They will also upload the tests to the DB if required.

petal_qc-0.0.0/petal_qc/BTreport/CheckBTtests.py

@@ -0,0 +1,321 @@
+#!/usr/bin/env python3
+"""Check that bus tapes in petal have been tested.
+
+Upload teh Bus Tape Summary TEst to the PDB.
+
+To run it
+
+python3 CheckBTtests.py petal_SN
+
+The main routine is BTreport and can be called from anywhere else.
+
+"""
+
+import sys
+import traceback
+import json
+import getpass
+import datetime
+import dateutil.parser
+import itkdb
+from itkdb_gtk import ITkDBlogin
+
+def complain(main_msg, secondary_msg=None):
+    """Prints an error message
+
+    Args:
+    -----
+        main (): Main message
+        secondary (): Seconday message
+    """
+    print("**Error\n{}".format(main_msg))
+    if secondary_msg:
+        msg = secondary_msg.replace("\n", "\n\t")
+        print("\t{}".format(msg))
+
+
+def find_petal(session, SerialN, silent=False, complain_func=complain):
+    """Find petal with given SerialN.
+
+    Args:
+    -----
+        session (itkdb.Client): The DB session
+        SerialN (str): The petal SerialNumber
+        silent (bool, optional): No compllaint writen. Defaults to False.
+
+    Returns
+    -------
+        dict: A petal (JSon)
+
+    Raises
+    ------
+        LookupError if petal not found
+        TypeError if SerialN is not a CORE_AVS
+    """
+    try:
+        petal_core = session.get('getComponent', json={'component': SerialN})
+
+    except Exception as ex:
+        if not silent:
+            complain_func("Could not find Petal Core in DB", str(ex))
+
+        raise LookupError("Could not find Petal core with SN {}".format(SerialN)) from ex
+
+    if petal_core["type"]["code"] != "CORE_AVS":
+        if not silent:
+            complain_func("Wrong component type", "This is not an AVS petal core")
+
+        raise TypeError("This is not an AVS petal core")
+
+    return petal_core
+
+
+def get_type(child):
+    """Return object type
+
+    Args:
+    -----
+        child: object
+
+    Returns
+    -------
+        str: object type
+
+    """
+    if child["type"] is not None:
+        comp_type = child["type"]["code"]
+
+    else:
+        comp_type = child["componentType"]["code"]
+
+    return comp_type
+
+
+def find_bus_tapes(session, petal, complain_func=complain):
+    """Find Bus tapes in petal.
+
+    Args:
+    ----
+        session (itkdb.Client): The DB session
+        petal (Json): The petal object
+
+    Returns
+    -------
+        dict: a dict with the bustapes. Key is the BT type.
+    """
+    bt_list = {}
+    for child in petal["children"]:
+        cstage = "Missing"
+        if child["component"] is None:
+            continue
+
+        else:
+            child_sn = child["component"]["serialNumber"]
+            comp_type = get_type(child)
+            if "BT_PETAL" not in comp_type:
+                continue
+
+            # We are left with the bus tapes
+            cobj = session.get('getComponent', json={'component': child["component"]["id"]})
+            cstage = cobj["currentStage"]['code']
+            if cstage != "COMPLETED":
+                complain_func("Bus tape not in final stages", cstage)
+                continue
+
+            bt_list[comp_type] = cobj, child['id']
+
+    return bt_list
+
+
+def find_but_tape_tests(session, petal_date, bt_sn, complain_func=complain):
+    """Find tests in bus tape.
+
+    Args:
+        session (itkdb.Client): The DB session
+        petal_date (DateTime): The petal date
+        bt_sn (str): The bus tape SN
+
+    Returns:
+        dict: dict with all tests. key is the test type code.
+
+    """
+    test_list = session.get("listTestRunsByComponent", json={"component": bt_sn, "stage": "COMPLETED"})
+    bt_tests = {}
+    for tst in test_list:
+        test_type = tst["testType"]["name"]
+        test_code = tst["testType"]["code"]
+
+        # Create the storage for the tests. Used to sort by date in case of multiple tests
+        if test_code not in bt_tests:
+            bt_tests[test_code] = []
+
+        test_date = tst["date"]
+        bt_tests[test_code].append(tst)
+
+    for key, val in bt_tests.items():
+        val.sort(key=lambda a: dateutil.parser.parse(a["date"]), reverse=True)
+        the_test = val[0]
+        if petal_date > dateutil.parser.parse(val[0]["date"]):
+            complain_func("Test on tape happened before petal", "")
+            bt_tests[key] = None
+        else:
+            bt_tests[key] = val[0]
+
+    return bt_tests
+
+
+def date2string(the_date=None):
+    """REturns date string in TTkDB format."""
+    if the_date is None:
+        the_date = datetime.datetime.now()
+    out = the_date.isoformat(timespec='milliseconds')
+    if out[-1] not in ['zZ']:
+        out += 'Z'
+
+    return out
+
+
+def BTreport(session, SerialN, complain_func=complain):
+    """Makes the BTreport for a petal core.
+
+    Args:
+        session (itkdb.Client): The DB session
+        SerialN (str): The Petal core SB
+    """
+    # get petal frm DB.
+    try:
+        petal = find_petal(session, SerialN, complain_func=complain_func)
+
+    except Exception as ex:
+        print(str(ex))
+        return None
+
+    print("+++ Petal core {} [{}]".format(SerialN, petal["alternativeIdentifier"]))
+    petal_date = dateutil.parser.parse(petal["stateTs"])
+    comp_type = get_type(petal)
+    if comp_type != "CORE_AVS":
+        complain_func("This is not a petal cores", comp_type)
+        return None
+    
+    # Check that the petal core is in the proper stage.
+    stage = petal["currentStage"]['code']
+    if stage != "AT_QC_SITE":
+        complain_func("Petal core is not at QC_SITE", stage)
+        return None
+
+    # Check children
+    if "children" not in petal:
+        complain_func("{}[{}]".format(SerialN, id), "Not assembled")
+        return None
+
+    # Loop on children an find bustapes
+    bt_list = find_bus_tapes(session, petal, complain_func=complain_func)
+    if len(bt_list) == 0:
+        complain_func("no valid bustape found", "Either not assembled or in incorrect stage.")
+        return None
+
+    out = {
+        "component": SerialN,
+        "testType": "BTTESTING",
+        "institution": petal["currentLocation"]["code"],
+        "runNumber": "1",
+        "date": date2string(),
+        "passed": True,
+        "problems": False,
+        "results": {
+            "PASS": [],
+            "RUNS_ELECTRICALTEST": []
+            # "RUNS_STRETCHTEST": []
+        }
+    }
+
+    # Check te tests in the bustapes
+    ngood = 0
+    ntrouble = 0
+    for bt, cp_id in bt_list.values():
+        bt_sn = bt["serialNumber"]
+        print("bus tape {}".format(bt_sn))
+
+        bt_ngood = 0
+        bt_nprob = 0
+        # get list of tests and select the latest.
+        bt_tests = find_but_tape_tests(session, petal_date, bt_sn, complain_func=complain_func)
+
+        results = {}
+        childId = {}
+        for key, the_test in bt_tests.items():
+            print("\t->The Test {} [{}] {}".format(the_test["testType"]["name"],
+                                                   the_test["date"][0:16],
+                                                   "PASSED" if the_test["passed"] else "FAILED"))
+
+            results[the_test["testType"]["code"]] = the_test["passed"]
+            childId[the_test["testType"]["code"]] = the_test['id']
+            if the_test["passed"]:
+                ngood += 1
+                bt_ngood += 1
+
+            if the_test["problems"]:
+                ntrouble += 1
+                bt_nprob += 1
+
+        out["results"]["PASS"].append(
+            {"value": (bt_ngood == 2),
+             "childParentRelation": cp_id})
+
+        out["results"]["RUNS_ELECTRICALTEST"].append(
+            {"value": childId["BTELECTRICAL"],
+             "childParentRelation": cp_id})
+
+        # out["results"]["RUNS_STRETCHTEST"].append(
+        #     {"value": childId["BTSTRETCHP"],
+        #      "childParentRelation": cp_id})
+
+    out["passed"] = (ngood == 4)
+    out["problems"] = (ntrouble > 0)
+    print("BusTape Report\n\tN. good {}\n\tN. prob {}".format(ngood, ntrouble))
+
+    return out
+
+def main():
+    """Main entry."""
+    try:
+        SN = sys.argv[1]
+    except IndexError:
+        print("I need a petal  core SN")
+        sys.exit()
+
+    # ITk PDB authentication
+    dlg = None
+    try:
+        # We use here the Gtk GUI
+        dlg = ITkDBlogin.ITkDBlogin()
+        client = dlg.get_client()
+
+    except Exception:
+        # Login with "standard" if the above fails.
+        client = itkdb.Client()
+        client.user._access_code1 = getpass.getpass("Access 1: ")
+        client.user._access_code2 = getpass.getpass("Access 2: ")
+        client.user.authenticate()
+        print("Hello {} !".format(client.user.name))
+
+    # Check the Bustape tests
+    try:
+        out = BTreport(client, SN)
+        # Upload test
+        if out:
+            db_response = client.post("uploadTestRunResults", json=out)
+            print(json.dumps(db_response, indent=3))
+
+
+    except Exception:
+        print(traceback.format_exc())
+
+    try:
+        dlg.die()
+
+    except Exception:
+        print("Bye !")
+        
+if __name__ == "__main__":
+    main()

petal_qc-0.0.0/petal_qc/BTreport/bustapeReport.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+from contextlib import redirect_stdout
+
+from itkdb_gtk import ITkDButils
+from itkdb_gtk import dbGtkUtils
+from itkdb_gtk import ITkDBlogin
+import itkdb
+
+from petal_qc.BTreport import CheckBTtests
+
+import gi
+gi.require_version("Gtk", "3.0")
+from gi.repository import Gtk, Gio
+
+
+class BusTapeReport(dbGtkUtils.ITkDBWindow):
+    """Makes a report of bustapes."""
+
+    def __init__(self, session=None, title="",  panel_size=100):
+        """Initialization.
+
+        Args:
+            title: The title of the window.
+            pannel_size: size of message panel.
+
+        """
+        super().__init__(session=session, title=title, show_search="SEarch for Petal CORE")
+        self.petal_SN = None
+        self.alternativeID = None
+        self.outDB = None
+
+
+        # Active button in header
+        button = Gtk.Button()
+        icon = Gio.ThemedIcon(name="document-send-symbolic")
+        image = Gtk.Image.new_from_gicon(icon, Gtk.IconSize.BUTTON)
+        button.add(image)
+        button.set_tooltip_text("Click to upload test")
+        button.connect("clicked", self.upload_test_gui)
+        self.hb.pack_end(button)
+
+        # JScon edit
+        button = Gtk.Button()
+        icon = Gio.ThemedIcon(name="accessories-text-editor-symbolic")
+        image = Gtk.Image.new_from_gicon(icon, Gtk.IconSize.BUTTON)
+        button.add(image)
+        button.set_tooltip_text("Click to see the test data")
+        button.connect("clicked", self.show_test_gui)
+        self.hb.pack_end(button)
+
+        # The Serial number
+        self.SN = dbGtkUtils.TextEntry()
+        self.SN.connect("text-changed", self.on_SN_changed)
+
+        # Put the 3 objects in a Grid
+        grid = Gtk.Grid(column_spacing=5, row_spacing=5)
+        self.mainBox.pack_start(grid, False, True, 0)
+
+        grid.attach(Gtk.Label(label="Serial No."), 0, 0, 1, 1)
+        grid.attach(self.SN.entry, 1, 0, 1, 1)
+
+
+        self.mainBox.pack_start(self.message_panel.frame, True, True, 0)
+
+
+    def quit(self, *args):
+        """Quits the application."""
+        self.hide()
+        self.destroy()
+
+    def on_SN_changed(self, entry, value):
+        """New SN given. Ask in PDB,"""
+        if len(value) <= 0:
+            return None
+
+
+        obj = ITkDButils.get_DB_component(self.session, value)
+        if obj is not None:
+            entry.set_text(obj["serialNumber"])
+            self.alternativeID = obj["alternativeIdentifier"]
+
+        else:
+            dbGtkUtils.complain("Invalid SN", value)
+
+    def query_db(self, *args):
+        """Search petal and bustapes."""
+        SN = self.SN.get_text()
+        if SN is None or len(SN)==0:
+            dbGtkUtils.complain("Invalid Serial Number", "Wrong value: {}".format(SN))
+            return
+        
+        self.outDB = CheckBTtests.BTreport(self.session, SN, complain_func=dbGtkUtils.complain)
+
+        if self.outDB is None:
+            dbGtkUtils.complain("Could not get he report.")
+
+    def show_test_gui(self, *args):
+        """Show test data."""
+        if self.outDB is None:
+            return
+
+        values, rc = dbGtkUtils.DictDialog.create_json_data_editor(self.outDB)
+        if rc == Gtk.ResponseType.OK:
+            self.outDB = values
+
+
+    def upload_test_gui(self, *args):
+        """Uploads test and attachments."""
+        pass
+
+def main():
+    # ITk PDB authentication
+    dlg = None
+    try:
+        # We use here the Gtk GUI
+        dlg = ITkDBlogin.ITkDBlogin()
+        client = dlg.get_client()
+
+    except Exception:
+        # Login with "standard" if the above fails.
+        client = itkdb.Client()
+        client.user._access_code1 = getpass.getpass("Access 1: ")
+        client.user._access_code2 = getpass.getpass("Access 2: ")
+        client.user.authenticate()
+        print("Hello {} !".format(client.user.name))
+
+    BT = BusTapeReport(client, title="Bustape Report")
+    BT.write_message("Welcome !!\n")
+    BT.connect("destroy", Gtk.main_quit)
+    BT.show_all()
+
+    try:
+        Gtk.main()
+    except KeyboardInterrupt:
+        print("Arrrgggg!!!")
+
+    try:
+        dlg.die()
+
+    except Exception:
+        print("Bye !")
+
+if __name__ == "__main__":
+    main()

petal_qc-0.0.0/petal_qc/__init__.py

@@ -0,0 +1,14 @@
+"""petal_qc python module."""
+__version__ = "0.0.0"
+
+
+def coreMetrology():
+    """Launches the Core metrology analysis ahd PDB script."""
+    from .metrology.coreMetrology import main
+    main()
+
+def bustapeReport():
+    """Launches the Core metrology analysis ahd PDB script."""
+    from .BTreport.bustapeReport import main
+    main()
+

petal_qc-0.0.0/petal_qc/metrology/Cluster.py

@@ -0,0 +1,90 @@
+"""Find point clisters."""
+import math
+
+import numpy as np
+
+
+class Cluster(object):
+    """A cluster."""
+
+    def __init__(self, x=0, y=0, z=0):
+        """Initialize the cluster."""
+        self.x = x
+        self.y = y
+        self.z = z
+        self.N = 0.0
+        self.points = []
+        self.xtra = []
+
+    def add(self, P, xtra=None):
+        """Add a new point."""
+        N = self.N + 1.0
+        self.x = (self.x * self.N + P[0])/N
+        self.y = (self.y * self.N + P[1])/N
+        try:
+            self.z = (self.z * self.N + P[2])/N
+
+        except IndexError:
+            pass
+
+        self.N += 1.0
+        self.points.append(P)
+        self.xtra.append(xtra)
+
+    def get_points(self):
+        """Return the array of points."""
+        return np.array(self.points)
+
+    def distance(self, P):
+        """Compute distance to Point."""
+        dist = math.sqrt((self.x-P[0])**2 + (self.y-P[1])**2)
+        return dist
+
+    def __lt__(self, other):
+        """Sort two clusters.
+
+        A cluster is smaller if has smaller Y.
+        """
+        return self.y < other.y
+
+
+def cluster_points(points, distance):
+    """Cluster Points.
+
+    Group the points in clusters formed by points whose
+    distance is smaller than distance
+
+    Args:
+    ----
+        points (list): list of points in the for  [x, y, z] or equivalent
+        distance (float): distance.
+
+    Returns
+    -------
+        list: List of Clusters
+
+    """
+    # Cluster points which are closer than distance.
+    clusters = []
+    for ipoint, P in enumerate(points):
+        if np.isnan(P[0]) or np.isnan(P[1]):
+            continue
+
+        dist_min = 1e9
+        clst_min = -1
+        for iclst, C in enumerate(clusters):
+            dist = C.distance(P)
+            if dist < dist_min:
+                clst_min = iclst
+                dist_min = dist
+
+        if clst_min < 0 or dist_min > distance:
+            C = Cluster()
+            C.add(P, ipoint)
+            clusters.append(C)
+
+        else:
+            clusters[clst_min].add(P, ipoint)
+
+    clusters.sort(key=lambda x: x.N, reverse=True)
+    return clusters

petal_qc-0.0.0/petal_qc/metrology/DataFile.py

@@ -0,0 +1,47 @@
+"""Gets the Metrology data from a file."""
+from tempfile import NamedTemporaryFile
+
+import numpy as np
+
+from .convert_mitutoyo import mitutoyo2cvs
+from .convert_smartscope import read_smartscope
+
+
+def read(fname, label='\\w+', type="Punto", keep=False):
+    """Read a file.
+
+    Args:
+    ----
+        fname: The file name
+        label: the label for an mitutyyo file
+        type: the entry type in a mitutoyo file
+        keep: if true keeps the label
+    """
+    try:
+        data = np.loadtxt(fname, unpack=False, skiprows=1, delimiter=',')
+
+    except FileNotFoundError:
+        print("Input file not found.")
+        return None
+
+    except Exception:
+        # This might be CMM file
+        is_mitutoyo = False
+        with open(fname, 'r', encoding='cp1252') as fin:
+            for line in fin:
+                if 'Elemento' in line:
+                    is_mitutoyo = True
+                    break
+                elif 'Quality Vision' in line:
+                    is_mitutoyo = False
+                    break
+        
+        ofile = NamedTemporaryFile()
+        if is_mitutoyo:
+            mitutoyo2cvs([fname], ofile.name, label=label, data_type=type, keep=keep)
+        else:
+            read_smartscope(fname, ofile.name, label, keep=keep)
+            
+        data = np.loadtxt(ofile.name, unpack=False, skiprows=1, delimiter=',')
+
+    return data