schain Commit - r1289:303db73c0c9d · Jicamarca Repository

Update README

Juan C. Espinoza -

r1289:303db73c0c9d

parent child

Context file:

r1289:303db73c0c9d

Collapse all files

README.md +62 -59

             # Signal Chain
             ## Introduction
             Signal Chain (SCh) is a radar data processing library developed using [Python](www.python.org) at JRO. SCh provides modules to read, write, process and plot data.
             ## Installation
-            Install system dependencies, clone the latest version from [here](http://jro-dev.igp.gob.pe/rhodecode/schain/) and install it as a normal python package.
+            Install system dependencies, clone the latest version from [here](http://jro-dev.igp.gob.pe/rhodecode/schain/) and install it as a normal python package, we strongly recommend to use Anaconda or a virtual environment for the installation.
-            ### Linux based system
+            ### Dependencies
+            - GCC (gcc or gfortran)
+            - Python.h (python-dev or python-devel)
+            - Python-TK (python-tk)
+            - HDF5 libraries (libhdf5-dev)
+            ### Linux based system (e.g. ubuntu)
             ```
-            $ sudo apt-get install python-pip python-dev gfortran libpng-dev freetype* libblas-dev liblapack-dev libatlas-base-dev python-qt4 python-tk libssl-dev libhdf5-dev
             $ git clone http://jro-dev.igp.gob.pe/rhodecode/schain/
             $ cd schain
+            $ git checkout `schain-branch` (optional)
             $ sudo pip install ./
             ```
             ### MAC Os
             ```
             $ brew install python
-            $ brew install cartr/qt4/pyqt
             $ git clone http://jro-dev.igp.gob.pe/rhodecode/schain/
             $ cd schain
-            $ pip install ./
+            $ git checkout `schain-branch` (optional)
-            ```
+            $ sudo pip install ./
-            **It is recommended to install schain in a virtual environment**
-            ```
-            $ virtualenv /path/to/virtual
-            $ source /path/to/virtual/bin/activate
-            (virtual) $ cd schain
-            (virtual) $ pip install ./
-            (virtual) $ bash link_PyQt4.sh
             ```
             ### Docker
             Download Dockerfile from the repository, and create a docker image
             ```
             $ docker build -t schain .
             ```
             You can run a container using an xml file or a schain script also you need to mount a volume for the data input and for the output files/plots
             ```
             $ docker run -it --rm --volume /path/to/host/data:/data schain xml /data/test.xml
             $ docker run -it --rm --volume /path/to/host/data:/data --entrypoint /urs/local/bin/python schain /data/test.py
             ```
+            ## CLI (command line interface)
+            Signal Chain provides the following commands:
+            - schainGUI: Open the GUI
+            - schain: Signal chain command line
             ## First Script
-            Read Spectra data (.pdata) - remove dc - plot spectra & RTI
+            Here you can find an script to read Spectra data (.pdata), remove dc and plot spectra & RTI
-            Import SCh and creating a project
+            First import SCh and creating a project
             ```python
             #!/usr/bin/python
             from schainpy.controller import Project
-            controller = Project()
+            prj = Project()
-            controller.setup(id = '100',
+            prj.setup(
-                             name='test',
+                id = '100',
-                             description='Basic experiment')
+                name='test',
+                description='Basic experiment'
+                )
             ```
-            Adding read unit and operations
+            Add read unit and operations
             ```python
-            read_unit = controller.addReadUnit(datatype='Spectra',
+            read_unit = prj.addReadUnit(
-                                               path='/path/to/pdata/',
+                datatype='Spectra',
-                                               startDate='2014/01/31',
+                path='/path/to/pdata/',
-                                               endDate='2014/03/31',
+                startDate='2014/01/31',
-                                               startTime='00:00:00',
+                endDate='2014/03/31',
-                                               endTime='23:59:59',
+                startTime='00:00:00',
-                                               online=0,
+                endTime='23:59:59',
-                                               walk=0)
+                online=0,
+                walk=0
-            proc_unit = controller.addProcUnit(datatype='Spectra',
-                                               inputId=read_unit.getId())
+            proc_unit = prj.addProcUnit(datatype='Spectra', inputId=read_unit.getId())
             op = proc_unit.addOperation(name='selectChannels')
-            op.addParameter(name='channelList', value='0,1', format='intlist')
+            op.addParameter(name='channelList', value='0,1')
             op = proc_unit.addOperation(name='selectHeights')
-            op.addParameter(name='minHei', value='80', format='float')
+            op.addParameter(name='minHei', value='80')
-            op.addParameter(name='maxHei', value='200', format='float')
+            op.addParameter(name='maxHei', value='200')
             op = proc_unit.addOperation(name='removeDC')
             ```
-            Plotting data & start project
+            Plot data & start project
             ```python
-            op = proc_unit.addOperation(name='SpectraPlot', optype='other')
+            op = proc_unit.addOperation(name='SpectraPlot')
-            op.addParameter(name='id', value='1', format='int')
+            op.addParameter(name='id', value='1')
-            op.addParameter(name='wintitle', value='Spectra', format='str')
+            op.addParameter(name='wintitle', value='Spectra')
-            op = procUnitConfObj1.addOperation(name='RTIPlot', optype='other')
+            op = procUnitConfObj1.addOperation(name='RTIPlot')
-            op.addParameter(name='id', value='2', format='int')
+            op.addParameter(name='id', value='2')
-            op.addParameter(name='wintitle', value='RTI', format='str')
+            op.addParameter(name='wintitle', value='RTI')
-            controller.start()
+            prj.start()
             ```
             Full script
             ```python
             #!/usr/bin/python
-            from schainpy.controller import Project
+            from schainpy.prj import Project
-            controller = Project()
+            prj = Project()
-            controller.setup(id = '100',
+            prj.setup(id = '100',
                              name='test',
                              description='Basic experiment')
-            read_unit = controller.addReadUnit(datatype='Spectra',
+            read_unit = prj.addReadUnit(datatype='Spectra',
                                                path='/path/to/pdata/',
                                                startDate='2014/01/31',
                                                endDate='2014/03/31',
                                                startTime='00:00:00',
                                                endTime='23:59:59',
                                                online=0,
                                                walk=0)
-            proc_unit = controller.addProcUnit(datatype='Spectra',
+            proc_unit = prj.addProcUnit(datatype='Spectra',
                                                inputId=read_unit.getId())
             op = proc_unit.addOperation(name='selectChannels')
-            op.addParameter(name='channelList', value='0,1', format='intlist')
+            op.addParameter(name='channelList', value='0,1')
             op = proc_unit.addOperation(name='selectHeights')
-            op.addParameter(name='minHei', value='80', format='float')
+            op.addParameter(name='minHei', value='80')
-            op.addParameter(name='maxHei', value='200', format='float')
+            op.addParameter(name='maxHei', value='200')
             op = proc_unit.addOperation(name='removeDC')
-            op = proc_unit.addOperation(name='SpectraPlot', optype='other')
+            op = proc_unit.addOperation(name='SpectraPlot')
-            op.addParameter(name='id', value='6', format='int')
             op.addParameter(name='wintitle', value='Spectra', format='str')
-            op = procUnitConfObj1.addOperation(name='RTIPlot', optype='other')
+            op = procUnitConfObj1.addOperation(name='RTIPlot')
-            op.addParameter(name='id', value='2', format='int')
             op.addParameter(name='wintitle', value='RTI', format='str')
-            controller.start()
+            prj.start()
             ```

schainpy/model/graphics/jroplot_base.py +2 -2

             import os
             import sys
             import zmq
             import time
             import numpy
             import datetime
             from functools import wraps
             from threading import Thread
             import matplotlib
             if 'BACKEND' in os.environ:
                 matplotlib.use(os.environ['BACKEND'])
             elif 'linux' in sys.platform:
                 matplotlib.use("TkAgg")
             elif 'darwin' in sys.platform:
                 matplotlib.use('WxAgg')
             else:
                 from schainpy.utils import log
                 log.warning('Using default Backend="Agg"', 'INFO')
                 matplotlib.use('Agg')
             import matplotlib.pyplot as plt
             from matplotlib.patches import Polygon
             from mpl_toolkits.axes_grid1 import make_axes_locatable
             from matplotlib.ticker import FuncFormatter, LinearLocator, MultipleLocator
             from schainpy.model.data.jrodata import PlotterData
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
             from schainpy.utils import log
             jet_values = matplotlib.pyplot.get_cmap('jet', 100)(numpy.arange(100))[10:90]
             blu_values = matplotlib.pyplot.get_cmap(
                 'seismic_r', 20)(numpy.arange(20))[10:15]
             ncmap = matplotlib.colors.LinearSegmentedColormap.from_list(
                 'jro', numpy.vstack((blu_values, jet_values)))
             matplotlib.pyplot.register_cmap(cmap=ncmap)
             CMAPS = [plt.get_cmap(s) for s in ('jro', 'jet', 'viridis',
                                                'plasma', 'inferno', 'Greys', 'seismic', 'bwr', 'coolwarm')]
             EARTH_RADIUS = 6.3710e3
             def ll2xy(lat1, lon1, lat2, lon2):
                 p = 0.017453292519943295
                 a = 0.5 - numpy.cos((lat2 - lat1) * p)/2 + numpy.cos(lat1 * p) * \
                     numpy.cos(lat2 * p) * (1 - numpy.cos((lon2 - lon1) * p)) / 2
                 r = 12742 * numpy.arcsin(numpy.sqrt(a))
                 theta = numpy.arctan2(numpy.sin((lon2-lon1)*p)*numpy.cos(lat2*p), numpy.cos(lat1*p)
                                       * numpy.sin(lat2*p)-numpy.sin(lat1*p)*numpy.cos(lat2*p)*numpy.cos((lon2-lon1)*p))
                 theta = -theta + numpy.pi/2
                 return r*numpy.cos(theta), r*numpy.sin(theta)
             def km2deg(km):
                 '''
                 Convert distance in km to degrees
                 '''
                 return numpy.rad2deg(km/EARTH_RADIUS)
             def figpause(interval):
                 backend = plt.rcParams['backend']
                 if backend in matplotlib.rcsetup.interactive_bk:
                     figManager = matplotlib._pylab_helpers.Gcf.get_active()
                     if figManager is not None:
                         canvas = figManager.canvas
                         if canvas.figure.stale:
                             canvas.draw()
                         try:
                             canvas.start_event_loop(interval)
                         except:
                             pass
                         return
             def popup(message):
                 '''
                 '''
                 fig = plt.figure(figsize=(12, 8), facecolor='r')
                 text = '\n'.join([s.strip() for s in message.split(':')])
                 fig.text(0.01, 0.5, text, ha='left', va='center',
                          size='20', weight='heavy', color='w')
                 fig.show()
                 figpause(1000)
             class Throttle(object):
                 '''
                 Decorator that prevents a function from being called more than once every
                 time period.
                 To create a function that cannot be called more than once a minute, but
                 will sleep until it can be called:
                 @Throttle(minutes=1)
                 def foo():
                   pass
                 for i in range(10):
                   foo()
                   print "This function has run %s times." % i
                 '''
                 def __init__(self, seconds=0, minutes=0, hours=0):
                     self.throttle_period = datetime.timedelta(
                         seconds=seconds, minutes=minutes, hours=hours
                     )
                     self.time_of_last_call = datetime.datetime.min
                 def __call__(self, fn):
                     @wraps(fn)
                     def wrapper(*args, **kwargs):
                         coerce = kwargs.pop('coerce', None)
                         if coerce:
                             self.time_of_last_call = datetime.datetime.now()
                             return fn(*args, **kwargs)
                         else:
                             now = datetime.datetime.now()
                             time_since_last_call = now - self.time_of_last_call
                             time_left = self.throttle_period - time_since_last_call
                             if time_left > datetime.timedelta(seconds=0):
                                 return
                         self.time_of_last_call = datetime.datetime.now()
                         return fn(*args, **kwargs)
                     return wrapper
             def apply_throttle(value):
                 @Throttle(seconds=value)
                 def fnThrottled(fn):
                     fn()
                 return fnThrottled
             @MPDecorator
             class Plot(Operation):
                 '''
                 Base class for Schain plotting operations
                 '''
                 CODE = 'Figure'
                 colormap = 'jet'
                 bgcolor = 'white'
                 buffering = True
                 __missing = 1E30
                 __attrs__ = ['show', 'save', 'ymin', 'ymax', 'zmin', 'zmax', 'title',
                              'showprofile']
                 def __init__(self):
                     Operation.__init__(self)
                     self.isConfig = False
                     self.isPlotConfig = False
                     self.save_counter = 1
                     self.sender_counter = 1
                     self.data = None
                     self.firsttime = True
                     self.plots_adjust = {'left': 0.125, 'right': 0.9, 'bottom': 0.15, 'top': 0.9, 'wspace': 0.2, 'hspace': 0.2}
                 def __fmtTime(self, x, pos):
                     '''
                     '''
                     return '{}'.format(self.getDateTime(x).strftime('%H:%M'))
                 def __setup(self, **kwargs):
                     '''
                     Initialize variables
                     '''
                     self.figures = []
                     self.axes = []
                     self.cb_axes = []
                     self.localtime = kwargs.pop('localtime', True)
                     self.show = kwargs.get('show', True)
                     self.save = kwargs.get('save', False)
                     self.save_period = kwargs.get('save_period', 1)
                     self.ftp = kwargs.get('ftp', False)
                     self.colormap = kwargs.get('colormap', self.colormap)
                     self.colormap_coh = kwargs.get('colormap_coh', 'jet')
                     self.colormap_phase = kwargs.get('colormap_phase', 'RdBu_r')
                     self.colormaps = kwargs.get('colormaps', None)
                     self.bgcolor = kwargs.get('bgcolor', self.bgcolor)
                     self.showprofile = kwargs.get('showprofile', False)
                     self.title = kwargs.get('wintitle', self.CODE.upper())
                     self.cb_label = kwargs.get('cb_label', None)
                     self.cb_labels = kwargs.get('cb_labels', None)
                     self.labels = kwargs.get('labels', None)
                     self.xaxis = kwargs.get('xaxis', 'frequency')
                     self.zmin = kwargs.get('zmin', None)
                     self.zmax = kwargs.get('zmax', None)
                     self.zlimits = kwargs.get('zlimits', None)
                     self.xmin = kwargs.get('xmin', None)
                     self.xmax = kwargs.get('xmax', None)
                     self.xrange = kwargs.get('xrange', 24)
                     self.xscale = kwargs.get('xscale', None)
                     self.ymin = kwargs.get('ymin', None)
                     self.ymax = kwargs.get('ymax', None)
                     self.yscale = kwargs.get('yscale', None)
                     self.xlabel = kwargs.get('xlabel', None)
                     self.attr_time = kwargs.get('attr_time', 'utctime')
                     self.decimation = kwargs.get('decimation', None)
                     self.showSNR = kwargs.get('showSNR', False)
                     self.oneFigure = kwargs.get('oneFigure', True)
                     self.width = kwargs.get('width', None)
                     self.height = kwargs.get('height', None)
                     self.colorbar = kwargs.get('colorbar', True)
                     self.factors = kwargs.get('factors', [1, 1, 1, 1, 1, 1, 1, 1])
                     self.channels = kwargs.get('channels', None)
                     self.titles = kwargs.get('titles', [])
                     self.polar = False
                     self.type = kwargs.get('type', 'iq')
                     self.grid = kwargs.get('grid', False)
                     self.pause = kwargs.get('pause', False)
                     self.save_code = kwargs.get('save_code', None)
                     self.realtime = kwargs.get('realtime', True)
                     self.throttle = kwargs.get('throttle', 0)
                     self.exp_code = kwargs.get('exp_code', None)
                     self.plot_server = kwargs.get('plot_server', False)
                     self.sender_period = kwargs.get('sender_period', 1)
                     self.height_index = kwargs.get('height_index', None)
                     self.__throttle_plot = apply_throttle(self.throttle)
                     self.data = PlotterData(
                         self.CODE, self.throttle, self.exp_code, self.buffering, snr=self.showSNR)
                     if self.plot_server:
                         if not self.plot_server.startswith('tcp://'):
                             self.plot_server = 'tcp://{}'.format(self.plot_server)
                         log.success(
                             'Sending to server: {}'.format(self.plot_server),
                             self.name
                         )
                     if 'plot_name' in kwargs:
                         self.plot_name = kwargs['plot_name']
                 def __setup_plot(self):
                     '''
                     Common setup for all figures, here figures and axes are created
                     '''
                     self.setup()
                     self.time_label = 'LT' if self.localtime else 'UTC'
                     if self.width is None:
                         self.width = 8
                     self.figures = []
                     self.axes = []
                     self.cb_axes = []
                     self.pf_axes = []
                     self.cmaps = []
                     size = '15%' if self.ncols == 1 else '30%'
                     pad = '4%' if self.ncols == 1 else '8%'
                     if self.oneFigure:
                         if self.height is None:
                             self.height = 1.4 * self.nrows + 1
                         fig = plt.figure(figsize=(self.width, self.height),
                                          edgecolor='k',
                                          facecolor='w')
                         self.figures.append(fig)
                         for n in range(self.nplots):
                             ax = fig.add_subplot(self.nrows, self.ncols,
                                                  n + 1, polar=self.polar)
                             ax.tick_params(labelsize=8)
                             ax.firsttime = True
                             ax.index = 0
                             ax.press = None
                             self.axes.append(ax)
                             if self.showprofile:
                                 cax = self.__add_axes(ax, size=size, pad=pad)
                                 cax.tick_params(labelsize=8)
                                 self.pf_axes.append(cax)
                     else:
                         if self.height is None:
                             self.height = 3
                         for n in range(self.nplots):
                             fig = plt.figure(figsize=(self.width, self.height),
                                              edgecolor='k',
                                              facecolor='w')
                             ax = fig.add_subplot(1, 1, 1, polar=self.polar)
                             ax.tick_params(labelsize=8)
                             ax.firsttime = True
                             ax.index = 0
                             ax.press = None
                             self.figures.append(fig)
                             self.axes.append(ax)
                             if self.showprofile:
                                 cax = self.__add_axes(ax, size=size, pad=pad)
                                 cax.tick_params(labelsize=8)
                                 self.pf_axes.append(cax)
                     for n in range(self.nrows):
                         if self.colormaps is not None:
                             cmap = plt.get_cmap(self.colormaps[n])
                         else:
                             cmap = plt.get_cmap(self.colormap)
                         cmap.set_bad(self.bgcolor, 1.)
                         self.cmaps.append(cmap)
                 def __add_axes(self, ax, size='30%', pad='8%'):
                     '''
                     Add new axes to the given figure
                     '''
                     divider = make_axes_locatable(ax)
                     nax = divider.new_horizontal(size=size, pad=pad)
                     ax.figure.add_axes(nax)
                     return nax
                 def fill_gaps(self, x_buffer, y_buffer, z_buffer):
                     '''
                     Create a masked array for missing data
                     '''
                     if x_buffer.shape[0] < 2:
                         return x_buffer, y_buffer, z_buffer
                     deltas = x_buffer[1:] - x_buffer[0:-1]
                     x_median = numpy.median(deltas)
                     index = numpy.where(deltas > 5 * x_median)
                     if len(index[0]) != 0:
                         z_buffer[::, index[0], ::] = self.__missing
                         z_buffer = numpy.ma.masked_inside(z_buffer,
 .99 * self.__missing,
 .01 * self.__missing)
                     return x_buffer, y_buffer, z_buffer
                 def decimate(self):
                     # dx = int(len(self.x)/self.__MAXNUMX) + 1
                     dy = int(len(self.y) / self.decimation) + 1
                     # x = self.x[::dx]
                     x = self.x
                     y = self.y[::dy]
                     z = self.z[::, ::, ::dy]
                     return x, y, z
                 def format(self):
                     '''
                     Set min and max values, labels, ticks and titles
                     '''
                     if self.xmin is None:
                         xmin = self.data.min_time
                     else:
                         if self.xaxis is 'time':
                             dt = self.getDateTime(self.data.min_time)
                             xmin = (dt.replace(hour=int(self.xmin), minute=0, second=0) -
                                     datetime.datetime(1970, 1, 1)).total_seconds()
                             if self.data.localtime:
                                 xmin += time.timezone
                         else:
                             xmin = self.xmin
                     if self.xmax is None:
                         xmax = xmin + self.xrange * 60 * 60
                     else:
                         if self.xaxis is 'time':
                             dt = self.getDateTime(self.data.max_time)
                             xmax = self.xmax - 1
                             xmax = (dt.replace(hour=int(xmax), minute=59, second=59) -
                                     datetime.datetime(1970, 1, 1) + datetime.timedelta(seconds=1)).total_seconds()
                             if self.data.localtime:
                                 xmax += time.timezone
                         else:
                             xmax = self.xmax
                     ymin = self.ymin if self.ymin else numpy.nanmin(self.y)
                     ymax = self.ymax if self.ymax else numpy.nanmax(self.y)
                     for n, ax in enumerate(self.axes):
                         if ax.firsttime:
                             dig = int(numpy.log10(ymax))
                             if dig == 0:
                                 digD = len(str(ymax)) - 2
                                 ydec = ymax*(10**digD)
                                 dig = int(numpy.log10(ydec))
                                 ystep = ((ydec + (10**(dig)))//10**(dig))*(10**(dig))
                                 ystep = ystep/5
                                 ystep = ystep/(10**digD)
                             else:
                                 ystep = ((ymax + (10**(dig)))//10**(dig))*(10**(dig))
                                 ystep = ystep/5
                             if self.xaxis is not 'time':
                                 dig = int(numpy.log10(xmax))
                                 if dig <= 0:
                                     digD = len(str(xmax)) - 2
                                     xdec = xmax*(10**digD)
                                     dig = int(numpy.log10(xdec))
                                     xstep = ((xdec + (10**(dig)))//10**(dig))*(10**(dig))
                                     xstep = xstep*0.5
                                     xstep = xstep/(10**digD)
                                 else:
                                     xstep = ((xmax + (10**(dig)))//10**(dig))*(10**(dig))
                                     xstep = xstep/5
                             ax.set_facecolor(self.bgcolor)
                             ax.yaxis.set_major_locator(MultipleLocator(ystep))
                             if self.xscale:
                                 ax.xaxis.set_major_formatter(FuncFormatter(
                                     lambda x, pos: '{0:g}'.format(x*self.xscale)))
                             if self.xscale:
                                 ax.yaxis.set_major_formatter(FuncFormatter(
                                     lambda x, pos: '{0:g}'.format(x*self.yscale)))
                             if self.xaxis is 'time':
                                 ax.xaxis.set_major_formatter(FuncFormatter(self.__fmtTime))
                                 ax.xaxis.set_major_locator(LinearLocator(9))
                             else:
                                 ax.xaxis.set_major_locator(MultipleLocator(xstep))
                             if self.xlabel is not None:
                                 ax.set_xlabel(self.xlabel)
                             ax.set_ylabel(self.ylabel)
                             ax.firsttime = False
                             if self.showprofile:
                                 self.pf_axes[n].set_ylim(ymin, ymax)
                                 self.pf_axes[n].set_xlim(self.zmin, self.zmax)
                                 self.pf_axes[n].set_xlabel('dB')
                                 self.pf_axes[n].grid(b=True, axis='x')
                                 [tick.set_visible(False)
                                  for tick in self.pf_axes[n].get_yticklabels()]
                             if self.colorbar:
                                 ax.cbar = plt.colorbar(
                                     ax.plt, ax=ax, fraction=0.05, pad=0.02, aspect=10)
                                 ax.cbar.ax.tick_params(labelsize=8)
                                 ax.cbar.ax.press = None
                                 if self.cb_label:
                                     ax.cbar.set_label(self.cb_label, size=8)
                                 elif self.cb_labels:
                                     ax.cbar.set_label(self.cb_labels[n], size=8)
                             else:
                                 ax.cbar = None
                         if self.grid:
                             ax.grid(True)
                         if not self.polar:
                             ax.set_xlim(xmin, xmax)
                             ax.set_ylim(ymin, ymax)
                             ax.set_title('{} {} {}'.format(
                                 self.titles[n],
                                 self.getDateTime(self.data.max_time).strftime(
                                     '%Y-%m-%d %H:%M:%S'),
                                 self.time_label),
                                 size=8)
                         else:
                             ax.set_title('{}'.format(self.titles[n]), size=8)
                             ax.set_ylim(0, 90)
                             ax.set_yticks(numpy.arange(0, 90, 20))
                             ax.yaxis.labelpad = 40
                     if self.firsttime:
                         for n, fig in enumerate(self.figures):
                             fig.subplots_adjust(**self.plots_adjust)
                         self.firsttime = False
                 def clear_figures(self):
                     '''
                     Reset axes for redraw plots
                     '''
                     for ax in self.axes+self.pf_axes+self.cb_axes:
                         ax.clear()
                         ax.firsttime = True
                         if ax.cbar:
                             ax.cbar.remove()
                 def __plot(self):
                     '''
                     Main function to plot, format and save figures
                     '''
                     self.plot()
                     self.format()
                     for n, fig in enumerate(self.figures):
                         if self.nrows == 0 or self.nplots == 0:
                             log.warning('No data', self.name)
                             fig.text(0.5, 0.5, 'No Data', fontsize='large', ha='center')
                             fig.canvas.manager.set_window_title(self.CODE)
                             continue
                         fig.canvas.manager.set_window_title('{} - {}'.format(self.title,
                                                                              self.getDateTime(self.data.max_time).strftime('%Y/%m/%d')))
                         fig.canvas.draw()
                         if self.show:
                             fig.show()
                             figpause(0.01)
                         if self.save:
                             self.save_figure(n)
                     if self.plot_server:
                         self.send_to_server()
                 def save_figure(self, n):
                     '''
                     '''
                     if self.save_counter < self.save_period:
                         self.save_counter += 1
                         return
                     self.save_counter = 1
                     fig = self.figures[n]
                     if self.save_code:
                         if isinstance(self.save_code, str):
                             labels = [self.save_code for x in self.figures]
                         else:
                             labels = self.save_code
                     else:
                         labels = [self.CODE for x in self.figures]
                     figname = os.path.join(
                         self.save,
                         labels[n],
                         '{}_{}.png'.format(
                             labels[n],
                             self.getDateTime(self.data.max_time).strftime(
                                 '%Y%m%d_%H%M%S'
                                 ),
                             )
                         )
                     log.log('Saving figure: {}'.format(figname), self.name)
                     if not os.path.isdir(os.path.dirname(figname)):
                         os.makedirs(os.path.dirname(figname))
                     fig.savefig(figname)
                     if self.throttle == 0:
                         figname = os.path.join(
                             self.save,
                             '{}_{}.png'.format(
                                 labels[n],
                                 self.getDateTime(self.data.min_time).strftime(
                                     '%Y%m%d'
                                     ),
                                 )
                             )
                         fig.savefig(figname)
                 def send_to_server(self):
                     '''
                     '''
                     if self.sender_counter < self.sender_period:
                         self.sender_counter += 1
                         return
                     self.sender_counter = 1
                     self.data.meta['titles'] = self.titles
                     retries = 2
                     while True:
                         self.socket.send_string(self.data.jsonify(self.plot_name, self.plot_type))
                         socks = dict(self.poll.poll(5000))
                         if socks.get(self.socket) == zmq.POLLIN:
                             reply = self.socket.recv_string()
                             if reply == 'ok':
                                 log.log("Response from server ok", self.name)
                                 break
                             else:
                                 log.warning(
                                     "Malformed reply from server: {}".format(reply), self.name)
                         else:
                             log.warning(
                                 "No response from server, retrying...", self.name)
                         self.socket.setsockopt(zmq.LINGER, 0)
                         self.socket.close()
                         self.poll.unregister(self.socket)
                         retries -= 1
                         if retries == 0:
                             log.error(
                                 "Server seems to be offline, abandoning", self.name)
                             self.socket = self.context.socket(zmq.REQ)
                             self.socket.connect(self.plot_server)
                             self.poll.register(self.socket, zmq.POLLIN)
                             time.sleep(1)
                             break
                         self.socket = self.context.socket(zmq.REQ)
                         self.socket.connect(self.plot_server)
                         self.poll.register(self.socket, zmq.POLLIN)
                         time.sleep(0.5)
                 def setup(self):
                     '''
                     This method should be implemented in the child class, the following
                     attributes should be set:
                     self.nrows: number of rows
                     self.ncols: number of cols
                     self.nplots: number of plots (channels or pairs)
                     self.ylabel: label for Y axes
                     self.titles: list of axes title
                     '''
                     raise NotImplementedError
                 def plot(self):
                     '''
                     Must be defined in the child class
                     '''
                     raise NotImplementedError
                 def run(self, dataOut, **kwargs):
                     '''
                     Main plotting routine
                     '''
                     if self.isConfig is False:
                         self.__setup(**kwargs)
                         t = getattr(dataOut, self.attr_time)
                         if dataOut.useLocalTime:
                             self.getDateTime = datetime.datetime.fromtimestamp
                             if not self.localtime:
                                 t += time.timezone
                         else:
                             self.getDateTime = datetime.datetime.utcfromtimestamp
                             if self.localtime:
                                 t -= time.timezone
                         if 'buffer' in self.plot_type:
                             if self.xmin is None:
                                 self.tmin = t
                                 self.xmin = self.getDateTime(t).hour
                             else:
                                 self.tmin = (
                                     self.getDateTime(t).replace(
                                         hour=int(self.xmin),
                                         minute=0,
                                         second=0) - self.getDateTime(0)).total_seconds()
                         self.data.setup()
                         self.isConfig = True
                         if self.plot_server:
                             self.context = zmq.Context()
                             self.socket = self.context.socket(zmq.REQ)
                             self.socket.connect(self.plot_server)
                             self.poll = zmq.Poller()
                             self.poll.register(self.socket, zmq.POLLIN)
                     tm = getattr(dataOut, self.attr_time)
                     if not dataOut.useLocalTime and self.localtime:
                         tm -= time.timezone
                     if dataOut.useLocalTime and not self.localtime:
                         tm += time.timezone
                     if self.xaxis is 'time' and self.data and (tm - self.tmin) >= self.xrange*60*60:
                         self.save_counter = self.save_period
                         self.__plot()
                         self.xmin += self.xrange
                         if self.xmin >= 24:
                             self.xmin -= 24
                         self.tmin += self.xrange*60*60
                         self.data.setup()
                         self.clear_figures()
                     self.data.update(dataOut, tm)
                     if self.isPlotConfig is False:
                         self.__setup_plot()
                         self.isPlotConfig = True
                     if self.throttle == 0:
                         self.__plot()
                     else:
                         self.__throttle_plot(self.__plot)#, coerce=coerce)
                 def close(self):
-                    if not self.data.flagNoData:
+                    if self.data and not self.data.flagNoData:
                         self.save_counter = self.save_period
                         self.__plot()
-                    if not self.data.flagNoData and self.pause:
+                    if self.data and not self.data.flagNoData and self.pause:
                         figpause(10)

schainpy/model/proc/jroproc_base.py +1 -1

             '''
             Base clases to create Processing units and operations, the MPDecorator
             must be used in plotting and writing operations to allow to run as an
             external process.
             '''
             import inspect
             import zmq
             import time
             import pickle
             import traceback
             try:
                 from queue import Queue
             except:
                 from Queue import Queue
             from threading import Thread
             from multiprocessing import Process, Queue
             from schainpy.utils import log
             class ProcessingUnit(object):
                 '''
                 Base class to create Signal Chain Units
                 '''
                 proc_type = 'processing'
                 def __init__(self):
                     self.dataIn = None
                     self.dataOut = None
                     self.isConfig = False
                     self.operations = []
                 def setInput(self, unit):
                     self.dataIn = unit.dataOut
                 def getAllowedArgs(self):
                     if hasattr(self, '__attrs__'):
                         return self.__attrs__
                     else:
                         return inspect.getargspec(self.run).args
                 def addOperation(self, conf, operation):
                     '''
                     '''
                     self.operations.append((operation, conf.type, conf.getKwargs()))
                 def getOperationObj(self, objId):
                     if objId not in list(self.operations.keys()):
                         return None
                     return self.operations[objId]
                 def call(self, **kwargs):
                     '''
                     '''
                     try:
                         if self.dataIn is not None and self.dataIn.flagNoData and not self.dataIn.error:
                             return self.dataIn.isReady()
                         elif self.dataIn is None or not self.dataIn.error:
                             self.run(**kwargs)
                         elif self.dataIn.error:
                             self.dataOut.error = self.dataIn.error
                             self.dataOut.flagNoData = True
                     except:
                         err = traceback.format_exc()
                         if 'SchainWarning' in err:
                             log.warning(err.split('SchainWarning:')[-1].split('\n')[0].strip(), self.name)
                         elif 'SchainError' in err:
                             log.error(err.split('SchainError:')[-1].split('\n')[0].strip(), self.name)
                         else:
-                            log.error(err, self.name)
+                            log.error(err.split('\n')[-2], self.name)
                         self.dataOut.error = True
                     for op, optype, opkwargs in self.operations:
                         if optype == 'other' and not self.dataOut.flagNoData:
                             self.dataOut = op.run(self.dataOut, **opkwargs)
                         elif optype == 'external' and not self.dataOut.flagNoData:
                             op.queue.put(self.dataOut)
                         elif optype == 'external' and self.dataOut.error:
                             op.queue.put(self.dataOut)
                     return 'Error' if self.dataOut.error else self.dataOut.isReady()
                 def setup(self):
                     raise NotImplementedError
                 def run(self):
                     raise NotImplementedError
                 def close(self):
                     return
             class Operation(object):
                 '''
                 '''
                 proc_type = 'operation'
                 def __init__(self):
                     self.id = None
                     self.isConfig = False
                     if not hasattr(self, 'name'):
                         self.name = self.__class__.__name__
                 def getAllowedArgs(self):
                     if hasattr(self, '__attrs__'):
                         return self.__attrs__
                     else:
                         return inspect.getargspec(self.run).args
                 def setup(self):
                     self.isConfig = True
                     raise NotImplementedError
                 def run(self, dataIn, **kwargs):
                     """
                     Realiza las operaciones necesarias sobre la dataIn.data y actualiza los
                     atributos del objeto dataIn.
                     Input:
                         dataIn    :    objeto del tipo JROData
                     Return:
                         None
                     Affected:
                         __buffer    :    buffer de recepcion de datos.
                     """
                     if not self.isConfig:
                         self.setup(**kwargs)
                     raise NotImplementedError
                 def close(self):
                     return
             def MPDecorator(BaseClass):
                 """
                 Multiprocessing class decorator
                 This function add multiprocessing features to a BaseClass.
                 """
                 class MPClass(BaseClass, Process):
                     def __init__(self, *args, **kwargs):
                         super(MPClass, self).__init__()
                         Process.__init__(self)
                         self.args = args
                         self.kwargs = kwargs
                         self.t = time.time()
                         self.op_type = 'external'
                         self.name = BaseClass.__name__
                         self.__doc__ = BaseClass.__doc__
                         if 'plot' in self.name.lower() and not self.name.endswith('_'):
                             self.name = '{}{}'.format(self.CODE.upper(), 'Plot')
                         self.start_time = time.time()
                         self.err_queue = args[3]
                         self.queue = Queue(maxsize=1)
                         self.myrun = BaseClass.run
                     def run(self):
                         while True:
                             dataOut = self.queue.get()
                             if not dataOut.error:
                                 try:
                                     BaseClass.run(self, dataOut, **self.kwargs)
                                 except:
                                     err = traceback.format_exc()
                                     log.error(err.split('\n')[-2], self.name)
                             else:
                                 break
                         self.close()
                     def close(self):
                         BaseClass.close(self)
                         log.success('Done...(Time:{:4.2f} secs)'.format(time.time()-self.start_time), self.name)
                 return MPClass

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages