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

petal_qc/BTreport/CheckBTtests.py

@@ -104,6 +104,7 @@ def find_bus_tapes(session, petal, complain_func=complain):
         dict: a dict with the bustapes. Key is the BT type.
     """
     bt_list = {}
+    bt_valid = {}
     for child in petal["children"]:
         cstage = "Missing"
         if child["component"] is None:
@@ -117,14 +118,17 @@ def find_bus_tapes(session, petal, complain_func=complain):
 
             # We are left with the bus tapes
             cobj = session.get('getComponent', json={'component': child["component"]["id"]})
+            bt_list[comp_type] = cobj, child['id']
             cstage = cobj["currentStage"]['code']
             if cstage != "COMPLETED":
                 complain_func("Bus tape not in final stages", cstage)
-                continue
+                bt_valid[comp_type] = False
+                
+            else:
+                bt_valid[comp_type] = True
 
-            bt_list[comp_type] = cobj, child['id']
 
-    return bt_list
+    return bt_list, bt_valid
 
 
 def find_but_tape_tests(session, petal_date, bt_sn, complain_func=complain):
@@ -209,8 +213,14 @@ def BTreport(session, SerialN, complain_func=complain):
         return None
 
     # Loop on children an find bustapes
-    bt_list = find_bus_tapes(session, petal, complain_func=complain_func)
-    if len(bt_list) == 0:
+    bt_list, bt_valid = find_bus_tapes(session, petal, complain_func=complain_func)
+    
+    nvalid = 0
+    for valid in bt_valid.values():
+        if valid:
+            nvalid += 1
+            
+    if nvalid != 2:
         complain_func("no valid bustape found", "Either not assembled or in incorrect stage.")
         return None
 
@@ -229,7 +239,7 @@ def BTreport(session, SerialN, complain_func=complain):
         }
     }
 
-    # Check te tests in the bustapes
+    # Check the tests in the bustapes
     ngood = 0
     ntrouble = 0
     for bt, cp_id in bt_list.values():

petal_qc/BTreport/bustapeReport.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
-from contextlib import redirect_stdout
-
+"""GUI for the BTtest."""
+import dateutil.parser
 from itkdb_gtk import ITkDButils
 from itkdb_gtk import dbGtkUtils
 from itkdb_gtk import ITkDBlogin
@@ -16,6 +16,8 @@ from gi.repository import Gtk, Gio
 class BusTapeReport(dbGtkUtils.ITkDBWindow):
     """Makes a report of bustapes."""
 
+    BUSTAPE, SERIAL_NO, STAGE, DATE, PASSED = range(5)
+
     def __init__(self, session=None, title="",  panel_size=100):
         """Initialization.
 
@@ -28,7 +30,9 @@ class BusTapeReport(dbGtkUtils.ITkDBWindow):
         self.petal_SN = None
         self.alternativeID = None
         self.outDB = None
-
+        self.tree = None
+        self.petal = None
+        self.petal_date = None
 
         # Active button in header
         button = Gtk.Button()
@@ -60,6 +64,10 @@ class BusTapeReport(dbGtkUtils.ITkDBWindow):
         grid.attach(self.SN.entry, 1, 0, 1, 1)
 
 
+        # the list of attachments
+        self.create_tree_view()
+        self.mainBox.pack_start(self.tree, True, True, 5)
+
         self.mainBox.pack_start(self.message_panel.frame, True, True, 0)
 
 
@@ -68,6 +76,32 @@ class BusTapeReport(dbGtkUtils.ITkDBWindow):
         self.hide()
         self.destroy()
 
+    def create_tree_view(self):
+        """Creates the Tree vvew"""
+        model = Gtk.ListStore(str, str, str, str, bool)
+        self.tree = Gtk.TreeView(model=model)
+
+        renderer = Gtk.CellRendererText()
+        column = Gtk.TreeViewColumn("Tape", renderer, text=BusTapeReport.BUSTAPE)
+        self.tree.append_column(column)
+
+        renderer = Gtk.CellRendererText()
+        column = Gtk.TreeViewColumn("SN", renderer, text=BusTapeReport.SERIAL_NO)
+        self.tree.append_column(column)
+
+        renderer = Gtk.CellRendererText()
+        column = Gtk.TreeViewColumn("Stage", renderer, text=BusTapeReport.STAGE)
+        self.tree.append_column(column)
+
+        renderer = Gtk.CellRendererText()
+        column = Gtk.TreeViewColumn("Test Date", renderer, text=BusTapeReport.DATE)
+        self.tree.append_column(column)
+
+        renderer = Gtk.CellRendererText()
+        column = Gtk.TreeViewColumn("Passed", renderer, text=BusTapeReport.PASSED)
+        self.tree.append_column(column)
+
+
     def on_SN_changed(self, entry, value):
         """New SN given. Ask in PDB,"""
         if len(value) <= 0:
@@ -76,19 +110,54 @@ class BusTapeReport(dbGtkUtils.ITkDBWindow):
 
         obj = ITkDButils.get_DB_component(self.session, value)
         if obj is not None:
-            entry.set_text(obj["serialNumber"])
-            self.alternativeID = obj["alternativeIdentifier"]
+            if self.check_petal(obj):
+                entry.set_text(obj["serialNumber"])
+                self.alternativeID = obj["alternativeIdentifier"]
+                self.petal = obj
+                self.petal_date = dateutil.parser.parse(self.petal["stateTs"])
+
+                self.query_db()
 
         else:
             dbGtkUtils.complain("Invalid SN", value)
 
+    def check_petal(self, petal):
+        """Check that the petal is a good one."""
+        comp_type = CheckBTtests.get_type(petal)
+        if comp_type != "CORE_AVS":
+            dbGtkUtils.complain("This is not a petal coree", comp_type)
+            return False
+
+        # Check that the petal core is in the proper stage.
+        stage = petal["currentStage"]['code']
+        if stage != "AT_QC_SITE":
+            dbGtkUtils.complain("Petal core is not at QC_SITE", "Current stage: {}".format(stage))
+            return False
+
+        return True
     def query_db(self, *args):
         """Search petal and bustapes."""
-        SN = self.SN.get_text()
-        if SN is None or len(SN)==0:
-            dbGtkUtils.complain("Invalid Serial Number", "Wrong value: {}".format(SN))
+        if self.petal is None:
             return
-        
+
+        model = Gtk.ListStore(str, str, str, str, bool)
+        self.tree = Gtk.TreeView(model=model)
+
+        # Loop on children an find bustapes
+        bt_list, bt_valid = CheckBTtests.find_bus_tapes(self.session,
+                                                        self.petal,
+                                                        complain_func=dbGtkUtils.complain)
+
+        for btype, item in bt_list.items():
+            bt_sn = item[0]["serialNumber"]
+            cstage = item[0]["currentStage"]['code']
+            bt_tests = CheckBTtests.find_but_tape_tests(self.session,
+                                                        self.petal_date,
+                                                        bt_sn,
+                                                        complain_func=dbGtkUtils.complain)
+
+            values = [btype, child_sn, cstage]
+
         self.outDB = CheckBTtests.BTreport(self.session, SN, complain_func=dbGtkUtils.complain)
 
         if self.outDB is None:

petal_qc/__init__.py

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

petal_qc/dashBoard.py

@@ -0,0 +1,21 @@
+"""Test dashboard."""
+import sys
+
+try:
+    import petal_qc
+    
+except ImportError:
+    from pathlib import Path
+    cwd = Path(__file__).parent.parent
+    sys.path.append(cwd.as_posix())
+    
+from itkdb_gtk import dbGtkUtils
+from itkdb_gtk import GetShipments
+from itkdb_gtk import PetalReceptionTests
+from itkdb_gtk import ITkDBlogin
+from itkdb_gtk import CreateShipments
+from itkdb_gtk import UploadTest
+from itkdb_gtk import UploadMultipleTests
+from itkdb_gtk import GlueWeight
+from itkdb_gtk import UploadModuleIV
+from itkdb_gtk import WireBondGui

petal_qc/metrology/coreMetrology.py

@@ -3,11 +3,11 @@
 from pathlib import Path
 from argparse import Action
 from argparse import ArgumentParser
-import itkdb_gtk.ITkDButils
-import itkdb_gtk.dbGtkUtils
-import numpy as np
 from contextlib import redirect_stdout
+import numpy as np
 import itkdb_gtk
+import itkdb_gtk.ITkDButils
+import itkdb_gtk.dbGtkUtils
 import itkdb_gtk.UploadTest
 
 from petal_qc.metrology.do_Metrology import do_analysis
@@ -147,6 +147,7 @@ class CoreMetrology(itkdb_gtk.dbGtkUtils.ITkDBWindow):
 
         self.mainBox.pack_start(self.message_panel.frame, True, True, 0)
 
+
     def quit(self, *args):
         """Quits the application."""
         self.hide()
@@ -333,6 +334,20 @@ class CoreMetrology(itkdb_gtk.dbGtkUtils.ITkDBWindow):
         uploadW = itkdb_gtk.UploadTest.UploadTest(self.session, payload=self.outDB)
 
 
+class CoreMetrologyOptions(object):
+    """Dummy options"""
+    def __init__(self):
+        self.files = []
+        self.SN = None
+        self.desy = False
+        self.folder = None
+        self.prefix = None
+        self.locking_points = None
+        self.title = None
+        self.nbins = 25
+        self.label = "\\w+"
+        self.type = "Punto"
+
 def main():
     """Entry point."""
     parser = ArgumentParser()

petal_qc/thermal/IRPetalParam.py

@@ -14,6 +14,7 @@ class IRPetalParam(object):
         """
         self.institute = 'IFIC'   # Either IFIC or DESY to treat the different files
         self.thrs = -20.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
         self.distance = 5         # Distance in contour between slices
@@ -58,6 +59,7 @@ class IRPetalParam(object):
                             default=P.institute,
                             help="Either IFIC or DESY to treat the different files")
         parser.add_argument("--thrs", type=float, default=P.thrs, help="Temperature threshold")
+        parser.add_argument("--tco2", type=float, default=P.tco2, help="CO2 Inlet temperature")
         parser.add_argument("--gauss_size", type=int, default=P.gauss_size, help="Radius of gausian filtering")
         parser.add_argument("--distance", type=float, default=P.distance, help="Distance in contour beteween slices")
         parser.add_argument("--npoints", type=int, default=P.npoints, help="Number of points per segment")

petal_qc/thermal/analyze_IRCore.py

@@ -162,6 +162,15 @@ def create_golden_average(files, options):
 
     return golden, result_list
 
+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"]   
 
 def show_golden_average(golden, results, value):
     """Create golden average.
@@ -174,7 +183,7 @@ def show_golden_average(golden, results, value):
 
     """
     tick_labels = ["R0", "R1", "R2", "R3", "R3", "R4", "R4", "R5", "R5", "EoS"]
-
+    figures = []
     factor = 1.0
     if value.find("sensor") >= 0:
         factor = 2.0
@@ -184,6 +193,7 @@ def show_golden_average(golden, results, value):
 
     for iside in range(2):
         fig, ax = plt.subplots(2, 1, tight_layout=True, gridspec_kw={'height_ratios': (0.66, 0.34)}, figsize=(7, 6))
+        figures.append(fig)
         fig.suptitle("Golden average for {} - side {}.".format(value, iside))
         for a in ax:
             a.grid()
@@ -231,6 +241,7 @@ def show_golden_average(golden, results, value):
         if value.find("temp") >= 0 or value.find("_avg") >= 0:
             ax[1].set_ylim(-Tband, Tband)
 
+    return figures
 
 def compare_golden(core, golden, value):
     """Comapres petal core with golden average.
@@ -270,12 +281,15 @@ def analyze_petal_cores(files, golden, options):
     """Create golden average.
 
     Args:
-    ----
         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)
     for i, ifile in enumerate(files):
         ifile = find_file(options.folder, ifile)
@@ -352,13 +366,17 @@ def analyze_petal_cores(files, golden, options):
 
         # Check if we are given an output folder
         ofile = output_folder(options.folder, ofile)
-        with open(ofile, 'w') as fp:
+        with open(ofile, 'w', encoding="UTF-8") as fp:
             print("writing {}".format(ofile))
             json.dump(dbOut, fp, indent=3, cls=IRCore.NumpyArrayEncoder)
 
+        output.append(dbOut)
+        
+    return output
 
 def analyze_IRCore(options):
     """Main entry."""
+    output = None
     if options.create_golden:
         golden, results = create_golden_average(options.files, options)
         if options.out is None:
@@ -390,9 +408,10 @@ def analyze_IRCore(options):
         for i, Jside in enumerate(J):
             golden[i].from_json(Jside)
 
-        analyze_petal_cores(options.files, golden, options)
+        output = analyze_petal_cores(options.files, golden, options)
 
     plt.show()
+    return output
 
 
 if __name__ == "__main__":

petal_qc/thermal/coreThermal.py

@@ -0,0 +1,429 @@
+#!/usr/bin/env python3
+"""GUI for thermal QC of petal cores."""
+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
+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)
+
+        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()
+
+class CoreThermal(itkdb_gtk.dbGtkUtils.ITkDBWindow):
+    """Application window."""
+
+    def __init__(self, params=None, session=None, title="",  panel_size=100):
+        """Initialization
+
+        Args:
+            params (IRPetalParam, optional): Petal thermal parameters.
+            session (itkdb.Client): ITk PDB session.
+            title: Window title.
+            panel_size: size of message pannel.
+        """
+        super().__init__(session=session, title=title)
+
+        self.petal_SN = None
+        self.param = params if params else IRPetalParam()
+        self.param.add_attachments = True
+        self.param.create_golden = False
+        self.irbfile = None
+        self.folder = None
+        self.golden = None
+        self.results = None
+        self.alternativeID = None
+        self.outDB = None
+
+         # Active button in header
+        button = Gtk.Button()
+        icon = Gio.ThemedIcon(name="document-send-symbolic")
+        image = Gtk.Image.new_from_gicon(icon, Gtk.IconSize.BUTTON)
+        button.add(image)
+        button.set_tooltip_text("Click to upload test")
+        button.connect("clicked", self.upload_test_gui)
+        self.hb.pack_end(button)
+
+        # JScon edit
+        button = Gtk.Button()
+        icon = Gio.ThemedIcon(name="accessories-text-editor-symbolic")
+        image = Gtk.Image.new_from_gicon(icon, Gtk.IconSize.BUTTON)
+        button.add(image)
+        button.set_tooltip_text("Click to see the test data")
+        button.connect("clicked", self.show_test_gui)
+        self.hb.pack_end(button)
+
+        # The file chooser
+        self.btnData = Gtk.FileChooserButton()
+        self.btnData.connect("file-set", self.on_file_set)
+
+
+        # The file chooser
+        self.goldenData = Gtk.FileChooserButton()
+        self.goldenData.connect("file-set", self.on_golden_set)
+
+        # The Serial number
+        self.SN = itkdb_gtk.dbGtkUtils.TextEntry()
+        self.SN.connect("text-changed", self.on_SN_changed)
+
+        self.run = Gtk.Button(label="Run")
+        self.run.connect("clicked", self.run_analysis)
+
+        self.btn_state = Gtk.Button(label="Undef")
+        self.btn_state.set_name("btnState")
+        self.btn_state.connect("clicked", self.show_state)
+        self.btn_state.set_tooltip_text("If green all good. Click to see commnets and defects.")
+
+        # Put the 3 objects in a Grid
+        grid = Gtk.Grid(column_spacing=5, row_spacing=5)
+        self.mainBox.pack_start(grid, False, True, 0)
+
+        irow = 0
+        grid.attach(Gtk.Label(label="Serial No."), 0, irow, 1, 1)
+        grid.attach(self.SN.entry, 1, irow, 1, 1)
+        grid.attach(self.btn_state, 3, irow, 1, 1)
+
+        irow += 1
+        grid.attach(Gtk.Label(label="IRB File"), 0, irow, 1, 1)
+        grid.attach(self.btnData, 1, irow, 1, 1)
+
+        self.entryTemp = Gtk.Entry()
+        self.entryTemp.set_text("{:.1f}".format(self.param.tco2))
+        self.entryTemp.set_tooltip_text("CO2 inlet temperature")
+        lbl = Gtk.Label(label="T<sub>CO2</sub>")
+        lbl.set_use_markup(True)
+        grid.attach(lbl, 2, irow, 1, 1)
+        grid.attach(self.entryTemp, 3, irow, 1, 1)
+
+
+        irow += 1
+        grid.attach(Gtk.Label(label="Golden File"), 0, 2, 1, 1)
+        grid.attach(self.goldenData, 1, 2, 1, 1)
+
+        self.entryTHrs = Gtk.Entry()
+        self.entryTHrs.set_tooltip_text("Temperature threshold.")
+        self.entryTHrs.set_text("{:.1f}".format(self.param.thrs))
+        lbl = Gtk.Label(label="Threshold")
+        grid.attach(lbl, 2, irow, 1, 1)
+        grid.attach(self.entryTHrs, 3, irow, 1, 1)
+
+
+        irow += 1
+        # the folder option
+        self.btnFolder = Gtk.FileChooserButton()
+        self.btnFolder.set_tooltip_text("Select folder for all output. If none selected, output in current folder.")
+        self.btnFolder.set_action(Gtk.FileChooserAction.SELECT_FOLDER)
+        self.btnFolder.connect("file-set", self.on_folder_set)
+        if self.param.folder and len(self.param.folder) > 0 :
+            ifile = Path(self.param.folder).expanduser().resolve().as_posix()
+            self.btnFolder.set_filename(ifile)
+
+        grid.attach(Gtk.Label(label="Folder"), 0, irow, 1, 1)
+        grid.attach(self.btnFolder, 1, irow, 1, 1)
+
+        self.entryDist = Gtk.Entry()
+        self.entryDist.set_text("{}".format(self.param.distance))
+        self.entryDist.set_tooltip_text("Distance in contour beteween slices")
+        lbl = Gtk.Label(label="Distance")
+        grid.attach(lbl, 2, irow, 1, 1)
+        grid.attach(self.entryDist, 3, irow, 1, 1)
+
+
+        grid.attach(self.run, 0, 4, 5, 1)
+
+        self.mainBox.pack_start(self.message_panel.frame, True, True, 0)
+
+
+    def on_file_set(self, *args):
+        """File chosen from FileChooser."""
+        PSF = self.btnData.get_filename()
+        if PSF is None or not Path(PSF).exists():
+            itkdb_gtk.dbGtkUtils.complain("Could not find Data File", PSF, parent=self)
+            return
+
+        self.irbfile = PSF
+        self.param.files =[PSF,]
+
+    def on_golden_set(self, *args):
+        """File chosen from FileChooser."""
+        PSF = self.goldenData.get_filename()
+        if PSF is None or not Path(PSF).exists():
+            itkdb_gtk.dbGtkUtils.complain("Could not find Golden File", PSF, parent=self)
+            return
+
+        with open(PSF, "r", encoding='utf-8') as fp:
+            self.golden = golden_from_json(json.load(fp))
+
+        self.param.golden = PSF
+
+    def on_folder_set(self, *args):
+        """Folder chosen."""
+        F = self.btnFolder.get_filename()
+        if F is None or not Path(F).exists():
+            itkdb_gtk.dbGtkUtils.complain("Could not find Output folder", F, parent=self)
+            return
+
+        self.folder = F
+        self.param.folder = F
+
+    def on_SN_changed(self, entry, value):
+        """New SN given. Ask in PDB,"""
+        if len(value) <= 0:
+            return None
+
+
+        obj = itkdb_gtk.ITkDButils.get_DB_component(self.session, value)
+        if obj is not None:
+            entry.set_text(obj["serialNumber"])
+            self.alternativeID = obj["alternativeIdentifier"]
+
+        else:
+            itkdb_gtk.dbGtkUtils.complain("Invalid SN", value)
+
+    def show_state(self, *arg):
+        """Shows the status"""
+        if self.outDB is None:
+            dialog = Gtk.MessageDialog(
+                transient_for=self,
+                flags=0,
+                message_type=Gtk.MessageType.INFO,
+                buttons=Gtk.ButtonsType.OK,
+                text="State undefined",
+                )
+            dialog.format_secondary_text(
+                 "No analysis data available yet."
+                )
+            dialog.run()
+            dialog.destroy()
+            return
+
+        ndef = len(self.outDB["defects"])
+        ncomm = len(self.outDB["comments"])
+
+        if ndef+ncomm == 0:
+            dialog = Gtk.MessageDialog(
+                transient_for=self,
+                flags=0,
+                message_type=Gtk.MessageType.INFO,
+                buttons=Gtk.ButtonsType.OK,
+                text="All good",
+                )
+            dialog.format_secondary_text(
+                 "Petal core passed without problems."
+                )
+            dialog.run()
+            dialog.destroy()
+            return
+
+        msg = ""
+        if ndef:
+            msg += "Defects\n"
+        for D in self.outDB["defects"]:
+            msg += "{}: {}\n".format(D["name"], D["description"])
+
+        if ncomm:
+            msg += "Comments\n"
+            for C in self.outDB["comments"]:
+                msg += "{}\n".format(C)
+
+
+        dialog = Gtk.MessageDialog(
+                transient_for=self,
+                flags=0,
+                message_type=Gtk.MessageType.INFO,
+                buttons=Gtk.ButtonsType.OK,
+                text="Problems found",
+                )
+
+        dialog.format_secondary_text(msg)
+        dialog.run()
+        dialog.destroy()
+
+
+    def show_test_gui(self, *args):
+        """Show test data."""
+        if self.outDB is None:
+            return
+
+        values, rc = itkdb_gtk.dbGtkUtils.DictDialog.create_json_data_editor(self.outDB)
+        if rc == Gtk.ResponseType.OK:
+            self.outDB = values
+
+    def upload_test_gui(self, *args):
+        """Uploads test and attachments."""
+        self.upload_test()
+
+    def upload_test(self):
+        """Uploads test and attachments."""
+        if self.outDB is None:
+            return
+        uploadW = itkdb_gtk.UploadTest.UploadTest(self.session, payload=self.outDB)
+
+    def run_analysis(self, *args):
+        """Run analysis."""
+        if self.irbfile is None:
+            self.write_message("Missing IRB file\n")
+            return
+
+        self.write_message("Start analysis\n.")
+        self.param.out = "{}.json".format(self.alternativeID)
+        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")
+
+        outW = ShowThermalResults(self.golden, [core, ])
+        if self.outDB:
+            if len(self.outDB["defects"]) > 0:
+                itkdb_gtk.dbGtkUtils.set_button_color(self.btn_state, "red", "white")
+                self.btn_state.set_label("FAILED")
+            elif len(self.outDB["comments"]) > 0:
+                itkdb_gtk.dbGtkUtils.set_button_color(self.btn_state, "orange", "white")
+                self.btn_state.set_label("PROBLEMS")
+            else:
+                itkdb_gtk.dbGtkUtils.set_button_color(self.btn_state, "green", "white")
+                self.btn_state.set_label("PASSED")
+
+def main():
+    """Entry point."""
+    # Argument parser
+    parser = ArgumentParser()
+    #parser.add_argument('files', nargs='*', help="Input files")
+    parser.add_argument("--nframe", type=int, default=-1, help="Number of frames. (negative means all.")
+    parser.add_argument('--frame', type=int, default=-1, help="First frame to start.")
+    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")
+
+    IRPetalParam.add_parameters(parser)
+
+    options = parser.parse_args()
+    #if len(options.files) == 0:
+    #    print("I need an input file")
+    #    sys.exit()
+
+    # ITk PDB authentication
+    dlg = None
+    try:
+        # We use here the Gtk GUI
+        from itkdb_gtk import ITkDBlogin
+        dlg = ITkDBlogin.ITkDBlogin()
+        client = dlg.get_client()
+
+    except Exception:
+        # Login with "standard" if the above fails.
+        import itkdb
+        import getpass
+        client = itkdb.Client()
+        client.user._access_code1 = getpass.getpass("Access 1: ")
+        client.user._access_code2 = getpass.getpass("Access 2: ")
+        client.user.authenticate()
+        print("Hello {} !".format(client.user.name))
+
+    CT = CoreThermal(options, session=client, title="Petal Thermal analysis.")
+    CT.show_all()
+    CT.connect("destroy", Gtk.main_quit)
+    CT.write_message("Welcome !")
+
+    try:
+        Gtk.main()
+
+    except KeyboardInterrupt:
+        print("Arrrgggg!!!")
+
+
+    try:
+        dlg.die()
+
+    except Exception:
+        print("Bye !")
+
+if __name__ == "__main__":
+    main()

petal_qc/thermal/create_IRCore.py

@@ -58,7 +58,7 @@ def create_IR_core(options):
 
     except NotImplemented:
         print("*** Invalid institute name. ***")
-        return
+        return None
 
     # Set parameters from command line
     params = IRPetal.IRPetalParam(options)
@@ -154,11 +154,13 @@ def create_IR_core(options):
 
     # Check if we are given an output folder
     ofile = output_folder(options.folder, options.out)
-    with open(ofile, "w") as ofile:
+    with open(ofile, "w", encoding="utf-8") as ofile:
         core.to_json(ofile)
 
     if options.debug:
         plt.show()
+        
+    return core
 
 
 if __name__ == "__main__":
@@ -169,7 +171,6 @@ if __name__ == "__main__":
     parser.add_argument('files', nargs='*', help="Input files")
     parser.add_argument("--nframe", type=int, default=-1, help="Number of frames. (negative means all.")
     parser.add_argument('--frame', type=int, default=-1, help="First frame to start.")
-    parser.add_argument("--tco2", default=0, type=float, help="CO2 inlet temperature.")
     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")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: petal_qc
-Version: 0.0.0
+Version: 0.0.1
 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.0.dist-info → petal_qc-0.0.1.dist-info}/RECORD

@@ -1,7 +1,8 @@
-petal_qc/__init__.py,sha256=jVzpfX2cxFKJtyeuUIhf3o6dornHFtUkoUUjFRN9H08,337
-petal_qc/BTreport/CheckBTtests.py,sha256=WGENYpswLxs-BLQxXRxJC-6i-tdRZkIhNzhYtItfVBY,8845
+petal_qc/__init__.py,sha256=2q00gtEJFdw6a2_u6tM6FVJIlBYFKb1bQ8iqoEugWpA,337
+petal_qc/dashBoard.py,sha256=aPugRYhCcAzEBPrCyh8A8QKYaB4Q-_T1q3r5A3J2eog,553
+petal_qc/BTreport/CheckBTtests.py,sha256=4hNP1V-zcFBN5UvWVbx9nAmittF8Jmb5J17L33t68Eg,9086
 petal_qc/BTreport/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-petal_qc/BTreport/bustapeReport.py,sha256=Db4WhOhvqku-YatNwxrIwZ4g7l7hVfMth2hAV3JRZ6A,4151
+petal_qc/BTreport/bustapeReport.py,sha256=c5VERxPm6BOgW_yN9O_bEPmCYpuwZ_Yt_I2sMVAp0-I,6895
 petal_qc/metrology/Cluster.py,sha256=UtZ5q1EFb8f3qC0hEYBbhRg2pPbW_28aJX2EEMu00Ho,2105
 petal_qc/metrology/DataFile.py,sha256=PbFqy3-WSj69epV5EjhHc1GKhA8I74FmJYOXUjN0V20,1367
 petal_qc/metrology/PetalMetrology.py,sha256=H4MwuQ2QxP_Td9KtMly_-osXT1owigzC7QlmRub7oRo,11886
@@ -12,7 +13,7 @@ petal_qc/metrology/cold_noise.py,sha256=PuTaQ73WrQCJdE9ezS4UFmA3atwCuvM0ZsUOYu1Z
 petal_qc/metrology/comparisonTable.py,sha256=6Zmh-x0ahs28ZJQuHMrIiRcblUmTN1_-1otFSRNMPds,1743
 petal_qc/metrology/convert_mitutoyo.py,sha256=HdXQzFL5y7r8qXDzti91VItDQ-y6D9rEAYknn4yHwBs,5449
 petal_qc/metrology/convert_smartscope.py,sha256=es3PoUd5d5rpHebgwsS9nrc3uuy9uFKOQ00ZdU5XHQ0,3836
-petal_qc/metrology/coreMetrology.py,sha256=yDgChOmOZ7lKd6c_Je0pFLS0ahszYZoBBgyJ57Nbj3E,13256
+petal_qc/metrology/coreMetrology.py,sha256=L_uoxq8ObmmiMSx41gFCdpQnalR-HgaVUPHzhDYsDiE,13610
 petal_qc/metrology/data2csv.py,sha256=2ttMSmfGLPIaOqZGima2dH6sdnSRAFTHlEbSOfW5ebA,1809
 petal_qc/metrology/do_Metrology.py,sha256=4tbZJfJYXY8QVLiG5_2pThNPzyuqbC3s8xhFdQfC1TU,3977
 petal_qc/metrology/flatness4nigel.py,sha256=SUHwn6pCEUWQV_62-_9-VKrmUdL4gVQcSA3aTtYq958,4071
@@ -27,14 +28,17 @@ petal_qc/thermal/IRBFile.py,sha256=zj82SdI-MDfZq1i0n47PuZMLLx_0oKpE-ZaykJZs6BU,2
 petal_qc/thermal/IRCore.py,sha256=Iasus1wy1pDQvBMPhcPYN1gFHZGv7tO5KJlpJZGuck4,3029
 petal_qc/thermal/IRDataGetter.py,sha256=dX_FjeGc7qxinJ1JPC_4rSLSJlYtkKuAL31LURfv2a8,9662
 petal_qc/thermal/IRPetal.py,sha256=X6I7JmyWf_9mPHjTsuBztM-1b5wre2NW4VM-6dz4Gow,38208
-petal_qc/thermal/IRPetalParam.py,sha256=BcS302s4kyAuGm_F9zIlKVsPJkftSG71GGMzAl5eZMo,3366
+petal_qc/thermal/IRPetalParam.py,sha256=KlCJn0s9f0LSbQiUQG9aAJfwZ7EHApg2Aj665glZUr8,3516
 petal_qc/thermal/PetalColorMaps.py,sha256=6CvJHzRdojLHu3BROYSekHw8g_BJ1lJ_edyhovTIydU,3831
 petal_qc/thermal/Petal_IR_Analysis.py,sha256=8Deh_bJ5B7DdaUV18saboF7fXZ_8Bt1vkUlsk5RqVeo,3910
 petal_qc/thermal/PipeFit.py,sha256=qbNvi547U9EttfRxCaIrizK69Hw3mJOKuG4SGRQaHRk,17191
 petal_qc/thermal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-petal_qc/thermal/analyze_IRCore.py,sha256=v9cf5GAP_yfL829WK5Qyv1fOl5LdIsLfZEVPQQXiQ1A,13740
+petal_qc/thermal/analyze_IRCore.py,sha256=A2i6_O2XfS8uRCpaUXDRm_p8_1zTBS3DJJHC4kS5s90,14463
 petal_qc/thermal/contours.py,sha256=ampCKm4byZYKb_4eJFjIkdFIl2bqVXD2mV13d2XUWlw,8244
-petal_qc/thermal/create_IRCore.py,sha256=S4M7OQYHcuh7lX3XmDHWOnIhT_1EIr-XdbsRgMGOOEQ,5678
+petal_qc/thermal/coreThermal.py,sha256=B4LAOaZ6DWWoRtqQ0WU3VyRCluKxvQWZ_1GWRmLOF6o,14428
+petal_qc/thermal/create_IRCore.py,sha256=u1sSSTX4nsBIW0bclu4O7tEvWL_bXlB97V8THJE_ppI,5638
+petal_qc/thermal/pipe_back.npz,sha256=yooZuVYtHU541HcV6Gh_5B0BqdYAVEvYAuVvMMSY7Jc,3632
+petal_qc/thermal/pipe_front.npz,sha256=DuwruG9C2Z1rLigqWMApY4Orsf1SGUQGKy0Yan8Bk8A,3697
 petal_qc/thermal/pipe_read.py,sha256=HrAtEbf8pMhJDETzkevodiTbuprIOh4yHv6PzpRoz7Q,5040
 petal_qc/thermal/show_IR_petal.py,sha256=PGAq7qiWmchYx4tGPgWJxeHi2N-pM_C1a4tmXYe0htY,13029
 petal_qc/utils/Geometry.py,sha256=XwA_aojk880N-jC1_bnMYFK0bcD-L96JPS81NUerJf0,19765
@@ -44,8 +48,8 @@ petal_qc/utils/all_files.py,sha256=4ja_DkbTYPY3gUPBAZq0p7KB9lnXZx-OCnpTHg9tm4I,1
 petal_qc/utils/docx_utils.py,sha256=Eye16PF8W0mPBVdQvgFKWxPYV7-hzBgANPDZtUEjzf8,5805
 petal_qc/utils/fit_utils.py,sha256=3KUGWpBMV-bVDkQHWBigXot8chOpjAVBJ5H5b5dbdjk,5349
 petal_qc/utils/utils.py,sha256=CqCsNIcEg6FQb3DN70tmqeLVLlQqsRfDzhfGevlnfBc,4035
-petal_qc-0.0.0.dist-info/METADATA,sha256=rg1E5POenrFwIY540PaK6cYolr9epkR7V3OPUO7HDWo,943
-petal_qc-0.0.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-petal_qc-0.0.0.dist-info/entry_points.txt,sha256=ZsBmzA1gRvZSe4ZKcxlo0b-RBjySccqBhL6g_CJhNaM,92
-petal_qc-0.0.0.dist-info/top_level.txt,sha256=CCo1Xe6kLS79PruhsB6bk2CuL9VFtNdNpgJjYUs4jk4,9
-petal_qc-0.0.0.dist-info/RECORD,,
+petal_qc-0.0.1.dist-info/METADATA,sha256=I0nY8IdvLJW9DEnt6pZ8TiRQWR-ammo41RonPXaPfpg,943
+petal_qc-0.0.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+petal_qc-0.0.1.dist-info/entry_points.txt,sha256=ZsBmzA1gRvZSe4ZKcxlo0b-RBjySccqBhL6g_CJhNaM,92
+petal_qc-0.0.1.dist-info/top_level.txt,sha256=CCo1Xe6kLS79PruhsB6bk2CuL9VFtNdNpgJjYUs4jk4,9
+petal_qc-0.0.1.dist-info/RECORD,,