petal-qc 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

petal_qc/__init__.py

@@ -1,5 +1,5 @@
 """petal_qc python module."""
-__version__ = "0.0.1"
+__version__ = "0.0.3"
 
 
 def coreMetrology():
@@ -7,6 +7,12 @@ def coreMetrology():
     from .metrology.coreMetrology import main
     main()
 
+def coreThermal():
+    """Launches the Core thermal analysis ahd PDB script."""
+    from .thermal.coreThermal import main
+    main()
+
+
 def bustapeReport():
     """Launches the Core metrology analysis ahd PDB script."""
     from .BTreport.bustapeReport import main

petal_qc/metrology/analyze_locking_points.py

@@ -303,7 +303,7 @@ def analyze_locking_point_data(orig_data, nbins=50, plane_fit=True, cut=3, docum
     max_par = -9999
     for i in range(3):
         pts = M[iloc_indx[i], 2] + 0.435
-        _, _, band = get_min_max(pts)
+        vmin, vmax, band = get_min_max(pts)
         avg_pts = np.mean(pts)
         if abs(avg_pts) > max_par:
             max_par = abs(avg_pts)
@@ -312,8 +312,6 @@ def analyze_locking_point_data(orig_data, nbins=50, plane_fit=True, cut=3, docum
         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))
 
-    parallelism = max_avg
-
     ax.legend(loc='upper left')
     y_lim = ax.get_ylim()
     ax.fill_between([-0.100, 0.100], y_lim[0], y_lim[1], facecolor="grey", alpha=0.1)
@@ -330,7 +328,7 @@ def analyze_locking_point_data(orig_data, nbins=50, plane_fit=True, cut=3, docum
 
     outDB["PARALLELISM"] = parallelism
     outDB["OFFSET"] = mean_dist
-    print("Paralelism test: {:.4f}.\n{}".format(parallelism, txt))
+    print("Parallelism test: {:.4f}.\n{}".format(parallelism, txt))
     if document:
         txt = """To study parallelism, we subtract -0.435 mm to the Z values. \
                  This is the nominal position of locator points. \

petal_qc/metrology/compare_Cores.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+"""Compare quantities."""
+
+import sys
+import argparse
+import glob
+import json
+from pathlib import Path
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def get_value(data, value_path):
+    """Get the value."""
+    a = data
+    for k in value_path.split('/'):
+        a = a[k]
+
+    return a
+
+
+def main(options):
+    labels = []
+    front = {}
+    back = {}
+    
+    for fnam in options.files:
+        ifile = Path(fnam).expanduser().resolve()
+        print(ifile.name)
+        if not ifile.exists():
+            print("File does not exist: ", fnam)
+            continue
+
+        data = None
+        with open(ifile, 'r', encoding="UTF-8") as fp:
+            data = json.load(fp)
+
+        if data is None:
+            print("Problems reading ", fnam)
+            continue
+
+        tmp = ifile.name.split('-')
+        label = tmp[0]
+        if not label in labels:
+            labels.append(label)
+            
+        is_front = False
+        if "front" in tmp[1].lower():
+            is_front = True
+            
+        val = get_value(data, options.value)
+        if is_front:
+            front[label] = val
+        else:
+            back[label] = val
+
+    labels.sort()
+    X = np.arange(0, len(labels))
+    fig, ax = plt.subplots(1, 1, tight_layout=True)
+    fig.suptitle(options.value)
+    ax.set_xticks(range(len(labels)), labels=labels)
+    ax.grid()
+    
+    vfront = [front[x] for x in labels]
+    vback = [back[x] for x in labels]
+    ax.plot(X, vfront, '*', label="Front")
+    ax.plot(X, vback, 'o', label="Back")
+    ax.legend()
+    
+    if options.out:
+        fig.savefig(options.out, dpi=300)
+    
+    plt.show()
+    
+
+if __name__ == "__main__":
+    # Argument parser
+    parser = argparse.ArgumentParser()
+    parser.add_argument('files', nargs='*', help="Input files")
+    parser.add_argument("--value", default=None, help="Value to plot")
+    parser.add_argument("--out", default=None, help="File to store the figure.")
+
+    options = parser.parse_args()
+    if len(options.files) == 0:
+        print("I need at least one input file")
+        sys.exit()
+
+    if len(options.files) == 1:
+        xxx = any(elem in options.files[0] for elem in r"*?")
+        if xxx:
+            options.files = glob.glob(options.files[0])
+
+    if options.value[0] == '/':
+        options.value = options.value[1:]
+    options.value = "results/METROLOGY/" + options.value
+    main(options)

petal_qc/metrology/do_Metrology.py

@@ -14,6 +14,14 @@ from argparse import Action
 from argparse import ArgumentParser
 from pathlib import Path
 import numpy as np
+
+try:
+    import petal_qc
+
+except ImportError:
+    cwd = Path(__file__).parent.parent.parent
+    sys.path.append(cwd.as_posix())
+
 from petal_qc.utils.utils import output_folder
 
 from petal_qc.metrology.PetalMetrology import petal_metrology

petal_qc/thermal/IRBFile.py

@@ -12,6 +12,7 @@ import os
 import pickle
 import struct
 import sys
+from argparse import ArgumentParser
 from collections.abc import Iterable
 from pathlib import Path
 
@@ -689,7 +690,7 @@ def open_file(fname):
         fname: Path of input file or list of files.
 
     """
-    irb = None
+    irbf = None
     if is_iterable(fname):
         # we assume it is a list of IRB files...
         try:
@@ -719,13 +720,12 @@ def open_file(fname):
     return irbf
 
 
-if __name__ == "__main__":
+def main():
     """Example of use of IRBFile.
 
-    Shows all the images in a file.
+       Shows all the images in a file.
 
     """
-    from argparse import ArgumentParser
     parser = ArgumentParser()
     parser.add_argument('files', nargs='*', help="Input files")
     parser.add_argument("--save", action="store_true",
@@ -743,7 +743,8 @@ if __name__ == "__main__":
     fig = None
     nimg = 0
     ratio = -1
-    for img in IRfile.images():
+    for ximg in IRfile.images():
+        img = ximg[0]
         tmin = np.min(img.image)
         print("Tmin {:1f} - {}x{}".format(tmin, img.width, img.height))
         if ratio < 0:
@@ -766,3 +767,6 @@ if __name__ == "__main__":
         plt.pause(0.00001)
 
     plt.show()
+
+if __name__ == "__main__":
+    main()

petal_qc/thermal/IRCore.py

@@ -41,6 +41,7 @@ class IRCore(object):
         self.files = []
         self.results = [] if results is None else results  # list of AnalysisResults. One per side
         self.golden = []                                    # list of Golden results. One per side.
+        self.inlet = -9999
 
     def set_files(self, files):
         """Set the input files."""

petal_qc/thermal/IRDataGetter.py

@@ -1,11 +1,29 @@
 """Encapsulates different data structure at DESY and IFIC.
 """
+import sys
+from pathlib import Path
+import numpy as np
+
+try:
+    import petal_qc
+
+except ImportError:
+    cwd = Path(__file__).parent.parent.parent
+    sys.path.append(cwd.as_posix())
 
 
-import numpy as np
 from petal_qc.thermal import IRPetal
 from petal_qc.thermal import Petal_IR_Analysis
 
+HAS_GRAPHANA = False
+try:
+    from petal_qc.utils.readGraphana import ReadGraphana
+    HAS_GRAPHANA = True
+    
+except ImportError:
+    HAS_GRAPHANA = False
+    
+
 
 class IRDataGetter(object):
     """BAse class defining the interface."""
@@ -13,6 +31,7 @@ class IRDataGetter(object):
     def __init__(self):
         """Initialization."""
         self.factor = 1
+        self.indx = -1
         return
 
     @staticmethod
@@ -101,6 +120,10 @@ class IRDataGetter(object):
         """Get the frame where we want to perform the analysis."""
         return None
 
+    def get_inlet_temperature(self):
+        """REturn the inlet temperature."""
+        return -9999
+
 
 class IRDataIFIC(IRDataGetter):
     """Gets data for IFIC analysis."""
@@ -108,6 +131,11 @@ class IRDataIFIC(IRDataGetter):
     def __init__(self) -> None:
         """Initialization."""
         super().__init__()
+        self.analysis_frame = None
+        if HAS_GRAPHANA:
+            self.DB = ReadGraphana("localhost")
+        else:
+            self.DB = None
 
     def find_reference_image(self, irbf, *args, **kargs):
         """Find first image in sequence with T < T_min.
@@ -126,17 +154,23 @@ class IRDataIFIC(IRDataGetter):
 
 
         """
-        if len(args) == 0:
-            T_min = -22.0
-        else:
-            T_min = args[0]
-
         irbf.set_concatenate(True)
-        min_T, i_min, ref_img = IRPetal.find_reference_image(irbf, T_min)
-        values = self.get_IR_data(ref_img)
-        self.factor = values.shape[0]/640
-
-        return min_T, i_min, [values, ]
+        frame = self.get_analysis_frame(irbf)
+        i_min = self.indx
+        min_T = np.min(frame[0].image)
+        return min_T, i_min, frame
+
+        #  if len(args) == 0:
+        #      T_min = -22.0
+        #  else:
+        #      T_min = args[0]
+#  
+        #  irbf.set_concatenate(True)
+        #  min_T, i_min, ref_img = IRPetal.find_reference_image(irbf, T_min)
+        #  values = self.get_IR_data(ref_img)
+        #  self.factor = values.shape[0]/640
+#  
+        #  return min_T, i_min, [values, ]
 
     def get_IR_data(self, image, **kargs):
         """Get the data from the image in the proper orientation.
@@ -235,8 +269,20 @@ class IRDataIFIC(IRDataGetter):
         for img in irbf.images():
             min_T.append(np.min(img[0].image))
 
-        indx = IRDataIFIC.find_minimum(min_T)
-        return [irbf.getImage(indx[-1])]
+        self.indx = IRDataIFIC.find_minimum(min_T)
+        self.analysis_frame = [irbf.getImage(self.indx[-1])]
+        return self.analysis_frame
+
+    def get_inlet_temperature(self):
+        """REturn the inlet temperature."""
+        if self.DB:
+            img = self.analysis_frame[0]
+            X, T = self.DB.get_temperature(img.timestamp, 1)
+            return np.min(T)
+        
+        else:
+            return -9999
+            
 
 
 class IRDataDESY(IRDataGetter):

petal_qc/thermal/IRPetal.py

@@ -13,6 +13,13 @@ from scipy import ndimage
 from scipy.optimize import minimize
 from skimage import measure
 
+try:
+    import petal_qc
+
+except ImportError:
+    cwd = Path(__file__).parent.parent.parent
+    sys.path.append(cwd.as_posix())
+
 from petal_qc.thermal import contours
 from petal_qc.thermal import CSVImage
 from petal_qc.thermal import DebugPlot
@@ -1212,7 +1219,7 @@ def get_image_from_irb(irbf, frame, thrs):
     """
     img = None
     i_min = frame
-    if irbf.n_images() == 0:
+    if irbf.nimages == 0:
         print("Input file does not contain images.")
 
     else:
@@ -1246,12 +1253,12 @@ def read_image(fnam, frame=-1, thrs=-20):
     ifile = Path(fnam).expanduser().resolve()
     if not ifile.exists():
         print("Input file does not exist.")
-        return None
+        return None, None
 
     suffix = ifile.suffix.lower()
-    img = None
+    img = None, None
     if suffix == ".csv":
-        img = CSVImage.CSVImage(ifile)
+        img = CSVImage.CSVImage(ifile), 0
 
     elif suffix == ".irb":
         irbf = IRBFile.IRBFile(ifile)
@@ -1274,12 +1281,12 @@ def main(fnam, options):
     params.debug = False
 
     print("Open file")
-    img = read_image(fnam, options.frame, options.thrs)
+    img, _ = read_image(fnam, options.frame, options.thrs)
     if img is None:
         sys.exit()
 
     # Show original Image
-    fig, ax = plt.subplots(1, 1, dpi=300)
+    fig, ax = plt.subplots(1, 1)
     values = get_IR_data(img, False)
     min_T = np.min(values)
     fig.suptitle("Original image - Temp. {:.1f}".format(min_T))
@@ -1290,7 +1297,7 @@ def main(fnam, options):
     # Show rotated image
     values = get_IR_data(img, True)
     min_T = np.min(values)
-    fig, ax = plt.subplots(1, 1, dpi=300)
+    fig, ax = plt.subplots(1, 1)
     fig.suptitle("Rotated image - Temp. {:.1f}".format(min_T))
     pcm = ax.imshow(values, origin='lower', cmap="jet")
     fig.colorbar(pcm, ax=ax)

petal_qc/thermal/IRPetalParam.py

@@ -13,7 +13,7 @@ class IRPetalParam(object):
 
         """
         self.institute = 'IFIC'   # Either IFIC or DESY to treat the different files
-        self.thrs = -20.0         # the threshold
+        self.thrs = -22.0         # the threshold
         self.tco2 = -35.0         # Inlet temperature
         self.gauss_size = 15      # Radius of gausian filtering
         self.grad_sigma = 2.5     # Sigma of grading calculation
@@ -26,6 +26,7 @@ class IRPetalParam(object):
         self.do_fit = True        # True to fit the segment points.
         self.rotate = True        # Rotate to have a vertical petal in mirror image
         self.debug = False        # To debug
+        self.report = False       # 
 
         if values is not None:
             self.set_values(values)
@@ -71,3 +72,4 @@ class IRPetalParam(object):
         parser.add_argument("--contour_smooth", type=float, default=P.contour_smooth,
                             help="Value to smooth contour")
         parser.add_argument("--debug", action="store_true", default=False, help="Show additional information.")
+        parser.add_argument("--report", action="store_true", default=False, help="True if figures kept for the report.")

petal_qc/thermal/PipeFit.py

@@ -511,6 +511,7 @@ class PipeFit(object):
         ax.legend()
         plt.draw()
         plt.pause(0.0001)
+        return fig, ax
 
 
 def main(data_file, opts):

petal_qc/thermal/analyze_IRCore.py

@@ -12,6 +12,7 @@ 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
+import petal_qc.utils.docx_utils as docx_utils
 
 from petal_qc.thermal import IRCore
 from petal_qc.thermal import Petal_IR_Analysis
@@ -33,6 +34,23 @@ def get_names(files):
         names.append(ifile.stem)
     return names
 
+def add_figures_to_doc(doc, figures, name=None):
+    """Add figures to doc.
+
+    Args:
+        doc (Document): Document
+        figures (list): List of figures.
+
+    """
+    if doc is None or len(figures)==0:
+        return
+
+    if name:
+        doc.add_heading(name, level=1)
+
+    for F in figures:
+        doc.add_picture(F, True, 12, caption=F._suptitle.get_text())
+
 
 class GoldenAxis(object):
     """Get best X path."""
@@ -166,11 +184,102 @@ def golden_from_json(js_golden):
     """Converst a JSon golden into a Golden object."""
     golden = [Petal_IR_Analysis.AnalysisResult() for i in range(2)]
     for i, G in enumerate(golden):
-        G.path_length = js_golden[i]["path_length"]
-        G.path_temp = js_golden[i]["path_temp"]
-        G.path_spread = js_golden[i]["path_spread"]
-        G.sensor_avg = js_golden[i]["sensor_avg"]
-        G.sensor_std = js_golden[i]["sensor_std"]   
+        G.path_length = np.array(js_golden[i]["path_length"])
+        G.path_temp = np.array(js_golden[i]["path_temp"])
+        G.path_spread = np.array(js_golden[i]["path_spread"])
+        G.sensor_avg = np.array(js_golden[i]["sensor_avg"])
+        G.sensor_std = np.array(js_golden[i]["sensor_std"])
+
+    return golden
+
+def get_golden_axis(R, golden):
+    """Compute result on golden points."""
+    xvalues = [ [x for x in golden[i].path_length] for i in range(2) ]
+    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 = np.array(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)
+
+
+def plot_profile_and_golden(golden, core, value):
+    """Plot petal core and golden average.
+
+    Args:
+    ----
+        resuls: results from create_golden_average
+        golden: golden values (from create_golgen_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"]
+    figures = []
+    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)})
+        figures.append(fig)
+        fig.suptitle("Petal core .vs. Golden 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)
+
+        RS = core.results[iside]
+        # convert to golden X
+        # TODO: get X, Y from petal core. Move golden to this X axis and draw differences.
+        # This only happens for the "_path" values, not for the sensors.
+        if value.find("path") >= 0:
+            X = RS.path_length
+            Y = getattr(RS, value)
+            spln = CubicSpline(golden[iside].path_length, getattr(golden[iside], value))
+            gY = np.array([spln(x) for x in X])
+        else:
+            X = np.array([float(x) for x in range(10)])
+            Y = getattr(RS, value)
+            gY = getattr(golden[iside], value)
+
+        delta = Y - gY
+        ax[0].plot(X, Y, '-', label=core.aliasID, linewidth=1)
+        ax[1].plot(X, delta, '-', label=core.aliasID, linewidth=1)
+
+        # Draw golden line
+        ax[0].plot(X, gY, '-', label="Golden", linewidth=4, alpha=0.4, color="black")
+
+        Tmean = np.mean(Y)
+        Tband = factor*abs(Tmean)/3
+
+        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(X, gY + band, gY - band,
+                               facecolor="yellow", alpha=0.25,
+                               label="Acceptance band")
+
+            ax[1].fill_between(X, 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)
+
+    return figures
 
 def show_golden_average(golden, results, value):
     """Create golden average.
@@ -202,10 +311,11 @@ def show_golden_average(golden, results, value):
             for i in range(2):
                 ax[i].set_xticks(range(10), labels=tick_labels)
 
+        G = golden[iside]
         for R in results:
             RS = R.results[iside]
             Y = getattr(RS, value)
-            gY = getattr(golden[iside], value)
+            gY = getattr(G, value)
             O = getattr(R.golden[iside], value) - gY
             if value.find("path") >= 0:
                 X = RS.path_length
@@ -284,12 +394,13 @@ def analyze_petal_cores(files, golden, options):
         files (list): List of input files
         golden: the golden object
         options: other options.
-    
+
     Return:
         array with JSon objects corresponding to the PDB test.
-        
+
     """
     output = []
+    cores = []
     names = get_names(files)
     for i, ifile in enumerate(files):
         ifile = find_file(options.folder, ifile)
@@ -306,6 +417,7 @@ def analyze_petal_cores(files, golden, options):
             print("+++ File {} does not have component serial number.")
             continue
 
+        cores.append(core)
         out = [{}, {}]
         for iside in range(2):
             for val in ("path_temp", "sensor_avg", "sensor_std"):
@@ -371,10 +483,10 @@ def analyze_petal_cores(files, golden, options):
             json.dump(dbOut, fp, indent=3, cls=IRCore.NumpyArrayEncoder)
 
         output.append(dbOut)
-        
-    return output
 
-def analyze_IRCore(options):
+    return output, cores
+
+def analyze_IRCore(options, show=True):
     """Main entry."""
     output = None
     if options.create_golden:
@@ -408,9 +520,35 @@ def analyze_IRCore(options):
         for i, Jside in enumerate(J):
             golden[i].from_json(Jside)
 
-        output = analyze_petal_cores(options.files, golden, options)
+        output, cores  = analyze_petal_cores(options.files, golden, options)
+
+        if show or options.report:
+            for C in cores:
+                get_golden_axis(C, golden)
+
+            if options.report:
+                document = docx_utils.Document()
+                document.add_page_numbers()
+                document.styles['Normal'].font.name = "Calibri"
+                document.add_heading("Comparing to Golden", 0)
+            else:
+                document = None
+
+            F = show_golden_average(golden, cores, "path_temp")
+            add_figures_to_doc(document, F, "Temperature along pipe")
+            F = show_golden_average(golden, cores, "path_spread")
+            add_figures_to_doc(document, F, "Spread along pipe")
+            F = show_golden_average(golden, cores, "sensor_avg")
+            add_figures_to_doc(document, F, "Sensor avg")
+            F = show_golden_average(golden, cores, "sensor_std")
+            add_figures_to_doc(document, F, "Sendor std")
+
+            if document:
+                document.save("Compare-to-Golden.docx")
+
+    if show:
+        plt.show()
 
-    plt.show()
     return output
 
 
@@ -425,6 +563,8 @@ if __name__ == "__main__":
     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("--report", action="store_true", default=False, help="Set to produce plots for report")
+
     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")