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

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

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

@@ -1,5 +1,5 @@
 """petal_qc python module."""
-__version__ = "0.0.2"
+__version__ = "0.0.4"
 
 
 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-0.0.2 → 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.2 → petal_qc-0.0.4}/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-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.2 → petal_qc-0.0.4}/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-0.0.2 → 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.2/petal_qc/thermal → petal_qc-0.0.4/petal_qc/test}/test_Graphana.py

@@ -3,6 +3,7 @@
 import sys
 from pathlib import Path
 import datetime
+import numpy as np
 try:
     import petal_qc
 
@@ -16,15 +17,21 @@ from petal_qc.thermal.IRPetalParam import IRPetalParam
 from petal_qc.thermal import IRBFile
 
 
+
 options = IRPetalParam()
-options.files = ["/Users/lacasta/tmp/thermal/PPC.007.irb"]
+options.files = [Path("~/tmp/thermal/PPC.008.irb").expanduser().resolve()]
 getter = IRDataGetter.factory(options.institute, options)
 DB = ReadGraphana("localhost")
 irbf = IRBFile.open_file(options.files)
 
 frames = getter.get_analysis_frame(irbf)
 print(frames[0].timestamp)
-the_time = datetime.fromtimestamp(timestamp, timezone.utc)
-val = DB.get_temperature(frames[0].timestamp, 10)
-
-print(val)
+the_time = frames[0].timestamp
+try:
+    X, val = DB.get_temperature(the_time, 5)
+    for x, y in zip(X, val):
+        print("{} - {:.1f}".format(x, y))
+        
+    print("{:.1f}".format(np.min(val)))
+except ValueError as e:
+    print(e)

{petal_qc-0.0.2 → petal_qc-0.0.4}/petal_qc/thermal/IRBFile.py

@@ -690,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:

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

@@ -31,6 +31,7 @@ class IRDataGetter(object):
     def __init__(self):
         """Initialization."""
         self.factor = 1
+        self.indx = -1
         return
 
     @staticmethod
@@ -132,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
 
@@ -153,18 +155,25 @@ 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
-
+        frame = self.get_analysis_frame(irbf)
+        i_min = self.indx[-1]
+        min_T = np.min(frame[0].image)
+        values = self.get_IR_data(frame[0])
         return min_T, i_min, [values, ]
 
+        #  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.
 
@@ -262,16 +271,16 @@ class IRDataIFIC(IRDataGetter):
         for img in irbf.images():
             min_T.append(np.min(img[0].image))
 
-        indx = IRDataIFIC.find_minimum(min_T)
-        self.analysis_frame = [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]
-            val = self.DB.get_temperature(img.timestamp, 10)
-            return val
+            X, T = self.DB.get_temperature(img.timestamp, 1)
+            return np.min(T)
         
         else:
             return -9999

{petal_qc-0.0.2 → 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.2 → petal_qc-0.0.4}/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."""
@@ -293,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
@@ -381,6 +400,7 @@ def analyze_petal_cores(files, golden, options):
 
     """
     output = []
+    cores = []
     names = get_names(files)
     for i, ifile in enumerate(files):
         ifile = find_file(options.folder, ifile)
@@ -397,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"):
@@ -463,7 +484,7 @@ def analyze_petal_cores(files, golden, options):
 
         output.append(dbOut)
 
-    return output
+    return output, cores
 
 def analyze_IRCore(options, show=True):
     """Main entry."""
@@ -499,7 +520,31 @@ def analyze_IRCore(options, show=True):
         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()

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

@@ -4,6 +4,8 @@ import sys
 from pathlib import Path
 from argparse import ArgumentParser
 import json
+import numpy as np
+
 import itkdb_gtk
 import itkdb_gtk.ITkDButils
 import itkdb_gtk.dbGtkUtils
@@ -19,9 +21,11 @@ except ImportError:
 
 
 from petal_qc.thermal.IRPetalParam import IRPetalParam
-from petal_qc.thermal.create_IRCore import create_IR_core
-from petal_qc.thermal.analyze_IRCore import analyze_IRCore, golden_from_json, get_golden_axis, plot_profile_and_golden
-from petal_qc.utils.utils import output_folder
+from petal_qc.thermal import IRBFile
+from petal_qc.thermal.IRDataGetter import IRDataGetter
+
+from petal_qc.thermal.analyze_IRCore import golden_from_json
+from petal_qc.utils.readGraphana import ReadGraphana
 
 import gi
 gi.require_version("Gtk", "3.0")
@@ -162,6 +166,19 @@ class CoreThermal(itkdb_gtk.dbGtkUtils.ITkDBWindow):
 
         self.irbfile = PSF
         self.param.files =[PSF,]
+        
+        #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)
+        try:
+            X, val = DB.get_temperature(frames[0].timestamp, 3)
+            inlet = np.min(val)
+            self.entryTemp.set_text("{:.1f}".format(inlet))
+            
+        except ValueError:
+            pass
 
     def on_golden_set(self, *args):
         """File chosen from FileChooser."""

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

@@ -7,6 +7,7 @@ from datetime import datetime
 from pathlib import Path
 
 import dateutil
+import numpy as np
 import matplotlib.pyplot as plt
 
 try:
@@ -23,6 +24,7 @@ from petal_qc.thermal import Petal_IR_Analysis
 from petal_qc.thermal import PipeFit
 from petal_qc.thermal.IRDataGetter import IRDataGetter
 from petal_qc.thermal.IRPetalParam import IRPetalParam
+from petal_qc.utils.readGraphana import ReadGraphana
 from petal_qc.utils.utils import output_folder
 
 
@@ -70,6 +72,30 @@ def clean_figures():
 
     __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()
+    frames = getter.get_analysis_frame(irbf)
+    the_time = frames[0].timestamp
+    try:
+        X, val = DB.get_temperature(the_time, 5)
+        for x, y in zip(X, val):
+            print("{} - {:.1f}".format(x, y))
+
+        imin = np.argmin(val)
+        out = val[imin]
+        print("{}: T_co2 = {:.1f}".format(X[imin], out))
+
+    except ValueError:
+        out = -9999
+
+    return out
+
 def create_IR_core(options):
     """Entry point."""
     global __figures__
@@ -83,13 +109,25 @@ def create_IR_core(options):
         print("*** Invalid institute name. ***")
         return None
 
-    # Set parameters from command line
-    params = IRPetal.IRPetalParam(options)
-    params.debug = False
-
     # Open the sequence file
     print("## ", options.files)
     irbf = IRBFile.open_file(options.files)
+    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
+    params = IRPetal.IRPetalParam(options)
+    params.debug = False
 
     # FInd first image below the threshold or the corresponding frame
     # We will use the pipe obtained from here as the reference
@@ -153,7 +191,7 @@ def create_IR_core(options):
 
     # get the framea from where extract the data
     # reorder if needed
-    frames = getter.get_analysis_frame(irbf)        
+    frames = getter.get_analysis_frame(irbf)
     if pipe_order[0]:
         tmp = frames[0]
         frames[0] = frames[1]

{petal_qc-0.0.2 → petal_qc-0.0.4}/petal_qc/thermal/create_core_report.py

@@ -82,11 +82,15 @@ def create_report(options):
     document.add_heading('Temperature along path', level=1)
     document.add_picture(figures[0], True, 12, caption="Petal core .vs. Golden (side 0).")
     document.add_picture(figures[0], True, 12, caption="Petal core .vs. Golden (side 1).")
+    for F in figures:
+        plt.close(F)
 
     figures = plot_profile_and_golden(golden, core, "sensor_avg")
     document.add_heading('Average Temperatur on sensors areas.', level=1)
     document.add_picture(figures[0], True, 12, caption="Sensors .vs. Golden (side 0).")
     document.add_picture(figures[0], True, 12, caption="Sensors .vs. Golden (side 1).")
+    for F in figures:
+        plt.close(F)
 
     ofile = utils.output_folder(options.folder, "{}-thermal.docx".format(options.SN))
     document.save(ofile)

{petal_qc-0.0.2 → petal_qc-0.0.4}/petal_qc/utils/readGraphana.py

@@ -31,31 +31,34 @@ class ReadGraphana(object):
         if not isinstance(the_time, datetime.datetime):
             the_time = parse(the_time)
 
-        td = datetime.timedelta(minutes=window/2)
-        t1 = the_time - td # datetime.datetime(year=2024, month=5, day=22, hour=15)
-        t2 = the_time + td #datetime.datetime(year=2024, month=5, day=23, hour=15)
+        wnd = int(window/2.0+0.5)
+        td = datetime.timedelta(minutes=wnd)
+        t1 = the_time - td 
+        t2 = the_time + td
 
         measure="Temp"
         setup="MARTA_APP|MARTA_tt06"
         query = "select location,value from {measure} where (location =~ /.*{location}*/ and time>'{t1}' and time < '{t2}') group by \"location\"".format(
             measure=measure,
             location=setup,
-            t1=t1.isoformat()+'Z',
-            t2=t2.isoformat()+'Z')
+            t1=t1.astimezone(datetime.UTC).isoformat(),
+            t2=t2.astimezone(datetime.UTC).isoformat()
+        )
 
         ss = self.client.query(query)
         nitems = 0
         for s in ss:
+            
             nitems += len(s)
 
         if nitems==0:
             raise ValueError(("No data found"))
 
         T = []
+        X = []
         for s in ss:
             for v in s:
                 T.append(v['value'])
+                X.append(v['time'])
 
-
-        val = np.mean(T)
-        return val
+        return X, T

{petal_qc-0.0.2 → 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.2
+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.2 → petal_qc-0.0.4}/petal_qc.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ petal_qc/metrology/__init__.py
 petal_qc/metrology/all2csv.py
 petal_qc/metrology/analyze_locking_points.py
 petal_qc/metrology/cold_noise.py
+petal_qc/metrology/compare_Cores.py
 petal_qc/metrology/comparisonTable.py
 petal_qc/metrology/convert_mitutoyo.py
 petal_qc/metrology/convert_smartscope.py
@@ -30,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
@@ -50,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.2 → petal_qc-0.0.4}/petal_qc.egg-info/entry_points.txt

@@ -1,3 +1,4 @@
 [gui_scripts]
 bustapeReport = petal_qc:bustapeReport
 coreMetrology = petal_qc:coreMetrology
+coreThermal = petal_qc:coreThermal

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "petal_qc"
-version = "0.0.2"
+version = "0.0.4"
 authors = [
   { name="Carlos Lacasta", email="carlos.lacasta@cern.ch" },
 ]
@@ -31,6 +31,7 @@ classifiers = [
 
 [project.gui-scripts]
 coreMetrology = "petal_qc:coreMetrology"
+coreThermal = "petal_qc:coreThermal"
 bustapeReport = "petal_qc:bustapeReport"
 
 [tool.setuptools]