petal-qc 0.0.14.dev1__py3-none-any.whl → 0.0.16__py3-none-any.whl

petal_qc/__init__.py

@@ -1,5 +1,5 @@
 """petal_qc python module."""
-__version__ = "0.0.14.dev1"
+__version__ = "0.0.16"
 
 
 def coreMetrology():
@@ -9,9 +9,14 @@ def coreMetrology():
 
 def doMetrology():
     """Launches the Core metrology analysis in the command line."""
-    from .metrology.do_metrology import main
+    from .metrology.do_Metrology import main
     main()
 
+def coreMetrologyTTY():
+    """Launches the Core metrology analysis in the command line."""
+    from .metrology.do_Metrology import analyze_core_metrology
+    analyze_core_metrology()
+
 def coreThermal():
     """Launches the Core thermal analysis ahd PDB script."""
     from .thermal.coreThermal import main
@@ -43,6 +48,11 @@ def petalReceptionTests():
     from .PetalReceptionTests import main
     main()
 
+def petalCoreTestSummary():
+    """GND/VI tests."""
+    from .getPetalCoreTestSummary import main
+    main()
+
 def dashBoard():
     """Launches the Core thermal analysis ahd PDB script."""
     from .dashBoard import main

petal_qc/{test/getPetalCoreTestSummary.py → getPetalCoreTestSummary.py}

@@ -1,20 +1,26 @@
 #!/usr/bin/env python3
 """Get a summery of Petal core TEsts."""
+import json
+import sys
+import re
+from argparse import ArgumentParser
 
+
+from pathlib import Path
 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
+from petal_qc.utils.ArgParserUtils import RangeListAction
 
+r_petal_id = re.compile("PPC.([0-9]*)")
 
-def main(session):
+def petalCoreTest(session, options):
     """Main entry point."""
 
     # find all cores
@@ -24,17 +30,25 @@ def main(session):
             #"componentType": ["BT"],
             "componentType": ["CORE_PETAL"],
             "type": ["CORE_AVS"],
-            "currentLocation": ["IFIC"],
+            # "currentLocation": ["IFIC"],
         },
         "sorterList": [
             {"key": "alternativeIdentifier", "descending": False }
         ],
     }
+    suff = "ALL"
+    if options.institute:
+        payload["filterMap"]["currentLocation"] = options.institute
+        suff = options.institute
+        
     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
+    petal_id_db = {}
+    
+    has_list = len(options.cores) != 0
     
     for core in core_list:
         SN = core["serialNumber"]
@@ -42,7 +56,16 @@ def main(session):
         if "PPC" not in altid:
             continue
         
+        R = r_petal_id.search(altid)
+        if R is None:
+            continue
 
+        pid = int(R.group(1))
+        
+        if has_list and pid not in options.cores:
+            continue
+        
+        petal_id_db[altid] = SN
         location = core["currentLocation"]['code']
         coreStage = core["currentStage"]['code']
         if do_check_stage:
@@ -73,17 +96,29 @@ def main(session):
             for D in T["defects"]:
                 print("\t{} - {}".format(D["name"], D["description"]))
 
+    with open("petal_ID_db_{}.json".format(suff), "w", encoding="utf-8") as fOut:
+        json.dump(petal_id_db, fOut, indent=3)
 
-if __name__ == "__main__":
+def main():
+    """Main entry"""
+    parser = ArgumentParser()
+    parser.add_argument("--institute", default=None, help="The petal current location")
+    parser.add_argument("--cores", dest="cores", action=RangeListAction, default=[],
+                        help="Create list of cores to analyze. The list is made with  numbers or ranges (ch1:ch2 or ch1:ch2:step) ")
+    options = parser.parse_args()
+    
     # ITk_PB authentication
     dlg = ITkDBlogin.ITkDBlogin()
     session = dlg.get_client()
 
     try:
-        main(session)
+        petalCoreTest(session, options)
 
     except Exception as E:
         print(E)
 
     dlg.die()
+    
+    if __name__ == "__main__":
+        main()
 

petal_qc/metrology/PetalMetrology.py

@@ -45,19 +45,6 @@ def check_spec(val, nom, fraction=0.0):
         rc = val <= (1+fraction)*nom
         return rc
 
-
-class CommaSeparatedListAction(Action):
-    """Create a list from the comma sepparated numbers at imput."""
-
-    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 ValueError("{} needs a 3D vector".format(self.dest))
-
-        setattr(namespace, self.dest, value)
-
-
 def petal_metrology(ifile, options):
     """Do the analysis of the petal metrology data.
 

petal_qc/metrology/analyze_locking_points.py

@@ -513,12 +513,12 @@ def locking_point_positions(positions, document=None):
     dPL2 = np.linalg.norm(positions[1, 0:2] - positions[4, 0:2])
     deltaPL1 = (nPL1-dPL1)
     deltaPL2 = (nPL2-dPL2)
-    fPL1 = "PASSED" if abs(deltaPL1) <= 0.050 else "FAILED"
-    fPL2 = "PASSED" if abs(deltaPL2) <= 0.050 else "FAILED"
+    fPL1 = "PASSED" if abs(deltaPL1) <= 0.075 else "FAILED"
+    fPL2 = "PASSED" if abs(deltaPL2) <= 0.075 else "FAILED"
 
     for key, val in outDB["REL_POS_DELTA"].items():
         deltaPL = np.linalg.norm(val)
-        fPL = "PASSED" if abs(deltaPL) <= 0.050 else "FAILED"
+        fPL = "PASSED" if abs(deltaPL) <= 0.075 else "FAILED"
         print("Distance {}: {:.3f} mm ({})".format(key, deltaPL, fPL))
 
     if document:
@@ -559,7 +559,7 @@ def locking_point_positions(positions, document=None):
         document.add_paragraph("")
         for key, val in outDB["REL_POS_DELTA"].items():
             deltaPL = np.linalg.norm(val)
-            fPL = "PASSED" if abs(deltaPL) <= 0.050 else "FAILED"
+            fPL = "PASSED" if abs(deltaPL) <= 0.075 else "FAILED"
             document.add_paragraph("Distance {}: {:.3f} mm ({})".format(key, deltaPL, fPL))
 
     return outDB

petal_qc/metrology/compare_Cores.py

@@ -2,13 +2,43 @@
 """Compare quantities."""
 
 import sys
+import re
+
 import argparse
 import glob
 import json
+import math
 from pathlib import Path
 import numpy as np
 import matplotlib.pyplot as plt
 
+r_petal_id = re.compile("PPC.([0-9]*)")
+
+class PetalCoreListAction(argparse.Action):
+    """Create a list from the comma sepparated numbers at imput."""
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        """The actual action."""
+        value = []
+        for V in values.split(','):
+            try:
+                value.append(int(V))
+            except ValueError:
+                if ':' not in V:
+                    continue
+
+                items = V.split(':')
+                if len(items)==1:
+                    continue
+
+                ival = list(map(int, items))
+                ival[1] += 1
+                for x in range(*ival):
+                    value.append(int(x))
+
+
+        setattr(namespace, self.dest, value)
+
 
 def get_value(data, value_path):
     """Get the value from the path given."""
@@ -58,12 +88,25 @@ def read_data_files(options):
     front = {}
     back = {}
 
+    has_list = len(options.cores) != 0
+
     for fnam in options.files:
         ifile = Path(fnam).expanduser().resolve()
         if not ifile.exists():
             print("File does not exist: ", fnam)
             continue
 
+        R = r_petal_id.search(fnam)
+        if R is None:
+            continue
+
+        petal_id = R.group(0)
+        pid = int(R.group(1))
+
+        if has_list and pid not in options.cores:
+            continue
+
+
         data = None
         with open(ifile, 'r', encoding="UTF-8") as fp:
             data = json.load(fp)
@@ -100,17 +143,22 @@ def draw_deltas(data, keys, fnam=None, title="Front", draw_text=True):
     P = [np.zeros([nfiles, 2]),
          np.zeros([nfiles, 2]),
          np.zeros([nfiles, 2])]
+    D = [[],[],[]]
+    
     fig_width = 12.0
     fig_height = 1.2*fig_width/3.0
     fig, ax = plt.subplots(nrows=1, ncols=3, tight_layout=True, figsize=(fig_width, fig_height))
     fig.suptitle(title)
+    figb, bx = plt.subplots(nrows=1, ncols=3, tight_layout=True, figsize=(fig_width, fig_height))
+    figb.suptitle(title)
+    
     for i in range(3):
         LBL = [[],[],[]]
         ax[i].set_title(keys[i])
         ax[i].set_aspect('equal', adjustable='box')
-        ax[i].set_xlim(-100, 100)
-        ax[i].set_ylim(-100, 100)
-        circle = plt.Circle((0,0), 50, color="red", alpha=0.25)
+        ax[i].set_xlim(-150, 150)
+        ax[i].set_ylim(-150, 150)
+        circle = plt.Circle((0,0), 75, color="red", alpha=0.25)
         ax[i].add_patch(circle)
         circle = plt.Circle((0,0), 25, color="green", alpha=0.25)
         ax[i].add_patch(circle)
@@ -118,20 +166,34 @@ def draw_deltas(data, keys, fnam=None, title="Front", draw_text=True):
         ax[i].set_xlabel("X (µm)")
         ax[i].set_ylabel("Y (µm)")
         ax[i].grid()
+        
+        bx[i].set_title(keys[i])
+        bx[i].set_xlabel("Distance (µm)")
+        bx[i].grid()
+        
 
         for j, v in enumerate(data.items()):
             label, values = v
             for k in range(3):
                 ky = key_table[keys[k]]
-                P[k][j, :] = 1000*np.array(values[ky])
+                point = 1000*np.array(values[ky])
+                P[k][j, :] = point
+                D[k].append(math.sqrt(point[0]**2+point[1]**2))
                 LBL[k].append(label.split('.')[1].lstrip('0'))
 
+        bx[i].hist(D[i], bins=15, range=(0, 150))
         ax[i].scatter(P[i][:,0], P[i][:,1])
         if draw_text:
             for j in range(len(LBL[i])):
                 ax[i].text(P[i][j,0], P[i][j,1], LBL[i][j]) #, ha='center', va='top')
 
+    ofile = Path(fnam).expanduser().resolve()
+    print("* parent: ", ofile.parent)
+    print("* stem: ", ofile.stem)
+    bnam = ofile.parent / "{}-h.png".format(ofile.stem)
+    print(bnam.as_posix())
     save_figure(fig, fnam, prefix=title)
+    save_figure(figb, bnam, prefix=title)
 
 
 def show_positions(options):
@@ -184,6 +246,7 @@ def show_flatness(options):
         a.set_ylim(0, 1.2*max(y_lim[0][1], y_lim[1][1]))
         x_lim = a.get_xlim()
         a.fill_between(x_lim, 0, 0.050, facecolor="darkseagreen", alpha=0.1)
+        a.fill_between(x_lim, 0.050, 0.100, facecolor="mediumseagreen", alpha=0.1)
         if not options.no_legend:
             a.legend(ncol=3, fontsize="x-small")
 
@@ -230,6 +293,8 @@ if __name__ == "__main__":
     parser.add_argument("--out", default=None, help="File to store the figure.")
     parser.add_argument("--no-legend", dest="no_legend", default=False, action="store_true", help="Do not draw the legend")
     parser.add_argument("--no-show", dest="no_show", default=False, action="store_true", help="Do not show the figure")
+    parser.add_argument("--cores", dest="cores", action=PetalCoreListAction, default=[],
+                        help="Create list of cores to analyze. The list is made with  numbers or ranges (ch1:ch2 or ch1:ch2:step) ")
 
     opts = parser.parse_args()
     if len(opts.files) == 0:

petal_qc/metrology/coreMetrology.py

@@ -18,18 +18,6 @@ from gi.repository import Gtk, GObject, Gio, GLib
 
 __HELP__ = "https://petal-qc.docs.cern.ch/metrology.html"
 
-class CommaSeparatedListAction(Action):
-    """Create a list from the comma sepparated numbers at imput."""
-
-    def __call__(self, 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 ValueError("{} needs a 3D vector".format(self.dest))
-
-        setattr(namespace, self.dest, value)
-
-
 class CoreMetrology(itkdb_gtk.dbGtkUtils.ITkDBWindow):
     """Application window."""
 

petal_qc/metrology/do_Metrology.py

@@ -23,21 +23,8 @@ except ImportError:
     sys.path.append(cwd.as_posix())
 
 from petal_qc.utils.utils import output_folder
-
 from petal_qc.metrology.PetalMetrology import petal_metrology
 
-
-class CommaSeparatedListAction(Action):
-    """Create a list from the comma sepparated numbers at imput."""
-
-    def __call__(self, 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))
-
-        setattr(namespace, self.dest, value)
-
 def do_analysis(fnam, prefix, SN, options):
     """Perform analysis of a file.
 
@@ -68,6 +55,7 @@ def do_analysis(fnam, prefix, SN, options):
 
 def analyze_files(ifile, options):
     """Main entry."""
+    failed_files = []
     with open(ifile, 'r', encoding='UTF-8') as inp:
 
         for line in inp:
@@ -84,10 +72,26 @@ def analyze_files(ifile, options):
             except Exception:
                 fnam, prefix, SN, *_ = line.split()
 
-            do_analysis(fnam, prefix, SN, options)
+            try:
+                with open(fnam, "r", encoding="ISO-8859-1") as fin:
+                    ss = fin.read()
+                    if ss.find("Punto:")<0:
+                        options.desy=True
+                    else:
+                        options.desy=False
+
+                do_analysis(fnam, prefix, SN, options)
+                print("\n\n")
+            except Exception as E:
+                failed_files.append([fnam, E])
+                continue
+
+    if len(failed_files)>0:
+        for fnam, E in failed_files:
+            print("### Failed file {}\n{}".format(fnam, E))
 
-def main():
-    "Main entry."
+def parse_options():
+    """Parse command line options."""
     parser = ArgumentParser()
     parser.add_argument('files', nargs='*', help="Input files")
     parser.add_argument("--prefix", dest='prefix', default=None, help="prefix telling if it is front or back.")
@@ -113,11 +117,21 @@ def main():
         print("I need an input file")
         sys.exit()
 
+    return options
+
+def main():
+    "Main entry."
+    options = parse_options()
     try:
         analyze_files(options.files[0], options)
 
     except Exception:
         print(traceback.format_exc())
 
+def analyze_core_metrology():
+    """Do a single file analysis."""
+    options = parse_options()
+    do_analysis(options.files[0], options.prefix, options.SN, options)
+
 if __name__ == "__main__":
     main()

petal_qc/metrology/petal_flatness.py

@@ -31,19 +31,6 @@ from .show_data_file import show_data, TOP_VIEW
 
 figure_width = 14
 
-
-class CommaSeparatedListAction(Action):
-    """Create a list from the comma sepparated numbers at imput."""
-
-    def __call__(self, 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))
-
-        setattr(namespace, self.dest, value)
-
-
 def plot_sensor(Spoints, ax, marker='o', cmap='magma'):
     """Plot the points given in a scatter plot."""
     ax.scatter(Spoints[:, 0], Spoints[:, 1], Spoints[:, 2],

petal_qc/metrology/readAVSdata.py

@@ -696,6 +696,8 @@ def readProductionSheet(session, file_path, SN):
     manufacturing["results"]["LOCATOR_B"] = sheet["{}{}".format(id_col, i_items+3)].value
     manufacturing["results"]["LOCATOR_C"] = sheet["{}{}".format(id_col, i_items+4)].value
     manufacturing["results"]["HONEYCOMBSET"] = split_comp_list( sheet["{}{}".format(id_col, i_items+5)].value)
+    manufacturing["results"]["HONEYCOMBSET"] = [ str(x) for x in manufacturing["results"]["HONEYCOMBSET"]]
+    
     manufacturing["results"]["EPOXY_ADHESIVE"] = split_comp_list(sheet["{}{}".format(id_col, i_items+8)].value)
     manufacturing["results"]["EPOXY_PUTTY"] = split_comp_list( sheet["{}{}".format(id_col, i_items+9)].value)
     manufacturing["results"]["EPOXY_CONDUCTIVE"] = split_comp_list( sheet["{}{}".format(id_col, i_items+10)].value)

petal_qc/metrology/uploadPetalInformation.py

@@ -537,6 +537,23 @@ class AVSPanel(dbGtkUtils.ITkDBWindow):
             if self.petal_core is None:
                 return
 
+        this_petal = self.SN.get_text()
+        # Check for HonneyComb set
+        for P in self.petal_core["properties"]:
+            if P["code"] == "HC_ID" and P["value"] is None:
+                if dbGtkUtils.is_iterable(components["HoneyCombSet"]):
+                    val = ','.join([str(x) for x in components["HoneyCombSet"]])
+                else:
+                    val = str(components["HoneyCombSet"])
+                rc = ITkDButils.set_component_property(self.session,
+                                                        this_petal,
+                                                        "HC_ID",
+                                                        val)
+                if rc is None:
+                    error_txt.append("Problems setting HoneyCombSet ID.\n")
+
+                break
+
         comp_map = {
             "BT_PETAL_FRONT": "FacingFront",
             "BT_PETAL_BACK": "FacingBack",
@@ -565,7 +582,6 @@ class AVSPanel(dbGtkUtils.ITkDBWindow):
         error_txt = []
         txt = "Click OK to add\n\t{}".format("\n\t".join(missing))
         if dbGtkUtils.ask_for_confirmation("Missing components", txt, parent=self):
-            this_petal = self.SN.get_text()
             for cmp in missing:
                 SN = components[comp_map[cmp]]
                 if SN[0:5] == "20USE":
@@ -582,22 +598,6 @@ class AVSPanel(dbGtkUtils.ITkDBWindow):
                         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:
-                    if dbGtkUtils.is_iterable(components["HoneyCombSet"]):
-                        val = ' '.join(components["HoneyCombSet"])
-                    else:
-                        val = str(components["HoneyCombSet"])
-                    rc = ITkDButils.set_component_property(self.session,
-                                                           this_petal,
-                                                           "HC_ID",
-                                                           val)
-                    if rc is None:
-                        error_txt.append("Problems setting HoneyCombSet ID.\n")
-
-                    break
-
             # Check the final stage of the assembled objects
             # for child in self.petal_core["children"]:
             #     if child["component"]:

petal_qc/test/analyzeMetrologyTable.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""Analyze the table generated by createMetrologyTable."""
+
+import sys
+from pathlib import Path
+import math
+import argparse
+import pandas as pd
+import numpy as np
+from numpy.linalg import norm
+import matplotlib.pyplot as plt
+from lmfit.models import LinearModel
+
+from petal_qc.utils.fit_utils import draw_best_fit
+
+def distance(P1, P2, P3):
+    C = np.cross(P2-P1, P3-P1)
+    D = C/norm(P2-P1)
+    return D
+
+def remove_outliers_indx(data, cut=2.0, debug=False):
+    """Remove points far away form the rest.
+
+    Args:
+    ----
+        data : The data
+        cut: max allowed distance
+        debug: be verbose if True.
+
+    Returns
+    -------
+        index of valid pints in data array.
+
+    """
+    d = np.abs(data - np.median(data))
+    mdev = np.median(d)
+    s = d / (mdev if mdev else 1.)
+    indx = np.where(s < cut)[0]
+    return indx
+
+
+def main(options):
+    """main entry."""
+    fig_width = 12.0
+    fig_height = 1.2*fig_width/3.0
+
+    T = pd.read_csv(options.files[0])
+
+    if options.mould > 0:
+        x = 1000*T.loc[T['mould'] == options.mould, 'fd_dx'].values
+        y = 1000*T.loc[T['mould'] == options.mould, 'fd_dy'].values
+
+    else:
+        x = 1000*T['fd_dx'].values
+        y = 1000*T['fd_dy'].values
+
+    fig, ax = plt.subplots(nrows=1, ncols=3, tight_layout=True, figsize=(fig_width, fig_height))
+    fig.suptitle("Relative Position FD01-FD02")
+    ax[0].set_title("FD01-FD02")
+    ax[0].set_aspect('equal', adjustable='box')
+    ax[0].set_xlim(-150, 150)
+    ax[0].set_ylim(-150, 150)
+    circle = plt.Circle((0,0), 75, color="red", alpha=0.25)
+    ax[0].add_patch(circle)
+    circle = plt.Circle((0,0), 25, color="green", alpha=0.25)
+    ax[0].add_patch(circle)
+
+    ax[0].set_xlabel("X (µm)")
+    ax[0].set_ylabel("Y (µm)")
+    ax[0].grid()
+
+    ax[0].scatter(x, y, marker='.')
+
+    model = LinearModel()
+    params = model.guess(y, x=x)
+    result = model.fit(y, params, x=x)
+
+
+    P1 = np.array([0, result.eval(x=0)])
+    P2 = np.array([1, result.eval(x=1)])
+    values = []
+    for v, w in zip(x, y):
+        P3 = np.array([v, w])
+        values.append(distance(P1, P2, P3))
+
+    indx = remove_outliers_indx(values)
+
+    xx = x[indx]
+    yy = y[indx]
+    params = model.guess(yy, xx)
+    result = model.fit(yy, params, x=xx)
+    result.plot_fit(ax=ax[0])
+    print("slope {:.5f}, intercept {:.5f}".format(result.best_values['slope'], result.best_values["intercept"]))
+    angle = 180*math.atan( result.best_values['slope'])/math.pi
+    print("angle {:.5f} deg.".format(angle))
+
+    ax[1].set_xlim(-150, 150)
+    ax[1].set_xlabel("X (µm)")
+    ax[1].grid()
+    ax[1].hist(x)
+
+    ax[2].set_xlim(-150, 150)
+    ax[2].set_xlabel("Y (µm)")
+    ax[2].grid()
+    ax[2].hist(y)
+
+    plt.show()
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument('files', nargs='*', help="Input files")
+    parser.add_argument('--mould', default=-1, type=int, help="mould index")
+
+    opts = parser.parse_args()
+    if len(opts.files) == 0:
+        print("I need at least one input file")
+        sys.exit()
+
+    main(opts)

petal_qc/test/checkAVStests.py

@@ -169,8 +169,8 @@ if __name__ == "__main__":
     client = dlg.get_client()
 
     try:
-        # main(session)
-        the_test = analyze_avs_metrology(client, "20USEBC1000124", "PPC.015")
+        main(client)
+        # the_test = analyze_avs_metrology(client, "20USEBC1000124", "PPC.015")
         #rc = ITkDButils.upload_test(client, the_test, check_runNumber=True)
         #if rc:
         #    print(rc)