petal-qc 0.0.10__py3-none-any.whl → 0.0.12__py3-none-any.whl

petal_qc/BTreport/CheckBTtests.py

@@ -271,12 +271,8 @@ def main():
 
     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))
-
+        client = ITkDButils.create_client()
+        
     # Check the Bustape tests
     try:
         out = BTreport(client, SN)

petal_qc/__init__.py

@@ -1,5 +1,5 @@
 """petal_qc python module."""
-__version__ = "0.0.10"
+__version__ = "0.0.12"
 
 
 def coreMetrology():
@@ -28,6 +28,17 @@ def uploadPetalInformation():
     from .metrology.uploadPetalInformation import main
     main()
 
+def createCoreThermalReport():
+    """Create a petal core thermal report."""
+    from .thermal.create_core_report import main
+    main()
+
+def analyzeIRCore():
+    """Create a petal core thermal report."""
+    from .thermal.analyze_IRCore import main
+    main()
+
+
 def dashBoard():
     """Launches the Core thermal analysis ahd PDB script."""
     from .dashBoard import main

petal_qc/dashBoard.py

@@ -87,10 +87,13 @@ class DashWindow(dbGtkUtils.ITkDBWindow):
 
         self.mask |= bt
         opt = IRPetalParam()
+        opt.files = []
+        opt.golden = None
         opt.folder = None
         opt.out = None
         opt.alias = None
         opt.SN = None
+        opt.desy = False
         W = CoreThermal(opt, self.session, title="Petal Thermal Test.")
         W.connect("destroy", self.app_closed, bitn)
         W.show_all()

petal_qc/metrology/PetalMetrology.py

@@ -320,11 +320,6 @@ def do_petal_metrology():
     parser.add_argument("--save", dest='save', action="store_true", default=False)
     parser.add_argument("--out", dest="out", default="petal_flatness.docx",
                         type=str, help="The output fiel name")
-    parser.add_argument("--bottom-lp", dest='bLP', action=CommaSeparatedListAction, default=None,
-                        help="Bottom locking point fiducial coordinates")
-    parser.add_argument("--upper-lp", dest='uLP', action=CommaSeparatedListAction, default=None,
-                        help="upper locking point fiducials coordinates")
-
     parser.add_argument("--title", dest="title", default=None,
                         type=str, help="Document title")
     parser.add_argument("--nbins", dest="nbins", default=25,

petal_qc/metrology/coreMetrology.py

@@ -89,14 +89,11 @@ class CoreMetrology(itkdb_gtk.dbGtkUtils.ITkDBWindow):
         # The Serial number
         self.SN = itkdb_gtk.dbGtkUtils.TextEntry()
         self.SN.connect("text-changed", self.on_SN_changed)
-        if options.SN:
-            self.on_SN_changed(self.SN.entry, options.SN)
 
         # The prefix
         self.prefix = Gtk.Entry()
-        if options.prefix:
-            self.SN.set_text(options.prefix)
 
+        # The switch
         self.desy = Gtk.Switch()
         self.desy.props.halign = Gtk.Align.START
 
@@ -147,6 +144,22 @@ class CoreMetrology(itkdb_gtk.dbGtkUtils.ITkDBWindow):
 
         self.mainBox.pack_start(self.message_panel.frame, True, True, 0)
 
+        if self.options.SN:
+            self.on_SN_changed(self.SN.entry, self.options.SN)
+
+        if self.options.is_front:
+            self.back.set_active(True)
+
+        if self.options.folder:
+            the_folder = Gio.File.new_for_path(self.options.folder)
+            self.btnFolder.set_file(the_folder)
+            self.on_folder_set(None)
+
+        if len(self.options.files)>0:
+            the_file = Gio.File.new_for_path(self.options.files[0])
+            self.btnData.set_file(the_file)
+            self.on_file_set(None)
+
 
     def quit(self, *args):
         """Quits the application."""
@@ -340,6 +353,7 @@ class CoreMetrologyOptions(object):
         self.files = []
         self.SN = None
         self.desy = False
+        self.is_front = False
         self.folder = None
         self.prefix = None
         self.locking_points = None
@@ -354,15 +368,12 @@ def main():
     parser.add_argument('files', nargs='*', help="Input files")
     parser.add_argument("--prefix", dest='prefix', default=None)
     parser.add_argument("--SN", dest='SN', default=None)
+    parser.add_argument("--front", dest='is_front', action="store_true", default=False)
+
     parser.add_argument("--save", dest='save', action="store_true", default=False)
     parser.add_argument("--desy", dest='desy', action="store_true", default=False)
     parser.add_argument("--out", dest="out", default="petal_flatness.docx",
                         type=str, help="The output fiel name")
-    parser.add_argument("--bottom-lp", dest='bLP', action=CommaSeparatedListAction, default=None,
-                        help="Bottom locking point fiducial coordinates")
-    parser.add_argument("--upper-lp", dest='uLP', action=CommaSeparatedListAction, default=None,
-                        help="upper locking point fiducials coordinates")
-
     parser.add_argument("--title", dest="title", default=None,
                         type=str, help="Document title")
     parser.add_argument("--nbins", dest="nbins", default=25,

petal_qc/metrology/do_Metrology.py

@@ -96,11 +96,6 @@ def main():
     parser.add_argument("--desy", dest='desy', action="store_true", default=False, help="True if data is from DESY's SmartScope")
     parser.add_argument("--out", dest="out", default="petal_flatness.docx",
                         type=str, help="The output file name")
-    parser.add_argument("--bottom-lp", dest='bLP', action=CommaSeparatedListAction, default=None,
-                        help="Bottom locking point fiducial coordinates")
-    parser.add_argument("--upper-lp", dest='uLP', action=CommaSeparatedListAction, default=None,
-                        help="upper locking point fiducials coordinates")
-
     parser.add_argument("--title", dest="title", default=None,
                         type=str, help="Report Document title")
     parser.add_argument("--nbins", dest="nbins", default=25,

petal_qc/metrology/petal_flatness.py

@@ -328,10 +328,6 @@ if __name__ == "__main__":
     parser.add_argument("--save", dest='save', action="store_true", default=False)
     parser.add_argument("--front", dest='is_front', action="store_true", default=True)
     parser.add_argument("--back", dest='is_front', action="store_false", default=True)
-    parser.add_argument("--bottom-lp", dest='bLP', action=CommaSeparatedListAction, default=None,
-                        help="Bottom locking point fiducial coordinates")
-    parser.add_argument("--upper-lp", dest='uLP', action=CommaSeparatedListAction, default=None,
-                        help="upper locking point fiducials coordinates")
     parser.add_argument("--out", dest="out", default="petal_flatness.docx",
                         type=str, help="The output fiel name")
     parser.add_argument("--title", dest="title", default=None,

petal_qc/metrology/readAVSdata.py

@@ -2,6 +2,7 @@
 """Read AVS dats file."""
 import sys
 import re
+import numpy as np
 from argparse import ArgumentParser
 from pathlib import Path
 
@@ -243,7 +244,7 @@ def get_float(cell, separator=None, default=0.0):
                 rr = re.findall(r"[-+]?[.]?[\d]+(?:,\d\d\d)*[\.]?\d*(?:[eE][-+]?\d+)?", txt)
                 if len(rr) == 0:
                     return default
-                
+
                 val = float(rr[0])
                 return val
             except ValueError:
@@ -300,10 +301,10 @@ def get_res_and_accep(sheet, indx):
     sval = sheet["g{}".format(indx)].value
     if isinstance(sval, float) or isinstance(sval, int):
         val = sval
-        
+
     else:
         sval = ' '.join(sval.strip().split()).split()
-        
+
         scale = 1.0
         try:
             rr = re.findall(r"[-+]?[.]?[\d]+(?:,\d\d\d)*[\.]?\d*(?:[eE][-+]?\d+)?", sval[0])
@@ -315,19 +316,19 @@ def get_res_and_accep(sheet, indx):
                     U = sval[1].upper()[0]
                     if U=='G':
                         scale = 1000
-                    
+
         except ValueError:
             val = 0
-        
+
         val = val * scale
     #val = get_float(sheet["g{}".format(indx)])
     pass_val = sheet["h{}".format(indx)]
-    if pass_val.value is None: 
+    if pass_val.value is None:
         # Operator did not set the PASS/FAIL thing
         accept = True
     else:
         accept = get_boolean(pass_val)
-        
+
     return val, accept
 
 
@@ -351,6 +352,70 @@ def cell_value(sheet, coord):
 
     return None
 
+def distance(P1, P2):
+    """Distance between 2 points."""
+    P = (P2-P1)
+    S = np.sum(np.square(P))
+    D = np.sqrt(S)
+    return D
+
+def find_test_indx(tests, val):
+    """Apply brute force."""
+    try:
+        indx = tests.index(val)
+
+    except ValueError:
+        for ix, key in enumerate(tests):
+            if key is None:
+                continue
+
+            if val in key:
+                indx = ix
+                break
+
+    return indx
+
+def fix_commas(P):
+    """Fix commas in cells."""
+    for i in range(2):
+        if P[i] > 1000:
+            P[i] /= 1000
+
+
+def get_locator_distance(sheet, results, tests, nom, result):
+    """Compute distance to nominal."""
+    Pnom = np.array([
+        get_float(sheet['E{}'.format(find_test_indx(tests, "{}_X".format(nom)))]),
+        get_float(sheet['E{}'.format(find_test_indx(tests, "{}_Y".format(nom)))])
+        ])
+    fix_commas(Pnom)
+
+    P = np.array([results["{}_X".format(result)], results["{}_Y".format(result)]])
+    fix_commas(P)
+
+    D = distance(Pnom, P)
+    return D
+
+
+def check_locator_positions(sheet, the_test, tests):
+    """Check position of locators."""
+
+    defects = []
+    locators = [("PL01", "LOCATOR1"), ("PL02", "LOCATOR2"), ("PL03", "LOCATOR3"),
+                ("FD01", "FIDUCIAL1"), ("FD02", "FIDUCIAL2")]
+
+    for nom, val in locators:
+        D = get_locator_distance(sheet, the_test["results"], tests,  nom, val)
+        if D > 0.075:
+            defects.append({
+                "name": nom,
+                "description": "{:.3f} mm out".format(D)
+            })
+
+    if len(defects)>0:
+        the_test["passed"] = False
+        the_test["defects"].extend(defects)
+
 
 def check_for_problems(sheet, the_test, row_range):
     """Finds FAIL massages in the Acceptance column."""
@@ -364,7 +429,8 @@ def check_for_problems(sheet, the_test, row_range):
         if txt[0] == 'f':
             nfail += 1
             hdr = get_text(sheet["d{}".format(row)])
-            reason = cell_value(sheet, "i{}".format(row))
+            result = get_float(sheet["g{}".format(row)])
+            reason = "{} [{}]".format(result, cell_value(sheet, "i{}".format(row)))
 
             if reason:
                 if len(reason) < 1:
@@ -374,8 +440,8 @@ def check_for_problems(sheet, the_test, row_range):
                     the_test["defects"].append({"name": hdr,
                                                 "description": reason})
 
-    if nfail:
-        the_test["passed"] = False
+    #if nfail:
+    #    the_test["passed"] = False
 
 
 def get_coreID(bustapeID):
@@ -529,7 +595,8 @@ def readFATfile(session, file_path, SN=None):
     metrology_test["results"]["PARALLELISM_BACK"] = get_float(sheet["g{}".format(find_idx(tests, "B.PARAL")[0])])
 
     # Get defects
-    check_for_problems(sheet, metrology_test, [tests.index("WEIGH")+1, sheet.max_row])
+    check_locator_positions(sheet, metrology_test, tests)
+    check_for_problems(sheet, metrology_test, [tests.index("VANGL"), sheet.max_row])
 
     return vi_test, delamination_test, grounding_test, metrology_test, batch, petal_weight
 
@@ -576,8 +643,8 @@ def readProductionSheet(session, file_path, SN):
 
     # Assume active sheet is the good one, otherwise will have tofind in wb.sheetnames
     sheet = wb.active
-    if sheet.max_row > 30 or sheet.max_column > 8:
-        raise AVSDataException("Wrong PS file")
+    if sheet.max_row > 30 or sheet.max_column > 9:
+        raise AVSDataException("Wrong PS file:\nmx row {} mx_col {}".format(sheet.max_row, sheet.max_column))
 
     # Find the start
     indx = find_label(sheet, "PETAL", "A")
@@ -690,6 +757,6 @@ if __name__ == "__main__":
         sys.exit()
 
     fnam = Path(options.files[0]).expanduser().resolve()
-    readProductionSheet(client, fnam, options.SN)
-#    readFATfile(client, fnam, options.SN)
+#    readProductionSheet(client, fnam, options.SN)
+    readFATfile(client, fnam, options.SN)
     dlg.die()

petal_qc/metrology/uploadPetalInformation.py

@@ -56,7 +56,6 @@ def get_type(child):
 
     return ctype
 
-
 class AVSPanel(dbGtkUtils.ITkDBWindow):
     """Dialog for interaction with DB."""
 
@@ -270,6 +269,9 @@ class AVSPanel(dbGtkUtils.ITkDBWindow):
         self.SN.set_text("")
         self.btnPSF.unselect_all()
         self.btnFAT.unselect_all()
+        self.btn_state.set_label("Undef")
+        dbGtkUtils.set_button_color(self.btn_state, "azure", "black")
+        
 
     def create_test_window(self, test_json, test_name, label):
         """Create the dialog for a DB test and add it to the notebook.
@@ -571,6 +573,15 @@ class AVSPanel(dbGtkUtils.ITkDBWindow):
                     if rc is None:
                         error_txt.append("Problem assembling {} into Petal\n".format(cmp))
 
+                    # Check for child stage
+                    cobj = ITkDButils.get_DB_component(self.session, SN)
+                    ctype = get_type(cobj)
+                    cstage = cobj["currentStage"]['code']
+                    if cstage != final_stage[ctype]:
+                        rc = ITkDButils.set_object_stage(self.session, SN, final_stage[ctype])
+                        if rc is None:
+                            print("Could not set final stage of {} [{}]".format(ctype, SN))
+
             # Check for HonneyComb set
             for P in self.petal_core["properties"]:
                 if P["code"] == "HC_ID" and P["value"] is None:
@@ -588,17 +599,17 @@ class AVSPanel(dbGtkUtils.ITkDBWindow):
                     break
 
             # Check the final stage of the assembled objects
-            for child in self.petal_core["children"]:
-                if child["component"]:
-                    cSN = child["component"]["serialNumber"]
-                    ctype = get_type(child)
-                    cobj = ITkDButils.get_DB_component(self.session, cSN)
-                    cstage = cobj["currentStage"]['code']
-                    if cstage != final_stage[ctype]:
-                        rc = ITkDButils.set_object_stage(self.session, cSN, final_stage[ctype])
-                        if rc is None:
-                            print("Could not set final stage of {}".format(cSN))
-
+            # for child in self.petal_core["children"]:
+            #     if child["component"]:
+            #         cSN = child["component"]["serialNumber"]
+            #         ctype = get_type(child)
+            #         cobj = ITkDButils.get_DB_component(self.session, cSN)
+            #         cstage = cobj["currentStage"]['code']
+            #         if cstage != final_stage[ctype]:
+            #             rc = ITkDButils.set_object_stage(self.session, cSN, final_stage[ctype])
+            #             if rc is None:
+            #                 print("Could not set final stage of {}".format(cSN))
+            #
             if len(error_txt)>0:
                 dbGtkUtils.complain("Assembly of {} could not be completeed:".format(this_petal),
                          "\n".join(error_txt))

petal_qc/test/checkAVStests.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+"""Analize AVS metrology tests."""
+import sys
+from pathlib import Path
+import numpy as np
+
+try:
+    import itkdb_gtk
+
+except ImportError:
+    cwd = Path(__file__).parent.parent
+    sys.path.append(cwd.as_posix())
+
+from itkdb_gtk import ITkDBlogin, ITkDButils
+from petal_qc.metrology.readAVSdata import readFATfile
+
+
+def set_pos(V, results, obj):
+    """Update positions."""
+    results["{}_X".format(obj)] = V[0]
+    results["{}_Y".format(obj)] = V[1]
+
+
+def get_pos(results, obj):
+    """Return position."""
+    try:
+        X = results["{}_X".format(obj)]
+        Y = results["{}_Y".format(obj)]
+
+        if abs(X) > 1000:
+            X /= 1000
+        if abs(Y)>1000:
+            Y /= 1000
+    except KeyError:
+        X = 0.0
+        Y = 0.0
+
+    P = np.array([X, Y], dtype="float64")
+    return P
+
+
+def check_locators(results):
+    """Accumulate metrology values."""
+    points = ["LOCATOR1", "LOCATOR2", "LOCATOR3", "FIDUCIAL1", "FIDUCIAL2"]
+    coord = {}
+    for P in points:
+        coord[P] = get_pos(results, P)
+
+    changed = False
+    fd1 = np.array(coord["FIDUCIAL1"], dtype="float64")
+    if fd1[0]!=0.0 or fd1[1]!=0:
+        changed = True
+        for V in coord.values():
+            V -= fd1
+
+        for O, P in coord.items():
+            set_pos(coord[O], results, O)
+
+    return changed
+
+ROOT_DIR = Path("/Users/lacasta/Nextcloud/ITk/5-Petal_cores")
+
+
+
+def analyze_avs_metrology(session, SN, altid):
+    """Regenerate test json from FAT file."""
+    P = ROOT_DIR / altid
+    files = list(P.glob("AVS.P052.FRT.*.xlsx"))
+    if len(files)==0:
+        print("Cannot find FAT file for {}".format(altid))
+        return None
+    elif len(files)>1:
+        print("More than one FAT file for {}".format(altid))
+        for i, f in enumerate(files):
+            print("{} - {}".format(i, Path/f).name)
+
+        ifile = int(input("Choose file (-1 to discard): "))
+        if ifile < 0:
+            return None
+
+        the_file = files[ifile]
+
+    else:
+        the_file = files[0]
+
+
+    tests = readFATfile(session, the_file, SN)
+    the_test = tests[3]
+    check_locators(the_test["results"])
+    the_test["isRetroactive"] = True
+    the_test["stage"] = "ASSEMBLY"
+    
+    return the_test
+
+def main(session):
+    """Entry point"""
+    # find all cores
+    # Now all the objects
+    payload = {
+        "filterMap": {
+            "componentType": ["CORE_PETAL"],
+            "type": ["CORE_AVS"],
+            #"currentLocation": ["IFIC"],
+        },
+        "sorterList": [
+            {"key": "alternativeIdentifier", "descending": False }
+        ],
+    }
+
+    core_list = session.get("listComponents", json=payload)
+    core_tests = ["METROLOGY_AVS"]
+
+    petal_ids = []
+    for core in core_list:
+        SN = core["serialNumber"]
+        altid = core['alternativeIdentifier']
+        if "PPC" not in altid:
+            continue
+
+        petal_ids.append(altid)
+
+        location = core["currentLocation"]['code']
+        coreStage = core["currentStage"]['code']
+
+        print("\nPetal {} [{}] - {}. {}".format(SN, altid, coreStage, location))
+        test_list = session.get("listTestRunsByComponent", json={"filterMap":{"serialNumber": SN, "state": "ready", "testType":core_tests}})
+
+        good_tests = {}
+        for tst in test_list:
+            ttype = tst["testType"]["code"]
+            if ttype not in core_tests:
+                print(ttype)
+                continue
+
+            T = session.get("getTestRun", json={"testRun": tst["id"]})
+            if T["state"] != "ready":
+                continue
+
+            if ttype in good_tests:
+                if good_tests[ttype]["runNumber"] < T["runNumber"]:
+                    good_tests[ttype] = T
+            else:
+                good_tests[ttype] = T
+
+        for ttype, T in good_tests.items():
+            if ttype != "METROLOGY_AVS":
+                continue
+
+            found = False
+            for value in T["results"]:
+                if  value["code"] == "LOCATOR1_X":
+                    found = True
+                    break
+
+            if not found:
+                print("LOCATOR1 is not here")
+                the_test = analyze_avs_metrology(session, SN, altid)
+                if the_test is None:
+                    continue
+                
+                rc = ITkDButils.upload_test(session, the_test, check_runNumber=True)
+                if rc:
+                    print(rc)
+
+
+if __name__ == "__main__":
+    # ITk_PB authentication
+    dlg = ITkDBlogin.ITkDBlogin()
+    client = dlg.get_client()
+
+    try:
+        # main(session)
+        the_test = analyze_avs_metrology(client, "20USEBC1000124", "PPC.015")
+        #rc = ITkDButils.upload_test(client, the_test, check_runNumber=True)
+        #if rc:
+        #    print(rc)
+
+    except Exception as E:
+        print(E)
+
+    dlg.die()

petal_qc/test/compare_golden.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+"""Compara golden files."""
+import json
+import sys
+from pathlib import Path
+from argparse import ArgumentParser
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def compare_golden(files):
+    """Go through files."""
+    fig, ax = plt.subplots(2, 1, tight_layout=True)
+    for ff in files:
+        ifile = Path(ff).expanduser().resolve()
+        if not ifile.exists():
+            print("ff does not exist.")
+            continue
+        
+        js = None
+        with open(ifile, "r", encoding="utf-8") as fp:
+            js = json.load(fp)
+            
+        if js is None:
+            print("Cannot load {}".format(ff))
+            continue
+        
+        for iside in range(2):
+            ax[iside].plot(js[iside]["path_length"], js[iside]["path_temp"], '-', label=ifile.name)
+    
+    for iside in range(2):   
+        ax[iside].legend()
+    plt.show()
+
+if __name__ == "__main__":
+    parser = ArgumentParser()
+    parser.add_argument('files', nargs='*', help="Input files")
+
+    options = parser.parse_args()
+    if len(options.files) == 0:
+        print("I need an input file")
+        sys.exit()
+
+    compare_golden(options.files)