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

petal_qc/test/getAVStests.py

@@ -15,8 +15,86 @@ except ImportError:
 from itkdb_gtk import ITkDBlogin, ITkDButils
 
 
-def do_metrology(results, M_values):
-    pass
+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.
@@ -30,10 +108,27 @@ def do_weighing(results, weights):
         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", 
+    labels = ["COOLINGLOOPASSEMBLY", "LOCATOR_A", "LOCATOR_B", "LOCATOR_C",
+              "HONEYCOMBSET", "FACING_FRONT", "FACING_BACK",
               "EPOXYADHESIVE", "EPOXYPUTTY", "EPOXYCONDUCTIVE"]
 
     fig = plt.figure(tight_layout=True)
@@ -55,7 +150,7 @@ def plot_weighing(weights, tick_labels, show_total=False):
         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")
+    ax.legend(loc="upper left", ncol=4)
 
 
 def main(session):
@@ -74,27 +169,34 @@ def main(session):
     }
 
     core_list = session.get("listComponents", json=payload)
-    core_tests = ["METROLOGY_AVS", "WEIGHING"]
+    core_tests = ["METROLOGY_AVS", "WEIGHING", "MANUFACTURING"]
 
     weights = {}
     petal_ids = []
-    M_values = []
+    M_values = {}
+    Mould_values = {}
+    mould_id = None
     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}})
+        test_list = session.get(
+            "listTestRunsByComponent",
+            json={
+                "filterMap": {
+                    "serialNumber": SN,
+                    "state": "ready",
+                    "testType": core_tests,
+                }
+            },
+        )
 
         good_tests = {}
         for tst in test_list:
@@ -114,30 +216,37 @@ def main(session):
             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)
-            
+                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 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")
+            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__":
@@ -151,4 +260,4 @@ if __name__ == "__main__":
     except Exception as E:
         print(E)
 
-    dlg.die()
+    dlg.die()

petal_qc/test/getPetalCoreTestSummary.py

@@ -52,7 +52,7 @@ def main(session):
                     print("Could not change stage")
                     return False
 
-        print("Petal {} [{}] - {}. {}".format(SN, id, coreStage, location))
+        print("\n\nPetal {} [{}] - {}. {}".format(SN, altid, coreStage, location))
 
         test_list = session.get("listTestRunsByComponent", json={"filterMap":{"serialNumber": SN, "state": "ready", "testType":core_tests}})
 

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()

petal_qc/thermal/DESYdata.py

@@ -0,0 +1,58 @@
+"""Dialog to get DESY IRB files."""
+from pathlib import Path
+import itkdb_gtk
+import itkdb_gtk.dbGtkUtils
+
+import gi
+gi.require_version("Gtk", "3.0")
+from gi.repository import Gtk, Gio
+
+
+class DesyData(Gtk.Dialog):
+    """To get DESY data"""
+
+    def __init__(self, files=None):
+        super().__init__(title="DESY IRB files")
+
+        self.front = None
+        self.back = None
+
+        self.add_buttons(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
+                         Gtk.STOCK_OK, Gtk.ResponseType.OK)
+
+        area = self.get_content_area()
+        box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
+        area.pack_start(box, True, True, 10)
+
+        lbl = Gtk.Label(label="Choose the IRB files.")
+        box.pack_start(lbl, True, True, 10)
+
+        grid = Gtk.Grid(column_spacing=10, row_spacing=5)
+        box.pack_start(grid, True, True, 10)
+        grid.attach(Gtk.Label(label="Front"), 0, 0, 1, 1)
+        grid.attach(Gtk.Label(label="Back"), 0, 1, 1, 1)
+
+        fback = Gtk.FileChooserButton()
+        fback.connect("file-set", self.on_file_set, 0)
+        ffront = Gtk.FileChooserButton()
+        ffront.connect("file-set", self.on_file_set, 1)
+        grid.attach(ffront, 1, 0, 1, 1)
+        grid.attach(fback, 1, 1, 1, 1)
+        
+        if files is not None and len(files)==2:
+            ffront.set_file(Gio.File.new_for_path(files[0]))
+            fback.set_file(Gio.File.new_for_path(files[1]))
+
+    def on_file_set(self, *args):
+        """Get back side file."""
+        fnam = args[0].get_filename()
+        if fnam is None or not Path(fnam).exists():
+            itkdb_gtk.dbGtkUtils.complain("Could not find Data File", fnam, parent=self)
+            return
+
+        if args[1] == 0:
+            self.back = fnam
+        elif args[1] == 1:
+            self.front = fnam
+        else:
+            itkdb_gtk.dbGtkUtils.complain("This should not happen.", fnam, parent=self)

petal_qc/thermal/IRBFile.py

@@ -166,11 +166,32 @@ class HeaderBlock(object):
         self.word8 = ifile.getInt()
         self.end = ifile.tell()
 
+        if self.end - self.where != 32:
+            raise RuntimeError("byte counting error in parsing of HeaderBlock")
+
     def get_name(self):
         """Return the header type as string."""
         return HeaderBlock.header_name[self.type]
 
 
+class IRBPreview(object):
+    """A preview in the IRB file."""
+
+    def __init__(self, block):
+        """Initialize.
+
+        Args:
+            block: the block with the information.
+
+        """
+        self.block = block
+        old_position = block.ifile.tell()
+
+
+
+        block.ifile.seek(old_position)
+
+
 class IRBImage(object):
     """An image in the IRBis file."""
 
@@ -181,7 +202,6 @@ class IRBImage(object):
         """Initialize.
 
         Args:
-        ----
             ifile: The input file
             block: The block with the information.
 
@@ -233,9 +253,8 @@ class IRBImage(object):
         zero = ifile.getShort()
 
         if self.width > 10000 or self.height > 10000:
-            print("Image size out of range ({}x{})".format(
+            raise RuntimeError("Image size out of range ({}x{})".format(
                 self.width, self.height))
-            return
 
         flagsPosition = block.offset + IRBImage.FLAGS_OFFSET
         self.readImageFlags(flagsPosition)
@@ -314,13 +333,18 @@ class IRBImage(object):
                 if v2_count < 1:
                     v2_count = v2_data[v2_pos]
                     v2 = v2_data[v2_pos+1]
-                    P1 = self.palette[v2+1]
+                    if v2 < 0:
+                        v2 += 256
+                    P1 = self.palette[(v2+1) % 256]
                     P2 = self.palette[v2]
                     v2_pos += 2
 
                 v2_count -= 1
 
                 v1 = v1_data[i]
+                if v1 < 0:
+                    v1 += 256
+
                 f = v1/256.0
 
                 # linear interpolation betweeen eighboring palette entries
@@ -423,6 +447,7 @@ class IRBFile(object):
         """
         self.concatenate = concatenate
         self.imgList = []
+        self.previewList = []
         self.blocks = []
         self.ifiles = []
         self.file_images = []
@@ -493,6 +518,9 @@ class IRBFile(object):
             if block.type == HeaderBlock.IMAGE:
                 image = IRBImage(block)
                 self.imgList.append(image)
+            elif block.type == HeaderBlock.PREVIEW:
+                image = IRBPreview(block)
+                self.previewList.append(image)
 
         if self.is_sequence:
             offset = -1
@@ -549,6 +577,10 @@ class IRBFile(object):
         self.current_file = i
         self.imgList = self.file_images[i]
 
+    def getImage_timestamp(self, i):
+        """Return timestamp of i-th image."""
+        return self.imgList[i].timestamp
+
     def getImage(self, i):
         """Get i-th image in current file.
 
@@ -682,7 +714,7 @@ class IRBFile(object):
         return out
 
 
-def open_file(fname):
+def open_file(fname, concat=False):
     """Opens a file an returns a IRBFile instance.
 
     Args:
@@ -694,7 +726,19 @@ def open_file(fname):
     if is_iterable(fname):
         # we assume it is a list of IRB files...
         try:
-            irbf = IRBFile(fname)
+            if concat:
+                irbf = IRBFile(fname)
+                return irbf
+            else:
+                out = []
+                for f in fname:
+                    irbf = IRBFile(f)
+                    out.append(irbf)
+                
+                if len(out) == 1:
+                    out = out[0]
+                    
+                return out
 
         except FileNotFoundError as eee:
             print(eee)
@@ -769,4 +813,4 @@ def main():
     plt.show()
 
 if __name__ == "__main__":
-    main()
+    main()

petal_qc/thermal/IRDataGetter.py

@@ -343,14 +343,28 @@ class IRDataDESY(IRDataGetter):
             nframes = -1
 
         min_T = 1e50
-        avg_img = irbf.append_average(nframes=nframes)
-        for img in avg_img:
-            val = np.min(img.image)
-            if val < min_T:
-                min_T = val
+        i_min = -1
+        try:
+            avg_img = irbf.append_average(nframes=nframes)
+            for img in avg_img:
+                val = np.min(img.image)
+                if val < min_T:
+                    min_T = val
+
+            i_min = irbf.nimages-1
+            values = self.get_IR_data(avg_img)
 
-        i_min = irbf.nimages-1
-        values = self.get_IR_data(avg_img)
+        except AttributeError:
+            # We have 2 files, one front y the second back
+            values = []
+            factors = []
+            for ifile in irbf:
+                val = self.get_IR_data(ifile.getImage(0))
+                Tmin = np.min(val)
+                if Tmin < min_T:
+                    min_T = Tmin
+                    i_min = 0
+                values.append(val)
 
         factors = []
         for img in values:
@@ -359,25 +373,26 @@ class IRDataDESY(IRDataGetter):
 
         return min_T, i_min, values
 
-    def extract_pipe_path(self, images, params) -> list:
+    def extract_pipe_path(self, image, params) -> list:
         """Extract the "pipe path"  in a petal IR image.
 
         Args:
-        ----
-            images(list(ndarray)): The array of 2D arrays containing the images
+            image(list(ndarray)): The array of 2D arrays containing the images
             params: IRPetalPam object with options.
 
         Returns
-        -------
             pipe: the list of pipe contours or paths.
 
         """
         pipes = []
-        for img in images:
+        points_3d = []
+        for img in image:
             pipe = IRPetal.extract_pipe_path(img, params)
+            points_3d.append(IRPetal.get_all_3d_points())
             pipes.append(pipe)
 
-        IRPetal.set_images(images)
+        IRPetal.set_all_3d_points(points_3d)
+        IRPetal.set_images(image)
         return pipes
 
     def analyze_IR_image(self, img, pipes, sensors, iside, params):
@@ -401,7 +416,11 @@ class IRDataDESY(IRDataGetter):
 
         DESY gets the average of all frames.
         """
-        if not irbf.has_average:
-            irbf.append_average(nframes=5)
+        try:
+            if not irbf.has_average:
+                irbf.append_average(nframes=5)
+
+            return [v[-1] for v in irbf.file_images]
 
-        return [v[-1] for v in irbf.file_images]
+        except AttributeError:
+            return [irbf[0].getImage(0), irbf[1].getImage(0)]

petal_qc/thermal/IRPetal.py

@@ -72,6 +72,12 @@ def get_all_3d_points():
     """Return all pipe path 3D points."""
     return the_3d_points
 
+def set_all_3d_points(all_3d_points):
+    """Set all pipe path 3D points."""
+    global the_3d_points
+    the_3d_points = all_3d_points
+
+
 def get_last_segments():
     """Return the last segments found."""
     global the_segments

petal_qc/thermal/IRPetalParam.py

@@ -12,7 +12,7 @@ class IRPetalParam(object):
             values: ArgParser or dict with user values-
 
         """
-        self.institute = 'IFIC'   # Either IFIC or DESY to treat the different files
+        self.institute = None     # Either IFIC or DESY to treat the different files
         self.thrs = -22.0         # the threshold
         self.tco2 = -35.0         # Inlet temperature
         self.gauss_size = 15      # Radius of gausian filtering

petal_qc/thermal/PipeFit.py

@@ -413,6 +413,14 @@ class PipeFit(object):
         """
         if M0 is None:
             M = self.initial_guess(data)
+            for i, val in enumerate(M):
+                if val < self.bounds[0][i]:
+                    val = 1.01 *  self.bounds[0][i]
+                    M[i] = val
+                elif val > self.bounds[1][i]:
+                    val = 0.99 *  self.bounds[0][i]
+                    M[i] = val
+                    
             if self.debug:
                 print("\n** Initial guess")
                 self.print_transform(M)

petal_qc/thermal/analyze_IRCore.py

@@ -528,12 +528,14 @@ def analyze_IRCore(options, show=True):
             print("I need a golden file to compare with")
             sys.exit(1)
 
-        golden_file = find_file(options.folder, options.golden)
+        golden_file = Path(options.golden).expanduser().resolve()
         if not golden_file.exists():
-            print("Golden file does not exist.")
-            sys.exit(1)
+            golden_file = find_file(options.folder, options.golden)
+            if not golden_file.exists():
+                print("Golden file {} does not exist.".format(options.golden))
+                sys.exit(1)
 
-        with open(golden_file, 'r') as fp:
+        with open(golden_file, 'r', encoding="utf-8") as fp:
             J = json.load(fp)
 
         golden = [Petal_IR_Analysis.AnalysisResult() for i in range(2)]
@@ -563,7 +565,7 @@ def analyze_IRCore(options, show=True):
             F = show_golden_average(golden, cores, "sensor_std")
             add_figures_to_doc(document, F, "Sensor std")
 
-            if document:
+            if document and not hasattr(options, "no_golden_doc"):
                 ofile = utils.output_folder(options.folder, "Compare-to-Golden.docx")
                 document.save(ofile)
 
@@ -573,7 +575,8 @@ def analyze_IRCore(options, show=True):
     return output
 
 
-if __name__ == "__main__":
+def main():
+    """Main entry."""
     from argparse import ArgumentParser
     # Argument parser
     parser = ArgumentParser()
@@ -595,3 +598,6 @@ if __name__ == "__main__":
         sys.exit()
 
     analyze_IRCore(options)
+
+if __name__ == "__main__":
+    main()