petal-qc 0.0.0__py3-none-any.whl

petal_qc/metrology/PetalMetrology.py

@@ -0,0 +1,327 @@
+#!/usr/bin/env python3
+"""Produce metrology report."""
+import io
+import json
+import sys
+import traceback
+from argparse import Action
+from argparse import ArgumentParser
+from datetime import datetime
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import petal_qc.utils.docx_utils as docx_utils
+from petal_qc.utils.Geometry import project_to_plane
+from petal_qc.utils.utils import output_folder
+from petal_qc.metrology import DataFile
+from petal_qc.metrology.analyze_locking_points import analyze_locking_point_data
+from petal_qc.metrology.analyze_locking_points import locking_point_positions
+from petal_qc.metrology.convert_mitutoyo import mitutoyo2cvs
+from petal_qc.metrology.petal_flatness import petal_flatness
+
+
+def check_spec(val, nom, fraction=0.0):
+    """Checks if value is consistent with specs.
+
+    Args:
+    ----
+        val (): Actual value
+        nom (): Nominal value
+        fraction (float, optional): Fraction of nominal allowable. Defaults to 0.05.
+
+    Returns
+    -------
+        bool: true if within specs.
+
+    """
+    if val <= nom:
+        return True
+    else:
+        rc = val <= (1+fraction)*nom
+        return rc
+
+
+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 petal_metrology(ifile, options):
+    """Do the analysis of the petal metrology data.
+
+    Args:
+    ----
+        ifile: Input file from Mitutoyo.
+        options: Command line options.
+
+    Return
+    ------
+        Dictionary with DB values
+
+    """
+    ifile = Path(ifile).expanduser().resolve()
+    if not ifile.exists():
+        print("input file {} does not exist.".format(ifile))
+        return
+
+    # We infer the date of the test from the creation date of data file.
+    test_date = datetime.fromtimestamp(ifile.stat().st_ctime).isoformat(timespec='milliseconds')
+    if test_date[-1] not in ['zZ']:
+        test_date += 'Z'
+
+    # The JSon output
+    sNames = {0: "petal", 1: "R0", 2: "R1", 3: "R2", 4: "R3S0", 5: "R3S1", 6: "R4S0", 7: "R4S1", 8: "R5S0", 9: "R5S1"}
+
+    dbOut = {
+        "component": options.SN,
+        "testType": "PETAL_METROLOGY_FRONT" if options.is_front else "PETAL_METROLOGY_BACK",
+        "institution": "DESYHH" if options.desy else "IFIC",
+        "runNumber": "1",
+        "date": test_date,
+        "passed": True,
+        "problems": False,
+        "properties": {
+            "OPERATOR": "Ohian Elesgaray",
+            "MACHINETYPE": "Mitutoyo"
+        },
+        "comments": [],
+        "defects": [],
+        "results": {
+            "METROLOGY": {},
+        }
+    }
+
+    results = {
+        "LOCATION_DELTA": {},
+        "REL_POS_DELTA": {},
+        "FD01_DIAM": 0,
+        "FD02_DIAM": 0,
+        "FLATNESS_GLOBAL": 0,
+        "FLATNESS_LOCAL": [],   # a 12 element array
+        "COPLANARITY_LOCATORS": 0,
+        "PARALLELISM": 0,
+        "CHECK_BOT_LOC_DIAM": True,
+        "CHECK_SLOT_LOC_DIAM": True,
+        "CHECK_OVERSIZE_LOC_DIAM": True
+    }
+
+    # Open the output doc.
+    # Open the output document if a title is given in the options.
+    document = docx_utils.Document()
+    document.add_page_numbers()
+    document.styles['Normal'].font.name = "Calibri"
+    if options.title:
+        document.add_heading(options.title, 0)
+
+    P = document.add_paragraph(ifile.name, "Subtitle")
+    P.alignment = docx_utils.paragraph_align_center()
+
+    # Do petal flatness analysis
+    Fmean = 0.0
+    if options.desy:
+        flatness_data = DataFile.read(ifile, "PetalPlane")
+    else:
+        flatness_data = DataFile.read(ifile, r"Punto[-|Vision-]\w", "Punto")
+        Fmean = np.mean(flatness_data[:, 2])
+        flatness_data[:, 2] -= Fmean
+
+    TM = None
+    if not options.locking_points:
+        TM, avg, Zmean, Flatness = petal_flatness(flatness_data, options, document=document)
+        results["FLATNESS_GLOBAL"] = Flatness[0]
+        if not check_spec(Flatness[0], 0.250):
+            dbOut["comments"].append("Global flatness in sensor area {:.3f}".format(Flatness[0]))
+
+        results["FLATNESS_LOCAL"] = Flatness[1:]
+        for i, v in enumerate(Flatness[1:]):
+            if not check_spec(v, 0.050):
+                dbOut["defects"].append({
+                    "name": "FLATNESS",
+                    "description": "Flatness of {} is {:.3f} mm > 0.050 mm".format(sNames[i+1], v)
+                })
+
+    # Do locator flatness analysis
+    TM = None  # TODO: fix this
+    if options.desy:
+        locator_data = DataFile.read(ifile, ".*_FineFlatness")
+    else:
+        locator_data = DataFile.read(ifile, "PuntoLocator", "Punto")
+        locator_data[:, 2] -= Fmean
+
+    if TM:
+        M = project_to_plane(locator_data, TM, [0., 0., avg[2]])
+        M[:, 2] -= Zmean
+        out = analyze_locking_point_data(M, document=document, nbins=options.nbins, plane_fit=False)
+    else:
+        data = np.concatenate((flatness_data, locator_data))
+        out = analyze_locking_point_data(data, document=document, nbins=options.nbins, plane_fit=True)
+
+    for key, val in out.items():
+        results[key] = val
+        if key == "COPLANARITY_LOCATORS" and not check_spec(val, 0.1):
+            dbOut["comments"].append(
+                "Coplanarity of locators: {:.3f} mm".format(val))
+        elif key == "PARALLELISM" and not check_spec(abs(val), 0.1):
+            dbOut["defects"].append({
+                "name": key,
+                "description": "Paralelism of locators is {:.3f} mm > 0.100 mm".format(val)
+            })
+        elif key == "OFFSET" and not check_spec(abs(val), 0.100):
+            dbOut["comments"].append("Offset of locator plane w.r.t BT is  {:.3f} mm".format(val))
+
+    # Analyze locking point positions
+    if not options.desy:
+        ofile = io.StringIO()
+        mitutoyo2cvs([ifile], ofile,
+                     label=r"agujero_inf|Locator\w*|Slot\w+|Fiducial\w+",
+                     data_type="Círculo|Punto",
+                     keep=True, fill=6)
+        ofile.seek(0)
+
+        tbl = pd.read_csv(ofile, names=["X", "Y", "Z", "D", "R", "C", "Name"], sep=',', skiprows=1, index_col="Name")
+        print(tbl)
+
+        keywords = [n for n in tbl.index]
+        # if "FiducialBot" in keywords:
+        #     indx = ["agujero_inf", "LocatorTop", "FiducialBot", "FiducialTop"]
+        #     offset = 0
+        # else:
+        #     indx = ["LocatorBot", "LocatorTop", "agujero_inf", "FiducialTop"]
+        #     offset = 3
+            
+        indx = ["LocatorBot", "LocatorTop", "agujero_inf", "FiducialTop"]
+        offset = 3
+        
+
+        slot_center = np.mean(tbl.loc[["SlotSup", "SlotInf"]][["X", "Y", "D"]].values, axis=0)
+
+        print("")
+        print()
+        print(tbl.loc[indx][["X", "Y", "D"]])
+        input = tbl.loc[indx][["X", "Y", "D"]].values
+
+        ninput = np.insert(input, 1, slot_center, axis=0)
+        ninput[:, 1] += offset
+        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.050):
+                        dbOut["defects"].append({
+                            "name": key,
+                            "description": "Delta {} is {:.3f} mm > 0.050 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.025):
+                        dbOut["defects"].append({
+                            "name": key,
+                            "description": "Delta {} is {:.3f} mm > 0.025 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.025 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()
+
+
+    # Add a section for defects.
+    document.add_heading("Comments and Defects.", level=1)
+    added_defects = False
+    if len(dbOut["comments"])>0:
+        added_defects = True
+        document.add_heading("Comments.", level=2)
+        for C in dbOut["comments"]:
+            document.add_paragraph(C)
+
+    if len(dbOut["defects"])>0:
+        added_defects = True
+        document.add_heading("Defects.", level=2)
+        for D in dbOut["defects"]:
+            document.add_paragraph("{}: {}".format(D["name"], D["description"]))
+
+    if not added_defects:
+        document.add_paragraph("Petal is GOOD. No comments nor defects found.")
+
+
+    # close the doc file
+    ofile = output_folder(options.folder, options.out)
+    document.save(ofile)
+
+    dbOut["results"]["METROLOGY"] = results
+
+    if len(dbOut["defects"])>0:
+        dbOut["passed"] = False
+
+    if len(dbOut["comments"])>0:
+        dbOut["problems"] = True
+
+    return dbOut
+
+
+if __name__ == "__main__":
+    parser = ArgumentParser()
+    parser.add_argument('files', nargs='*', help="Input files")
+    parser.add_argument("--SN", default="SNxxxx", help="Petal core serial nunber")
+    parser.add_argument("--front", dest='is_front', action="store_true", default=True)
+    parser.add_argument("--back", dest='is_front', action="store_false", default=True)
+    parser.add_argument("--prefix", dest='prefix', default="petal_metrology")
+    parser.add_argument("--desy", dest='desy', action="store_true", default=False)
+    parser.add_argument("--save", dest='save', action="store_true", default=False)
+    parser.add_argument("--out", dest="out", default="petal_flatness.docx",
+                        type=str, help="The output fiel name")
+    parser.add_argument("--bottom-lp", dest='bLP', action=CommaSeparatedListAction, default=None,
+                        help="Bottom locking point fiducial coordinates")
+    parser.add_argument("--upper-lp", dest='uLP', action=CommaSeparatedListAction, default=None,
+                        help="upper locking point fiducials coordinates")
+
+    parser.add_argument("--title", dest="title", default=None,
+                        type=str, help="Document title")
+    parser.add_argument("--nbins", dest="nbins", default=25,
+                        type=int, help="Number of bins")
+    parser.add_argument("--folder", default=None, help="Folder to store output files. Superseeds folder in --out")
+    parser.add_argument("--locking_points", action="store_true", default=False)
+    # This is to convert a CMM file
+    parser.add_argument("--label", default="\\w+", help="The label to select")
+    parser.add_argument("--type", default="Punto", help="The class to select")
+
+    options = parser.parse_args()
+    if len(options.files) == 0:
+        print(sys.argv[0])
+        print("I need an input file")
+        sys.exit()
+
+    try:
+        outDB = petal_metrology(options.files[0], options)
+        ofile = output_folder(options.folder, options.prefix + '.json')
+        with open(ofile, 'w') as of:
+            json.dump(outDB, of)
+
+    except Exception:
+        print(traceback.format_exc())
+
+    plt.show()

petal_qc/metrology/all2csv.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+"""Convert all files in input file to CSV (petal, locators)"""
+import sys
+from metrology.data2csv import data2cvs
+from metrology.convert_smartscope import read_smartscope
+from collections import namedtuple
+
+
+class OptDict(dict):
+    """https://stackoverflow.com/a/1639632/6494418"""
+
+    def __getattr__(self, name):
+        return self[name] if not isinstance(self[name], dict) \
+            else OptDict(self[name])
+
+
+def all2cvs(ifile):
+    """Convert files listed in input to CSV."""
+    with open(ifile, 'r') as inp:
+
+        for line in inp:
+            line = line.strip()
+            if len(line) == 0:
+                continue
+
+            if line[0] == '#':
+                continue
+
+            SN = ""
+            try:
+                fnam, prefix = line.split()
+            except Exception:
+                fnam, prefix, SN, *_ = line.split()
+
+            opts = OptDict({"prefix": prefix})
+            print(fnam, prefix)
+            if options.desy:
+                read_smartscope(fnam, prefix + "-petal.csv", "PetalPlane")
+                
+            else:
+                data2cvs([fnam, ], opts)
+
+
+if __name__ == "__main__":
+    from argparse import ArgumentParser
+    parser = ArgumentParser()
+    parser.add_argument('files', nargs='*', help="Input files")
+    parser.add_argument("--desy", dest='desy', action="store_true", default=False)
+
+
+    options = parser.parse_args()
+    if len(options.files) == 0:
+        print(sys.argv[0])
+        print("I need an input file")
+        sys.exit()
+
+    all2cvs(options.files[0])