schain Commit - r1080:af3edc5dd0e9 · Jicamarca Repository

kwargs restantes. Templates y changelog actualizado

José Chávez -

r1080:af3edc5dd0e9

parent child

Context file:

r1080:af3edc5dd0e9

Collapse all files

The requested changes are too big and content was truncated. Show full diff

schaincli/templates.py +5 -3

             basic = '''from schainpy.controller import Project
             desc = "{desc}"
             project = Project()
             project.setup(id='200', name="{name}", description=desc)
             voltage_reader = project.addReadUnit(datatype='VoltageReader',
                                                   path="{path}",
                                                   startDate="{startDate}",
                                                   endDate="{endDate}",
                                                   startTime="{startHour}",
                                                   endTime="{endHour}",
                                                   online=0,
                                                   verbose=1,
                                                   walk=1,
                                                   )
             voltage_proc = project.addProcUnit(datatype='VoltageProc', inputId=voltage_reader.getId())
             profile = voltage_proc.addOperation(name='ProfileSelector', optype='other')
             profile.addParameter(name='profileRangeList', value='120,183', format='intlist')
             rti = voltage_proc.addOperation(name='RTIPlot', optype='other')
             rti.addParameter(name='wintitle', value='Jicamarca Radio Observatory', format='str')
             rti.addParameter(name='showprofile', value='0', format='int')
             rti.addParameter(name='xmin', value='0', format='int')
             rti.addParameter(name='xmax', value='24', format='int')
             rti.addParameter(name='figpath', value="{figpath}", format='str')
             rti.addParameter(name='wr_period', value='5', format='int')
             rti.addParameter(name='exp_code', value='22', format='int')
             controller.start()
             '''
             multiprocess = '''from schainpy.controller import Project, MPProject
             from time import sleep
             desc = "{desc}"
             ####################
             # PLOTTER RECEIVER #
             ####################
             plotter = Project()
             plotter.setup(id='100', name='receiver', description=desc)
-            receiver_proc = plotter.addProcUnit(name='PlotterReceiver')
+            receiver_plot = plotter.addProcUnit(name='PlotterReceiver')
-            receiver_proc.addParameter(name='throttle', value=20, format='int')
+            receiver_plot.addParameter(name='throttle', value=20, format='int')
+            receiver_plot.addParameter(name='plottypes', value='rti', format='str')
-            rti = receiver_proc.addOperation(name='PlotRTIData', optype='other')
+            rti = receiver_plot.addOperation(name='PlotRTIData', optype='other')
             rti.addParameter(name='zmin', value='-40.0', format='float')
             rti.addParameter(name='zmax', value='100.0', format='float')
+            rti.addParameter(name='decimation', value='200', format='int')
             rti.addParameter(name='xmin', value='0.0', format='int')
             rti.addParameter(name='colormap', value='jet', format='str')
             plotter.start()
             sleep(2)
             ################
             # DATA EMITTER #
             ################
             project = Project()
             project.setup(id='200', name="{name}", description=desc)
             spectra_reader = project.addReadUnit(datatype='SpectraReader',
                                                     path="{path}",
                                                     startDate={startDate},
                                                     endDate={endDate},
                                                     startTime="{startHour}",
                                                     endTime="{endHour}",
                                                     online=0,
                                                     verbose=1,
                                                     walk=1,
                                                     )
             spectra_proc = project.addProcUnit(datatype='Spectra', inputId=spectra_reader.getId())
             parameters_proc = project.addProcUnit(datatype='ParametersProc', inputId=spectra_proc.getId())
             moments = parameters_proc.addOperation(name='SpectralMoments', optype='other')
             publish = parameters_proc.addOperation(name='PublishData', optype='other')
             publish.addParameter(name='zeromq', value=1, format='int')
             publish.addParameter(name='verbose', value=0, format='bool')
             MPProject(project, 16)
             '''

schainpy/CHANGELOG.md +2 -2

             ## CHANGELOG:
             ### 2.3
-            * Added high order function `multiSchain` for multiprocessing scripts.
+            * Added high order function `MPProject` for multiprocessing scripts.
             * Added two new Processing Units `PublishData` and `ReceiverData` for receiving and sending dataOut through multiple ways (tcp, ipc, inproc).
             * Added a new graphics Processing Unit `PlotterReceiver`. It is decoupled from normal processing sequence with support for data generated by multiprocessing scripts.
             * Added support for sending realtime graphic to web server.
-            * GUI command `schain`  is now `schainGUI`.
+            * GUI command `schain` is now `schainGUI`.
             * Added a CLI tool named `schain`.
             	* Scripts templates can be now generated with `schain generate`.
             	* Now it is possible to search Processing Units and Operations with `schain search [module]` to get the right name and its allowed parameters.
             	* `schain xml` to run xml scripts.
             * Added suggestions when parameters are poorly written.
             * `Controller.start()` now runs in a different process than the process calling it.
             * Added `schainpy.utils.log` for log standarization.
             * Running script on online mode no longer ignores date and hour. Issue #1109.
             * Added support for receving voltage data directly from JARS (tcp, ipc).
             * Updated README for MAC OS GUI installation.
             * Setup now installs numpy.
             ### 2.2.6
             * Graphics generated by the GUI are now the same as generated by scripts. Issue #1074.
             * Added support for C extensions.
             * Function `hildebrand_sehkon` optimized with a C wrapper.
             * Numpy version updated.
             * Migration to GIT.
             ### 2.2.5:
             * splitProfiles and combineProfiles modules were added to VoltageProc and Signal Chain GUI.
             * nProfiles of USRP data (hdf5) is the number of profiles thera are in one second.
             * jroPlotter works directly with data objects instead of dictionaries
             * script "schain" was added to Signal Chain installer
             ### 2.2.4.1:
             * jroIO_usrp.py is update to read Sandra's data
             * decimation in Spectra and RTI plots is always enabled.
             * time* window option added to GUI
             ### 2.2.4:
             * jroproc_spectra_lags.py added to schainpy
             * Bug fixed in schainGUI: ProcUnit was created with the same id in some cases.
             * Bug fixed in jroHeaderIO: Header size validation.
             ### 2.2.3.1:
             * Filtering block by time has been added.
             * Bug fixed plotting RTI, CoherenceMap and others using xmin and xmax parameters. The first day worked
             properly but the next days did not.
             ### 2.2.3:
             * Bug fixed in GUI: Error getting(reading) Code value
             * Bug fixed in GUI: Flip option always needs channelList field
             * Bug fixed in jrodata: when one branch modified a value in "dataOut" (example: dataOut.code) this value
             was modified for every branch (because this was a reference). It was modified in data.copy()
             * Bug fixed in jroproc_voltage.profileSelector(): rangeList replaces to profileRangeList.
             ### 2.2.2:
             * VoltageProc: ProfileSelector, Reshape, Decoder with nTxs!=1 and getblock=True was tested
             * Rawdata and testRawdata.py added to Signal Chain project
             ### 2.2.1:
             * Bugs fixed in GUI
             * Views were improved in GUI
             * Support to MST* ISR experiments
             * Bug fixed getting noise using hyldebrant. (minimum number of points > 20%)
             * handleError added to jroplotter.py
             ### 2.2.0:
             * GUI: use of external plotter
             * Compatible with matplotlib 1.5.0
             ### 2.1.5:
             * serializer module added to Signal Chain
             * jroplotter.py added to Signal Chain
             ### 2.1.4.2:
             * A new Plotter Class was added
             * Project.start() does not accept filename as a parameter anymore
             ### 2.1.4.1:
             * Send notifications when an error different to ValueError is detected
             ### 2.1.4:
             * Sending error notifications to signal chain administrator
             * Login to email server added
             ### 2.1.3.3:
             * Colored Button Icons were added to GUI
             ### 2.1.3.2:
             * GUI: user interaction enhanced
             * controller_api.py: Safe access to ControllerThead
             ### 2.1.3.1:
             * GUI: every icon were resized
             * jroproc_voltage.py: Print a message when "Read from code" option is selected and the code is not defined inside data file
             ### 2.1.3:
             * jroplot_heispectra.py: SpectraHeisScope was not showing the right channels
             * jroproc_voltage.py: Bug fixed selecting profiles (self.nProfiles took a wrong value),
             					 Bug fixed selecting heights by block (selecting profiles instead heights)
             * jroproc_voltage.py: New feature added: decoding data by block using FFT.
             * jroIO_heispectra.py: Bug fixed in FitsReader. Using local Fits instance instead schainpy.mode.data.jrodata.Fits.
             * jroIO_heispectra.py: Channel index list does not exist.
             ### 2.1.2:
             * jroutils_ftp.py: Bug fixed, Any error sending file stopped the Server Thread
             				  Server thread opens and closes remote server each time file list is sent
             * jroplot_spectra.py: Noise path was not being created when noise data is saved.
             * jroIO_base.py: startTime can be greater than endTime. Example: SpreadF [18:00 *  07:00]

schainpy/model/graphics/jroplot_data.py +152 -128

             import os
             import time
             import glob
             import datetime
             from multiprocessing import Process
             import zmq
             import numpy
             import matplotlib
             import matplotlib.pyplot as plt
             from mpl_toolkits.axes_grid1 import make_axes_locatable
             from matplotlib.ticker import FuncFormatter, LinearLocator, MultipleLocator
             from schainpy.model.proc.jroproc_base import Operation
             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]
+            blu_values = matplotlib.pyplot.get_cmap(
-            ncmap = matplotlib.colors.LinearSegmentedColormap.from_list("jro", numpy.vstack((blu_values, jet_values)))
+                "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)
-            func = lambda x, pos: '{}'.format(datetime.datetime.fromtimestamp(x).strftime('%H:%M'))
-            UT1970 = datetime.datetime(1970, 1, 1) - datetime.timedelta(seconds=time.timezone)
+            def func(x, pos): return '{}'.format(
+                datetime.datetime.fromtimestamp(x).strftime('%H:%M'))
+            UT1970 = datetime.datetime(1970, 1, 1) - \
+                datetime.timedelta(seconds=time.timezone)
             CMAPS = [plt.get_cmap(s) for s in ('jro', 'jet', 'RdBu_r', 'seismic')]
             class PlotData(Operation, Process):
                 '''
                 Base class for Schain plotting operations
                 '''
                 CODE = 'Figure'
                 colormap = 'jro'
                 bgcolor = 'white'
                 CONFLATE = False
                 __MAXNUMX = 80
                 __missing = 1E30
                 def __init__(self, **kwargs):
                     Operation.__init__(self, plot=True, **kwargs)
                     Process.__init__(self)
                     self.kwargs['code'] = self.CODE
                     self.mp = False
                     self.data = None
                     self.isConfig = False
                     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.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.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.ymin = kwargs.get('ymin', None)
                     self.ymax = kwargs.get('ymax', None)
                     self.xlabel = kwargs.get('xlabel', None)
                     self.__MAXNUMY = kwargs.get('decimation', 100)
                     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.titles = ['' for __ in range(16)]
                 def __setup(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%'
+                    size = '15%' if self.ncols == 1 else '30%'
-                    pad = '4%' if self.ncols==1 else '8%'
+                    pad = '4%' if self.ncols == 1 else '8%'
                     if self.oneFigure:
                         if self.height is None:
-                            self.height = 1.4*self.nrows + 1
+                            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)
+                            ax = fig.add_subplot(self.nrows, self.ncols, n + 1)
                             ax.tick_params(labelsize=8)
                             ax.firsttime = True
                             ax.index = 0
                             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',
+                                             edgecolor='k',
-                                                facecolor='w')
+                                             facecolor='w')
                             ax = fig.add_subplot(1, 1, 1)
                             ax.tick_params(labelsize=8)
                             ax.firsttime = True
                             ax.index = 0
                             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)
                     for fig in self.figures:
                         fig.canvas.mpl_connect('key_press_event', self.event_key_press)
                 def event_key_press(self, event):
                     '''
                     '''
                     for ax in self.axes:
                         if ax == event.inaxes:
                             if event.key == 'down':
                                 ax.index += 1
                             elif event.key == 'up':
                                 ax.index -= 1
                             if ax.index < 0:
                                 ax.index = len(CMAPS) - 1
                             elif ax.index == len(CMAPS):
                                 ax.index = 0
                             cmap = CMAPS[ax.index]
                             ax.cbar.set_cmap(cmap)
                             ax.cbar.draw_all()
                             ax.plt.set_cmap(cmap)
                             ax.cbar.patch.figure.canvas.draw()
                 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
                     self.setup()
                 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, 'Implement this method in child class')
                 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)
+                    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,
+.99 * self.__missing,
-.01*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.__MAXNUMY) + 1
+                    dy = int(len(self.y) / self.__MAXNUMY) + 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.min_time
                     else:
                         if self.xaxis is 'time':
                             dt = datetime.datetime.fromtimestamp(self.min_time)
                             xmin = (datetime.datetime.combine(dt.date(),
-                                                            datetime.time(int(self.xmin), 0, 0))-UT1970).total_seconds()
+                                                              datetime.time(int(self.xmin), 0, 0)) - UT1970).total_seconds()
                         else:
                             xmin = self.xmin
                     if self.xmax is None:
-                        xmax = xmin+self.xrange*60*60
+                        xmax = xmin + self.xrange * 60 * 60
                     else:
                         if self.xaxis is 'time':
                             dt = datetime.datetime.fromtimestamp(self.min_time)
                             xmax = (datetime.datetime.combine(dt.date(),
-                                                            datetime.time(int(self.xmax), 0, 0))-UT1970).total_seconds()
+                                                              datetime.time(int(self.xmax), 0, 0)) - UT1970).total_seconds()
                         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)
-                    ystep = 200 if ymax>= 800 else 100 if ymax>=400 else 50 if ymax>=200 else 20
-                    for n, ax in enumerate(self.axes):
+                    ystep = 200 if ymax >= 800 else 100 if ymax >= 400 else 50 if ymax >= 200 else 20
+                    for n, ax in enumerate(self.axes):
                         if ax.firsttime:
                             ax.set_facecolor(self.bgcolor)
                             ax.yaxis.set_major_locator(MultipleLocator(ystep))
                             if self.xaxis is 'time':
                                 ax.xaxis.set_major_formatter(FuncFormatter(func))
                                 ax.xaxis.set_major_locator(LinearLocator(9))
                             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()]
+                                [tick.set_visible(False)
+                                 for tick in self.pf_axes[n].get_yticklabels()]
                             if self.colorbar:
                                 ax.cbar = plt.colorbar(ax.plt, ax=ax, pad=0.02, aspect=10)
                                 ax.cbar.ax.tick_params(labelsize=8)
                                 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)
                         ax.set_title('{} - {} {}'.format(
-                                self.titles[n],
+                            self.titles[n],
-                                datetime.datetime.fromtimestamp(self.max_time).strftime('%H:%M:%S'),
+                            datetime.datetime.fromtimestamp(
-                                self.time_label),
+                                self.max_time).strftime('%H:%M:%S'),
+                            self.time_label),
                             size=8)
                         ax.set_xlim(xmin, xmax)
                         ax.set_ylim(ymin, ymax)
                 def __plot(self):
                     '''
                     '''
                     log.success('Plotting', self.name)
                     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)
                             continue
                         if self.show:
                             fig.show()
                         fig.tight_layout()
                         fig.canvas.manager.set_window_title('{} - {}'.format(self.title,
                                                                              datetime.datetime.fromtimestamp(self.max_time).strftime('%Y/%m/%d')))
                         # fig.canvas.draw()
                         if self.save and self.data.ended:
                             channels = range(self.nrows)
                             if self.oneFigure:
                                 label = ''
                             else:
                                 label = '_{}'.format(channels[n])
                             figname = os.path.join(
                                 self.save,
                                 '{}{}_{}.png'.format(
                                     self.CODE,
                                     label,
-                                    datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d_%H%M%S')
+                                    datetime.datetime.fromtimestamp(
+                                        self.saveTime).strftime('%y%m%d_%H%M%S')
                                 )
                             )
                             print 'Saving figure: {}'.format(figname)
                             fig.savefig(figname)
                 def plot(self):
                     '''
                     '''
                     raise(NotImplementedError, 'Implement this method in child class')
                 def run(self):
                     log.success('Starting', self.name)
                     context = zmq.Context()
                     receiver = context.socket(zmq.SUB)
                     receiver.setsockopt(zmq.SUBSCRIBE, '')
                     receiver.setsockopt(zmq.CONFLATE, self.CONFLATE)
                     if 'server' in self.kwargs['parent']:
-                        receiver.connect('ipc:///tmp/{}.plots'.format(self.kwargs['parent']['server']))
+                        receiver.connect(
+                            'ipc:///tmp/{}.plots'.format(self.kwargs['parent']['server']))
                     else:
                         receiver.connect("ipc:///tmp/zmq.plots")
                     while True:
                         try:
                             self.data = receiver.recv_pyobj(flags=zmq.NOBLOCK)
                             if self.localtime:
                                 self.times = self.data.times - time.timezone
                             else:
                                 self.times = self.data.times
                             self.min_time = self.times[0]
                             self.max_time = self.times[-1]
                             if self.isConfig is False:
                                 self.__setup()
                                 self.isConfig = True
                             self.__plot()
                         except zmq.Again as e:
                             log.log('Waiting for data...')
                             if self.data:
                                 plt.pause(self.data.throttle)
                             else:
                                 time.sleep(2)
                 def close(self):
                     if self.data:
                         self.__plot()
             class PlotSpectraData(PlotData):
                 '''
                 Plot for Spectra data
                 '''
                 CODE = 'spc'
                 colormap = 'jro'
                 def setup(self):
                     self.nplots = len(self.data.channels)
-                    self.ncols = int(numpy.sqrt(self.nplots)+ 0.9)
+                    self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
-                    self.nrows = int((1.0*self.nplots/self.ncols) + 0.9)
+                    self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
-                    self.width = 3.4*self.ncols
+                    self.width = 3.4 * self.ncols
-                    self.height = 3*self.nrows
+                    self.height = 3 * self.nrows
                     self.cb_label = 'dB'
                     if self.showprofile:
-                        self.width += 0.8*self.ncols
+                        self.width += 0.8 * self.ncols
                     self.ylabel = 'Range [Km]'
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     if self.CODE == 'spc_mean':
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.heights
                     self.y = y
                     z = self.data['spc']
                     for n, ax in enumerate(self.axes):
                         noise = self.data['noise'][n][-1]
                         if self.CODE == 'spc_mean':
                             mean = self.data['mean'][n][-1]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
-                                                 vmin=self.zmin,
+                                                   vmin=self.zmin,
-                                                 vmax=self.zmax,
+                                                   vmax=self.zmax,
-                                                 cmap=plt.get_cmap(self.colormap)
+                                                   cmap=plt.get_cmap(self.colormap)
+                                                   )
                             if self.showprofile:
-                                ax.plt_profile= self.pf_axes[n].plot(self.data['rti'][n][-1], y)[0]
+                                ax.plt_profile = self.pf_axes[n].plot(
+                                    self.data['rti'][n][-1], y)[0]
                                 ax.plt_noise = self.pf_axes[n].plot(numpy.repeat(noise, len(y)), y,
-                                                                     color="k", linestyle="dashed", lw=1)[0]
+                                                                    color="k", linestyle="dashed", lw=1)[0]
                             if self.CODE == 'spc_mean':
                                 ax.plt_mean = ax.plot(mean, y, color='k')[0]
                         else:
                             ax.plt.set_array(z[n].T.ravel())
                             if self.showprofile:
                                 ax.plt_profile.set_data(self.data['rti'][n][-1], y)
                                 ax.plt_noise.set_data(numpy.repeat(noise, len(y)), y)
                             if self.CODE == 'spc_mean':
                                 ax.plt_mean.set_data(mean, y)
                         self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
                         self.saveTime = self.max_time
             class PlotCrossSpectraData(PlotData):
                 CODE = 'cspc'
                 zmin_coh = None
                 zmax_coh = None
                 zmin_phase = None
                 zmax_phase = None
                 def setup(self):
                     self.ncols = 4
                     self.nrows = len(self.data.pairs)
-                    self.nplots = self.nrows*4
+                    self.nplots = self.nrows * 4
-                    self.width = 3.4*self.ncols
+                    self.width = 3.4 * self.ncols
-                    self.height = 3*self.nrows
+                    self.height = 3 * self.nrows
                     self.ylabel = 'Range [Km]'
                     self.showprofile = False
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.heights
                     self.y = y
                     spc = self.data['spc']
                     cspc = self.data['cspc']
                     for n in range(self.nrows):
                         noise = self.data['noise'][n][-1]
                         pair = self.data.pairs[n]
-                        ax = self.axes[4*n]
+                        ax = self.axes[4 * n]
-                        ax3 = self.axes[4*n+3]
+                        ax3 = self.axes[4 * n + 3]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(spc)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(spc)
                             ax.plt = ax.pcolormesh(x, y, spc[pair[0]].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
+                                                   )
                         else:
                             ax.plt.set_array(spc[pair[0]].T.ravel())
                         self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
-                        ax = self.axes[4*n+1]
+                        ax = self.axes[4 * n + 1]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, spc[pair[1]].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(spc[pair[1]].T.ravel())
                         self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
-                        out = cspc[n]/numpy.sqrt(spc[pair[0]]*spc[pair[1]])
+                        out = cspc[n] / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
                         coh = numpy.abs(out)
-                        phase = numpy.arctan2(out.imag, out.real)*180/numpy.pi
+                        phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
-                        ax = self.axes[4*n+2]
+                        ax = self.axes[4 * n + 2]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, coh.T,
                                                    vmin=0,
                                                    vmax=1,
                                                    cmap=plt.get_cmap(self.colormap_coh)
                                                    )
                         else:
                             ax.plt.set_array(coh.T.ravel())
-                        self.titles.append('Coherence Ch{} * Ch{}'.format(pair[0], pair[1]))
+                        self.titles.append(
+                            'Coherence Ch{} * Ch{}'.format(pair[0], pair[1]))
-                        ax = self.axes[4*n+3]
+                        ax = self.axes[4 * n + 3]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, phase.T,
                                                    vmin=-180,
                                                    vmax=180,
                                                    cmap=plt.get_cmap(self.colormap_phase)
                                                    )
                         else:
                             ax.plt.set_array(phase.T.ravel())
                         self.titles.append('Phase CH{} * CH{}'.format(pair[0], pair[1]))
                         self.saveTime = self.max_time
             class PlotSpectraMeanData(PlotSpectraData):
                 '''
                 Plot for Spectra and Mean
                 '''
                 CODE = 'spc_mean'
                 colormap = 'jro'
             class PlotRTIData(PlotData):
                 '''
                 Plot for RTI data
                 '''
                 CODE = 'rti'
                 colormap = 'jro'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = len(self.data.channels)
                     self.nplots = len(self.data.channels)
                     self.ylabel = 'Range [Km]'
                     self.cb_label = 'dB'
-                    self.titles = ['{} Channel {}'.format(self.CODE.upper(), x) for x in range(self.nrows)]
+                    self.titles = ['{} Channel {}'.format(
+                        self.CODE.upper(), x) for x in range(self.nrows)]
                 def plot(self):
                     self.x = self.times
                     self.y = self.data.heights
                     self.z = self.data[self.CODE]
                     self.z = numpy.ma.masked_invalid(self.z)
                     for n, ax in enumerate(self.axes):
                         x, y, z = self.fill_gaps(*self.decimate())
                         self.zmin = self.zmin if self.zmin else numpy.min(self.z)
                         self.zmax = self.zmax if self.zmax else numpy.max(self.z)
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
-                                                 vmin=self.zmin,
+                                                   vmin=self.zmin,
-                                                 vmax=self.zmax,
+                                                   vmax=self.zmax,
-                                                 cmap=plt.get_cmap(self.colormap)
+                                                   cmap=plt.get_cmap(self.colormap)
+                                                   )
                             if self.showprofile:
-                                ax.plot_profile= self.pf_axes[n].plot(self.data['rti'][n][-1], self.y)[0]
+                                ax.plot_profile = self.pf_axes[n].plot(
+                                    self.data['rti'][n][-1], self.y)[0]
                                 ax.plot_noise = self.pf_axes[n].plot(numpy.repeat(self.data['noise'][n][-1], len(self.y)), self.y,
                                                                      color="k", linestyle="dashed", lw=1)[0]
                         else:
                             ax.collections.remove(ax.collections[0])
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
+                                                   )
                             if self.showprofile:
                                 ax.plot_profile.set_data(self.data['rti'][n][-1], self.y)
-                                ax.plot_noise.set_data(numpy.repeat(self.data['noise'][n][-1], len(self.y)), self.y)
+                                ax.plot_noise.set_data(numpy.repeat(
+                                    self.data['noise'][n][-1], len(self.y)), self.y)
                     self.saveTime = self.min_time
             class PlotCOHData(PlotRTIData):
                 '''
                 Plot for Coherence data
                 '''
                 CODE = 'coh'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = len(self.data.pairs)
                     self.nplots = len(self.data.pairs)
                     self.ylabel = 'Range [Km]'
                     if self.CODE == 'coh':
                         self.cb_label = ''
-                        self.titles = ['Coherence Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
+                        self.titles = [
+                            'Coherence Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
                     else:
                         self.cb_label = 'Degrees'
-                        self.titles = ['Phase Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
+                        self.titles = [
+                            'Phase Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
             class PlotPHASEData(PlotCOHData):
                 '''
                 Plot for Phase map data
                 '''
                 CODE = 'phase'
                 colormap = 'seismic'
             class PlotNoiseData(PlotData):
                 '''
                 Plot for noise
                 '''
                 CODE = 'noise'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Intensity [dB]'
                     self.titles = ['Noise']
                     self.colorbar = False
                 def plot(self):
                     x = self.times
                     xmin = self.min_time
-                    xmax = xmin+self.xrange*60*60
+                    xmax = xmin + self.xrange * 60 * 60
                     Y = self.data[self.CODE]
                     if self.axes[0].firsttime:
                         for ch in self.data.channels:
                             y = Y[ch]
                             self.axes[0].plot(x, y, lw=1, label='Ch{}'.format(ch))
                         plt.legend()
                     else:
                         for ch in self.data.channels:
                             y = Y[ch]
                             self.axes[0].lines[ch].set_data(x, y)
                     self.ymin = numpy.nanmin(Y) - 5
                     self.ymax = numpy.nanmax(Y) + 5
                     self.saveTime = self.min_time
             class PlotSNRData(PlotRTIData):
                 '''
                 Plot for SNR Data
                 '''
                 CODE = 'snr'
                 colormap = 'jet'
             class PlotDOPData(PlotRTIData):
                 '''
                 Plot for DOPPLER Data
                 '''
                 CODE = 'dop'
                 colormap = 'jet'
             class PlotSkyMapData(PlotData):
                 '''
                 Plot for meteors detection data
                 '''
                 CODE = 'met'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.width = 7.2
                     self.height = 7.2
                     self.xlabel = 'Zonal Zenith Angle (deg)'
                     self.ylabel = 'Meridional Zenith Angle (deg)'
                     if self.figure is None:
                         self.figure = plt.figure(figsize=(self.width, self.height),
                                                  edgecolor='k',
                                                  facecolor='w')
                     else:
                         self.figure.clf()
-                    self.ax = plt.subplot2grid((self.nrows, self.ncols), (0, 0), 1, 1, polar=True)
+                    self.ax = plt.subplot2grid(
+                        (self.nrows, self.ncols), (0, 0), 1, 1, polar=True)
                     self.ax.firsttime = True
                 def plot(self):
-                    arrayParameters = numpy.concatenate([self.data['param'][t] for t in self.times])
+                    arrayParameters = numpy.concatenate(
-                    error = arrayParameters[:,-1]
+                        [self.data['param'][t] for t in self.times])
+                    error = arrayParameters[:, -1]
                     indValid = numpy.where(error == 0)[0]
-                    finalMeteor = arrayParameters[indValid,:]
+                    finalMeteor = arrayParameters[indValid, :]
-                    finalAzimuth = finalMeteor[:,3]
+                    finalAzimuth = finalMeteor[:, 3]
-                    finalZenith = finalMeteor[:,4]
+                    finalZenith = finalMeteor[:, 4]
-                    x = finalAzimuth*numpy.pi/180
+                    x = finalAzimuth * numpy.pi / 180
                     y = finalZenith
                     if self.ax.firsttime:
                         self.ax.plot = self.ax.plot(x, y, 'bo', markersize=5)[0]
-                        self.ax.set_ylim(0,90)
+                        self.ax.set_ylim(0, 90)
-                        self.ax.set_yticks(numpy.arange(0,90,20))
+                        self.ax.set_yticks(numpy.arange(0, 90, 20))
                         self.ax.set_xlabel(self.xlabel)
                         self.ax.set_ylabel(self.ylabel)
                         self.ax.yaxis.labelpad = 40
                         self.ax.firsttime = False
                     else:
                         self.ax.plot.set_data(x, y)
+                    dt1 = datetime.datetime.fromtimestamp(
-                    dt1 = datetime.datetime.fromtimestamp(self.min_time).strftime('%y/%m/%d %H:%M:%S')
+                        self.min_time).strftime('%y/%m/%d %H:%M:%S')
-                    dt2 = datetime.datetime.fromtimestamp(self.max_time).strftime('%y/%m/%d %H:%M:%S')
+                    dt2 = datetime.datetime.fromtimestamp(
+                        self.max_time).strftime('%y/%m/%d %H:%M:%S')
                     title = 'Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n' % (dt1,
                                                                                                  dt2,
                                                                                                  len(x))
                     self.ax.set_title(title, size=8)
                     self.saveTime = self.max_time
             class PlotParamData(PlotRTIData):
                 '''
                 Plot for data_param object
                 '''
                 CODE = 'param'
                 colormap = 'seismic'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = self.data.shape(self.CODE)[0]
                     self.nplots = self.nrows
                     if self.showSNR:
                         self.nrows += 1
                         self.nplots += 1
                     self.ylabel = 'Height [Km]'
                     self.titles = self.data.parameters \
                         if self.data.parameters else ['Param {}'.format(x) for x in xrange(self.nrows)]
                     if self.showSNR:
                         self.titles.append('SNR')
                 def plot(self):
                     self.data.normalize_heights()
                     self.x = self.times
                     self.y = self.data.heights
                     if self.showSNR:
                         self.z = numpy.concatenate(
                             (self.data[self.CODE], self.data['snr'])
                         )
                     else:
                         self.z = self.data[self.CODE]
                     self.z = numpy.ma.masked_invalid(self.z)
                     for n, ax in enumerate(self.axes):
                         x, y, z = self.fill_gaps(*self.decimate())
                         if ax.firsttime:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
-                            self.zmax = self.zmax if self.zmax is not None else numpy.nanmax(abs(self.z[:-1, :]))
+                            self.zmax = self.zmax if self.zmax is not None else numpy.nanmax(
+                                abs(self.z[:-1, :]))
                             self.zmin = self.zmin if self.zmin is not None else -self.zmax
-                            ax.plt = ax.pcolormesh(x, y, z[n, :, :].T*self.factors[n],
+                            ax.plt = ax.pcolormesh(x, y, z[n, :, :].T * self.factors[n],
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n]
+                                                   )
                         else:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.collections.remove(ax.collections[0])
-                            ax.plt = ax.pcolormesh(x, y, z[n, :, :].T*self.factors[n],
+                            ax.plt = ax.pcolormesh(x, y, z[n, :, :].T * self.factors[n],
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n]
+                                                   )
                     self.saveTime = self.min_time
             class PlotOuputData(PlotParamData):
                 '''
                 Plot data_output object
                 '''
                 CODE = 'output'
                 colormap = 'seismic'

schainpy/model/proc/jroproc_amisr.py +8 -6

             '''
             @author: Daniel Suarez
             '''
             import numpy
             from jroproc_base import ProcessingUnit, Operation
             from schainpy.model.data.jroamisr import AMISR
             class AMISRProc(ProcessingUnit):
-                def __init__(self):
+                def __init__(self, **kwargs):
-                    ProcessingUnit.__init__(self)
+                    ProcessingUnit.__init__(self, **kwargs)
                     self.objectDict = {}
                     self.dataOut = AMISR()
                 def run(self):
                     if self.dataIn.type == 'AMISR':
                         self.dataOut.copy(self.dataIn)
             class PrintInfo(Operation):
-                def __init__(self):
+                def __init__(self, **kwargs):
+                    Operation.__init__(self, **kwargs)
                     self.__isPrinted = False
                 def run(self, dataOut):
                     if not self.__isPrinted:
                         print 'Number of Records by File: %d'%dataOut.nRecords
                         print 'Number of Pulses: %d'%dataOut.nProfiles
                         print 'Number of Pulses by Frame: %d'%dataOut.npulseByFrame
                         print 'Number of Samples by Pulse: %d'%len(dataOut.heightList)
                         print 'Ipp Seconds: %f'%dataOut.ippSeconds
                         print 'Number of Beams: %d'%dataOut.nBeams
                         print 'BeamCodes:'
                         beamStrList = ['Beam %d -> Code=%d, azimuth=%2.2f,  zenith=%2.2f, gain=%2.2f'%(k,v[0],v[1],v[2],v[3]) for k,v in dataOut.beamCodeDict.items()]
                         for b in beamStrList:
                             print b
                         self.__isPrinted = True
                     return
             class BeamSelector(Operation):
                 profileIndex = None
                 nProfiles = None
-                def __init__(self):
+                def __init__(self, **kwargs):
+                    Operation.__init__(self, **kwargs)
                     self.profileIndex = 0
                     self.__isConfig = False
                 def incIndex(self):
                     self.profileIndex += 1
                     if self.profileIndex >= self.nProfiles:
                         self.profileIndex = 0
                 def isProfileInRange(self, minIndex, maxIndex):
                     if self.profileIndex < minIndex:
                         return False
                     if self.profileIndex > maxIndex:
                         return False
                     return True
                 def isProfileInList(self, profileList):
                     if self.profileIndex not in profileList:
                         return False
                     return True
                 def run(self, dataOut, beam=None):
                     dataOut.flagNoData = True
                     if not(self.__isConfig):
                         self.nProfiles = dataOut.nProfiles
                         self.profileIndex = dataOut.profileIndex
                         self.__isConfig = True
                     if beam != None:
                         if self.isProfileInList(dataOut.beamRangeDict[beam]):
                             beamInfo = dataOut.beamCodeDict[beam]
                             dataOut.azimuth = beamInfo[1]
                             dataOut.zenith = beamInfo[2]
                             dataOut.gain = beamInfo[3]
                             dataOut.flagNoData = False
                         self.incIndex()
                         return 1
                     else:
                         raise ValueError, "BeamSelector needs beam value"
                     return 0
             class ProfileToChannels(Operation):
-                def __init__(self):
+                def __init__(self, **kwargs):
+                    Operation.__init__(self, **kwargs)
                     self.__isConfig = False
                     self.__counter_chan = 0
                     self.buffer = None
                 def isProfileInList(self, profileList):
                     if self.profileIndex not in profileList:
                         return False
                     return True
                 def run(self, dataOut):
                     dataOut.flagNoData = True
                     if not(self.__isConfig):
                         nchannels = len(dataOut.beamRangeDict.keys())
                         nsamples = dataOut.nHeights
                         self.buffer = numpy.zeros((nchannels, nsamples), dtype = 'complex128')
                         dataOut.beam.codeList = [dataOut.beamCodeDict[x][0] for x in range(nchannels)]
                         dataOut.beam.azimuthList = [dataOut.beamCodeDict[x][1] for x in range(nchannels)]
                         dataOut.beam.zenithList = [dataOut.beamCodeDict[x][2] for x in range(nchannels)]
                         self.__isConfig = True
                     for i in range(self.buffer.shape[0]):
                         if dataOut.profileIndex in dataOut.beamRangeDict[i]:
                             self.buffer[i,:] = dataOut.data
                             break
                     self.__counter_chan += 1
                     if self.__counter_chan >= self.buffer.shape[0]:
                         self.__counter_chan = 0
                         dataOut.data = self.buffer.copy()
                         dataOut.channelList = range(self.buffer.shape[0])
                         self.__isConfig = False
                         dataOut.flagNoData = False
                     pass
   No newline at end of file

schainpy/model/proc/jroproc_parameters.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

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