Features and bug-fixes

- Reimplemented csv-writing of each data block (separate at the moment)
- Fixed injection selection/read-out
- y-axis2 is Conductivity now by default

Author: pyahmed

examplescripts/pycorn-bin.py

@@ -1,37 +1,74 @@
-import argparse
-# from pathlib import Path
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
 
+import argparse
 from mpl_toolkits.axes_grid1 import host_subplot
+from matplotlib.ticker import AutoMinorLocator
 import mpl_toolkits.axisartist as AA
 import matplotlib.pyplot as plt
-# ^^^ = from matplotlib.pyplot import axvline, savefig, subplots, annotate
-
 from pycorn import pc_res3
 
-parser = argparse.ArgumentParser()
+pcscript_version = 0.13
 
+parser = argparse.ArgumentParser(
+    description = "Extract data from UNICORN .res files to .csv/.txt and plot them (matplotlib required)",
+    epilog = "Make it so!")
+parser.add_argument("-c", "--check", 
+                    help = "Perform simple check if file is supported",
+                    action = "store_true")
+parser.add_argument("-n", "--info", 
+                    help = "Display entries in header",
+                    action = "store_true")
+parser.add_argument("-i", "--inject", type = int, default = None, 
+                    help = "Set injection number # as zero retention, use -t to find injection points",
+                    metavar="#")
+parser.add_argument("-r", "--reduce", type = int, default = 1,
+                    help = "Write/Plot only every n sample",
+                    metavar="#")
+parser.add_argument("-t", "--points", 
+                    help = "Display injection points",
+                    action = "store_true")
+
+group0 = parser.add_argument_group('Extracting', 'Options for writing csv/txt files')
+group0.add_argument("-e", "--extract", 
+                    help = "Write csv file for supported data blocks",
+                    action = "store_true")
+
+group1 = parser.add_argument_group('Plotting', 'Options for plotting')
+group1.add_argument("-p", "--plot", 
+                    help = 'Plot curves',
+                    action = "store_true")
+group1.add_argument("--no_fractions", 
+                    help="Disable plotting of fractions",
+                    action = "store_false")
+group1.add_argument("--xmin", type = float, default=None,
+                    help="Lower bound on the x-axis",
+                    metavar="#")
+group1.add_argument("--xmax", type = float, default=None,
+                    help="Upper bound on the x-axis",
+                    metavar="#")
+group1.add_argument("--par1", type = str, default='Cond',
+                    help="Data for 2nd y-axis (Default=Cond)")
+group1.add_argument("--par2", type = str, default=None,
+                    help="Data for 3rd y-axis (Default=None)")                 
+group1.add_argument('-f', '--format', type = str,
+                    choices=['svg','svgz','tif','tiff','jpg','jpeg',
+                    'png','ps','eps','raw','rgba','pdf','pgf'],
+                    default = 'pdf',
+                    help = "File format of plot files (default: pdf)")
+group1.add_argument('-d', '--dpi', default=300, type=int, 
+					help="DPI (dots per inch) for raster images (png, jpg, etc.). Default is 300.")
+parser.add_argument("-u", "--user", 
+                    help = "Show stored user name",
+                    action = "store_true")
+parser.add_argument('--version', action='version', version=str(pcscript_version))
 parser.add_argument("inp_res",
                     help="Input .res file(s)",
                     nargs='+',
                     metavar="<file>.res")
-parser.add_argument("-e", "--ext", default='.pdf',
-                    help="Image type to use, e.g. 'jpg', 'png', 'eps', or 'pdf' (default: pdf)")
-parser.add_argument("--xmin", default=None, type=float,
-                    help="Lower bound on the x-axis")
-parser.add_argument("--xmax", default=None, type=float,
-                    help="Upper bound on the x-axis")
-parser.add_argument("--dpi", default=None, type=int,
-                    help="DPI (dots per inch) for raster images (png, jpg, etc.)")
-parser.add_argument("--par1", default=None, type=str,
-                    help="First parasite")
-parser.add_argument("--par2", default=None, type=str,
-                    help="Second parasite")
-
-
 
 args = parser.parse_args()
 
-
 def mapper(min_val, max_val, perc):
     '''
     calculate relative position in delta min/max
@@ -177,26 +214,56 @@ def plotterX(inp,fname):
         print("Plotting: " + par2_data['data_name'])
         p2, = par2.plot(x_dat_p2, y_dat_p2, label=par2_data['data_name'], color=stl['color'],
                         ls=stl['ls'], lw=stl['lw'], alpha=stl['alpha'])
-    try:
-        frac_data = inp['Fractions']['data']
-        frac_x, frac_y = xy_data(frac_data)
-        frac_delta = [abs(a - b) for a, b in zip(frac_x, frac_x[1:])]
-        frac_delta.append(frac_delta[-1])
-        frac_y_pos = mapper(host.get_ylim()[0], host.get_ylim()[1], 0.015)
-        for i in frac_data:
-            host.axvline(x=i[0], ymin=0.065, ymax=0.0, color='r', linewidth=0.85)
-            host.annotate(str(i[1]), xy=(i[0] + frac_delta[frac_data.index(i)] * 0.55, frac_y_pos),
+    if args.no_fractions:
+        try:
+            frac_data = inp['Fractions']['data']
+            frac_x, frac_y = xy_data(frac_data)
+            frac_delta = [abs(a - b) for a, b in zip(frac_x, frac_x[1:])]
+            frac_delta.append(frac_delta[-1])
+            frac_y_pos = mapper(host.get_ylim()[0], host.get_ylim()[1], 0.015)
+            for i in frac_data:
+                host.axvline(x=i[0], ymin=0.065, ymax=0.0, color='r', linewidth=0.85)
+                host.annotate(str(i[1]), xy=(i[0] + frac_delta[frac_data.index(i)] * 0.55, frac_y_pos),
                          horizontalalignment='center', verticalalignment='bottom', size=8, rotation=90)
-    except:
-        KeyError
+        except:
+            KeyError
     host.set_xlim(plot_x_min, plot_x_max)
-    host.legend(fontsize=8, fancybox=True, labelspacing=0.4)
+    host.legend(fontsize=8, fancybox=True, labelspacing=0.4, loc='upper right')
+    host.xaxis.set_minor_locator(AutoMinorLocator())
+    host.yaxis.set_minor_locator(AutoMinorLocator())
     plt.title(fname, loc='left')
     internal_run_name = str(inp['Logbook']['run_name'])
-    plot_file = fname[:-4] + "_" + internal_run_name + "_plot" + args.ext
+    plot_file = fname[:-4] + "_" + internal_run_name + "_plot." + args.format
     plt.savefig(plot_file, bbox_inches='tight', dpi=args.dpi)
     print("Plot saved to: " + plot_file)
-#4e62ff
+
+def data_writer1(fname, inp):
+    '''
+    writes sensor/run-data to csv-files
+    '''
+    run_name = inp['Logbook']['run_name']
+    for i in inp.keys():
+        print("Extracting: " + inp[i]['data_name'])
+        outfile_base = fname[:-4] + "_" + run_name + "_" + inp[i]['data_name']
+        type = inp[i]['data_type']
+        if type == 'meta':
+            data = inp[i]['data']
+            data_to_write = data.encode('utf-8')
+            ext = '.txt'
+            sep = '\t'
+            with open(outfile_base + ext, 'wb') as fout:
+                fout.write(data_to_write)
+        else:
+            x_dat,y_dat = xy_data(inp[i]['data'])
+            ext = '.csv'
+            sep = ','
+            with open(outfile_base + ext, 'wb') as fout:
+                for x,y in zip(x_dat,y_dat):
+                    dp = str(x) + sep + str(y) + str('\r\n')
+                    data_to_write = dp.encode('utf-8')
+                    fout.write(data_to_write)
+
+                    
 styles = {'UV':{'color': '#1919FF', 'lw': 1.6, 'ls': "-", 'alpha':1.0},
 'UV1_':{'color': '#1919FF', 'lw': 1.6, 'ls': "-", 'alpha':1.0},
 'UV2_':{'color': '#e51616', 'lw': 1.4, 'ls': "-", 'alpha':1.0},
@@ -208,10 +275,25 @@ def plotterX(inp,fname):
 'Inje':{'color': '#d56d9d', 'lw': 1.0, 'ls': "-", 'alpha':0.75},
 'pH':{'color': '#0C7F7F', 'lw': 1.0, 'ls': "-", 'alpha':0.75},}
 
+
 def main2():
     for fname in args.inp_res:
-        fdata = pc_res3(fname)
+        if args.inject == None:
+            args.inject = -1
+        fdata = pc_res3(fname, reduce = args.reduce, inj_sel=args.inject)
         fdata.load()
-        plotterX(fdata, fname)
+        if args.extract:
+            data_writer1(fname, fdata)
+        if args.check:
+            fdata.input_check(show=True)
+        if args.info:
+            fdata.showheader()
+        if args.points:
+            fdata.inject_det(show=True)
+        if args.user:
+            user = fdata.get_user()
+            print("User: " + user)
+        if args.plot:
+            plotterX(fdata, fname)
 
 main2()

pycorn/pycorn.py

@@ -13,7 +13,6 @@
 import codecs
 import os
 
-
 class pc_res3(OrderedDict):
     """A class for holding the PyCORN/RESv3 data.
     A subclass of `dict`, with the form `data_name`: `data`.
@@ -33,12 +32,13 @@ class pc_res3(OrderedDict):
     Inject_id2 = b'\x00\x00\x01\x00\x04\x00\x47\x04'
     LogBook_id = b'\x00\x00\x01\x00\x02\x00\x01\x13'  # capital B!
 
-    def __init__(self, file_name, reduce=1, default_inject=1):
+    def __init__(self, file_name, reduce=1, inj_sel=-1):
         OrderedDict.__init__(self)
         self.file_name = file_name
         self.reduce = reduce
-        self.default_inject = default_inject
-        self.inj_sel = 0.0  # injection point is by default 0.0 ml
+        self.injection_points = None
+        self.inj_sel = inj_sel
+        self.inject_vol = None
         self.header_read = False
 
         with open(self.file_name, 'rb') as f:
@@ -115,7 +115,6 @@ def showheader(self, full=True):
         '''
         Prints content of header
         '''
-        self.readheader()
         print((" ---- \n Header of {0}: \n").format(self.file_name))
         if full:
             print("  MAGIC_ID, ENTRY_NAME, BLOCK_SIZE, OFFSET_TO_NEXT, ADRESSE, OFFSET_TO_DATA")
@@ -163,19 +162,21 @@ def dataextractor(self, dat, show=False):
             dat.update(data=values, unit=unit, data_type= 'curve')
             return dat
 
-    def meta1_read(self, dat, show=False):
+    def meta1_read(self, dat, show=False, do_it_for_inj_det=False):
         '''
         Extracts meta-data/type1, Logbook, fractions and Inject marks
         for a specific datum
         '''
         if show:
             print((" Reading: {0}").format(dat['data_name']))
         final_data = []
-
+        inj_vol_to_subtract = self.inject_vol
+        if do_it_for_inj_det:
+            inj_vol_to_subtract = 0.0     
         for i in range(dat['d_start'], dat['d_end'], 180):
             dp = struct.unpack("dd158s", self.raw_data[i:i + 174])
             # acc_time = dp[0] # not used atm
-            acc_volume = round(dp[1] - self.inj_sel, 4)
+            acc_volume = round(dp[1] - inj_vol_to_subtract, 4)
             label = (codecs.decode(dp[2], 'iso8859-1')).rstrip('\x00')
             merged_data = acc_volume, label
             final_data.append(merged_data)
@@ -219,51 +220,43 @@ def sensor_read(self, dat, show=False):
             s_unit_dec = (codecs.decode(s_unit[0], 'iso8859-1')).rstrip('\x00')
         for i in range(dat['d_start'], dat['d_end'], 8):
             sread = struct.unpack("ii", fread[i:i + 8])
-            data = round((sread[0] / 100.0) - self.inj_sel, 4), sread[1] / sensor_div
+            data = round((sread[0] / 100.0) - self.inject_vol, 4), sread[1] / sensor_div
             final_data.append(data)
         return (final_data[0::self.reduce], s_unit_dec)
 
     def inject_det(self, show=False):
         '''
         Finds injection points - required for adjusting retention volume
         '''
-        injection_points = []
-        self.readheader()
-        inject_ids = [self.Inject_id, self.Inject_id2]
-        for i in self.values():
-            if i['magic_id'] in inject_ids:
-                injection = self.meta1_read(i, show=show)[0][0]
-                injection_points.append(injection)
-                if injection != 0.0:
-                    injection_points.insert(0, 0.0)
-        if injection_points == []:
-            injection_points = [0.0]
-            if show:
-                print((" ---- \n Injection points: \n # \t ml \n 0 \t {0}").format(injection_points[0]))
-            return (injection_points)
-        else:
-            if show:
-                print(" ---- \n Injection points: \n # \t ml")
-                for x, y in enumerate(injection_points):
-                    print((" {0} \t {1}").format(x, y))
-            return (injection_points)
+        if self.injection_points == None:
+            self.injection_points = [0.0]
+            inject_ids = [self.Inject_id, self.Inject_id2]
+            for i in self.values():
+                if i['magic_id'] in inject_ids:
+                    injection = self.meta1_read(i, show=show, do_it_for_inj_det=True)[0][0]
+                    if injection != 0.0:
+                        self.injection_points.append(injection)
+        if show:
+            print(" ---- \n Injection points: \n # \t ml")
+            for x, y in enumerate(self.injection_points):
+                print((" {0} \t {1}").format(x, y))
+
 
     def load(self, show=False):
         '''
         extract all data and store in list
         '''
-        injection_points = self.inject_det(show=False)
+        self.readheader()
+        self.inject_det()
         try:
-            self.inj_sel = injection_points[self.default_inject]
+            self.inject_vol = self.injection_points[self.inj_sel]
         except IndexError:
-            if show:
-                print("\n ERROR - Injection point does not exist! Selected default.\n")
-            self.inj_sel = injection_points[-1]
-        self.readheader()
+            print("\n WARNING - Injection point does not exist! Selected default.\n")
+            self.inject_vol = self.injection_points[-1]
         for name, dat in list(self.items()):
             dat = self.dataextractor(dat, show=show)
             if dat is not None:
                 self[name] = dat
             else:
                 # TODO: Maybe we should keep this around?
-                del self[name]
+                del self[name]