petal-qc 0.0.17__py3-none-any.whl → 0.0.24__py3-none-any.whl

petal_qc/PetalReceptionTests.py

@@ -112,9 +112,9 @@ class PetalReceptionTests(dbGtkUtils.ITkDBWindow):
         self.create_test_box("Visual Inspection", "VISUAL_INSPECTION")
         self.create_test_box("Grounding", "GROUNDING_CHECK")
         self.create_test_box("Pipe bending", "BENDING120")
+        self.create_test_box("Delamination", "DELAMINATION")
         self.create_test_box("Weight", "PETAL_CORE_WEIGHT")
-        self.create_test_box("Bot. loc. Diam", "PETAL_CORE_LOC_DIAM")
-        self.create_test_box("Slot loc. Diam", "PETAL_CORE_SLOT_DIAM")
+        self.create_test_box("Metrology Template", "METROLOGY_TEMPLATE").set_callback("results.4H7_FIT", self.on_fit_changed)
         self.create_test_box("X-rays", "XRAYIMAGING")
 
 
@@ -127,6 +127,22 @@ class PetalReceptionTests(dbGtkUtils.ITkDBWindow):
 
         self.show_all()
 
+    def on_fit_changed(self, gM):
+        """Called when fit type changes."""
+        val = gM.get_value("results.4H7_FIT").lower()
+        if "loose" in val:
+            gM.set_value("passed", False)
+            gM.set_value("problems", False)
+
+
+        elif "slide" in val or "tight" in val:
+            gM.set_value("passed", True)
+            gM.set_value("problems", False)
+
+        elif "press" in val:
+            gM.set_value("passed", True)
+            gM.set_value("problems", True)
+
     def on_SN_changed(self, entry, value):
         """New SN given. Ask in PDB,"""
         if len(value) <= 0:
@@ -178,7 +194,9 @@ class PetalReceptionTests(dbGtkUtils.ITkDBWindow):
         box.dict_dialog = gM
         gM.box = box
 
-        self.notebook.append_page(box, Gtk.Label(label=label))
+        g_label = Gtk.Label(label=label)
+        g_label.set_halign(Gtk.Align.START)
+        self.notebook.append_page(box, g_label)
 
         return gM
 
@@ -247,7 +265,7 @@ class PetalReceptionTests(dbGtkUtils.ITkDBWindow):
         # rc = ITkDButils.upload_test(self.session, values, attachments=attachments, check_runNumber=True)
         # if rc is not None:
         #     dbGtkUtils.complain("Could not upload test", rc)
-        # 
+        #
         # else:
         #     self.write_message("Test uploaded. {} - {}\n".format(values["component"], values["testType"]))
         uploadW = UploadTest.UploadTest(self.session, values, attachments)
@@ -291,7 +309,7 @@ class PetalReceptionTests(dbGtkUtils.ITkDBWindow):
             if values["testType"] == "XRAYIMAGING":
                 if values["institution"] != "IFIC":
                     continue
-                
+
                 fnam = values["results"]["IMAGELINK"]
                 if fnam is None or len(fnam)==0:
                     continue

petal_qc/__init__.py

@@ -1,5 +1,5 @@
 """petal_qc python module."""
-__version__ = "0.0.17"
+__version__ = "0.0.24"
 
 
 def coreMetrology():
@@ -53,6 +53,11 @@ def petalCoreTestSummary():
     from .getPetalCoreTestSummary import main
     main()
 
+def readReceptionTests():
+    """Read tamplate table with results of REception tests."""
+    from .readTemplateTable import main
+    main()
+
 def dashBoard():
     """Launches the Core thermal analysis ahd PDB script."""
     from .dashBoard import main

petal_qc/getPetalCoreTestSummary.py

@@ -3,6 +3,7 @@
 import json
 import sys
 import re
+import copy
 from argparse import ArgumentParser
 
 
@@ -42,10 +43,36 @@ def petalCoreTest(session, options):
         suff = options.institute
 
     core_list = session.get("listComponents", json=payload)
-    core_tests = ["PETAL_METROLOGY_FRONT", "PETAL_METROLOGY_BACK", "XRAYIMAGING", "THERMAL_EVALUATION", "BTTESTING"]
+
+    # We want details about these tests
+    core_tests = [
+        "PETAL_METROLOGY_FRONT",
+        "PETAL_METROLOGY_BACK",
+        "XRAYIMAGING",
+        "THERMAL_EVALUATION",
+        "BTTESTING",
+        "METROLOGY_TEMPLATE",
+        "PETAL_CORE_WEIGHT"
+    ]
+
+    # this is the full list
+    at_qc_tests = [
+        "VISUAL_INSPECTION",
+        "BTTESTING",
+        "GROUNDING_CHECK",
+        "BENDING120",
+        "THERMAL_EVALUATION",
+        "XRAYIMAGING",
+        "METROLOGY_TEMPLATE",
+        "PETAL_METROLOGY_FRONT",
+        "PETAL_METROLOGY_BACK",
+        "PETAL_CORE_WEIGHT",
+        "CORE_THICKNESS",
+        "DELAMINATION",
+    ]
 
     do_check_stage = "AT_QC_SITE"
-    #do_check_stage = None
+    do_check_stage = None
     petal_id_db = {}
 
     has_list = len(options.cores) != 0
@@ -76,19 +103,35 @@ def petalCoreTest(session, options):
                     return False
 
         print("\n\nPetal {} [{}] - {}. {}".format(SN, altid, coreStage, location))
-
-        test_list = session.get("listTestRunsByComponent", json={"filterMap":{"serialNumber": SN, "state": "ready", "testType":core_tests}})
-
+        test_status = {}
+        test_list = session.get("listTestRunsByComponent", json={"filterMap":{"serialNumber": SN, "state": "ready", "stage": "AT_QC_SITE", "testType":at_qc_tests}})
+        missing_tests = copy.deepcopy(at_qc_tests)
         for tst in test_list:
             ttype = tst["testType"]["code"]
-            if ttype not in core_tests:
-                print(ttype)
-                continue
+            if ttype in missing_tests:
+                missing_tests.remove(ttype)
+
+            #if ttype not in core_tests:
+            #    print(ttype)
+            #    continue
 
             T = session.get("getTestRun", json={"testRun": tst["id"]})
             if T["state"] != "ready":
                 print(T)
 
+
+            if ttype in test_status:
+                try:
+                    if int(T["runNumber"]) > int(test_status[ttype]["runNumber"]):
+                        test_status[ttype] = T
+                
+                except ValueError:
+                    if T["date"] > test_status[ttype]["date"]:
+                        test_status[ttype] = T
+                        
+            else:
+                test_status[ttype] = T
+
             print("-- {} [{}]".format(T["testType"]["name"], T["runNumber"]))
             if not T["passed"]:
                 print("\t## test FAILED")
@@ -96,12 +139,30 @@ def petalCoreTest(session, options):
             for D in T["defects"]:
                 print("\t{} - {}".format(D["name"], D["description"]))
 
+        if len(test_status):
+            passed = True
+            for ttype, T in test_status.items():
+                if not T["passed"]:
+                    passed = False
+                    break
+
+            if passed:
+                print("\n--- PASSED")
+            else:
+                print("\n*** FAILED")
+
+        if options.show_missing:
+            print("missing tests:")
+            for tst in missing_tests:
+                print("-- {}".format(tst))
+
     with open("petal_ID_db_{}.json".format(suff), "w", encoding="utf-8") as fOut:
         json.dump(petal_id_db, fOut, indent=3)
 
 def main():
     """Main entry"""
     parser = ArgumentParser()
+    parser.add_argument("--show_missing", default=False, action="store_true", help="Show missing tests.")
     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) ")
@@ -121,4 +182,3 @@ def main():
 
 if __name__ == "__main__":
     main()
-    

petal_qc/metrology/PetalMetrology.py

@@ -78,8 +78,8 @@ def petal_metrology(ifile, options):
         "passed": True,
         "problems": False,
         "properties": {
-            "OPERATOR": "Ohian Elesgaray",
-            "MACHINETYPE": "Mitutoyo"
+            "OPERATOR": "Dario Ariza" if options.desy else "Ohian Elesgaray",
+            "MACHINETYPE": "SmartScope" if options.desy else "Mitutoyo",
         },
         "comments": [],
         "defects": [],
@@ -154,17 +154,27 @@ def petal_metrology(ifile, options):
         data = np.concatenate((flatness_data, locator_data))
         out = analyze_locking_point_data(data, document=document, nbins=options.nbins, plane_fit=True)
 
+    if "defects" in out:
+        for D in out["defects"]:
+            dbOut["defects"].append(D)
+            
+        del out["defects"] 
+
+    # SEt the percentage of deviation from nominal
+    fail_allowance = 0 # 0.05
+    parallelism_cut = 0.250
+
     for key, val in out.items():
         results[key] = val
-        if key == "COPLANARITY_LOCATORS" and not check_spec(val, 0.1):
+        if key == "COPLANARITY_LOCATORS" and not check_spec(val, 0.1, fail_allowance):
             dbOut["comments"].append(
                 "Coplanarity of locators: {:.3f} mm".format(val))
-        elif key == "PARALLELISM" and not check_spec(abs(val), 0.2):
+        elif key == "PARALLELISM" and not check_spec(abs(val), parallelism_cut, fail_allowance):
             dbOut["defects"].append({
                 "name": key,
-                "description": "Paralelism of locators is {:.3f} mm > 0.200 mm".format(val)
+                "description": "Paralelism of locators is {:.3f} mm > {:.3f} mm".format(val, parallelism_cut)
             })
-        elif key == "OFFSET" and not check_spec(abs(val), 0.100):
+        elif key == "OFFSET" and not check_spec(abs(val), 0.100, fail_allowance):
             dbOut["comments"].append("Offset of locator plane w.r.t BT is  {:.3f} mm".format(val))
 
     # Analyze locking point positions
@@ -223,26 +233,28 @@ def petal_metrology(ifile, options):
     results["DIAM"]["PL01"] = ninput[0, 2]
     results["DIAM"]["PL02"] = ninput[1, 2]
     results["DIAM"]["PL03"] = ninput[2, 2]
-    
+
+
+    max_delta = 0.1 #0.075
     out = locking_point_positions(ninput, document)
     for key, val in out.items():
         results[key] = val
         if key == "LOCATION_DELTA":
             for k, v in val.items():
                 delta = np.linalg.norm(v)
-                if not check_spec(delta, 0.075):
+                if not check_spec(delta, max_delta, fail_allowance):
                     dbOut["defects"].append({
                         "name": key,
-                        "description": "Delta {} is {:.3f} mm > 0.075 mm.".format(k, delta)
+                        "description": "Delta {} is {:.3f} mm > {:.3f} mm.".format(k, delta, max_delta)
                     })
 
         elif key == "REL_POS_DELTA":
             for k, v in val.items():
                 delta = np.linalg.norm(v)
-                if not check_spec(delta, 0.075):
+                if not check_spec(delta, max_delta, fail_allowance):
                     dbOut["defects"].append({
                         "name": key,
-                        "description": "Delta {} is {:.3f} mm > 0.075 mm.".format(k, delta)
+                        "description": "Delta {} is {:.3f} mm > {:.3f} mm.".format(k, delta, max_delta)
                     })
 
         # elif "CHECK_" in key:

petal_qc/metrology/analyze_locking_points.py

@@ -284,9 +284,10 @@ def analyze_locking_point_data(orig_data, nbins=50, plane_fit=True, cut=3, docum
 
     # Show the Z band
     Zband = Zp + 0.435
-    vmin, vmax, all_band = get_min_max(Zband)
+    indx = remove_outliers(Zband, 7.5)
+    vmin, vmax, all_band = get_min_max(Zband[indx])
     parallelism = all_band
-        
+
     print("Parallelism {:.3f} mm".format(parallelism))
 
     lxmin = min(vmin, -0.1)
@@ -308,7 +309,7 @@ def analyze_locking_point_data(orig_data, nbins=50, plane_fit=True, cut=3, docum
         if abs(avg_pts) > max_par:
             max_par = abs(avg_pts)
             max_avg = avg_pts
-            
+
         print("Loc par. {} - {:.3f} avg: {:.3f}".format(i, band, avg_pts))
         ax.hist(pts, bins=xaxis, label="Avg {:.3f} band {:.3f} mm".format(avg_pts, band))
 
@@ -435,6 +436,16 @@ def analyze_locking_point_data(orig_data, nbins=50, plane_fit=True, cut=3, docum
                         color_bar=True)
         zmean = np.mean(plane[C.xtra, 2])
         zstd = np.std(plane[C.xtra, 2])
+
+        if len(C.xtra) < 10 or zstd>0.05:
+            dl = outDB.setdefault("defects", [])
+            dl.append(
+                {
+                    "name": "LOCATOR_CLUSTERS",
+                    "description": "Cluster at {:.3f}, {:.3f} has few points [{}] or large spread {:.3f}".format(C.x, C.y, len(C.xtra), zstd)
+                }
+            )
+
         print("\t\t-> Z mean {:.3f} std {:.3f} [{}]".format(zmean, zstd, len(C.xtra)))
         if document:
             document.add_picture(fig, True, figure_width,

petal_qc/metrology/compare_Cores.py

@@ -158,7 +158,7 @@ def draw_deltas(data, keys, fnam=None, title="Front", draw_text=True):
         ax[i].set_aspect('equal', adjustable='box')
         ax[i].set_xlim(-150, 150)
         ax[i].set_ylim(-150, 150)
-        circle = plt.Circle((0,0), 75, color="red", alpha=0.25)
+        circle = plt.Circle((0,0), 100, 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)
@@ -243,7 +243,8 @@ def show_flatness(options):
         y_lim.append(ax[i].get_ylim())
 
     for a in ax:
-        a.set_ylim(0, 1.2*max(y_lim[0][1], y_lim[1][1]))
+        #a.set_ylim(0, 1.2*max(y_lim[0][1], y_lim[1][1]))
+        a.set_ylim(0, 0.150)
         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)
@@ -280,6 +281,18 @@ def main(options):
 
         save_figure(fig, options.out, prefix=options.prefix)
 
+        fig, ax = plt.subplots(1, 2, tight_layout=True)
+        fig.suptitle("Histogram: {}".format(options.value))
+        ax[0].hist(vfront, bins=15)
+        ax[0].set_title("Front")
+        ax[0].grid()
+        ax[1].hist(vback, bins=15)
+        ax[1].set_title("Back")
+        ax[1].grid()
+        name = Path(options.out)
+        name = name.parent / "{}-hst.png".format(name.stem)
+        save_figure(fig, name, prefix=options.prefix)
+
     if not options.no_show:
         plt.show()
 

petal_qc/metrology/convert_mitutoyo.py

@@ -111,6 +111,11 @@ def mitutoyo2cvs(infiles, ofile, label='\\w+', data_type="Punto", keep=False, fi
                 while len(line_data) < fill:
                     line_data.append(0.0)
 
+            else:
+                if len(line_data)<3:
+                    print("Warning: less than three data points: {}".format(','.join([str(v) for v in line_data])))
+                    continue
+
             slin = ','.join([str(v) for v in line_data])
             fout.write(slin)
             if keep:

petal_qc/metrology/coreMetrology.py

@@ -5,10 +5,7 @@ from argparse import Action
 from argparse import ArgumentParser
 from contextlib import redirect_stdout
 import numpy as np
-import itkdb_gtk
-import itkdb_gtk.ITkDButils
-import itkdb_gtk.dbGtkUtils
-import itkdb_gtk.UploadTest
+from itkdb_gtk import ITkDButils, ITkDBlogin, dbGtkUtils, UploadTest
 
 from petal_qc.metrology.do_Metrology import do_analysis
 
@@ -18,7 +15,7 @@ from gi.repository import Gtk, GObject, Gio, GLib
 
 __HELP__ = "https://petal-qc.docs.cern.ch/metrology.html"
 
-class CoreMetrology(itkdb_gtk.dbGtkUtils.ITkDBWindow):
+class CoreMetrology(dbGtkUtils.ITkDBWindow):
     """Application window."""
 
     def __init__(self, options, session=None, title="",  panel_size=100):
@@ -75,7 +72,7 @@ class CoreMetrology(itkdb_gtk.dbGtkUtils.ITkDBWindow):
             self.btnFolder.set_filename(ifile)
 
         # The Serial number
-        self.SN = itkdb_gtk.dbGtkUtils.TextEntry()
+        self.SN = dbGtkUtils.TextEntry()
         self.SN.connect("text-changed", self.on_SN_changed)
 
         # The prefix
@@ -159,7 +156,7 @@ class CoreMetrology(itkdb_gtk.dbGtkUtils.ITkDBWindow):
         """File chosen from FileChooser."""
         PSF = self.btnData.get_filename()
         if PSF is None or not Path(PSF).exists():
-            itkdb_gtk.dbGtkUtils.complain("Could not find Data File", PSF, parent=self)
+            dbGtkUtils.complain("Could not find Data File", PSF, parent=self)
             return
 
         self.data_file = PSF
@@ -168,7 +165,7 @@ class CoreMetrology(itkdb_gtk.dbGtkUtils.ITkDBWindow):
         """Folder chosen."""
         F = self.btnFolder.get_filename()
         if F is None or not Path(F).exists():
-            itkdb_gtk.dbGtkUtils.complain("Could not find Output folder", F, parent=self)
+            dbGtkUtils.complain("Could not find Output folder", F, parent=self)
             return
 
         self.folder = F
@@ -180,14 +177,14 @@ class CoreMetrology(itkdb_gtk.dbGtkUtils.ITkDBWindow):
             return None
 
 
-        obj = itkdb_gtk.ITkDButils.get_DB_component(self.session, value)
+        obj = ITkDButils.get_DB_component(self.session, value)
         if obj is not None:
             entry.set_text(obj["serialNumber"])
             self.alternativeID = obj["alternativeIdentifier"]
             self.change_to_back(None)
 
         else:
-            itkdb_gtk.dbGtkUtils.complain("Invalid SN", value)
+            dbGtkUtils.complain("Invalid SN", value)
 
     def change_to_back(self, *args):
         """The front/back switch has changed."""
@@ -207,7 +204,7 @@ class CoreMetrology(itkdb_gtk.dbGtkUtils.ITkDBWindow):
         if len(SN) <= 0:
             return None
 
-        obj = itkdb_gtk.ITkDButils.get_DB_component(self.session, SN)
+        obj = ITkDButils.get_DB_component(self.session, SN)
         if obj is None:
             return None
 
@@ -279,7 +276,7 @@ class CoreMetrology(itkdb_gtk.dbGtkUtils.ITkDBWindow):
     def run_analysis(self, *args):
         """Run metrology."""
         if self.data_file is None:
-            itkdb_gtk.dbGtkUtils.complain("No data file set", "Select one", parent=self)
+            dbGtkUtils.complain("No data file set", "Select one", parent=self)
             return
 
         if self.desy.get_active():
@@ -297,7 +294,7 @@ class CoreMetrology(itkdb_gtk.dbGtkUtils.ITkDBWindow):
 
         self.petal_SN = self.SN.get_text().strip()
         if len(self.petal_SN) == 0 or self.petal_SN is None:
-            itkdb_gtk.dbGtkUtils.complain("Invalid SN", "SN: {}".format(self.petal_SN), parent=self)
+            dbGtkUtils.complain("Invalid SN", "SN: {}".format(self.petal_SN), parent=self)
             return
 
 
@@ -305,13 +302,13 @@ class CoreMetrology(itkdb_gtk.dbGtkUtils.ITkDBWindow):
             self.outDB = do_analysis(self.data_file, self.petal_prefix, self.petal_SN, self.options)
 
         if len(self.outDB["defects"]) > 0:
-            itkdb_gtk.dbGtkUtils.set_button_color(self.btn_state, "red", "white")
+            dbGtkUtils.set_button_color(self.btn_state, "red", "white")
             self.btn_state.set_label("FAILED")
         elif len(self.outDB["comments"]) > 0:
-            itkdb_gtk.dbGtkUtils.set_button_color(self.btn_state, "orange", "white")
+            dbGtkUtils.set_button_color(self.btn_state, "orange", "white")
             self.btn_state.set_label("PROBLEMS")
         else:
-            itkdb_gtk.dbGtkUtils.set_button_color(self.btn_state, "green", "white")
+            dbGtkUtils.set_button_color(self.btn_state, "green", "white")
             self.btn_state.set_label("PASSED")
 
 
@@ -320,7 +317,7 @@ class CoreMetrology(itkdb_gtk.dbGtkUtils.ITkDBWindow):
         if self.outDB is None:
             return
 
-        values, rc = itkdb_gtk.dbGtkUtils.DictDialog.create_json_data_editor(self.outDB)
+        values, rc = dbGtkUtils.DictDialog.create_json_data_editor(self.outDB)
         if rc == Gtk.ResponseType.OK:
             self.outDB = values
 
@@ -332,7 +329,7 @@ class CoreMetrology(itkdb_gtk.dbGtkUtils.ITkDBWindow):
         """Uploads test and attachments."""
         if self.outDB is None:
             return
-        uploadW = itkdb_gtk.UploadTest.UploadTest(self.session, payload=self.outDB)
+        uploadW = UploadTest.UploadTest(self.session, payload=self.outDB)
 
 
 class CoreMetrologyOptions(object):
@@ -380,19 +377,12 @@ def main():
     dlg = None
     try:
         # We use here the Gtk GUI
-        from itkdb_gtk import ITkDBlogin
         dlg = ITkDBlogin.ITkDBlogin()
         client = dlg.get_client()
 
     except Exception:
         # Login with "standard" if the above fails.
-        import itkdb
-        import getpass
-        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()
 
     CM = CoreMetrology(options, session=client, title="Petal core metrology")
     CM.write_message("Welcome !\n")

petal_qc/metrology/do_Metrology.py

@@ -56,7 +56,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:
+    with open(ifile, 'r', encoding='ISO-8859-1') as inp:
 
         for line in inp:
             line = line.strip()

petal_qc/metrology/petal_flatness.py

@@ -24,10 +24,10 @@ from petal_qc.utils.Geometry import fit_plane
 from petal_qc.utils.Geometry import flatness_conhull, flatness_LSPL
 from petal_qc.utils.Geometry import project_to_plane
 
-from .analyze_locking_points import analyze_locking_point_data, locking_point_positions
-from .analyze_locking_points import remove_outliers
-from .Cluster import cluster_points
-from .show_data_file import show_data, TOP_VIEW
+from petal_qc.metrology.analyze_locking_points import analyze_locking_point_data, locking_point_positions
+from petal_qc.metrology.analyze_locking_points import remove_outliers
+from petal_qc.metrology.Cluster import cluster_points
+from petal_qc.metrology.show_data_file import show_data, TOP_VIEW
 
 figure_width = 14
 
@@ -132,7 +132,7 @@ def petal_flatness(orig_data, options, document=None):
 
     # group points by sensors.
     sensor_dict = {0: "R0", 10: "R1", 20: "R2", 30: "R3_0", 31: "R3_1", 40: "R4_0", 41: "R4_1", 50: "R5_0", 51: "R5_1"}
-    sensors, *_ = group_by_sensors(M, options.is_front, False)
+    sensors, *_ = group_by_sensors(M, options.is_front, True)
     all_data = np.vstack(list(sensors.values()))
 
     fig = show_data(all_data, "All points in core", view=TOP_VIEW, surf=False)
@@ -257,7 +257,7 @@ def get_iring(P, is_front):
     return -1
 
 
-def group_by_sensors(Min, is_front=True, remove_outliers=False):
+def group_by_sensors(Min, is_front=True, no_outliers=False):
     """Groups data points by sensors."""
     # Now move in Y to be on the ATLAS reference
     M = np.array(Min)
@@ -275,10 +275,11 @@ def group_by_sensors(Min, is_front=True, remove_outliers=False):
         else:
             sensors.setdefault(iring, []).append(P)
 
-    if remove_outliers:
+    if no_outliers:
         for key, val in sensors.items():
-            if remove_outliers:
-                sensors[key] = remove_outliers(sensors[key][:, 2], 0.075)
+            points = np.vstack(val)
+            indx = remove_outliers(points[:, 2])
+            sensors[key] = points[indx, :]
 
     return sensors, np.array(other)
 

petal_qc/metrology/readAVSdata.py

@@ -641,8 +641,15 @@ def readProductionSheet(session, file_path, SN):
         print(ee.message)
         return None
 
-    # Assume active sheet is the good one, otherwise will have tofind in wb.sheetnames
-    sheet = wb.active
+    # Sometimes it comes with an empty sheet in front
+    sheet = None
+    for name in wb.sheetnames:
+        value = wb[name]["C7"].value
+        if value is not None:
+            sheet = wb[name]
+            break
+        
+    #sheet = wb.active
     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))
 
@@ -759,6 +766,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/test_paralelism.py

@@ -8,8 +8,8 @@ from pathlib import Path
 import numpy as np
 import matplotlib.pyplot as plt
 
-import DataFile
-from analyze_locking_points import analyze_locking_point_data
+from petal_qc.metrology import DataFile
+from petal_qc.metrology.analyze_locking_points import analyze_locking_point_data
 
 
 def do_paralelism(ifile, options):