petal-qc 0.0.4__py3-none-any.whl → 0.0.5__py3-none-any.whl

petal_qc/BTreport/CheckBTtests.py

@@ -19,6 +19,7 @@ import datetime
 import dateutil.parser
 import itkdb
 from itkdb_gtk import ITkDBlogin
+from itkdb_gtk import ITkDButils
 
 def complain(main_msg, secondary_msg=None):
     """Prints an error message
@@ -34,42 +35,6 @@ def complain(main_msg, secondary_msg=None):
         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
 
@@ -143,7 +108,10 @@ def find_but_tape_tests(session, petal_date, bt_sn, complain_func=complain):
         dict: dict with all tests. key is the test type code.
 
     """
-    test_list = session.get("listTestRunsByComponent", json={"component": bt_sn, "stage": "COMPLETED"})
+    test_list = session.get("listTestRunsByComponent", 
+                            json={"filterMap":{"serialNumber": bt_sn, 
+                                               "stage": "COMPLETED"}
+                                  })
     bt_tests = {}
     for tst in test_list:
         test_type = tst["testType"]["name"]
@@ -187,13 +155,13 @@ def BTreport(session, SerialN, complain_func=complain):
         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))
+    petal = ITkDButils.get_DB_component(session, SerialN)
+    if petal is None:
+        complain_func(SerialN, "Could not find petal core.")
         return None
 
+    SerialN = petal["serialNumber"]
+
     print("+++ Petal core {} [{}]".format(SerialN, petal["alternativeIdentifier"]))
     petal_date = dateutil.parser.parse(petal["stateTs"])
     comp_type = get_type(petal)
@@ -291,7 +259,7 @@ def main():
     try:
         SN = sys.argv[1]
     except IndexError:
-        print("I need a petal  core SN")
+        print("I need a petal  core SN or AlternativeID")
         sys.exit()
 
     # ITk PDB authentication
@@ -314,8 +282,11 @@ def main():
         out = BTreport(client, SN)
         # Upload test
         if out:
-            db_response = client.post("uploadTestRunResults", json=out)
-            print(json.dumps(db_response, indent=3))
+            try:
+                db_response = client.post("uploadTestRunResults", json=out)
+            except Exception as ex:
+                print("Could not upload test.")
+                print(ex)
 
 
     except Exception:

petal_qc/__init__.py

@@ -1,5 +1,5 @@
 """petal_qc python module."""
-__version__ = "0.0.4"
+__version__ = "0.0.5"
 
 
 def coreMetrology():
@@ -7,14 +7,23 @@ def coreMetrology():
     from .metrology.coreMetrology import main
     main()
 
+def doMetrology():
+    """Launches the Core metrology analysis in the command line."""
+    from .metrology.do_metrology import main
+    main()
+
 def coreThermal():
     """Launches the Core thermal analysis ahd PDB script."""
     from .thermal.coreThermal import main
     main()
 
-
 def bustapeReport():
     """Launches the Core metrology analysis ahd PDB script."""
-    from .BTreport.bustapeReport import main
+    from .BTreport.CheckBTtests import main
+    # from .BTreport.bustapeReport import main
     main()
 
+def dashBoard():
+    """Launches the Core thermal analysis ahd PDB script."""
+    from .dashBoard import main
+    main()

petal_qc/dashBoard.py

@@ -6,16 +6,123 @@ try:
     
 except ImportError:
     from pathlib import Path
-    cwd = Path(__file__).parent.parent
+    cwd = Path(__file__).parent
     sys.path.append(cwd.as_posix())
-    
+
+from petal_qc.metrology.coreMetrology import CoreMetrology, CoreMetrologyOptions
+from petal_qc.thermal.coreThermal import CoreThermal
+from petal_qc.thermal.IRPetalParam import IRPetalParam
+
 from itkdb_gtk import dbGtkUtils
-from itkdb_gtk import GetShipments
-from itkdb_gtk import PetalReceptionTests
 from itkdb_gtk import ITkDBlogin
-from itkdb_gtk import CreateShipments
-from itkdb_gtk import UploadTest
-from itkdb_gtk import UploadMultipleTests
-from itkdb_gtk import GlueWeight
-from itkdb_gtk import UploadModuleIV
-from itkdb_gtk import WireBondGui
+
+import gi
+
+gi.require_version("Gtk", "3.0")
+from gi.repository import Gtk
+
+HELP_LINK="https://petal-qc.docs.cern.ch"
+
+class DashWindow(dbGtkUtils.ITkDBWindow):
+    """Dashboard class."""
+    PETAL_CORE_METRO = 1
+    PETAL_CORE_THERMAL = 2
+    
+
+    def __init__(self, session):
+        """Initialization."""
+        super().__init__(title="Petal-QC Dashboard", session=session, help_link=HELP_LINK)
+        self.mask = 0
+
+        # set border width
+        self.set_border_width(10)
+
+        # Prepare dashboard
+        grid = Gtk.Grid(column_spacing=5, row_spacing=5)
+        self.mainBox.pack_start(grid, False, True, 5)
+        
+        irow = 0
+        lbl = Gtk.Label()
+        lbl.set_markup("<b>Tests</b>")
+        lbl.set_xalign(0)
+        grid.attach(lbl, 0, irow, 1, 1)
+
+        irow += 1
+        btnPetalMetrology = Gtk.Button(label="Petal Core Metrology")
+        btnPetalMetrology.connect("clicked", self.petal_metrology)
+        grid.attach(btnPetalMetrology, 0, irow, 1, 1)
+        
+        btnPetalThermal = Gtk.Button(label="Petal Core Thermal")
+        btnPetalThermal.connect("clicked", self.petal_thermal)
+        grid.attach(btnPetalThermal, 1, irow, 1, 1)
+            
+
+        irow += 1
+        grid.attach(Gtk.Label(), 0, irow, 1, 1)
+        
+        self.mainBox.pack_start(Gtk.Separator(orientation=Gtk.Orientation.HORIZONTAL), False, True, 5)
+
+        self.show_all()
+        
+
+    def petal_metrology(self, *args):
+        """Do petal metrology"""
+        bitn = DashWindow.PETAL_CORE_METRO
+        bt = 1 << bitn
+        if self.mask & bt:
+            return
+
+        self.mask |= bt
+        opts = CoreMetrologyOptions()
+        W = CoreMetrology(opts, session=self.session, title="Petal Core Metrology")
+        W.connect("destroy", self.app_closed, bitn)
+        W.show_all()
+
+    def petal_thermal(self, *args):
+        """Do petal thermal."""
+        bitn = DashWindow.PETAL_CORE_THERMAL
+        bt = 1 << bitn
+        if self.mask & bt:
+            return
+
+        self.mask |= bt
+        opt = IRPetalParam()
+        opt.folder = None
+        opt.out = None
+        opt.alias = None
+        opt.SN = None
+        W = CoreThermal(opt, self.session, title="Petal Thermal Test.")
+        W.connect("destroy", self.app_closed, bitn)
+        W.show_all()
+
+    def app_closed(self, *args):
+        """Application window closed. Clear mask."""
+        bt = 1 << args[1]
+        self.mask &= ~bt
+        # print(bt, self.mask)
+        
+def main():
+    """Main entry"""
+    # DB login
+    dlg = ITkDBlogin.ITkDBlogin()
+    client = dlg.get_client()
+    if client is None:
+        print("Could not connect to DB with provided credentials.")
+        dlg.die()
+        sys.exit()
+
+    client.user_gui = dlg
+
+    dashW = DashWindow(client)
+    dashW.connect("destroy", Gtk.main_quit)
+    try:
+        Gtk.main()
+
+    except KeyboardInterrupt:
+        print("Arrrgggg!!!")
+
+    dlg.die()
+
+
+if __name__ == "__main__":
+    main()

petal_qc/metrology/PetalMetrology.py

@@ -4,6 +4,8 @@ import io
 import json
 import sys
 import traceback
+from tempfile import NamedTemporaryFile
+
 from argparse import Action
 from argparse import ArgumentParser
 from datetime import datetime
@@ -19,6 +21,7 @@ from petal_qc.metrology import DataFile
 from petal_qc.metrology.analyze_locking_points import analyze_locking_point_data
 from petal_qc.metrology.analyze_locking_points import locking_point_positions
 from petal_qc.metrology.convert_mitutoyo import mitutoyo2cvs
+from petal_qc.metrology.convert_smartscope import get_smarscope_locator_positions
 from petal_qc.metrology.petal_flatness import petal_flatness
 
 
@@ -46,11 +49,11 @@ def check_spec(val, nom, fraction=0.0):
 class CommaSeparatedListAction(Action):
     """Create a list from the comma sepparated numbers at imput."""
 
-    def __call__(self, parser, namespace, values, option_string=None):
+    def __call__(self, args_parser, namespace, values, option_string=None):
         """The actual action."""
         value = np.array(list(map(float, values.split(','))), dtype='float64')
         if value.shape[0] < 3:
-            raise Exception("{} needs a 3D vector".format(self.dest))
+            raise ValueError("{} needs a 3D vector".format(self.dest))
 
         setattr(namespace, self.dest, value)
 
@@ -59,12 +62,10 @@ def petal_metrology(ifile, options):
     """Do the analysis of the petal metrology data.
 
     Args:
-    ----
         ifile: Input file from Mitutoyo.
         options: Command line options.
 
     Return
-    ------
         Dictionary with DB values
 
     """
@@ -111,7 +112,8 @@ def petal_metrology(ifile, options):
         "PARALLELISM": 0,
         "CHECK_BOT_LOC_DIAM": True,
         "CHECK_SLOT_LOC_DIAM": True,
-        "CHECK_OVERSIZE_LOC_DIAM": True
+        "CHECK_OVERSIZE_LOC_DIAM": True,
+        "DIAM": {"FD01": 0., "FD02":0, "PL01":0, "PL02":0, "PL03":0}
     }
 
     # Open the output doc.
@@ -152,7 +154,7 @@ def petal_metrology(ifile, options):
     # Do locator flatness analysis
     TM = None  # TODO: fix this
     if options.desy:
-        locator_data = DataFile.read(ifile, ".*_FineFlatness")
+        locator_data = DataFile.read(ifile, "PL[0-9]+_Plane") #".*_FineFlatness")
     else:
         locator_data = DataFile.read(ifile, "PuntoLocator", "Punto")
         locator_data[:, 2] -= Fmean
@@ -179,8 +181,8 @@ def petal_metrology(ifile, options):
             dbOut["comments"].append("Offset of locator plane w.r.t BT is  {:.3f} mm".format(val))
 
     # Analyze locking point positions
+    ofile = io.StringIO()
     if not options.desy:
-        ofile = io.StringIO()
         mitutoyo2cvs([ifile], ofile,
                      label=r"agujero_inf|Locator\w*|Slot\w+|Fiducial\w+",
                      data_type="Círculo|Punto",
@@ -190,61 +192,85 @@ def petal_metrology(ifile, options):
         tbl = pd.read_csv(ofile, names=["X", "Y", "Z", "D", "R", "C", "Name"], sep=',', skiprows=1, index_col="Name")
         print(tbl)
 
-        keywords = [n for n in tbl.index]
+        # keywords = [n for n in tbl.index]
         # if "FiducialBot" in keywords:
         #     indx = ["agujero_inf", "LocatorTop", "FiducialBot", "FiducialTop"]
         #     offset = 0
         # else:
         #     indx = ["LocatorBot", "LocatorTop", "agujero_inf", "FiducialTop"]
         #     offset = 3
-            
+
         indx = ["LocatorBot", "LocatorTop", "agujero_inf", "FiducialTop"]
         offset = 3
-        
 
+        # Compute Slot center (get average of diameter)
         slot_center = np.mean(tbl.loc[["SlotSup", "SlotInf"]][["X", "Y", "D"]].values, axis=0)
 
         print("")
         print()
         print(tbl.loc[indx][["X", "Y", "D"]])
-        input = tbl.loc[indx][["X", "Y", "D"]].values
+        tvalues = tbl.loc[indx][["X", "Y", "D"]].values
 
-        ninput = np.insert(input, 1, slot_center, axis=0)
+        ninput = np.insert(tvalues, 1, slot_center, axis=0)
+        ninput[:, 1] += offset
+
+    else:
+        get_smarscope_locator_positions(ifile, ofile, "\\w+(PL|_Fiducial)\\s+", keep=True)
+        ofile.seek(0)
+        tbl = pd.read_csv(ofile, names=["X", "Y", "D", "Name"], sep=',', skiprows=1, index_col="Name")
+        print("")
+        print()
+        print(tbl)
+        ninput = tbl[["X", "Y", "D"]].values
+        offset = 3
         ninput[:, 1] += offset
-        out = locking_point_positions(ninput, document)
-        for key, val in out.items():
-            results[key] = val
-            if key == "LOCATION_DELTA":
-                for k, v in val.items():
-                    delta = np.linalg.norm(v)
-                    if not check_spec(delta, 0.050):
-                        dbOut["defects"].append({
-                            "name": key,
-                            "description": "Delta {} is {:.3f} mm > 0.050 mm.".format(k, delta)
-                        })
-
-            elif key == "REL_POS_DELTA":
-                for k, v in val.items():
-                    delta = np.linalg.norm(v)
-                    if not check_spec(delta, 0.025):
-                        dbOut["defects"].append({
-                            "name": key,
-                            "description": "Delta {} is {:.3f} mm > 0.025 mm.".format(k, delta)
-                        })
-
-            elif "CHECK_" in key:
-                if "OVERSIZE" in key:
-                    if not check_spec(abs(val), 0.050):
-                        dbOut["defects"].append({
-                            "name": key,
-                            "description": "LOC DIAM delta is {:.3f} mm > 0.025 mm.".format(abs(val))
-                        })
-                else:
-                    if val < 0 or val > 0.012:
-                        dbOut["defects"].append({
-                            "name": key,
-                            "description": "LOC DIAM  is not H7  0 <= {:.3f} <= 0.012 mm.".format(val)
-                        })
+
+    # Input array is
+    # 0 - Bottom locator (PL01)
+    # 1 - Top Slot (PL02)
+    # 2 - Oversized (PL03)
+    # 3 - Bottom Fid (FD01)
+    # 4 - Top Fid (FD02)
+    results["DIAM"]["FD01"] = ninput[3, 2]
+    results["DIAM"]["FD02"] = ninput[4, 2]
+    results["DIAM"]["PL01"] = ninput[0, 2]
+    results["DIAM"]["PL02"] = ninput[1, 2]
+    results["DIAM"]["PL03"] = ninput[2, 2]
+    
+    out = locking_point_positions(ninput, document)
+    for key, val in out.items():
+        results[key] = val
+        if key == "LOCATION_DELTA":
+            for k, v in val.items():
+                delta = np.linalg.norm(v)
+                if not check_spec(delta, 0.050):
+                    dbOut["defects"].append({
+                        "name": key,
+                        "description": "Delta {} is {:.3f} mm > 0.050 mm.".format(k, delta)
+                    })
+
+        elif key == "REL_POS_DELTA":
+            for k, v in val.items():
+                delta = np.linalg.norm(v)
+                if not check_spec(delta, 0.025):
+                    dbOut["defects"].append({
+                        "name": key,
+                        "description": "Delta {} is {:.3f} mm > 0.025 mm.".format(k, delta)
+                    })
+
+        elif "CHECK_" in key:
+            if "OVERSIZE" in key:
+                if not check_spec(abs(val), 0.050):
+                    dbOut["defects"].append({
+                        "name": key,
+                        "description": "LOC DIAM delta is {:.3f} mm > 0.025 mm.".format(abs(val))
+                    })
+            else:
+                if val < 0 or val > 0.012:
+                    dbOut["defects"].append({
+                        "name": key,
+                        "description": "LOC DIAM  is not H7  0 <= {:.3f} <= 0.012 mm.".format(val)
+                    })
 
         ofile.close()
 
@@ -282,8 +308,8 @@ def petal_metrology(ifile, options):
 
     return dbOut
 
-
-if __name__ == "__main__":
+def do_petal_metrology():
+    """main entry."""
     parser = ArgumentParser()
     parser.add_argument('files', nargs='*', help="Input files")
     parser.add_argument("--SN", default="SNxxxx", help="Petal core serial nunber")
@@ -309,19 +335,34 @@ if __name__ == "__main__":
     parser.add_argument("--label", default="\\w+", help="The label to select")
     parser.add_argument("--type", default="Punto", help="The class to select")
 
-    options = parser.parse_args()
-    if len(options.files) == 0:
+    args = parser.parse_args()
+    if len(args.files) == 0:
         print(sys.argv[0])
         print("I need an input file")
         sys.exit()
 
+    if len(args.files) == 1:
+        ifile = args.files[0]
+    else:
+        ifnam = NamedTemporaryFile(delete_on_close=False)
+        ifile = ifnam.name
+        for ff in args.files:
+            with open(ff, 'rb') as F:
+                ifnam.write(F.read())
+
+        ifnam.close()
+
+
     try:
-        outDB = petal_metrology(options.files[0], options)
-        ofile = output_folder(options.folder, options.prefix + '.json')
-        with open(ofile, 'w') as of:
+        outDB = petal_metrology(ifile, args)
+        ofile = output_folder(args.folder, args.prefix + '.json')
+        with open(ofile, 'w', encoding="UTF-8") as of:
             json.dump(outDB, of)
 
     except Exception:
         print(traceback.format_exc())
 
     plt.show()
+
+if __name__ == "__main__":
+    do_petal_metrology()

petal_qc/metrology/analyze_locking_points.py

@@ -14,7 +14,7 @@ import petal_qc.utils.docx_utils as docx_utils
 from petal_qc.metrology import DataFile
 from petal_qc.metrology.Cluster import cluster_points
 from petal_qc.utils.Geometry import fit_plane
-from petal_qc.utils.Geometry import flatness_conhull
+from petal_qc.utils.Geometry import flatness_conhull, flatness_LSPL
 from petal_qc.utils.Geometry import project_to_plane
 from petal_qc.utils.Geometry import vector_angle
 from petal_qc.utils.utils import get_min_max
@@ -400,15 +400,15 @@ def analyze_locking_point_data(orig_data, nbins=50, plane_fit=True, cut=3, docum
         print("{:7.3f} {:7.3f} {:7.3f}".format(C.x, C.y, C.z))
 
     if len(good):
-        flatness = flatness_conhull(plane[good, :])
-        print("Locking point flatness: {:.1f}".format(1000*flatness))
+        flatness = flatness_LSPL(plane[good, :])
+        print("Locking point flatness (LSPL): {:.1f}".format(1000*flatness))
     else:
         print("Not enough points to compute flatness.")
         flatness = -1.e-3
 
     outDB["COPLANARITY_LOCATORS"] = flatness
     if document:
-        document.add_paragraph("Locking point flatness (convex hull): {:.1f} µm.".format(1000*flatness))
+        document.add_paragraph("Locking point flatness (LSPL): {:.1f} µm.".format(1000*flatness))
 
     # Show all data
     fig = show_data(plane[good, :], "All", nbins=nbins, color_bar=True)