petal-qc 0.0.0__py3-none-any.whl → 0.0.2__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.2"
 
 
 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/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/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/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/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/thermal/IRPetalParam.py

@@ -13,7 +13,8 @@ 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
         self.distance = 5         # Distance in contour between slices
@@ -25,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)
@@ -58,6 +60,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")
@@ -69,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/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/thermal/analyze_IRCore.py

@@ -162,6 +162,106 @@ 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 = 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.
@@ -174,7 +274,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 +284,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 +332,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 +372,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 +457,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)
 
-def analyze_IRCore(options):
+    return output
+
+def analyze_IRCore(options, show=True):
     """Main entry."""
+    output = None
     if options.create_golden:
         golden, results = create_golden_average(options.files, options)
         if options.out is None:
@@ -390,9 +499,12 @@ 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)
+
+    if show:
+        plt.show()
 
-    plt.show()
+    return output
 
 
 if __name__ == "__main__":
@@ -406,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")