schain-jc Commit - r1098:831d2c3bd88d

merge v2.3

José Chávez -

r1098:831d2c3bd88d

parent child

Context file:

r1098:831d2c3bd88d

Collapse all files

schainpy/model/graphics/jroplot_data.py +41 -37

             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]
+            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]
+                'seismic_r', 20)(numpy.arange(20))[10:15]
             ncmap = matplotlib.colors.LinearSegmentedColormap.from_list(
-                "jro", numpy.vstack((blu_values, jet_values)))
+                'jro', numpy.vstack((blu_values, jet_values)))
             matplotlib.pyplot.register_cmap(cmap=ncmap)
             CMAPS = [plt.get_cmap(s) for s in ('jro', 'jet', 'RdBu_r', 'seismic')]
                 __MAXNUMX = 80
                 __missing = 1E30
+                __attrs__ = ['show', 'save', 'xmin', 'xmax', 'ymin', 'ymax', 'zmin', 'zmax',
+                             'zlimits', 'xlabel', 'ylabel', 'cb_label', 'title', 'titles', 'colorbar',
+                             'bgcolor', 'width', 'height', 'localtime', 'oneFigure', 'showprofile']
                 def __init__(self, **kwargs):
                     Operation.__init__(self, plot=True, **kwargs)
                     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)]
+                    self.polar = False
                 def __fmtTime(self, x, pos):
                     '''
                     Common setup for all figures, here figures and axes are created
                     '''
+                    if self.CODE not in self.data:
+                        raise ValueError(log.error('Missing data for {}'.format(self.CODE),
+                                                   self.name))
                     self.setup()
                     self.time_label = 'LT' if self.localtime else 'UTC'
                                          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, polar=self.polar)
                             ax.tick_params(labelsize=8)
                             ax.firsttime = True
                             ax.index = 0
                             fig = plt.figure(figsize=(self.width, self.height),
                                              edgecolor='k',
                                              facecolor='w')
-                            ax = fig.add_subplot(1, 1, 1)
+                            ax = fig.add_subplot(1, 1, 1, polar=self.polar)
                             ax.tick_params(labelsize=8)
                             ax.firsttime = True
                             ax.index = 0
                     else:
                         if self.xaxis is 'time':
                             dt = self.getDateTime(self.max_time)
-                            xmax = (dt.replace(hour=int(self.xmax), minute=0, second=0) -
+                            xmax = (dt.replace(hour=int(self.xmax), minute=59, second=59) -
                                     datetime.datetime(1970, 1, 1)).total_seconds()
                             if self.data.localtime:
                                 xmax += time.timezone
 ][0] < 0 else numpy.where(ymax < Y)[0][0]
                     ystep = Y[i - 1] / 5
-                    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)
                                 [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 = 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:
                             else:
                                 ax.cbar = None
+                        if not self.polar:
+                            ax.set_xlim(xmin, xmax)
+                            ax.set_ylim(ymin, ymax)
                             ax.set_title('{} - {} {}'.format(
                                 self.titles[n],
                                 self.getDateTime(self.max_time).strftime('%H:%M:%S'),
                                 self.time_label),
                                 size=8)
-                        ax.set_xlim(xmin, xmax)
+                        else:
-                        ax.set_ylim(ymin, ymax)
+                            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
                 def __plot(self):
                     '''
                     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')
                             continue
                         fig.tight_layout()
                                     str(self.contador),
                                 )
                             )
-                            print 'Saving figure: {}'.format(figname)
+                            log.log('Saving figure: {}'.format(figname), self.name)
                             fig.savefig(figname)
                 def plot(self):
                 Plot for meteors detection data
                 '''
-                CODE = 'met'
+                CODE = 'param'
                 def setup(self):
                     self.nrows = 1
                     self.width = 7.2
                     self.height = 7.2
+                    self.nplots = 1
                     self.xlabel = 'Zonal Zenith Angle (deg)'
                     self.ylabel = 'Meridional Zenith Angle (deg)'
+                    self.polar = True
-                    if self.figure is None:
+                    self.ymin = -180
-                        self.figure = plt.figure(figsize=(self.width, self.height),
+                    self.ymax = 180
-                                                 edgecolor='k',
+                    self.colorbar = False
-                                                 facecolor='w')
-                    else:
-                        self.figure.clf()
-                    self.ax = plt.subplot2grid(
-                        (self.nrows, self.ncols), (0, 0), 1, 1, polar=True)
-                    self.ax.firsttime = True
                 def plot(self):
-                    arrayParameters = numpy.concatenate(
+                    arrayParameters = numpy.concatenate(self.data['param'])
-                        [self.data['param'][t] for t in self.times])
                     error = arrayParameters[:, -1]
                     indValid = numpy.where(error == 0)[0]
                     finalMeteor = arrayParameters[indValid, :]
                     x = finalAzimuth * numpy.pi / 180
                     y = finalZenith
-                    if self.ax.firsttime:
+                    ax = self.axes[0]
-                        self.ax.plot = self.ax.plot(x, y, 'bo', markersize=5)[0]
-                        self.ax.set_ylim(0, 90)
+                    if ax.firsttime:
-                        self.ax.set_yticks(numpy.arange(0, 90, 20))
+                        ax.plot = ax.plot(x, y, 'bo', markersize=5)[0]
-                        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)
+                        ax.plot.set_data(x, y)
                     dt1 = self.getDateTime(self.min_time).strftime('%y/%m/%d %H:%M:%S')
                     dt2 = self.getDateTime(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.titles[0] = title
                     self.saveTime = self.max_time

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

                     return dtype_width
                 def getAllowedArgs(self):
+                    if hasattr(self, '__attrs__'):
+                        return self.__attrs__
+                    else:
                         return inspect.getargspec(self.run).args

schainpy/model/io/jroIO_bltr.py 0 -2

                     self.profileIndex = 1  # Always
                     self.dataOut.flagNoData = False
                     self.dataOut.nRdPairs = 0
-                    self.dataOut.pairsList = []
                     self.dataOut.data_spc = None
-                    self.dataOut.noise = []
                     self.dataOut.velocityX = []
                     self.dataOut.velocityY = []
                     self.dataOut.velocityV = []

schainpy/model/io/jroIO_mira35c.py +2 -4

                     self.profileIndex = 1  # Always
                     self.dataOut.flagNoData = False
                     self.dataOut.nRdPairs = 0
-                    self.dataOut.pairsList = []
                     self.dataOut.data_spc = None
-                    self.dataOut.normFactor = 1
                     self.nextfileflag = True
                     self.dataOut.RadarConst = 0
                     self.dataOut.HSDV = []
                     self.dataOut.NPW = []
                     self.dataOut.COFA = []
-                    self.dataOut.noise = 0
+                    # self.dataOut.noise = 0
                 def Files2Read(self, fp):
                     '''
                     self.dataOut.noise = self.dataOut.getNoise()
                     # print 'ACAAAAAA', self.dataOut.noise
                     self.dataOut.data_spc = self.dataOut.data_spc + self.dataOut.noise
+                    self.dataOut.normFactor = 1
                     # print 'self.dataOut.noise',self.dataOut.noise
                     return self.dataOut.data_spc

schainpy/model/proc/jroproc_base.py +12 0

                     self.args = args
                     self.kwargs = kwargs
+                    if not hasattr(self, 'name'):
+                        self.name = self.__class__.__name__
                     checkKwargs(self.run, kwargs)
                 def getAllowedArgs(self):
+                    if hasattr(self, '__attrs__'):
+                        return self.__attrs__
+                    else:
                         return inspect.getargspec(self.run).args
                 def addOperationKwargs(self, objId, **kwargs):
                     self.__buffer = None
                     self.isConfig = False
                     self.kwargs = kwargs
+                    if not hasattr(self, 'name'):
+                        self.name = self.__class__.__name__
                     checkKwargs(self.run, kwargs)
                 def getAllowedArgs(self):
+                    if hasattr(self, '__attrs__'):
+                        return self.__attrs__
+                    else:
                         return inspect.getargspec(self.run).args
                 def setup(self):

schainpy/model/proc/jroproc_parameters.py +18 -18

                 def __calculateMoments(self, oldspec, oldfreq, n0,
                                        nicoh = None, graph = None, smooth = None, type1 = None, fwindow = None, snrth = None, dc = None, aliasing = None, oldfd = None, wwauto = None):
-                    if (nicoh == None): nicoh = 1
+                    if (nicoh is None): nicoh = 1
-                    if (graph == None): graph = 0
+                    if (graph is None): graph = 0
-                    if (smooth == None): smooth = 0
+                    if (smooth is None): smooth = 0
                     elif (self.smooth < 3): smooth = 0
-                    if (type1 == None): type1 = 0
+                    if (type1 is None): type1 = 0
-                    if (fwindow == None): fwindow = numpy.zeros(oldfreq.size) + 1
+                    if (fwindow is None): fwindow = numpy.zeros(oldfreq.size) + 1
-                    if (snrth == None): snrth = -3
+                    if (snrth is None): snrth = -3
-                    if (dc == None): dc = 0
+                    if (dc is None): dc = 0
-                    if (aliasing == None): aliasing = 0
+                    if (aliasing is None): aliasing = 0
-                    if (oldfd == None): oldfd = 0
+                    if (oldfd is None): oldfd = 0
-                    if (wwauto == None): wwauto = 0
+                    if (wwauto is None): wwauto = 0
                     if (n0 < 1.e-20):   n0 = 1.e-20
                                 error1 = p0*numpy.nan
                             #Save
-                            if self.dataOut.data_param == None:
+                            if self.dataOut.data_param is None:
                                 self.dataOut.data_param = numpy.zeros((nGroups, p0.size, nHeights))*numpy.nan
                                 self.dataOut.data_error = numpy.zeros((nGroups, p0.size + 1, nHeights))*numpy.nan
                             self.__isConfig = True
-                        if self.__buffer == None:
+                        if self.__buffer is None:
                             self.__buffer = dataOut.data_param
                             self.__firstdata = copy.copy(dataOut)
                         else: mode = 'SA'
                         #Borrar luego esto
-                        if dataOut.groupList == None:
+                        if dataOut.groupList is None:
                             dataOut.groupList = [(0,1),(0,2),(1,2)]
                         groupList = dataOut.groupList
                         C = 3e8
                             self.__isConfig = True
-                        if self.__buffer == None:
+                        if self.__buffer is None:
                             self.__buffer = dataOut.data_param
                             self.__firstdata = copy.copy(dataOut)
                     #Getting Pairslist
-                    if channelPositions == None:
+                    if channelPositions is None:
             #             channelPositions = [(2.5,0), (0,2.5), (0,0), (0,4.5), (-2,0)]   #T
                         channelPositions = [(4.5,2), (2,4.5), (2,2), (2,0), (0,2)]   #Estrella
                     meteorOps = SMOperations()
             #             arrayFinal = arrayParameters.reshape((1,arrayParameters.shape[0],arrayParameters.shape[1]))
                         dataOut.data_param = arrayParameters
-                        if arrayParameters == None:
+                        if arrayParameters is None:
                             dataOut.flagNoData = True
                     else:
                         dataOut.flagNoData = True
                     arrayParameters[:,8:12] = numpy.angle(numpy.exp(1j*(arrayParameters[:,8:12] + phaseOffsets)))
                     meteorOps = SMOperations()
-                    if channelPositions == None:
+                    if channelPositions is None:
                 #             channelPositions = [(2.5,0), (0,2.5), (0,0), (0,4.5), (-2,0)]   #T
                         channelPositions = [(4.5,2), (2,4.5), (2,2), (2,0), (0,2)]   #Estrella
                         self.__isConfig = True
-                    if self.__buffer == None:
+                    if self.__buffer is None:
                         self.__buffer = dataOut.data_param.copy()
                     else:

schainpy/model/utils/jroutils_publish.py +21 -4

                 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
                             ret = numpy.swapaxes(ret, 0, 1)
                     return ret
+                def __contains__(self, key):
+                    return key in self.data
                 def setup(self):
                     '''
                     Configure object
                 Operation to send data over zmq.
                 '''
+                __attrs__ = ['host', 'port', 'delay', 'zeromq', 'mqtt', 'verbose']
                 def __init__(self, **kwargs):
                     """Inicio."""
                     Operation.__init__(self, **kwargs)
             class ReceiverData(ProcessingUnit):
+                __attrs__ = ['server']
                 def __init__(self, **kwargs):
                     ProcessingUnit.__init__(self, **kwargs)
             class PlotterReceiver(ProcessingUnit, Process):
                 throttle_value = 5
+                __attrs__ = ['server', 'plottypes', 'realtime', 'localtime', 'throttle']
                 def __init__(self, **kwargs):
                     while True:
                         dataOut = self.receiver.recv_pyobj()
+                        if not dataOut.flagNoData:
+                            if dataOut.type == 'Parameters':
+                                tm = dataOut.utctimeInit
+                            else:
                                 tm = dataOut.utctime
                             if dataOut.useLocalTime:
                                 if not self.localtime:
                                 if self.localtime:
                                     tm -= time.timezone
                                 dt = datetime.datetime.utcfromtimestamp(tm).date()
-                        sended = False
+                            coerce = False
                             if dt not in self.dates:
                                 if self.data:
                                     self.data.ended = True
                                     self.send(self.data)
-                                sended = True
+                                    coerce = True
                                 self.data.setup()
                                 self.dates.append(dt)
                                 self.send(self.data)
                                 # self.sender_web.send_string(self.data.jsonify())
                             else:
-                                if not sended:
+                                self.sendData(self.send, self.data, coerce=coerce)
-                                    self.sendData(self.send, self.data)
+                                coerce = False
                     return

schainpy/utils/paramsFinder.py +3 -4

             import schainpy
             from schainpy.model import Operation, ProcessingUnit
-            from importlib import import_module
             from pydoc import locate
             def clean_modules(module):
             def getProcs():
-                module = dir(import_module('schainpy.model'))
+                module = dir(schainpy.model)
                 procs = check_module(module, ProcessingUnit)
                 try:
                     procs.remove('ProcessingUnit')
                 return procs
             def getOperations():
-                module = dir(import_module('schainpy.model'))
+                module = dir(schainpy.model)
                 noProcs = [x for x in module if not x.endswith('Proc')]
                 operations = check_module(noProcs, Operation)
                 try:
                 return args
             def getAll():
-                allModules = dir(import_module('schainpy.model'))
+                allModules = dir(schainpy.model)
                 modules = check_module(allModules, Operation)
                 modules.extend(check_module(allModules, ProcessingUnit))
                 return modules

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