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

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,154 @@
+#!/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 do_metrology(results, M_values):
+    pass
+
+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_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=3, fontsize="x-small")
+
+
+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"]
+
+    weights = {}
+    petal_ids = []
+    M_values = []
+    for core in core_list:
+        SN = core["serialNumber"]
+        altid = core['alternativeIdentifier']
+        if "PPC" not in altid:
+            continue
+
+        if altid in ["PPC.016", "PPC.017"]:
+            pass
+
+        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
+
+        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)
+            
+            else:
+                for value in T["results"]:
+                    print("\t{} - {}".format(value["code"], value["value"]))
+
+
+                if not T["passed"]:
+                    print("\t## test FAILED")
+
+                print("\t+ Defects:")
+                if len(T["defects"]):
+                    for D in T["defects"]:
+                        print("\t{} - {}".format(D["name"], D["description"]))
+                else:
+                    print("\nNone")
+
+    plot_weighing(weights, 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("Petal {} [{}] - {}. {}".format(SN, id, 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/prepareDESYfiles.py

@@ -1,9 +1,10 @@
 #!/usr/bin/env python3
-"""Prepara input files from DESY RAW."""
+"""Prepare raw data input files from DESY so that we can use them with this code."""
 import os
 import fnmatch
 import re
 from pathlib import Path
+import argparse
 
 def all_files(root, patterns='*', single_level=False, yield_folders=False):
     """A generator that reruns all files in the given folder.
@@ -41,18 +42,26 @@ class PetalCore:
         self.back = {}
 
 def main(folder, out_folder):
-    """Main entry point."""
+    """Main entry point.
+
+    It takes DESY raw data files and combines them into  a single file for front
+    and back metrology.
+
+    Args:
+        folder: the input folder where to find the original files.
+        out_folder: the folder where the new fiels will be stored.
+    """
     outF = Path(out_folder).expanduser().resolve()
     if not outF.exists():
         os.mkdir(outF)
-        
-    rgx = re.compile(r"Project Name: (\w+)side_.*AlternativeID=PPC-(\d+)", re.MULTILINE|re.DOTALL)
+
+    rgx = re.compile(r"Project Name: (\w+)side_.*AlternativeID=PPC[-_](\d+)", re.MULTILINE|re.DOTALL)
     petal_cores = {}
     for fnam in all_files(folder, "*.txt"):
         P = Path(fnam).expanduser().resolve()
         with open(fnam, "r", encoding="UTF-8") as ff:
             R = rgx.search(ff.read())
-            if R:
+            if R: 
                 petal_id = "PPC.{}".format(R.group(2))
                 side = R.group(1).lower()
                 if "_2D_" in P.name:
@@ -75,12 +84,20 @@ def main(folder, out_folder):
             list_file.write("{} {}-{} {}\n".format(oname, petal_id, side, petal_id))
             data = ""
             for data_type, fnam in values.items():
+                if fnam is None:
+                    print("This should not happen.")
+                    
                 with open(fnam, "r", encoding="UTF-8") as ifile:
                     data += ifile.read()
-                    
+
             with open(oname, "w", encoding="UTF-8") as ofile:
                 ofile.write(data)
-       
+
     list_file.close()
+    
 if __name__ == "__main__":
-    main("/Users/lacasta/Downloads/DESY_Production", "/tmp/desy")
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input-folder", default=None, help="Input folder")
+    parser.add_argument("--output-folder", help="Outout fodler", default=None)
+    
+    main("/Users/lacasta/Downloads/Report_QC-desy_Sep2024", "/tmp/desy")

petal_qc/thermal/IRCore.py

@@ -41,7 +41,7 @@ class IRCore(object):
         self.files = []
         self.results = [] if results is None else results  # list of AnalysisResults. One per side
         self.golden = []                                    # list of Golden results. One per side.
-        self.inlet = -9999
+        self.inlet = params.tco2
 
     def set_files(self, files):
         """Set the input files."""

petal_qc/thermal/IRDataGetter.py

@@ -19,10 +19,10 @@ HAS_GRAPHANA = False
 try:
     from petal_qc.utils.readGraphana import ReadGraphana
     HAS_GRAPHANA = True
-    
+
 except ImportError:
     HAS_GRAPHANA = False
-    
+
 
 
 class IRDataGetter(object):
@@ -62,7 +62,7 @@ class IRDataGetter(object):
             kargs: keyword arguments to pass.
 
         """
-        pass
+        return
 
     def find_reference_image(self, irbf, *args, **kargs):
         """Find first image in sequence with T < T_min.
@@ -114,7 +114,7 @@ class IRDataGetter(object):
             An array of AnalysisResult objects.
 
         """
-        pass
+        return
 
     def get_analysis_frame(self, irbf):
         """Get the frame where we want to perform the analysis."""
@@ -166,12 +166,12 @@ class IRDataIFIC(IRDataGetter):
         #      T_min = -22.0
         #  else:
         #      T_min = args[0]
-#  
+        #
         #  irbf.set_concatenate(True)
         #  min_T, i_min, ref_img = IRPetal.find_reference_image(irbf, T_min)
         #  values = self.get_IR_data(ref_img)
         #  self.factor = values.shape[0]/640
-#  
+        #
         #  return min_T, i_min, [values, ]
 
     def get_IR_data(self, image, **kargs):
@@ -281,10 +281,10 @@ class IRDataIFIC(IRDataGetter):
             img = self.analysis_frame[0]
             X, T = self.DB.get_temperature(img.timestamp, 1)
             return np.min(T)
-        
+
         else:
             return -9999
-            
+
 
 
 class IRDataDESY(IRDataGetter):

petal_qc/thermal/IRPetal.py

@@ -35,7 +35,7 @@ debug_plot = DebugPlot.DebugPlot()
 the_segments = None  # global variable to store the last segments found.
 the_contours = None  # Global variable to store the last contours found
 the_images = None
-
+the_3d_points = None
 
 class DebugTempProfile(object):
     """Stores Debug data."""
@@ -68,6 +68,10 @@ class DebugTempProfile(object):
 T_profile = None      # Global to store the temp. profile.
 
 
+def get_all_3d_points():
+    """Return all pipe path 3D points."""
+    return the_3d_points
+
 def get_last_segments():
     """Return the last segments found."""
     global the_segments
@@ -145,6 +149,39 @@ class Segment(object):
 
         return points
 
+    @staticmethod
+    def get_3d_points_in_list(segments):
+        """Return a list with all the 3D points (x,y,T) in the list of segments.
+
+        Args:
+        ----
+            segments (list[Segment]): The list of segments
+
+        Returns
+        -------
+            np.array: array of points.
+
+        """
+        # Count the number of points
+        npts = 0
+        for S in segments:
+            if S.Pmin is not None:
+                npts += len(S.Pmin)
+
+        points = np.zeros([npts, 3])
+        ipoint = 0
+        for S in segments:
+            if S.Pmin is None:
+                continue
+
+            for i, Pmin in enumerate(S.Pmin):
+                points[ipoint, 0] = Pmin.x
+                points[ipoint, 1] = Pmin.y
+                points[ipoint, 2] = S.Tmin[i]
+                ipoint += 1
+
+        return points
+
     @staticmethod
     def get_spread_in_list(segments):
         """Return an array with spread values."""
@@ -323,7 +360,7 @@ def extract_mirrored_pipe_path(values, params):
         (left_pipe, right_pipe): The 2 paths.
 
     """
-    global the_images
+    global the_images, the_3d_points
     if params.rotate:
         rotated = rotate_full_image(values)
     else:
@@ -331,11 +368,14 @@ def extract_mirrored_pipe_path(values, params):
 
     imgs = split_IR_image(rotated)
     pipes = []
+    points_3d = []
     for img in imgs:
         pipe = extract_pipe_path(img, params)
         pipes.append(pipe)
+        points_3d.append(get_all_3d_points())
 
     the_images = imgs
+    the_3d_points = points_3d
     return list(pipes)
 
 
@@ -684,7 +724,7 @@ def get_derivatives(T_min, x_min, x_max, coeff):
     return valid_roots, valid_values, valid_curv
 
 
-def show_profile(debug_plot):
+def show_profile(debug_plot, title=None):
     """Plot a profile."""
     debug_plot.setup_debug("Slices", is_3d=True)
     if T_profile:
@@ -693,6 +733,12 @@ def show_profile(debug_plot):
         if T_profile._pF is not None:
             debug_plot.plotx("Slices", T_profile._pF[:, 0], T_profile._pF[:, 1], T_profile._Fn, 'b-')
 
+        if title:
+            debug_plot.set_title("Slices", title)
+
+
+__call_id__ = 0
+__img_num__ = 0
 
 def slice_contours(data, inner, outer, distance=50, npoints=15, do_fit=False, show=False) -> list[Segment]:
     """Make slices between contours.
@@ -712,8 +758,11 @@ def slice_contours(data, inner, outer, distance=50, npoints=15, do_fit=False, sh
         A list of Segments.
 
     """
-    global debug_plot
+    global debug_plot, __call_id__, __img_num__
 
+    __call_id__ += 1
+    __img_num__ = 0
+    #show=True
     segments = []
     dist = 0
     npts = len(outer)
@@ -726,7 +775,15 @@ def slice_contours(data, inner, outer, distance=50, npoints=15, do_fit=False, sh
     U = contours.find_closest(x0, y0, inner)
     Tmin, Pmin, spread = get_T_profile(data, Point(x0, y0), Point(U[0], U[1]), npts=npoints, do_fit=do_fit, debug=False)
     if show:
-        show_profile(debug_plot)
+        show_profile(debug_plot, "Dist {:.3f}, Tmin {:.2f} ({:.1f}, {:.1f})".format(dist, Tmin[0], Pmin[0].x, Pmin[0].y))
+        debug_plot.savefig("Slices", "/tmp/img_{}_{}.png".format(__call_id__, __img_num__))
+        __img_num__ += 1
+        try:
+            ax = debug_plot.get_ax("Contours")
+            ax.plot([x0, U[0]], [y0, U[1]], '-')
+            ax.plot(Pmin[0].x, Pmin[0].y, 'o')
+        except KeyError:
+            pass
 
     # store results: distance along segment and temperature
     T = []
@@ -764,7 +821,16 @@ def slice_contours(data, inner, outer, distance=50, npoints=15, do_fit=False, sh
 
                 segments.append(Segment((x0, y0), V, Pmin, path_length, Tmin, spread))
                 if show:
-                    show_profile(debug_plot)
+                    show_profile(debug_plot, "Dist {:.3f} Tmin {:.2f} ({:.1f}, {:.1f})".format(path_length, Tmin[0], Pmin[0].x, Pmin[0].y))
+                    debug_plot.savefig("Slices", "/tmp/img_{}_{}.png".format(__call_id__, __img_num__))
+                    __img_num__ += 1
+                    
+                    try:
+                        ax = debug_plot.get_ax("Contours")
+                        ax.plot([x0, V[0]], [y0, V[1]], '-')
+                        ax.plot(Pmin[0].x, Pmin[0].y, 'o')
+                    except KeyError:
+                        pass
 
             dist = 0
 
@@ -772,6 +838,7 @@ def slice_contours(data, inner, outer, distance=50, npoints=15, do_fit=False, sh
     if show:
         debug_plot.setup_debug("SlicePipe")
         debug_plot.plot("SlicePipe", D, T, '-o')
+        debug_plot.savefig("SlicePipe", "/tmp/slice_pipe_{}.png".format(__call_id__))
 
     return segments
 
@@ -829,10 +896,12 @@ def find_image_contours(data, params):
             print("contour area: {:.3f}".format(area))
 
     if params.debug:
+        debug_plot.setup_debug("Contours", 1, 1)
         colors = ["#ff9b54", "#ff7f51"]  # ["#540b0e", "#9e2a2b"]
         print("Number of countours:", len(out))
 
-        fig, ax = plt.subplots(1, 1, tight_layout=True)
+        ax = debug_plot.get_ax("Contours")
+        ax.clear()
         ax.imshow(data, origin='lower', cmap='jet')
         for i, cnt in enumerate(out):
             ax.plot(cnt[:, 0], cnt[:, 1], linewidth=3, color=colors[i % 2])
@@ -870,6 +939,7 @@ def get_segments(data, params) -> list[Segment]:
         list of segments. See `slice_contours`
 
     """
+    global the_3d_points
     cntrs = find_image_contours(data, params)
     if cntrs is None:
         return None
@@ -881,6 +951,7 @@ def get_segments(data, params) -> list[Segment]:
                                   do_fit=params.do_fit,
                                   show=params.debug)
 
+    the_3d_points = Segment.get_3d_points_in_list(the_segments)
     return the_segments
 
 

petal_qc/thermal/Petal_IR_Analysis.py

@@ -30,7 +30,7 @@ class AnalysisResult(object):
                 continue
 
 
-def show_2D_image(img, title=None):
+def show_2D_image(img, title=None, show_fig=True):
     """Show a 2D image."""
     if isinstance(img, list):
         fig, ax = plt.subplots(1, len(img))
@@ -51,8 +51,9 @@ def show_2D_image(img, title=None):
         pcm = ax.imshow(img, origin='lower', cmap=HighContrast.reversed())  # cmap="jet")
         fig.colorbar(pcm, ax=ax)
 
-    plt.draw()
-    plt.pause(0.001)
+    if show_fig:
+        plt.draw()
+        plt.pause(0.001)
 
     return fig, ax
 

petal_qc/thermal/PipeFit.py

@@ -498,7 +498,7 @@ class PipeFit(object):
 
         return X, Y
 
-    def plot(self):
+    def plot(self, show_fig=True):
         """Plot result of fit and data."""
         fig, ax = plt.subplots(1, 1, tight_layout=True)
         ax.plot(self.pipe[:, 0], self.pipe[:, 1], label="Pipe")
@@ -509,8 +509,9 @@ class PipeFit(object):
 
         ax.plot(out[:, 0], out[:, 1], 'o', label="Data")
         ax.legend()
-        plt.draw()
-        plt.pause(0.0001)
+        if show_fig:
+            plt.draw()
+            plt.pause(0.0001)
         return fig, ax