petal-qc 0.0.3__tar.gz → 0.0.4__tar.gz

{petal_qc-0.0.3 → petal_qc-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: petal_qc
-Version: 0.0.3
+Version: 0.0.4
 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.3 → petal_qc-0.0.4}/petal_qc/__init__.py

@@ -1,5 +1,5 @@
 """petal_qc python module."""
-__version__ = "0.0.3"
+__version__ = "0.0.4"
 
 
 def coreMetrology():

{petal_qc-0.0.3 → petal_qc-0.0.4}/petal_qc/metrology/PetalMetrology.py

@@ -130,7 +130,7 @@ def petal_metrology(ifile, options):
     if options.desy:
         flatness_data = DataFile.read(ifile, "PetalPlane")
     else:
-        flatness_data = DataFile.read(ifile, r"Punto[-|Vision-]\w", "Punto")
+        flatness_data = DataFile.read(ifile, r"Punto(-|(Vision-))\d", "Punto")
         Fmean = np.mean(flatness_data[:, 2])
         flatness_data[:, 2] -= Fmean
 
@@ -170,10 +170,10 @@ def petal_metrology(ifile, options):
         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):
+        elif key == "PARALLELISM" and not check_spec(abs(val), 0.2):
             dbOut["defects"].append({
                 "name": key,
-                "description": "Paralelism of locators is {:.3f} mm > 0.100 mm".format(val)
+                "description": "Paralelism of locators is {:.3f} mm > 0.200 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))

petal_qc-0.0.4/petal_qc/metrology/compare_Cores.py

@@ -0,0 +1,232 @@
+#!/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 from the path given."""
+    a = data
+    for k in value_path.split('/'):
+        a = a[k]
+
+    return a
+
+def save_figure(fig, fnam, prefix=None, dpi=192):
+    """Saves the figure
+
+    Args:
+        fig (Figure): The figure to save
+        fnam (str): The name of the output file
+        dpi (int, optional): The Dots por Inch. Defaults to 300.
+    """
+    if fnam is not None:
+        if prefix:
+            P = Path(fnam).expanduser().resolve()
+            name = prefix + P.name
+            out = P.parent / name
+            fnam = out
+            
+        print("out: {}".format(fnam))
+        fig.savefig(fnam, dpi=dpi)
+        
+
+def read_data_files(options):
+    """Read the data files.
+    
+    It assumes the data file names are in the format:
+    
+    <AlternativeID>-<side>.json
+    
+    AlternativeID is PPC.nnn side is either front or back.
+    
+    Returns the values for front and back petal tests.
+    
+    The results are a dictionary with the file label as key and the requested
+    value, which can be a number of an array. 
+    
+    the file labels are also returned.
+    
+    """
+    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)
+
+        val = get_value(data, options.value)
+        if "front" in tmp[1].lower():
+            front[label] = val
+        else:
+            back[label] = val
+            
+    labels.sort()
+    
+    return front, back, labels
+
+def draw_deltas(data, keys, fnam=None, title="Front"):
+    """Plot the  position deltas."""
+    key_table = {"Bot.": "PL01", "Slot": "PL02", "Top": "PL03",
+                 "Bot-FD01": "PL01-FD01", "Bot-FD02": "PL01-FD02", "FD01-FD02": "FD01-FD02" }
+    nfiles = len(data)
+
+    P = [np.zeros([nfiles, 2]),
+         np.zeros([nfiles, 2]),
+         np.zeros([nfiles, 2])]
+
+    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)
+    for i in range(3):
+        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].add_patch(circle)
+        circle = plt.Circle((0,0), 25, color="green", alpha=0.25)
+        ax[i].add_patch(circle)
+
+        ax[i].set_xlabel("X (µm)")
+        ax[i].set_ylabel("Y (µm)")
+        ax[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])
+
+        ax[i].scatter(P[i][:,0], P[i][:,1])
+
+    save_figure(fig, fnam, prefix=title)
+
+
+def show_positions(options):
+    """Make position plots."""
+    
+    if "LOCATION" in options.value:
+        keys = ["Bot.", "Slot", "Top"]
+    elif "REL_POS" in options.value:
+        keys = ["Bot-FD01", "Bot-FD02", "FD01-FD02"]
+    else:
+        print("Invalid value")
+        return
+
+    front, back, labels = read_data_files(options)
+    val_name = options.value.split('/')[-1]
+    draw_deltas(front, keys, fnam=options.out, title="{} - Front".format(val_name))
+    draw_deltas(back, keys, fnam=options.out, title="{} - Back".format(val_name))
+
+    plt.show()
+
+def show_flatness(options):
+    """Show flatness plots."""
+    tick_labels =  ["R0", "R1", "R2", "R3S0", "R3S1", "R4S0", "R4S1", "R5S0", "R5S1"]
+    cindx = ["Front", "Back"]
+
+    front, back, labels = read_data_files(options)
+    nfiles = len(labels)
+    npts = len(tick_labels)
+    X = np.array([float(x) for x in range(npts)])
+    
+    
+    fig, ax = plt.subplots(nrows=1, ncols=2, tight_layout=True, figsize=(9., 5.))
+    fig.suptitle(options.value)
+    
+    P = [ np.zeros([nfiles, npts]), np.zeros([nfiles, npts]) ]
+    y_lim = []
+    for i, V in enumerate([front, back]):
+        ax[i].set_title(cindx[i])
+        ax[i].set_xticks(range(npts), labels=tick_labels)
+        ax[i].grid()
+        
+        for lbl in labels:
+            ax[i].plot(X, V[lbl], '-', label=lbl)
+             
+        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.legend(ncol=3, fontsize="x-small")
+        
+    save_figure(fig, options.out, prefix="zzz-")
+
+def main(options):
+    """Main entry."""
+    
+    if "LOCATION" in options.value or "REL_POS" in options.value:
+        show_positions(options)
+        return
+
+    if "FLATNESS_LOCAL" in options.value:
+        show_flatness(options)
+        return
+
+
+    front, back, labels = read_data_files(options)
+
+    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()
+
+    save_figure(fig, options.out)
+    
+    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.")
+
+    opts = parser.parse_args()
+    if len(opts.files) == 0:
+        print("I need at least one input file")
+        sys.exit()
+
+    if len(opts.files) == 1:
+        xxx = any(elem in opts.files[0] for elem in r"*?")
+        if xxx:
+            opts.files = glob.glob(opts.files[0])
+
+    if opts.value[0] == '/':
+        opts.value = opts.value[1:]
+    opts.value = "results/METROLOGY/" + opts.value
+    main(opts)

{petal_qc-0.0.3 → petal_qc-0.0.4}/petal_qc/metrology/petal_flatness.py

@@ -162,7 +162,12 @@ def petal_flatness(orig_data, options, document=None):
     flatness_func = flatness_LSPL
     F = {}
     for key, val in sensors.items():
-        F[key] = flatness_func(val)
+        try:
+            F[key] = flatness_func(val)
+        except ValueError as E:
+            print("*** Error: Petal flatnes: key {}\n{}".format(key, E))
+            print(val)
+            return TM, avg, Zmean, [-9999, -9999]
 
     flatness_all_sensor_area = flatness_func(all_data)
 
@@ -182,7 +187,7 @@ def petal_flatness(orig_data, options, document=None):
             outF.extend(values)
             print("{}: {:.3f}  {}: {:.3f}".format(lbls[0], values[0], lbls[1], values[1]))
 
-    print("All sensor area: {:.3f}".format(flatness_all_sensor_area))
+    print("All sensor area: {:.3f}".format(1000*flatness_all_sensor_area))
 
     # Add table in document
     if document:

{petal_qc-0.0.3 → petal_qc-0.0.4}/petal_qc/thermal/IRDataGetter.py

@@ -133,7 +133,8 @@ class IRDataIFIC(IRDataGetter):
         super().__init__()
         self.analysis_frame = None
         if HAS_GRAPHANA:
-            self.DB = ReadGraphana("localhost")
+            #self.DB = ReadGraphana("localhost")
+            self.DB = ReadGraphana()
         else:
             self.DB = None
 
@@ -156,9 +157,10 @@ class IRDataIFIC(IRDataGetter):
         """
         irbf.set_concatenate(True)
         frame = self.get_analysis_frame(irbf)
-        i_min = self.indx
+        i_min = self.indx[-1]
         min_T = np.min(frame[0].image)
-        return min_T, i_min, frame
+        values = self.get_IR_data(frame[0])
+        return min_T, i_min, [values, ]
 
         #  if len(args) == 0:
         #      T_min = -22.0

{petal_qc-0.0.3 → petal_qc-0.0.4}/petal_qc/thermal/IRPetal.py

@@ -551,7 +551,7 @@ def get_T_profile(data, A, B, npts=10, do_fit=False, npdim=7, debug=False):
                         fmin.success = True
                         break
 
-            # If the re is aclear minimum within the segment
+            # If there is a clear minimum within the segment
             if fmin.success and fmin.x[0] > 0 and fmin.x[0] < mx_dist:
                 # This should no happen. if minimize returns we should have found
                 # at least a valid root.

{petal_qc-0.0.3 → petal_qc-0.0.4}/petal_qc/thermal/coreThermal.py

@@ -167,7 +167,8 @@ class CoreThermal(itkdb_gtk.dbGtkUtils.ITkDBWindow):
         self.irbfile = PSF
         self.param.files =[PSF,]
         
-        DB = ReadGraphana("localhost")
+        #DB = ReadGraphana("localhost")
+        DB = ReadGraphana()
         irbf = IRBFile.open_file(self.irbfile)
         getter = IRDataGetter.factory(self.param.institute, self.param)
         frames = getter.get_analysis_frame(irbf)

{petal_qc-0.0.3 → petal_qc-0.0.4}/petal_qc/thermal/create_IRCore.py

@@ -75,9 +75,11 @@ def clean_figures():
 def get_inlet_temp(irbf, param):
     """Gets the value of the inlet temperature from Graphana."""
 
+    print("# Getting the Inlet temperature. Contacting Graphana...")
     out = -9999
     getter = IRDataGetter.factory(param.institute, param)
-    DB = ReadGraphana("localhost")
+    #DB = ReadGraphana("localhost")
+    DB = ReadGraphana()
     frames = getter.get_analysis_frame(irbf)
     the_time = frames[0].timestamp
     try:
@@ -113,14 +115,14 @@ def create_IR_core(options):
     if irbf is None:
         print("Could not fine input file: {}".format(options.files))
         return
-    
+
     if options.tco2 <= -999:
         out = get_inlet_temp(irbf, options)
         if out <= -999:
             print("### Cannot get Tcos. Setting to default.")
             P = IRPetalParam()
             out = P.tco2
-            
+
         options.tco2 = out
 
     # Set parameters from command line

{petal_qc-0.0.3 → petal_qc-0.0.4}/petal_qc.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: petal_qc
-Version: 0.0.3
+Version: 0.0.4
 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.3 → petal_qc-0.0.4}/petal_qc.egg-info/SOURCES.txt

@@ -31,6 +31,8 @@ petal_qc/metrology/petal_flatness.py
 petal_qc/metrology/show_data_file.py
 petal_qc/metrology/testSummary.py
 petal_qc/metrology/test_paralelism.py
+petal_qc/test/test_Graphana.py
+petal_qc/test/test_coreThermal.py
 petal_qc/thermal/CSVImage.py
 petal_qc/thermal/DebugPlot.py
 petal_qc/thermal/IRBFile.py
@@ -51,8 +53,6 @@ petal_qc/thermal/pipe_back.npz
 petal_qc/thermal/pipe_front.npz
 petal_qc/thermal/pipe_read.py
 petal_qc/thermal/show_IR_petal.py
-petal_qc/thermal/test_Graphana.py
-petal_qc/thermal/test_coreThermal.py
 petal_qc/utils/Geometry.py
 petal_qc/utils/Progress.py
 petal_qc/utils/__init__.py

{petal_qc-0.0.3 → petal_qc-0.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "petal_qc"
-version = "0.0.3"
+version = "0.0.4"
 authors = [
   { name="Carlos Lacasta", email="carlos.lacasta@cern.ch" },
 ]

petal_qc-0.0.3/petal_qc/metrology/compare_Cores.py

@@ -1,96 +0,0 @@
-#!/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)