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

petal_qc/thermal/coreThermal.py

@@ -5,89 +5,33 @@ 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
-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.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)
+try:
+    import petal_qc
 
-        sw = create_canvas(figs[q])
-        box.pack_start(sw, True, True, 0)
+except ImportError:
+    cwd = Path(__file__).parent.parent.parent
+    sys.path.append(cwd.as_posix())
 
-        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)
+from petal_qc.thermal.IRPetalParam import IRPetalParam
+from petal_qc.thermal import IRBFile
+from petal_qc.thermal.IRDataGetter import IRDataGetter
 
-        self.mainBox.pack_start(btnBox, False, True, 0)
+from petal_qc.thermal.analyze_IRCore import golden_from_json
+from petal_qc.utils.readGraphana import ReadGraphana
 
-        self.show_all()
+import gi
+gi.require_version("Gtk", "3.0")
+from gi.repository import Gtk, GObject, Gio, GLib
 
-    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 +90,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")
@@ -222,6 +166,18 @@ class CoreThermal(itkdb_gtk.dbGtkUtils.ITkDBWindow):
 
         self.irbfile = PSF
         self.param.files =[PSF,]
+        
+        DB = ReadGraphana("localhost")
+        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."""
@@ -338,8 +294,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 +305,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/thermal/create_IRCore.py

@@ -7,8 +7,16 @@ from datetime import datetime
 from pathlib import Path
 
 import dateutil
+import numpy as np
 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
@@ -16,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
 
 
@@ -50,8 +59,46 @@ 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 get_inlet_temp(irbf, param):
+    """Gets the value of the inlet temperature from Graphana."""
+
+    out = -9999
+    getter = IRDataGetter.factory(param.institute, param)
+    DB = ReadGraphana("localhost")
+    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__
+    clean_figures()
+
     # Obtain the Data getter.
     try:
         getter = IRDataGetter.factory(options.institute, options)
@@ -60,13 +107,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
@@ -76,8 +135,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 +159,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
@@ -159,7 +220,7 @@ def create_IR_core(options):
 
     if options.debug:
         plt.show()
-        
+
     return core
 
 

petal_qc/thermal/create_core_report.py

@@ -0,0 +1,126 @@
+#!/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).")
+    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)
+
+    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/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/thermal/test_Graphana.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+"""Test the connection with graphana to get the value at the peak."""
+import sys
+from pathlib import Path
+import datetime
+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.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 = [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 = 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/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/utils/readGraphana.py

@@ -0,0 +1,64 @@
+#!/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)
+
+        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.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'])
+
+        return X, T

{petal_qc-0.0.1.dist-info → petal_qc-0.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: petal_qc
-Version: 0.0.1
+Version: 0.0.3
 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