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

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

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

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

{petal_qc-0.0.1 → petal_qc-0.0.2}/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
 
@@ -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-0.0.1 → petal_qc-0.0.2}/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-0.0.1 → petal_qc-0.0.2}/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."""
@@ -101,6 +119,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 +130,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.
@@ -236,7 +263,19 @@ class IRDataIFIC(IRDataGetter):
             min_T.append(np.min(img[0].image))
 
         indx = IRDataIFIC.find_minimum(min_T)
-        return [irbf.getImage(indx[-1])]
+        self.analysis_frame = [irbf.getImage(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
+        
+        else:
+            return -9999
+            
 
 
 class IRDataDESY(IRDataGetter):

{petal_qc-0.0.1 → petal_qc-0.0.2}/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-0.0.1 → petal_qc-0.0.2}/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-0.0.1 → petal_qc-0.0.2}/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-0.0.1 → petal_qc-0.0.2}/petal_qc/thermal/analyze_IRCore.py

@@ -166,11 +166,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.
@@ -284,10 +375,10 @@ 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 = []
     names = get_names(files)
@@ -371,10 +462,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):
+def analyze_IRCore(options, show=True):
     """Main entry."""
     output = None
     if options.create_golden:
@@ -410,7 +501,9 @@ def analyze_IRCore(options):
 
         output = analyze_petal_cores(options.files, golden, options)
 
-    plt.show()
+    if show:
+        plt.show()
+
     return output
 
 
@@ -425,6 +518,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")
 

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

@@ -4,90 +4,30 @@ import sys
 from pathlib import Path
 from argparse import ArgumentParser
 import json
-import numpy as np
-from matplotlib.backends.backend_gtk3agg import FigureCanvasGTK3Agg as FigureCanvas
-from matplotlib.backends.backend_gtk3 import NavigationToolbar2GTK3 as NavigationToolbar
 import itkdb_gtk
 import itkdb_gtk.ITkDButils
 import itkdb_gtk.dbGtkUtils
 import itkdb_gtk.UploadTest
+
+
+try:
+    import petal_qc
+
+except ImportError:
+    cwd = Path(__file__).parent.parent.parent
+    sys.path.append(cwd.as_posix())
+
+
 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, show_golden_average
+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
 
 import gi
 gi.require_version("Gtk", "3.0")
 from gi.repository import Gtk, GObject, Gio, GLib
 
-
-def create_canvas(fig, sx=400, sy=300):
-    """Creates a canvas."""
-    sw = Gtk.ScrolledWindow()  # Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
-    sw.set_border_width(10)
-    sw.set_size_request(310, 310)
-    canvas = FigureCanvas(fig)  # a Gtk.DrawingArea
-    canvas.set_size_request(sx, sy)
-    sw.add(canvas)
-    return sw
-
-class ShowThermalResults(Gtk.Window):
-    """Show thermal results."""
-    def __init__(self, golden, results):
-        """Create the window."""
-        super().__init__(title="Thermal Results")
-
-        # Create main content box
-        self.mainBox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
-        self.add(self.mainBox)
-
-        # The notebook
-        self.notebook = Gtk.Notebook()
-        self.notebook.set_tab_pos(Gtk.PositionType.LEFT)
-        self.mainBox.pack_start(self.notebook, True, True, 20)
-
-        # thermal path
-        box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
-        box.set_border_width(5)
-        label = Gtk.Label(label="Path Temp,")
-        self.notebook.append_page(box, label)
-
-        figs = show_golden_average(golden, results, "path_temp")
-        sw = create_canvas(figs[0])
-        box.pack_start(sw, True, True, 0)
-
-        sw = create_canvas(figs[q])
-        box.pack_start(sw, True, True, 0)
-
-        box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
-        box.set_border_width(5)
-        label = Gtk.Label(label="Sensor Avg,")
-        self.notebook.append_page(box, label)
-
-        figs = show_golden_average(golden, results, "sensor_avg")
-        sw = create_canvas(figs[0])
-        box.pack_start(sw, True, True, 0)
-
-        sw = create_canvas(figs[q])
-        box.pack_start(sw, True, True, 0)
-
-
-
-        # The button box
-        btnBox = Gtk.ButtonBox(orientation=Gtk.Orientation.HORIZONTAL)
-
-        btn = Gtk.Button(label="Quit")
-        btn.connect("clicked", self.quit)
-        btnBox.add(btn)
-
-        self.mainBox.pack_start(btnBox, False, True, 0)
-
-        self.show_all()
-
-    def quit(self, *args):
-        """Close window."""
-        self.hide()
-        self.destroy()
+from petal_qc.thermal.create_core_report import create_report
 
 class CoreThermal(itkdb_gtk.dbGtkUtils.ITkDBWindow):
     """Application window."""
@@ -146,7 +86,7 @@ class CoreThermal(itkdb_gtk.dbGtkUtils.ITkDBWindow):
         self.SN.connect("text-changed", self.on_SN_changed)
 
         self.run = Gtk.Button(label="Run")
-        self.run.connect("clicked", self.run_analysis)
+        self.run.connect("clicked", self.create_report)
 
         self.btn_state = Gtk.Button(label="Undef")
         self.btn_state.set_name("btnState")
@@ -338,8 +278,8 @@ class CoreThermal(itkdb_gtk.dbGtkUtils.ITkDBWindow):
             return
         uploadW = itkdb_gtk.UploadTest.UploadTest(self.session, payload=self.outDB)
 
-    def run_analysis(self, *args):
-        """Run analysis."""
+    def create_report(self, *args):
+        """Creates the thermal report."""
         if self.irbfile is None:
             self.write_message("Missing IRB file\n")
             return
@@ -349,16 +289,13 @@ class CoreThermal(itkdb_gtk.dbGtkUtils.ITkDBWindow):
         self.param.alias = self.alternativeID
         self.param.SN = self.SN.get_text()
 
-        core = create_IR_core(self.param)
-
-        self.param.files[0] = output_folder(self.param.folder, self.param.out)
-        self.param.out = None
-        out = analyze_IRCore(self.param)
-        self.outDB = out[0] if len(out) else None
-        self.param.files = []
-        self.write_message("Done\n")
+        self.param.tco2 = float(self.entryTemp.get_text())
+        self.param.distance = int(self.entryDist.get_text())
+        self.param.thrs = float(self.entryTHrs.get_text())
+        self.param.debug = False
+        self.param.report = True
 
-        outW = ShowThermalResults(self.golden, [core, ])
+        self.outDB = create_report(self.param)
         if self.outDB:
             if len(self.outDB["defects"]) > 0:
                 itkdb_gtk.dbGtkUtils.set_button_color(self.btn_state, "red", "white")

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

@@ -9,6 +9,13 @@ from pathlib import Path
 import dateutil
 import matplotlib.pyplot as plt
 
+try:
+    import petal_qc
+
+except ImportError:
+    cwd = Path(__file__).parent.parent.parent
+    sys.path.append(cwd.as_posix())
+
 from petal_qc.thermal import IRBFile
 from petal_qc.thermal import IRCore
 from petal_qc.thermal import IRPetal
@@ -50,8 +57,24 @@ def get_db_date(timestamp=None):
     return out
 
 
+__figures__ = {}
+def get_IRcore_plots():
+    """Return global list of figures."""
+    return __figures__
+
+def clean_figures():
+    global __figures__
+    for key, fig in __figures__:
+        fig.clean()
+        plt.close(fig)
+
+    __figures__ = {}
+
 def create_IR_core(options):
     """Entry point."""
+    global __figures__
+    clean_figures()
+
     # Obtain the Data getter.
     try:
         getter = IRDataGetter.factory(options.institute, options)
@@ -76,8 +99,9 @@ def create_IR_core(options):
         min_T, i_min, values = getter.find_reference_image(irbf, params.thrs, nframes=10)
         print("Image size: {} x {}".format(values[0].shape[0], values[0].shape[1]))
 
-        if options.debug:
-            Petal_IR_Analysis.show_2D_image(values)
+        if options.debug or options.report:
+            fig, ax = Petal_IR_Analysis.show_2D_image(values)
+            __figures__["original"] = fig
 
     except LookupError as e:
         print(e)
@@ -99,8 +123,9 @@ def create_IR_core(options):
         pipe_order[i] = pipe_type
         PF = PipeFit.PipeFit(pipe_type)
         R = PF.fit_ex(pipes[i], factor=getter.factor)
-        if options.debug:
-            PF.plot()
+        if options.debug or options.report:
+            fig, _ =PF.plot()
+            __figures__["fit_{}".format(i)] = fig
 
         transforms[pipe_type] = R
         fitter[pipe_type] = PF
@@ -128,7 +153,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]
@@ -159,7 +184,7 @@ def create_IR_core(options):
 
     if options.debug:
         plt.show()
-        
+
     return core
 
 

petal_qc-0.0.2/petal_qc/thermal/create_core_report.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+"""Creates the report of a core."""
+
+import math
+import sys
+import json
+from argparse import ArgumentParser
+from pathlib import Path
+
+import matplotlib.path as mplPath
+import matplotlib.pyplot as plt
+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.thermal.IRPetalParam import IRPetalParam
+from petal_qc.thermal.create_IRCore import create_IR_core, get_IRcore_plots
+from petal_qc.thermal.analyze_IRCore import analyze_IRCore, golden_from_json, get_golden_axis, plot_profile_and_golden
+
+import petal_qc.utils.docx_utils as docx_utils
+import petal_qc.utils.utils as utils
+
+
+
+def create_report(options):
+    """Create a writen report.
+    """
+    ifile = Path(options.files[0]).expanduser().resolve()
+    if not ifile.exists():
+        print("input file {} does not exist.".format(ifile))
+        return
+
+    goldenFile = Path(options.golden).expanduser().resolve()
+    if not goldenFile.exists():
+        print("I need a golden file.")
+
+    with open(goldenFile, "r", encoding='utf-8') as fp:
+        golden = golden_from_json(json.load(fp))
+
+
+
+    document = docx_utils.Document()
+    document.add_page_numbers()
+    document.styles['Normal'].font.name = "Calibri"
+    document.add_heading(options.SN, 0)
+
+    P = document.add_paragraph(ifile.name, "Subtitle")
+    P.alignment = docx_utils.paragraph_align_center()
+
+    P = document.add_paragraph("Golden: {}".format(goldenFile.name), "Subtitle")
+    P.alignment = docx_utils.paragraph_align_center()
+
+
+    core = create_IR_core(options)
+
+    figures = get_IRcore_plots()
+    document.add_heading('Original image', level=1)
+    document.add_picture(figures["original"], True, 14, caption="Original Thermal image.")
+
+    document.add_heading('Result of Pipe Fit', level=1)
+    document.add_picture(figures["fit_0"], True, 10, caption="Size 0 fit.")
+    document.add_picture(figures["fit_1"], True, 10, caption="Size 1 fit.")
+
+    options.add_attachments = True
+    options.create_golden = False
+
+    options.files[0] = utils.output_folder(options.folder, options.out)
+    options.out = None
+    out = analyze_IRCore(options, show=False)
+    outDB = out[0] if len(out) else None
+    options.files = []
+
+    get_golden_axis(core, golden)
+
+    figures = plot_profile_and_golden(golden, core, "path_temp")
+    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).")
+
+    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).")
+
+    ofile = utils.output_folder(options.folder, "{}-thermal.docx".format(options.SN))
+    document.save(ofile)
+
+    return outDB
+
+if __name__ == "__main__":
+    P = IRPetalParam()
+    parser = ArgumentParser()
+    parser.add_argument('files', nargs='*', help="Input files")
+    parser.add_argument("--orig", action="store_true", default=False, help="plot the original image")
+    parser.add_argument('--frame', default=-1, type=int, help="Frame to analize")
+    parser.add_argument("--out", default="core.json", help="Output file name")
+    parser.add_argument("--alias", default="", help="Alias")
+    parser.add_argument("--SN", default="", help="serial number")
+    parser.add_argument("--folder", default=None, help="Folder to store output files. Superseeds folder in --out")
+    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")
+
+
+    IRPetalParam.add_parameters(parser)
+
+    options = parser.parse_args()
+
+    if len(options.files) == 0:
+        print("I need an input file")
+        sys.exit()
+    else:
+        ifile = options.files[0]
+
+    options.debug = False
+    options.report = True
+    create_report(options)

{petal_qc-0.0.1 → petal_qc-0.0.2}/petal_qc/thermal/show_IR_petal.py

@@ -12,6 +12,14 @@ from pathlib import PurePath
 import matplotlib.pyplot as plt
 import matplotlib.ticker as ticker
 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.thermal import contours
 from petal_qc.thermal import IRBFile
 from petal_qc.thermal import IRPetal

petal_qc-0.0.2/petal_qc/thermal/test_Graphana.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+"""Test the connection with graphana to get the value at the peak."""
+import sys
+from pathlib import Path
+import datetime
+try:
+    import petal_qc
+
+except ImportError:
+    cwd = Path(__file__).parent.parent.parent
+    sys.path.append(cwd.as_posix())
+
+from petal_qc.utils.readGraphana import ReadGraphana
+from petal_qc.thermal.IRDataGetter import IRDataGetter
+from petal_qc.thermal.IRPetalParam import IRPetalParam
+from petal_qc.thermal import IRBFile
+
+
+options = IRPetalParam()
+options.files = ["/Users/lacasta/tmp/thermal/PPC.007.irb"]
+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)

petal_qc-0.0.2/petal_qc/thermal/test_coreThermal.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""Probando."""
+import sys
+import json
+from pathlib import Path
+
+try:
+    import petal_qc
+
+except ImportError:
+    cwd = Path(__file__).parent.parent.parent
+    sys.path.append(cwd.as_posix())
+
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+from matplotlib.backends.backend_gtk3agg import FigureCanvasGTK3Agg as FigureCanvas
+from matplotlib.backends.backend_gtk3 import NavigationToolbar2GTK3 as NavigationToolbar
+
+import petal_qc
+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
+
+
+irbFile="/private/tmp/thermal/PPB08.irb"
+goldenFIle = "/private/tmp/thermal/golden-PPB.json"
+outFolder = "/private/tmp/thermal"
+
+param = IRPetalParam()
+param.alias = "PPB_008"
+param.SN = "20USEBC1000028"
+param.tco2 = -31.7
+param.out = "{}.json".format(param.alias)
+param.files = [irbFile, ]
+param.golden = goldenFIle
+param.folder = outFolder
+param.create_golden = False
+param.add_attachments = True
+
+with open(goldenFIle, "r", encoding='utf-8') as fp:
+    golden = golden_from_json(json.load(fp))
+
+core = create_IR_core(param)
+
+param.files[0] = output_folder(outFolder, param.out)
+param.out = None
+out = analyze_IRCore(param)
+outDB = out[0] if len(out) else None
+param.files = []
+
+get_golden_axis(core, golden)
+
+plot_profile_and_golden(golden, core, "path_temp")
+
+plt.show()

petal_qc-0.0.2/petal_qc/utils/readGraphana.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+"""Class to access graphana data."""
+
+import datetime
+from dateutil.parser import parse
+import influxdb
+import numpy as np
+
+
+class ReadGraphana(object):
+    """Connect to the GraphanaDB"""
+
+    def __init__(self, host="silab15.ific.uv.es", port=8086):
+        """Connect to Graphan server
+
+        Args:
+            host (str, optional): The IP of the server.
+            port (int, optional): The port to the server.
+        """
+        self.client = influxdb.InfluxDBClient(host=host, port=port,
+                                 username="matlab", password="matlab",
+                                 database="clean_room")
+
+    def get_temperature(self, the_time, window=10):
+        """REturns the temperature
+
+        Args:
+            teh_time: the time to query the DB.
+            window: the time window, in minutes, around the given time.
+        """
+        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)
+
+        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')
+
+        ss = self.client.query(query)
+        nitems = 0
+        for s in ss:
+            nitems += len(s)
+
+        if nitems==0:
+            raise ValueError(("No data found"))
+
+        T = []
+        for s in ss:
+            for v in s:
+                T.append(v['value'])
+
+
+        val = np.mean(T)
+        return val

{petal_qc-0.0.1 → petal_qc-0.0.2}/petal_qc.egg-info/PKG-INFO

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

@@ -45,14 +45,18 @@ petal_qc/thermal/analyze_IRCore.py
 petal_qc/thermal/contours.py
 petal_qc/thermal/coreThermal.py
 petal_qc/thermal/create_IRCore.py
+petal_qc/thermal/create_core_report.py
 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/utils/all_files.py
 petal_qc/utils/docx_utils.py
 petal_qc/utils/fit_utils.py
+petal_qc/utils/readGraphana.py
 petal_qc/utils/utils.py

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

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