petal-qc 0.0.12__tar.gz → 0.0.15__tar.gz

{petal_qc-0.0.12 → petal_qc-0.0.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: petal_qc
-Version: 0.0.12
+Version: 0.0.15
 Summary: A collection of scripts for Petal CORE QC.
 Author-email: Carlos Lacasta <carlos.lacasta@cern.ch>
 Project-URL: Homepage, https://gitlab.cern.ch/atlas-itk/sw/db/itk-pdb-gtk-gui-utils

petal_qc-0.0.15/petal_qc/PetalReceptionTests.py

@@ -0,0 +1,330 @@
+#!/usr/bin/env python3
+"""Test dashboard."""
+import sys
+import copy
+from pathlib import Path
+
+try:
+    import itkdb_gtk
+
+except ImportError:
+    cwd = Path(__file__).parent.parent
+    sys.path.append(cwd.as_posix())
+    import itkdb_gtk
+
+from itkdb_gtk import dbGtkUtils, ITkDBlogin, ITkDButils
+from itkdb_gtk import UploadTest, UploadMultipleTests
+
+HELP_LINK="https://itkdb-gtk.docs.cern.ch"
+
+
+import gi
+gi.require_version("Gtk", "3.0")
+from gi.repository import Gtk, Gio
+
+
+def find_children(W):
+    """Find DictDialog among the children."""
+    try:
+        for c in W.get_children():
+            if "DictDialog" in c.get_name():
+                return c
+
+            else:
+                return find_children(c)
+
+    except Exception:
+        return None
+
+    return None
+
+
+class PetalReceptionTests(dbGtkUtils.ITkDBWindow):
+    """Petl Reception Test GUI."""
+
+    def __init__(self, session, help_link=None):
+        """Initialization."""
+        super().__init__(title="Petal Reception Tests",
+                         session=session,
+                         show_search="Find object with given SN.",
+                         help_link=help_link)
+
+        # Members
+        self.dbObject = None
+
+        # action button in header
+        button = Gtk.Button()
+        icon = Gio.ThemedIcon(name="document-send-symbolic")
+        image = Gtk.Image.new_from_gicon(icon, Gtk.IconSize.BUTTON)
+        button.add(image)
+        button.set_tooltip_text("Click to upload ALL tests.")
+        button.connect("clicked", self.upload_tests)
+        self.hb.pack_end(button)
+
+        grid = Gtk.Grid(column_spacing=5, row_spacing=1)
+        self.mainBox.pack_start(grid, False, False, 5)
+
+        lbl = Gtk.Label(label="Serial Number")
+        lbl.set_xalign(0)
+        grid.attach(lbl, 0, 0, 1, 1)
+
+
+        self.SN = itkdb_gtk.dbGtkUtils.TextEntry()
+        self.SN.connect("text-changed", self.on_SN_changed)
+
+        #self.SN = Gtk.Entry()
+        #self.SN.connect("focus-in-event", self.on_sn_enter)
+        #self.SN.connect("focus-out-event", self.on_sn_leave)
+        grid.attach(self.SN.entry, 1, 0, 1, 1)
+
+        self.alias = Gtk.Label(label="")
+        grid.attach(self.alias, 2, 0, 1, 1)
+
+        self.stage = Gtk.Label(label="")
+        grid.attach(self.stage, 3, 0, 1, 1)
+
+        lbl = Gtk.Label(label="Institute")
+        lbl.set_xalign(0)
+        grid.attach(lbl, 0, 1, 1, 1)
+
+        self.institute = self.pdb_user["institutions"][0]["code"]
+        inst = self.create_institute_combo(only_user=True)
+        inst.connect("changed", self.new_institute)
+        inst.set_tooltip_text("Select the Institute.")
+        grid.attach(inst, 1, 1, 1, 1)
+        self.inst_cmb = inst
+
+        # The "Add/Remove/Send Item" buttons.
+        box = Gtk.ButtonBox(orientation=Gtk.Orientation.HORIZONTAL)
+        box.set_layout(Gtk.ButtonBoxStyle.END)
+        self.mainBox.pack_start(box, False, False, 0)
+        dbGtkUtils.add_button_to_container(box, "Upload test", "Upload this test", self.upload_single_test)
+        dbGtkUtils.add_button_to_container(box, "Add Defect", "Click to add a defect", self.add_defect)
+        dbGtkUtils.add_button_to_container(box, "Add Comment", "Click to add a comment", self.add_comment)
+
+        # The notebook
+        self.notebook = Gtk.Notebook()
+        self.notebook.set_tab_pos(Gtk.PositionType.LEFT)
+        self.notebook.set_size_request(-1, 250)
+        self.mainBox.pack_start(self.notebook, True, True, 0)
+
+        # Create the Notebook pages
+        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("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("X-rays", "XRAYIMAGING")
+
+
+        # The text view
+        self.mainBox.pack_end(self.message_panel.frame, True, True, 5)
+
+        # Set the default institute
+        dbGtkUtils.set_combo_iter(inst, self.institute)
+
+
+        self.show_all()
+
+    def on_SN_changed(self, entry, value):
+        """New SN given. Ask in PDB,"""
+        if len(value) <= 0:
+            return None
+
+        self.query_db()
+        current_location = self.dbObject["currentLocation"]["code"]
+        dbGtkUtils.set_combo_iter(self.inst_cmb, current_location, 0)
+
+        stg = self.dbObject["currentStage"]["name"]
+        self.stage.set_text(stg)
+
+        entry.set_text(self.dbObject["serialNumber"])
+
+        alias = self.dbObject["alternativeIdentifier"]
+        self.alias.set_text(alias)
+
+        npages = self.notebook.get_n_pages()
+        for i in range(npages):
+            page = self.notebook.get_nth_page(i)
+            page.dict_dialog.factory_reset()
+
+
+    def create_test_box(self, label, test_name, institute=None):
+        """Create and add to notebook a test dialog.
+
+        Args:
+            label: The label for the Notebook
+            test_name: The DB name of the test
+            institute: The institute.
+
+        """
+        if institute is None:
+            institute = self.institute
+
+        defaults = {
+            "institution": institute,
+            "runNumber": "1",
+        }
+        dto = ITkDButils.get_test_skeleton(self.session, "CORE_PETAL", test_name, defaults)
+        if test_name == "VISUAL_INSPECTION":
+            scrolled, gM = dbGtkUtils.create_scrolled_dictdialog(dto, ("component", "testType", "results"))
+        else:
+            scrolled, gM = dbGtkUtils.create_scrolled_dictdialog(dto)
+
+        box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
+        box.set_border_width(5)
+        box.pack_end(scrolled, True, True, 0)
+        box.dict_dialog = gM
+        gM.box = box
+
+        self.notebook.append_page(box, Gtk.Label(label=label))
+
+        return gM
+
+    def query_db(self, *args):
+        """Search button clicked."""
+        SN = self.SN.get_text()
+        if len(SN) == 0:
+            dbGtkUtils.complain("Empty Serial number",
+                                "You should enter a valid Serial number for the petal core.",
+                                parent=self)
+
+        try:
+            self.dbObject = ITkDButils.get_DB_component(self.session, SN)
+
+        except Exception as E:
+            self.write_message(str(E)+'\n')
+            dbGtkUtils.complain("Could not find object in DB", str(E))
+            self.dbObject = None
+            return
+
+        #print(json.dumps(self.dbObject, indent=3))
+
+    def add_defect(self, btn):
+        """Add a new defect."""
+        page = self.notebook.get_nth_page(self.notebook.get_current_page())
+        values = dbGtkUtils.get_a_list_of_values("Insert new defect", ("Type", "Description/v"))
+        if len(values)>0:
+            defect = {"name": values[0], "description": values[1]}
+            page.dict_dialog.values["defects"].append(defect)
+            page.dict_dialog.refresh()
+
+    def add_comment(self, btn):
+        """Add a new comment."""
+        page = self.notebook.get_nth_page(self.notebook.get_current_page())
+        comment = dbGtkUtils.get_a_value("Insert new comment", is_tv=True)
+        if comment:
+            page.dict_dialog.values["comments"].append(comment)
+            page.dict_dialog.refresh()
+
+    def new_institute(self, combo):
+        """A new institute has been selected."""
+        inst = self.get_institute_from_combo(combo)
+        if inst:
+            self.institute = inst
+
+            npages = self.notebook.get_n_pages()
+            for i in range(npages):
+                page = self.notebook.get_nth_page(i)
+                page.dict_dialog.values["institution"] = self.institute
+                page.dict_dialog.refresh()
+
+    def upload_this_test(self, values):
+        """Upload a single test."""
+        # print(json.dumps(values, indent=2))
+
+        attachments = []
+        if values["testType"] == "XRAYIMAGING":
+            fnam = values["results"]["IMAGELINK"]
+            if fnam is not None and len(fnam)>0:
+                P = Path(fnam).expanduser().resolve()
+                if P.exists():
+                    A = ITkDButils.Attachment(path=P.as_posix(), title=P.name, desc="X-ray image")
+                    values["results"]["IMAGELINK"] = P.name
+                    attachments.append(A)
+
+        # 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)
+
+
+    def upload_single_test(self, *args):
+        """Upload the current test."""
+        SN = self.SN.get_text()
+        if len(SN) == 0:
+            dbGtkUtils.complain("Petal SN is empty")
+            return
+
+        page = self.notebook.get_nth_page(self.notebook.get_current_page())
+        dctD = find_children(page)
+        if dctD is None:
+            return
+
+        values = copy.deepcopy(dctD.values)
+        values["component"] = SN
+        self.upload_this_test(values)
+
+    def upload_tests(self, *args):
+        """Upload the current test."""
+        SN = self.SN.get_text()
+        if len(SN) == 0:
+            dbGtkUtils.complain("Petal SN is empty")
+            return
+
+        W = UploadMultipleTests.UploadMultipleTests(
+            self.session,
+            help_link="{}/uploadMultipleTests.html".format(HELP_LINK)
+        )
+
+        for ipage in range(self.notebook.get_n_pages()):
+            page = self.notebook.get_nth_page(ipage)
+            dctD = find_children(page)
+            if dctD is None:
+                continue
+
+            values = dctD.values
+            if values["testType"] == "XRAYIMAGING":
+                if values["institution"] != "IFIC":
+                    continue
+                
+                fnam = values["results"]["IMAGELINK"]
+                if fnam is None or len(fnam)==0:
+                    continue
+
+            values["component"] = SN
+            W.add_test_data_to_view(values)
+
+def main():
+    """Main entry."""
+    # DB login
+    HELP_LINK="https://petal-qc.docs.cern.ch/petalReceptionTests.html"
+
+    dlg = ITkDBlogin.ITkDBlogin()
+    client = dlg.get_client()
+    if client is None:
+        print("Could not connect to DB with provided credentials.")
+        dlg.die()
+        sys.exit()
+
+    client.user_gui = dlg
+
+    gTest = PetalReceptionTests(client, help_link=HELP_LINK)
+
+    gTest.present()
+    gTest.connect("destroy", Gtk.main_quit)
+    try:
+        Gtk.main()
+
+    except KeyboardInterrupt:
+        print("Arrrgggg!!!")
+
+    dlg.die()
+
+
+if __name__ == "__main__":
+    main()

{petal_qc-0.0.12 → petal_qc-0.0.15}/petal_qc/__init__.py

@@ -1,5 +1,5 @@
 """petal_qc python module."""
-__version__ = "0.0.12"
+__version__ = "0.0.15"
 
 
 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
@@ -38,6 +43,10 @@ def analyzeIRCore():
     from .thermal.analyze_IRCore import main
     main()
 
+def petalReceptionTests():
+    """GND/VI tests."""
+    from .PetalReceptionTests import main
+    main()
 
 def dashBoard():
     """Launches the Core thermal analysis ahd PDB script."""

{petal_qc-0.0.12 → petal_qc-0.0.15}/petal_qc/dashBoard.py

@@ -3,7 +3,7 @@ import sys
 
 try:
     import petal_qc
-    
+
 except ImportError:
     from pathlib import Path
     cwd = Path(__file__).parent
@@ -12,6 +12,7 @@ except ImportError:
 from petal_qc.metrology.coreMetrology import CoreMetrology, CoreMetrologyOptions
 from petal_qc.thermal.coreThermal import CoreThermal
 from petal_qc.thermal.IRPetalParam import IRPetalParam
+from petal_qc.PetalReceptionTests import PetalReceptionTests
 
 from itkdb_gtk import dbGtkUtils
 from itkdb_gtk import ITkDBlogin
@@ -27,7 +28,8 @@ class DashWindow(dbGtkUtils.ITkDBWindow):
     """Dashboard class."""
     PETAL_CORE_METRO = 1
     PETAL_CORE_THERMAL = 2
-    
+    PETAL_RECEPTION_TEST = 3
+
 
     def __init__(self, session):
         """Initialization."""
@@ -40,7 +42,7 @@ class DashWindow(dbGtkUtils.ITkDBWindow):
         # Prepare dashboard
         grid = Gtk.Grid(column_spacing=5, row_spacing=5)
         self.mainBox.pack_start(grid, False, True, 5)
-        
+
         irow = 0
         lbl = Gtk.Label()
         lbl.set_markup("<b>Tests</b>")
@@ -51,19 +53,34 @@ class DashWindow(dbGtkUtils.ITkDBWindow):
         btnPetalMetrology = Gtk.Button(label="Petal Core Metrology")
         btnPetalMetrology.connect("clicked", self.petal_metrology)
         grid.attach(btnPetalMetrology, 0, irow, 1, 1)
-        
+
         btnPetalThermal = Gtk.Button(label="Petal Core Thermal")
         btnPetalThermal.connect("clicked", self.petal_thermal)
         grid.attach(btnPetalThermal, 1, irow, 1, 1)
-            
+
 
         irow += 1
-        grid.attach(Gtk.Label(), 0, irow, 1, 1)
-        
+        btnReception = Gtk.Button(label="Reception Tests")
+        btnReception.connect("clicked", self.petal_reception_test)
+        grid.attach(btnReception, 0, irow, 1, 1)
+
         self.mainBox.pack_start(Gtk.Separator(orientation=Gtk.Orientation.HORIZONTAL), False, True, 5)
 
         self.show_all()
-        
+
+    def petal_reception_test(self, *args):
+        """Do petal reception test."""
+        bitn = DashWindow.PETAL_RECEPTION_TEST
+        bt = 1 << bitn
+        if self.mask & bt:
+            return
+
+        self.mask |= bt
+        W = PetalReceptionTests(
+            self.session,
+            help_link="{}/petalReceptionTests.html".format(HELP_LINK)
+        )
+        W.connect("destroy", self.app_closed, bitn)
 
     def petal_metrology(self, *args):
         """Do petal metrology"""
@@ -103,7 +120,7 @@ class DashWindow(dbGtkUtils.ITkDBWindow):
         bt = 1 << args[1]
         self.mask &= ~bt
         # print(bt, self.mask)
-        
+
 def main():
     """Main entry"""
     # DB login

{petal_qc-0.0.12 → petal_qc-0.0.15}/petal_qc/metrology/PetalMetrology.py

@@ -243,34 +243,34 @@ def petal_metrology(ifile, options):
         if key == "LOCATION_DELTA":
             for k, v in val.items():
                 delta = np.linalg.norm(v)
-                if not check_spec(delta, 0.050):
+                if not check_spec(delta, 0.075):
                     dbOut["defects"].append({
                         "name": key,
-                        "description": "Delta {} is {:.3f} mm > 0.050 mm.".format(k, delta)
+                        "description": "Delta {} is {:.3f} mm > 0.075 mm.".format(k, delta)
                     })
 
         elif key == "REL_POS_DELTA":
             for k, v in val.items():
                 delta = np.linalg.norm(v)
-                if not check_spec(delta, 0.050):
+                if not check_spec(delta, 0.075):
                     dbOut["defects"].append({
                         "name": key,
-                        "description": "Delta {} is {:.3f} mm > 0.050 mm.".format(k, delta)
+                        "description": "Delta {} is {:.3f} mm > 0.075 mm.".format(k, delta)
                     })
 
-        elif "CHECK_" in key:
-            if "OVERSIZE" in key:
-                if not check_spec(abs(val), 0.050):
-                    dbOut["defects"].append({
-                        "name": key,
-                        "description": "LOC DIAM delta is {:.3f} mm > 0.050 mm.".format(abs(val))
-                    })
-            else:
-                if val < 0 or val > 0.012:
-                    dbOut["defects"].append({
-                        "name": key,
-                        "description": "LOC DIAM  is not H7  0 <= {:.3f} <= 0.012 mm.".format(val)
-                    })
+        # elif "CHECK_" in key:
+        #     if "OVERSIZE" in key:
+        #         if not check_spec(abs(val), 0.050):
+        #             dbOut["defects"].append({
+        #                 "name": key,
+        #                 "description": "LOC DIAM delta is {:.3f} mm > 0.050 mm.".format(abs(val))
+        #             })
+        #     else:
+        #         if val < 0 or val > 0.012:
+        #             dbOut["defects"].append({
+        #                 "name": key,
+        #                 "description": "LOC DIAM  is not H7  0 <= {:.3f} <= 0.012 mm.".format(val)
+        #             })
 
         ofile.close()
 

{petal_qc-0.0.12 → petal_qc-0.0.15}/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-0.0.12 → petal_qc-0.0.15}/petal_qc/metrology/compare_Cores.py

@@ -5,6 +5,7 @@ import sys
 import argparse
 import glob
 import json
+import math
 from pathlib import Path
 import numpy as np
 import matplotlib.pyplot as plt
@@ -100,17 +101,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 +124,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 +204,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")
 

{petal_qc-0.0.12 → petal_qc-0.0.15}/petal_qc/metrology/do_Metrology.py

@@ -68,6 +68,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 +85,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
 
-def main():
-    "Main entry."
+    if len(failed_files)>0:
+        for fnam, E in failed_files:
+            print("### Failed file {}\n{}".format(fnam, E))
+
+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 +130,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()