schain Commit - r1308:fe4d0955eff6 · Jicamarca Repository

Update plots modules

Juan C. Espinoza -

r1308:fe4d0955eff6

parent child

Context file:

r1308:fe4d0955eff6

Collapse all files

schainpy/controller.py +1 -1

                     className = eval(self.name)
-                    if 'Plot' in self.name or 'Writer' in self.name or 'Send' in self.name:
+                    if 'Plot' in self.name or 'Writer' in self.name or 'Send' in self.name or 'print' in self.name:
                         kwargs = self.getKwargs()
                         opObj = className(self.id, self.id, self.project_id, self.err_queue, **kwargs)
                         opObj.start()

schainpy/model/data/jrodata.py +22 -25

                     self.localtime = False
                     self.data = {}
                     self.meta = {}
-                    self.__times = []
                     self.__heights = []
                     if 'snr' in code:
                         self.plottypes = ['snr']
                     elif code == 'spc':
                         self.plottypes = ['spc', 'noise', 'rti']
+                    elif code == 'cspc':
+                        self.plottypes = ['cspc', 'spc', 'noise', 'rti']
                     elif code == 'rti':
                         self.plottypes = ['noise', 'rti']
                     else:
                 def __str__(self):
                     dum = ['{}{}'.format(key, self.shape(key)) for key in self.data]
-                    return 'Data[{}][{}]'.format(';'.join(dum), len(self.__times))
+                    return 'Data[{}][{}]'.format(';'.join(dum), len(self.times))
                 def __len__(self):
-                    return len(self.__times)
+                    return len(self.data[self.key])
                 def __getitem__(self, key):
                     if key not in self.data:
                         raise KeyError(log.error('Missing key: {}'.format(key)))
                     if 'spc' in key or not self.buffering:
-                        ret = self.data[key]
+                        ret = self.data[key][self.tm]
                     elif 'scope' in key:
                         ret = numpy.array(self.data[key][float(self.tm)])
                     else:
                     '''
                     self.type = ''
                     self.ready = False
+                    del self.data
                     self.data = {}
-                    self.__times = []
                     self.__heights = []
                     self.__all_heights = set()
                     for plot in self.plottypes:
                     if len(self.data[key]):
                         if 'spc' in key or not self.buffering:
                             return self.data[key].shape
-                        return self.data[key][self.__times[0]].shape
+                        return self.data[key][self.times[0]].shape
                     return (0,)
                 def update(self, dataOut, tm):
                     '''
                     Update data object with new dataOut
                     '''
-                    if tm in self.__times:
-                        return
                     self.profileIndex = dataOut.profileIndex
                     self.tm = tm
                     self.type = dataOut.type
                     if True in ['spc' in ptype for ptype in self.plottypes]:
                         self.xrange = (dataOut.getFreqRange(1)/1000.,
                                        dataOut.getAcfRange(1), dataOut.getVelRange(1))
-                        self.factor = dataOut.normFactor
                     self.__heights.append(dataOut.heightList)
                     self.__all_heights.update(dataOut.heightList)
-                    self.__times.append(tm)
                     for plot in self.plottypes:
                         if plot in ('spc', 'spc_moments', 'spc_cut'):
                             z = dataOut.data_spc/dataOut.normFactor
                             buffer = 10*numpy.log10(z)
                         if plot == 'cspc':
-                            z = dataOut.data_spc/dataOut.normFactor
                             buffer = (dataOut.data_spc, dataOut.data_cspc)
                         if plot == 'noise':
                             buffer = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
                             self.nProfiles = dataOut.nProfiles
                         if plot == 'spc':
-                            self.data['spc'] = buffer
+                            self.data['spc'][tm] = buffer
                         elif plot == 'cspc':
-                            self.data['spc'] = buffer[0]
+                            self.data['cspc'][tm] = buffer
-                            self.data['cspc'] = buffer[1]
                         elif plot == 'spc_moments':
-                            self.data['spc'] = buffer
+                            self.data['spc'][tm] = buffer
                             self.data['moments'][tm] = dataOut.moments
                         else:
                             if self.buffering:
                                 self.data[plot][tm] = buffer
                             else:
-                                self.data[plot] = buffer
+                                self.data[plot][tm] = buffer
                     if dataOut.channelList is None:
                         self.channels = range(buffer.shape[0])
                     for key in self.data:
                         shape = self.shape(key)[:-1] + H.shape
                         for tm, obj in list(self.data[key].items()):
-                            h = self.__heights[self.__times.index(tm)]
+                            h = self.__heights[self.times.index(tm)]
                             if H.size == h.size:
                                 continue
                             index = numpy.where(numpy.in1d(H, h))[0]
                                 dummy[index] = obj
                             self.data[key][tm] = dummy
-                    self.__heights = [H for tm in self.__times]
+                    self.__heights = [H for tm in self.times]
-                def jsonify(self, plot_name, plot_type, decimate=False):
+                def jsonify(self, tm, plot_name, plot_type, decimate=False):
                     '''
                     Convert data to json
                     '''
-                    tm = self.times[-1]
                     dy = int(self.heights.size/self.MAXNUMY) + 1
-                    if self.key in ('spc', 'cspc') or not self.buffering:
+                    if self.key in ('spc', 'cspc'):
-                        dx = int(self.data[self.key].shape[1]/self.MAXNUMX) + 1
+                        dx = int(self.data[self.key][tm].shape[1]/self.MAXNUMX) + 1
                         data = self.roundFloats(
-                            self.data[self.key][::, ::dx, ::dy].tolist())
+                            self.data[self.key][tm][::, ::dx, ::dy].tolist())
                     else:
                         if self.key is 'noise':
                             data = [[x] for x in self.roundFloats(self.data[self.key][tm].tolist())]
                     Return the list of times of the current data
                     '''
-                    ret = numpy.array(self.__times)
+                    ret = numpy.array([*self.data[self.key]])
-                    ret.sort()
+                    if self:
+                        ret.sort()
                     return ret
                 @property

schainpy/model/graphics/jroplot_base.py +33 -21

                     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.xrange = kwargs.get('xrange', 12)
                     self.xscale = kwargs.get('xscale', None)
                     self.ymin = kwargs.get('ymin', None)
                     self.ymax = kwargs.get('ymax', None)
                     self.exp_code = kwargs.get('exp_code', None)
                     self.plot_server = kwargs.get('plot_server', False)
                     self.sender_period = kwargs.get('sender_period', 60)
+                    self.tag = kwargs.get('tag', '')
                     self.height_index = kwargs.get('height_index', None)
                     self.__throttle_plot = apply_throttle(self.throttle)
                     self.data = PlotterData(
                     self.sender_time = self.data.tm
-                    attrs = ['titles', 'zmin', 'zmax', 'colormap']
+                    attrs = ['titles', 'zmin', 'zmax', 'tag', 'ymin', 'ymax']
                     for attr in attrs:
                         value = getattr(self, attr)
-                        if value is not None:
+                        if value:
-                            self.data.meta[attr] = getattr(self, attr)
+                            if isinstance(value, (numpy.float32, numpy.float64)):
+                                value = round(float(value), 2)
+                            self.data.meta[attr] = value
+                    if self.colormap == 'jet':
+                        self.data.meta['colormap'] = 'Jet'
+                    elif 'RdBu' in self.colormap:
+                        self.data.meta['colormap'] = 'RdBu'
+                    else:
+                        self.data.meta['colormap'] = 'Viridis'
                     self.data.meta['interval'] = int(interval)
-                    msg = self.data.jsonify(self.plot_name, self.plot_type)
+                    # msg = self.data.jsonify(self.data.tm, self.plot_name, self.plot_type)
-                    self.sender_queue.put(msg)
+                    self.sender_queue.put(self.data.tm)
                     while True:
                         if self.sender_queue.empty():
                             break
-                        self.socket.send_string(self.sender_queue.get())
+                        tm = self.sender_queue.get()
+                        msg = self.data.jsonify(tm, self.plot_name, self.plot_type)
+                        self.socket.send_string(msg)
                         socks = dict(self.poll.poll(5000))
                         if socks.get(self.socket) == zmq.POLLIN:
                             reply = self.socket.recv_string()
                         else:
                             log.warning(
                                 "No response from server, retrying...", self.name)
-                            self.sender_queue.put(msg)
+                            self.sender_queue.put(self.data.tm)
                         self.socket.setsockopt(zmq.LINGER, 0)
                         self.socket.close()
                         self.poll.unregister(self.socket)
                             if self.localtime:
                                 t -= time.timezone
-                        if 'buffer' in self.plot_type:
+                        if self.xmin is None:
-                            if self.xmin is None:
+                            self.tmin = t
-                                self.tmin = t
+                            if 'buffer' in self.plot_type:
                                 self.xmin = self.getDateTime(t).hour
-                            else:
+                        else:
-                                self.tmin = (
+                            self.tmin = (
-                                    self.getDateTime(t).replace(
+                                self.getDateTime(t).replace(
-                                        hour=int(self.xmin),
+                                    hour=int(self.xmin),
-                                        minute=0,
+                                    minute=0,
-                                        second=0) - self.getDateTime(0)).total_seconds()
+                                    second=0) - self.getDateTime(0)).total_seconds()
                         self.data.setup()
                         self.isConfig = True
                     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:
+                    if self.data and (tm - self.tmin) >= self.xrange*60*60:
                         self.save_counter = self.save_period
                         self.__plot()
-                        self.xmin += self.xrange
+                        if 'time' in self.xaxis:
-                        if self.xmin >= 24:
+                            self.xmin += self.xrange
-                            self.xmin -= 24
+                            if self.xmin >= 24:
+                                self.xmin -= 24
                         self.tmin += self.xrange*60*60
                         self.data.setup()
                         self.clear_figures()

schainpy/model/graphics/jroplot_spectra.py +13 -13

                     y = self.data.heights
                     self.y = y
-                    spc = self.data['spc']
+                    nspc = self.data['spc']
-                    cspc = self.data['cspc']
+                    spc = self.data['cspc'][0]
+                    cspc = self.data['cspc'][1]
                     for n in range(self.nrows):
-                        noise = self.data['noise'][n][-1]
+                        noise = self.data['noise'][:,-1]
                         pair = self.data.pairs[n]
                         ax = self.axes[4 * n]
-                        spc0 = 10.*numpy.log10(spc[pair[0]]/self.data.factor)
                         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.zmin = self.zmin if self.zmin else numpy.nanmin(nspc)
-                            self.zmax = self.zmax if self.zmax else numpy.nanmax(spc)
+                            self.zmax = self.zmax if self.zmax else numpy.nanmax(nspc)
-                            ax.plt = ax.pcolormesh(x , y , spc0.T,
+                            ax.plt = ax.pcolormesh(x , y , nspc[pair[0]].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
-                            ax.plt.set_array(spc0.T.ravel())
+                            ax.plt.set_array(nspc[pair[0]].T.ravel())
-                        self.titles.append('CH {}: {:3.2f}dB'.format(pair[0], noise))
+                        self.titles.append('CH {}: {:3.2f}dB'.format(pair[0], noise[pair[0]]))
                         ax = self.axes[4 * n + 1]
-                        spc1 = 10.*numpy.log10(spc[pair[1]]/self.data.factor)
                         if ax.firsttime:
-                            ax.plt = ax.pcolormesh(x , y, spc1.T,
+                            ax.plt = ax.pcolormesh(x , y, nspc[pair[1]].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
-                            ax.plt.set_array(spc1.T.ravel())
+                            ax.plt.set_array(nspc[pair[1]].T.ravel())
-                        self.titles.append('CH {}: {:3.2f}dB'.format(pair[1], noise))
+                        self.titles.append('CH {}: {:3.2f}dB'.format(pair[1], noise[pair[1]]))
                         out = cspc[n] / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
                         coh = numpy.abs(out)
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Intensity [dB]'
+                    self.xlabel = 'Time'
                     self.titles = ['Noise']
                     self.colorbar = False

schainpy/model/io/__init__.py +2 -1

             from .jroIO_mira35c import *
             from .julIO_param import *
-            from .pxIO_param import *
  No newline at end of file
+            from .pxIO_param import *
+            from .jroIO_simulator import *
  No newline at end of file

schainpy/model/io/jroIO_base.py +3 -3

             import datetime
             import zmq
-            from schainpy.model.proc.jroproc_base import Operation
+            from schainpy.model.proc.jroproc_base import Operation, MPDecorator
             from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
             from schainpy.model.data.jroheaderIO import get_dtype_index, get_numpy_dtype, get_procflag_dtype, get_dtype_width
             from schainpy.utils import log
                     self.putData()
                     return self.dataOut
+            @MPDecorator
             class printInfo(Operation):
                 def __init__(self):
                 def run(self, dataOut, headers = ['systemHeaderObj', 'radarControllerHeaderObj', 'processingHeaderObj']):
                     if self.__printInfo == False:
-                        return dataOut
+                        return
                     for header in headers:
                         if hasattr(dataOut, header):
                             log.warning('Header {} Not found in object'.format(header))
                     self.__printInfo = False
-                    return dataOut
  No newline at end of file

schainpy/model/proc/jroproc_voltage.py +17 0

@@ -377,6 +377,23 class setAttribute(Operation):
377	return dataOut	377	return dataOut
378		378
379		379
		380	@MPDecorator
		381	class printAttribute(Operation):
		382	'''
		383	Print an arbitrary attribute of dataOut
		384	'''
		385
		386	def __init__(self):
		387
		388	Operation.__init__(self)
		389
		390	def run(self, dataOut, attributes):
		391
		392	for attr in attributes:
		393	if hasattr(dataOut, attr):
		394	log.log(getattr(dataOut, attr), attr)
		395
		396
380	class interpolateHeights(Operation):	397	class interpolateHeights(Operation):
381		398
382	def run(self, dataOut, topLim, botLim):	399	def run(self, dataOut, topLim, botLim):

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