petal-qc 0.0.0__py3-none-any.whl

petal_qc/thermal/analyze_IRCore.py

@@ -0,0 +1,417 @@
+#!/usr/bin/env python3
+"""Analyze the JS files generated by create_IRCore."""
+import json
+import os
+import sys
+from pathlib import Path
+
+import matplotlib.dates as pldates
+import matplotlib.pyplot as plt
+import matplotlib.ticker as ticker
+import numpy as np
+from scipy.interpolate import CubicSpline
+from petal_qc.utils.utils import find_file
+from petal_qc.utils.utils import output_folder
+
+from petal_qc.thermal import IRCore
+from petal_qc.thermal import Petal_IR_Analysis
+
+CO2_Temp_setting = -35
+
+
+def get_acceptance_band():
+    """returns the width of the acceptance band."""
+    band = 0.1*CO2_Temp_setting  # 10% of setting point
+    return abs(band)
+
+
+def get_names(files):
+    """GEt names from filenames."""
+    names = []
+    for ifile in files:
+        ifile = Path(ifile)
+        names.append(ifile.stem)
+    return names
+
+
+class GoldenAxis(object):
+    """Get best X path."""
+    def __init__(self) -> None:
+        self.xaxis = []   # Set of coordinates
+        self.nitems = []  # number of curves with this axis
+        self.index = []
+        self.size = []
+        self.current = 0
+
+    @staticmethod
+    def round_npts(V):
+        """Return the closest multiple of 10."""
+        npts = len(V)
+        return int(int(npts/10.0 + 0.5)*10)
+
+    def check_axis(self, X, indx):
+        """Check in X array is there or not.
+
+        Args:
+            X (np.ndarray): The axis to check.
+            i (int): the index in the array of results.
+
+        """
+        npts = self.round_npts(X)
+        for i, v in enumerate(self.xaxis):
+            nv = self.size[i]
+            if npts == nv:
+                self.nitems[i] += 1
+                self.index[i].append(indx)
+                return
+
+        self.xaxis.append(X)
+        self.size.append(npts)
+        self.nitems.append(1)
+        self.index.append([indx])
+
+    def get_axis(self):
+        """Get the actual axis."""
+        imax = -1
+        indx = -1
+        for i, n in enumerate(self.nitems):
+            if n > imax:
+                imax = n
+                indx = i
+
+        return np.linspace(0., 1.0, num=self.size[indx])
+
+
+def compute_average(values):
+    """Compute the mean of arrays in input."""
+    data = np.zeros([len(values), len(values[0])])
+    for i, V in enumerate(values):
+        data[i, :] = V
+
+    avg = np.mean(data, axis=0)
+    return avg
+
+
+def create_golden_average(files, options):
+    """Create golden average.
+
+    Args:
+    ----
+        files (list): List of input files
+        options: other options.
+
+    """
+    names = get_names(files)
+    result_list = []
+    # Create the axes
+    axes = [GoldenAxis() for i in range(2)]
+
+    # Get the Xaxis.
+    # Will be the linspace between 0 and 1 with the most repeated
+    # number of points.
+    for i, ifile in enumerate(files):
+        ifile = find_file(options.folder, ifile)
+        if not ifile.exists():
+            print("+++ File {} does not exist.".format(ifile))
+            continue
+
+        alias = names[i]
+        result = IRCore.IRCore.read_json(ifile)
+        if result.aliasID is None or result.aliasID == "":
+            result.aliasID = names[i]
+
+        result_list.append(result)
+
+        # Loop to get best axis
+        R = result.results
+        for iside in range(2):
+            the_axis = R[iside].path_length
+            axes[iside].check_axis(the_axis, i)
+
+    # Prepare the results for the golden average.
+    xvalues = [axes[i].get_axis() for i in range(2)]
+    for i, R in enumerate(result_list):
+        R.golden = []
+        for iside in range(2):
+            G = Petal_IR_Analysis.AnalysisResult()
+            splnT = CubicSpline(R.results[iside].path_length, R.results[iside].path_temp)
+            splnS = CubicSpline(R.results[iside].path_length, R.results[iside].path_spread)
+            G.path_length = xvalues[iside]
+            G.path_temp = np.array([splnT(x) for x in G.path_length])
+            G.path_spread = np.array([splnS(x) for x in G.path_length])
+            G.sensor_avg = np.array(R.results[iside].sensor_avg)
+            G.sensor_std = np.array(R.results[iside].sensor_std)
+            R.golden.append(G)
+
+        if options.debug:
+            fig, ax = plt.subplots(2, 1, tight_layout=True)
+            fig.suptitle(R.aliasID)
+            for i in range(2):
+                ax[i].plot(R.results[i].path_length, R.results[i].path_temp, label="original")
+                ax[i].plot(R.golden[i].path_length, R.golden[i].path_temp, label="golden")
+                ax[i].legend()
+
+    # Create the golden object
+    golden = [Petal_IR_Analysis.AnalysisResult() for i in range(2)]
+    for i, G in enumerate(golden):
+        G.path_length = xvalues[i]
+        G.path_temp = compute_average([R.golden[i].path_temp for R in result_list])
+        G.path_spread = compute_average([R.golden[i].path_spread for R in result_list])
+        G.sensor_avg = compute_average([R.golden[i].sensor_avg for R in result_list])
+        G.sensor_std = compute_average([R.golden[i].sensor_std for R in result_list])
+
+    return golden, result_list
+
+
+def show_golden_average(golden, results, value):
+    """Create golden average.
+
+    Args:
+    ----
+        golden: golden values (from create_golgen_average)
+        resuls: results from create_golden_average
+        value: value to show, ej path_temp, path_spread, sensor_avg, sensor_std
+
+    """
+    tick_labels = ["R0", "R1", "R2", "R3", "R3", "R4", "R4", "R5", "R5", "EoS"]
+
+    factor = 1.0
+    if value.find("sensor") >= 0:
+        factor = 2.0
+
+    # Get acceptance band
+    band = get_acceptance_band()
+
+    for iside in range(2):
+        fig, ax = plt.subplots(2, 1, tight_layout=True, gridspec_kw={'height_ratios': (0.66, 0.34)}, figsize=(7, 6))
+        fig.suptitle("Golden average for {} - side {}.".format(value, iside))
+        for a in ax:
+            a.grid()
+
+        if value.find("path") < 0:
+            for i in range(2):
+                ax[i].set_xticks(range(10), labels=tick_labels)
+
+        for R in results:
+            RS = R.results[iside]
+            Y = getattr(RS, value)
+            gY = getattr(golden[iside], value)
+            O = getattr(R.golden[iside], value) - gY
+            if value.find("path") >= 0:
+                X = RS.path_length
+                gX = golden[iside].path_length
+
+            else:
+                X = np.array([float(x) for x in range(10)])
+                gX = X
+
+            ax[0].plot(X, Y, '-', label=R.aliasID, linewidth=1)
+            ax[1].plot(gX, O, '-', label=R.aliasID, linewidth=1)
+
+        Tmean = np.mean(Y)
+        Tband = factor*abs(Tmean)/3
+        ax[0].plot(gX, gY, '-', label="Golden", linewidth=4, alpha=0.4, color="black")
+
+        ax[0].legend(ncol=3, fontsize="x-small")
+        ax[0].set_title("T$_{prof}$ values")
+        if value.find("temp") >= 0 or value.find("_avg") >= 0:
+            ax[0].set_ylim(Tmean-Tband, Tmean+Tband)
+            ax[0].fill_between(gX,
+                               getattr(golden[iside], value) + band,
+                               getattr(golden[iside], value) - band,
+                               facecolor="yellow", alpha=0.25,
+                               label="Acceptance band")
+
+            ax[1].fill_between(gX, band, -band,
+                               facecolor="yellow", alpha=0.25,
+                               label="Acceptance band")
+
+        ax[1].legend(ncol=4, fontsize="x-small")
+        ax[1].set_title("T$_{prof}$ - Golden avg.")
+        if value.find("temp") >= 0 or value.find("_avg") >= 0:
+            ax[1].set_ylim(-Tband, Tband)
+
+
+def compare_golden(core, golden, value):
+    """Comapres petal core with golden average.
+
+    Args:
+    ----
+        core (AnalusysResolt): The petal core
+        golden (AnalysisResult): The golden avrage
+        value (str): The name of the variable to compare
+
+    """
+    Y = getattr(core, value)
+    gY = getattr(golden, value)
+    if value.find("path") >= 0:
+        X = core.path_length
+        gX = golden.path_length
+
+    else:
+        X = np.array([float(x) for x in range(10)])
+        gX = X
+
+    # convert to golden X
+    spln = CubicSpline(X, Y)
+    gC = np.array([spln(x) for x in gX])
+
+    # compute difference
+    band = get_acceptance_band()
+    diff = np.abs(gC-gY)
+    outsiders = np.where(diff > band)
+    mxval = np.amax(diff)
+
+    rc = mxval < band
+    return rc, mxval, len(outsiders)
+
+
+def analyze_petal_cores(files, golden, options):
+    """Create golden average.
+
+    Args:
+    ----
+        files (list): List of input files
+        golden: the golden object
+        options: other options.
+
+    """
+    names = get_names(files)
+    for i, ifile in enumerate(files):
+        ifile = find_file(options.folder, ifile)
+        if not ifile.exists():
+            print("+++ File {} does not exist.".format(ifile))
+            continue
+
+        alias = names[i]
+        core = IRCore.IRCore.read_json(ifile)
+        if core.aliasID is None or core.aliasID == "":
+            core.aliasID = names[i]
+
+        if core.coreID is None or core.coreID == "":
+            print("+++ File {} does not have component serial number.")
+            continue
+
+        out = [{}, {}]
+        for iside in range(2):
+            for val in ("path_temp", "sensor_avg", "sensor_std"):
+                out[iside][val] = compare_golden(core.results[iside], golden[iside], val)
+
+        dbOut = {
+            "component": core.coreID,
+            "testType": "THERMAL_EVALUATION",
+            "institution": core.institute,
+            "runNumber": "1",
+            "date": core.date,
+            "passed": True,
+            "problems": True,
+            "comments": [],
+            "defects": [],
+            "results": {}
+        }
+
+        if options.add_attachments:
+            golden_file = Path(options.golden).expanduser().resolve()
+            dbOut["attachments"] = [
+                {
+                    "path": ifile.as_posix(),
+                    "title": "Raw data (IRCore)",
+                    "description": "Raw Data of the test"
+                },
+                {
+                    "path": golden_file.as_posix(),
+                    "title": "Golden",
+                    "description": "The golden object used for this test."
+                }
+            ]
+
+        for iside, side in enumerate(out):
+            for key, val in side.items():
+                if val[0]:
+                    continue
+
+                if val[2] < 2:
+                    dbOut["comments"].append(
+                        "{} in side {}: 1 point out of acceptance band.".format(
+                            key, iside)
+                    )
+                else:
+                    dbOut["defects"].append(
+                        {"name": key,
+                            "description": "{} in side {}: {} points out of acceptance band".format(key, iside, val[2]),
+                            "properties": "{} > {}".format(val[1], get_acceptance_band())
+                         }
+                    )
+        dbOut["passed"] = (len(dbOut["defects"]) == 0)
+        dbOut["problems"] = (len(dbOut["comments"]) > 0)
+
+        if options.out is None:
+            ofile = "{}-Thermal.json".format(core.coreID)
+        else:
+            ofile = options.out
+
+        # Check if we are given an output folder
+        ofile = output_folder(options.folder, ofile)
+        with open(ofile, 'w') as fp:
+            print("writing {}".format(ofile))
+            json.dump(dbOut, fp, indent=3, cls=IRCore.NumpyArrayEncoder)
+
+
+def analyze_IRCore(options):
+    """Main entry."""
+    if options.create_golden:
+        golden, results = create_golden_average(options.files, options)
+        if options.out is None:
+            options.out = "out-golden.json"
+
+        ofile = output_folder(options.folder, options.out)
+        with open(ofile, 'w') as fp:
+            json.dump(golden, fp, indent=3, cls=IRCore.NumpyArrayEncoder)
+
+        show_golden_average(golden, results, "path_temp")
+        show_golden_average(golden, results, "path_spread")
+        show_golden_average(golden, results, "sensor_avg")
+        show_golden_average(golden, results, "sensor_std")
+
+    else:
+        if options.golden is None:
+            print("I need a golden file to compare with")
+            sys.exit(1)
+
+        golden_file = find_file(options.folder, options.golden)
+        if not golden_file.exists():
+            print("Golden file does not exist.")
+            sys.exit(1)
+
+        with open(golden_file, 'r') as fp:
+            J = json.load(fp)
+
+        golden = [Petal_IR_Analysis.AnalysisResult() for i in range(2)]
+        for i, Jside in enumerate(J):
+            golden[i].from_json(Jside)
+
+        analyze_petal_cores(options.files, golden, options)
+
+    plt.show()
+
+
+if __name__ == "__main__":
+    from argparse import ArgumentParser
+    # Argument parser
+    parser = ArgumentParser()
+    parser.add_argument('files', nargs='*', help="Input files")
+    parser.add_argument("--create-golden", action="store_true", default=False, help="Draw golden average")
+    parser.add_argument("--add_attachments", action="store_true", default=False,
+                        help="If true add the attachments section os DB file.")
+    parser.add_argument("--golden", default=None, help="The golden to compare width")
+    parser.add_argument("--prefix", default="golden", help="Prefix for figures")
+    parser.add_argument("--debug", action="store_true", default=False, help="Set to debug")
+    parser.add_argument("--out", default=None, help="File to store Golden.")
+    parser.add_argument("--folder", default=None, help="Folder to store output files. Superseeds folder in --out")
+
+    options = parser.parse_args()
+    if len(options.files) == 0:
+        print("I need an input file")
+        sys.exit()
+
+    analyze_IRCore(options)