petal-qc 0.0.9__py3-none-any.whl → 0.0.11__py3-none-any.whl

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)

petal_qc/test/getAVSjson.py

@@ -0,0 +1,27 @@
+import json
+from itkdb_gtk import ITkDBlogin
+from petal_qc.metrology import readAVSdata
+dlg = ITkDBlogin.ITkDBlogin()
+session  = dlg.get_client()
+
+ofile = "weights_ppc16.json"
+PSF = "/Users/lacasta/Nextcloud/ITk/5-Petal_cores/PPC.016/AVS.P052.PSH.035 - Petal 016.xlsx"
+
+ofile = "weights_ppc17.json"
+ofat = "metrology_test_ppc17.json"
+PSF = "/Users/lacasta/Nextcloud/ITk/5-Petal_cores/PPC.017/AVS.P052.PSH.036 - Petal 017.xlsx"
+FAT = "/Users/lacasta/Nextcloud/ITk/5-Petal_cores/PPC.017/AVS.P052.FRT.036 r0 - FAT_Serie_017.xlsx"
+manuf_json, weights_json, DESY_comp, alias = readAVSdata.readProductionSheet(session, PSF, "SNnnnn")
+
+vi_test, delamination_test, grounding_test, metrology_test, batch, petal_weight = readAVSdata.readFATfile(session, FAT, "SNnnn")
+
+with open(ofile, "w", encoding="UTF-8") as fin:
+    json.dump(weights_json, fin, indent=3)
+    
+
+with open(ofat, "w", encoding="UTF-8") as fin:
+    json.dump(metrology_test, fin, indent=3)
+    
+
+print("done")
+dlg.die()

petal_qc/test/getAVStests.py

@@ -0,0 +1,263 @@
+#!/usr/bin/env python3
+"""Analize AVS metrology tests."""
+import numpy as np
+import matplotlib.pyplot as plt
+
+try:
+    import itkdb_gtk
+
+except ImportError:
+    import sys
+    from pathlib import Path
+    cwd = Path(__file__).parent.parent
+    sys.path.append(cwd.as_posix())
+
+from itkdb_gtk import ITkDBlogin, ITkDButils
+
+
+def get_value(results, code):
+    """Return the value of the test parameter."""
+    for param in results:
+        if param["code"] == code:
+            return param["value"]
+
+    raise KeyError
+
+def distance(P1, P2):
+    """Distance between 2 points."""
+    P = (P2-P1)
+    S = np.sum(np.square(P))
+    D = np.sqrt(S)
+    return D
+
+nominal_values = {
+    "LOCATOR1": np.array([0, -3]),
+    "LOCATOR2": np.array([127.916, 589.618]),
+    "LOCATOR3": np.array([127.916, 589.618]),
+    "FIDUCIAL1": np.array([0, 0]),
+    "FIDUCIAL2": np.array([131.104, 586.526]),
+}
+
+def get_pos(results, obj):
+    """Return position."""
+    try:
+        X = get_value(results, "{}_X".format(obj))
+        Y = get_value(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 distance_to_nominal(results, obj):
+    """Return position of given locator or fiducial."""
+    P = get_pos(results, obj)
+    N = nominal_values[obj]
+    D = distance(P, N)
+    if abs(D-3)<0.5:
+        P[1] -= 3
+        D = distance(P, N)
+    return D
+
+def do_metrology(results, M_values, Mould_values):
+    """Accumulate metrology values."""
+    points = ["LOCATOR1", "LOCATOR2", "LOCATOR3", "FIDUCIAL1", "FIDUCIAL2"]
+    coord = {}
+    for P in points:
+        coord[P] = get_pos(results, P)
+
+    fd1 = np.array(coord["FIDUCIAL1"], dtype="float64")
+    if fd1[0]!=0.0 or fd1[1]!=0:
+        for V in coord.values():
+            V -= fd1
+
+    for O, P in coord.items():
+        D = distance(P, nominal_values[O])
+        if D<1.0:
+            M_values.setdefault(O, []).append(D)
+            Mould_values.setdefault(O, []).append(D)
+
+        else:
+            print("Possibly wrong data in FAT: {} D={:.3f}".format(O, D))
+
+def do_manufacturing(T):
+    """Return mould."""
+    mould_id = None
+    for prop in T["properties"]:
+        if prop["code"] == "MOULD_ID":
+            mould_id = prop["value"]
+            break
+
+    return mould_id
+
+def do_weighing(results, weights):
+    """Accumulates weighing values to produce stack plot.
+
+    Args:
+        results (): Results from DB
+        weights (): Dict with the values.
+    """
+    for value in results:
+        ipos = value["code"].find("_")
+        weights.setdefault(value["code"][ipos+1:], []).append(value["value"])
+
+
+def plot_metrology(M_values, Mould_values, petal_ids):
+    """Plot metrology values."""
+    for key, values in M_values.items():
+        fig, ax = plt.subplots(ncols=1, nrows=1, tight_layout=True)
+        ax.hist(values, bins=15, range=(0, 0.150))
+        ax.set_title(key)
+
+    for obj in M_values.keys():
+        fig, ax = plt.subplots(ncols=1, nrows=4, tight_layout=True)
+        fig.suptitle("{} - Mould".format(obj))
+        for mould, m_values in Mould_values.items():
+            im = int(mould) - 1
+            ax[im].hist(m_values[obj], bins=15, range=(0, 0.150), label="Mould {}".format(mould))
+
+        for i in range(4):
+            ax[i].set_title("Mould {}".format(i+1))
+
+def plot_weighing(weights, tick_labels, show_total=False):
+    """Make the plot of weights."""
+    labels = ["COOLINGLOOPASSEMBLY", "LOCATOR_A", "LOCATOR_B", "LOCATOR_C",
+              "HONEYCOMBSET", "FACING_FRONT", "FACING_BACK",
+              "EPOXYADHESIVE", "EPOXYPUTTY", "EPOXYCONDUCTIVE"]
+
+    fig = plt.figure(tight_layout=True)
+    fig.suptitle("Petal Core weight (gr)")
+    ax = fig.add_subplot(1, 1, 1)
+    ax.set_ylabel("Weight [gr]")
+    ax.set_ylim(0, 300)
+    npoints = len(weights["CORE"])
+    X = np.arange(npoints)
+
+    values = [ weights[k] for k in labels]
+    Y = np.vstack(values)
+    ax.stackplot(X, Y, labels=labels)
+    ax.set_xticks(range(npoints), labels=tick_labels, rotation="vertical")
+
+    if not show_total:
+        ax.plot(X, [225.0 for x in range(npoints)], linestyle="dashed", color="black", linewidth=1)
+        ax.plot(X, [250.0 for x in range(npoints)], '-', color="black", linewidth=1, label="Nominal")
+        ax.plot(X, [275.0 for x in range(npoints)], linestyle="dashed", color="black", linewidth=1,)
+
+
+    ax.legend(loc="upper left", ncol=4)
+
+
+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", "WEIGHING", "MANUFACTURING"]
+
+    weights = {}
+    petal_ids = []
+    M_values = {}
+    Mould_values = {}
+    mould_id = None
+    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
+
+            print("-- {} [{}]".format(T["testType"]["name"], T["runNumber"]))
+            if ttype in good_tests:
+                if good_tests[ttype]["runNumber"] < T["runNumber"]:
+                    good_tests[ttype] = T
+            else:
+                good_tests[ttype] = T
+
+        mould_desc = do_manufacturing(good_tests["MANUFACTURING"])
+        pos = mould_desc.rfind('.')
+        mould_id = mould_desc[pos+1:]
+        if mould_id not in Mould_values:
+            Mould_values[mould_id] = {}
+
+        for ttype, T in good_tests.items():
+
+            if ttype == "WEIGHING":
+                do_weighing(T["results"], weights)
+
+            elif ttype == "METROLOGY_AVS":
+                do_metrology(T["results"], M_values, Mould_values[mould_id])
+
+            elif ttype == "MANUFACTURING":
+                continue
+
+            else:
+                for value in T["results"]:
+                    print("\t{} - {}".format(value["code"], value["value"]))
+
+            if not T["passed"]:
+                print("## test {} FAILED".format(T["testType"]["code"]))
+
+            if len(T["defects"]):
+                print("+ Defects:")
+                for D in T["defects"]:
+                    print("\t{} - {}".format(D["name"], D["description"]))
+
+    plot_weighing(weights, petal_ids)
+    plot_metrology(M_values, Mould_values, petal_ids)
+    plt.show()
+
+if __name__ == "__main__":
+    # ITk_PB authentication
+    dlg = ITkDBlogin.ITkDBlogin()
+    session = dlg.get_client()
+
+    try:
+        main(session)
+
+    except Exception as E:
+        print(E)
+
+    dlg.die()

petal_qc/test/getPetalCoreTestSummary.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""Get a summery of Petal core TEsts."""
+
+try:
+    import itkdb_gtk
+    
+except ImportError:
+    import sys
+    from pathlib import Path
+    cwd = Path(__file__).parent.parent
+    sys.path.append(cwd.as_posix())
+
+from itkdb_gtk import ITkDBlogin, ITkDButils
+from itkdb_gtk.dbGtkUtils import replace_in_container, DictDialog, ask_for_confirmation
+
+
+def main(session):
+    """Main entry point."""
+
+    # find all cores
+    # Now all the objects
+    payload = {
+        "filterMap": {
+            #"componentType": ["BT"],
+            "componentType": ["CORE_PETAL"],
+            "type": ["CORE_AVS"],
+            "currentLocation": ["IFIC"],
+        },
+        "sorterList": [
+            {"key": "alternativeIdentifier", "descending": False }
+        ],
+    }
+    core_list = session.get("listComponents", json=payload)
+    core_tests = ["PETAL_METROLOGY_FRONT", "PETAL_METROLOGY_BACK", "XRAYIMAGING", "THERMAL_EVALUATION", "BTTESTING"]
+    
+    do_check_stage = "AT_QC_SITE"
+    #do_check_stage = None
+    
+    for core in core_list:
+        SN = core["serialNumber"]
+        altid = core['alternativeIdentifier']
+        if "PPC" not in altid:
+            continue
+        
+
+        location = core["currentLocation"]['code']
+        coreStage = core["currentStage"]['code']
+        if do_check_stage:
+            if coreStage != do_check_stage:
+                rc = ITkDButils.set_object_stage(session, SN, do_check_stage)
+                if rc is None:
+                    print("Could not change stage")
+                    return False
+
+        print("\n\nPetal {} [{}] - {}. {}".format(SN, altid, coreStage, location))
+
+        test_list = session.get("listTestRunsByComponent", json={"filterMap":{"serialNumber": SN, "state": "ready", "testType":core_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":
+                print(T)
+            
+            print("-- {} [{}]".format(T["testType"]["name"], T["runNumber"]))
+            if not T["passed"]:
+                print("\t## test FAILED")
+                
+            for D in T["defects"]:
+                print("\t{} - {}".format(D["name"], D["description"]))
+
+
+if __name__ == "__main__":
+    # ITk_PB authentication
+    dlg = ITkDBlogin.ITkDBlogin()
+    session = dlg.get_client()
+
+    try:
+        main(session)
+
+    except Exception as E:
+        print(E)
+
+    dlg.die()
+

petal_qc/test/listPetalCoreComponents.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""List petal core components."""
+
+from itkdb_gtk import ITkDBlogin
+from itkdb_gtk import ITkDButils
+
+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 listPetalCoreComponents(session):
+    """List petal core components.
+
+    Args:
+        session: The itkdb session
+    """
+    final_stage = {
+            "BT_PETAL_FRONT": "COMPLETED",
+            "BT_PETAL_BACK": "COMPLETED",
+            "COOLING_LOOP_PETAL": "CLINCORE",
+            "THERMALFOAMSET_PETAL": "IN_CORE"
+        }
+    # 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)
+
+    for core in core_list:
+        SN = core["serialNumber"]
+        altid = core['alternativeIdentifier']
+        if "PPC" not in altid:
+            continue
+
+
+        location = core["currentLocation"]['code']
+        coreStage = core["currentStage"]['code']
+        print("\n\nPetal {} [{}] - {}. {}".format(SN, altid, coreStage, location))
+
+        for child in core["children"]:
+            obj = ITkDButils.get_DB_component(session, child["component"])
+            child_type = get_type(obj)
+            child_stage = obj["currentStage"]["code"]
+            child_sn = obj["serialNumber"]
+            print("+-- {}: {} [{}]".format(child_sn, child_type, child_stage))
+            if child_stage != final_stage[child_type]:
+                print("Updating child stage.")
+                rc = ITkDButils.set_object_stage(session, child_sn, final_stage[child_type])
+                if rc is None:
+                    print("Could not set final stage of {} [{}]".format(child_type, child_sn))
+
+
+if __name__ == "__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 = ITkDButils.create_client()
+
+    listPetalCoreComponents(client)
+    if dlg:
+        dlg.die()