schain Commit - r1483:c3f12c63a985 · Jicamarca Repository

Clean code and fix for one channel in WR

Juan C. Espinoza -

r1483:c3f12c63a985

parent child

Context file:

r1483:c3f12c63a985

Collapse all files

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

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

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

schainpy/model/graphics/jroplot_parameters.py +5 -1432

This diff has been collapsed as it changes many lines, (1437 lines changed) Show them Hide them
	@@ -1,1936 +1,509
	1	import os	1	import os
	2	import datetime	2	import datetime
	3	import numpy	3	import numpy
	4	from mpl_toolkits.axisartist.grid_finder import FixedLocator, DictFormatter	4	from mpl_toolkits.axisartist.grid_finder import FixedLocator, DictFormatter
	5		5
	6	from schainpy.model.graphics.jroplot_base import Plot, plt	6	from schainpy.model.graphics.jroplot_base import Plot, plt
	7	from schainpy.model.graphics.jroplot_spectra import SpectraPlot, RTIPlot, CoherencePlot, SpectraCutPlot	7	from schainpy.model.graphics.jroplot_spectra import SpectraPlot, RTIPlot, CoherencePlot, SpectraCutPlot
	8	from schainpy.utils import log	8	from schainpy.utils import log
	9	# libreria wradlib	9	# libreria wradlib
	10	#import wradlib as wrl	10	#import wradlib as wrl
	11		11
	12	EARTH_RADIUS = 6.3710e3	12	EARTH_RADIUS = 6.3710e3
	13		13
	14		14
	15	def ll2xy(lat1, lon1, lat2, lon2):	15	def ll2xy(lat1, lon1, lat2, lon2):
	16		16
	17	p = 0.017453292519943295	17	p = 0.017453292519943295
	18	a = 0.5 - numpy.cos((lat2 - lat1) * p)/2 + numpy.cos(lat1 * p) * \	18	a = 0.5 - numpy.cos((lat2 - lat1) * p)/2 + numpy.cos(lat1 * p) * \
	19	numpy.cos(lat2 * p) * (1 - numpy.cos((lon2 - lon1) * p)) / 2	19	numpy.cos(lat2 * p) * (1 - numpy.cos((lon2 - lon1) * p)) / 2
	20	r = 12742 * numpy.arcsin(numpy.sqrt(a))	20	r = 12742 * numpy.arcsin(numpy.sqrt(a))
	21	theta = numpy.arctan2(numpy.sin((lon2-lon1)p)numpy.cos(lat2p), numpy.cos(lat1p)	21	theta = numpy.arctan2(numpy.sin((lon2-lon1)p)numpy.cos(lat2p), numpy.cos(lat1p)
	22	* numpy.sin(lat2p)-numpy.sin(lat1p)numpy.cos(lat2p)numpy.cos((lon2-lon1)p))	22	* numpy.sin(lat2p)-numpy.sin(lat1p)numpy.cos(lat2p)numpy.cos((lon2-lon1)p))
	23	theta = -theta + numpy.pi/2	23	theta = -theta + numpy.pi/2
	24	return rnumpy.cos(theta), rnumpy.sin(theta)	24	return rnumpy.cos(theta), rnumpy.sin(theta)
	25		25
	26		26
	27	def km2deg(km):	27	def km2deg(km):
	28	'''	28	'''
	29	Convert distance in km to degrees	29	Convert distance in km to degrees
	30	'''	30	'''
	31		31
	32	return numpy.rad2deg(km/EARTH_RADIUS)	32	return numpy.rad2deg(km/EARTH_RADIUS)
	33		33
	34		34
	35		35
	36	class SpectralMomentsPlot(SpectraPlot):	36	class SpectralMomentsPlot(SpectraPlot):
	37	'''	37	'''
	38	Plot for Spectral Moments	38	Plot for Spectral Moments
	39	'''	39	'''
	40	CODE = 'spc_moments'	40	CODE = 'spc_moments'
	41	# colormap = 'jet'	41	# colormap = 'jet'
	42	# plot_type = 'pcolor'	42	# plot_type = 'pcolor'
	43		43
	44	class DobleGaussianPlot(SpectraPlot):	44	class DobleGaussianPlot(SpectraPlot):
	45	'''	45	'''
	46	Plot for Double Gaussian Plot	46	Plot for Double Gaussian Plot
	47	'''	47	'''
	48	CODE = 'gaussian_fit'	48	CODE = 'gaussian_fit'
	49	# colormap = 'jet'	49	# colormap = 'jet'
	50	# plot_type = 'pcolor'	50	# plot_type = 'pcolor'
	51		51
	52	class DoubleGaussianSpectraCutPlot(SpectraCutPlot):	52	class DoubleGaussianSpectraCutPlot(SpectraCutPlot):
	53	'''	53	'''
	54	Plot SpectraCut with Double Gaussian Fit	54	Plot SpectraCut with Double Gaussian Fit
	55	'''	55	'''
	56	CODE = 'cut_gaussian_fit'	56	CODE = 'cut_gaussian_fit'
	57		57
	58	class SnrPlot(RTIPlot):	58	class SnrPlot(RTIPlot):
	59	'''	59	'''
	60	Plot for SNR Data	60	Plot for SNR Data
	61	'''	61	'''
	62		62
	63	CODE = 'snr'	63	CODE = 'snr'
	64	colormap = 'jet'	64	colormap = 'jet'
	65		65
	66	def update(self, dataOut):	66	def update(self, dataOut):
	67		67
	68	data = {	68	data = {
	69	'snr': 10*numpy.log10(dataOut.data_snr)	69	'snr': 10*numpy.log10(dataOut.data_snr)
	70	}	70	}
	71		71
	72	return data, {}	72	return data, {}
	73		73
	74	class DopplerPlot(RTIPlot):	74	class DopplerPlot(RTIPlot):
	75	'''	75	'''
	76	Plot for DOPPLER Data (1st moment)	76	Plot for DOPPLER Data (1st moment)
	77	'''	77	'''
	78		78
	79	CODE = 'dop'	79	CODE = 'dop'
	80	colormap = 'jet'	80	colormap = 'jet'
	81		81
	82	def update(self, dataOut):	82	def update(self, dataOut):
	83		83
	84	data = {	84	data = {
	85	'dop': 10*numpy.log10(dataOut.data_dop)	85	'dop': 10*numpy.log10(dataOut.data_dop)
	86	}	86	}
	87		87
	88	return data, {}	88	return data, {}
	89		89
	90	class PowerPlot(RTIPlot):	90	class PowerPlot(RTIPlot):
	91	'''	91	'''
	92	Plot for Power Data (0 moment)	92	Plot for Power Data (0 moment)
	93	'''	93	'''
	94		94
	95	CODE = 'pow'	95	CODE = 'pow'
	96	colormap = 'jet'	96	colormap = 'jet'
	97		97
	98	def update(self, dataOut):	98	def update(self, dataOut):
	99	data = {	99	data = {
	100	'pow': 10*numpy.log10(dataOut.data_pow/dataOut.normFactor)	100	'pow': 10*numpy.log10(dataOut.data_pow/dataOut.normFactor)
	101	}	101	}
	102	return data, {}	102	return data, {}
	103		103
	104	class SpectralWidthPlot(RTIPlot):	104	class SpectralWidthPlot(RTIPlot):
	105	'''	105	'''
	106	Plot for Spectral Width Data (2nd moment)	106	Plot for Spectral Width Data (2nd moment)
	107	'''	107	'''
	108		108
	109	CODE = 'width'	109	CODE = 'width'
	110	colormap = 'jet'	110	colormap = 'jet'
	111		111
	112	def update(self, dataOut):	112	def update(self, dataOut):
	113		113
	114	data = {	114	data = {
	115	'width': dataOut.data_width	115	'width': dataOut.data_width
	116	}	116	}
	117		117
	118	return data, {}	118	return data, {}
	119		119
	120	class SkyMapPlot(Plot):	120	class SkyMapPlot(Plot):
	121	'''	121	'''
	122	Plot for meteors detection data	122	Plot for meteors detection data
	123	'''	123	'''
	124		124
	125	CODE = 'param'	125	CODE = 'param'
	126		126
	127	def setup(self):	127	def setup(self):
	128		128
	129	self.ncols = 1	129	self.ncols = 1
	130	self.nrows = 1	130	self.nrows = 1
	131	self.width = 7.2	131	self.width = 7.2
	132	self.height = 7.2	132	self.height = 7.2
	133	self.nplots = 1	133	self.nplots = 1
	134	self.xlabel = 'Zonal Zenith Angle (deg)'	134	self.xlabel = 'Zonal Zenith Angle (deg)'
	135	self.ylabel = 'Meridional Zenith Angle (deg)'	135	self.ylabel = 'Meridional Zenith Angle (deg)'
	136	self.polar = True	136	self.polar = True
	137	self.ymin = -180	137	self.ymin = -180
	138	self.ymax = 180	138	self.ymax = 180
	139	self.colorbar = False	139	self.colorbar = False
	140		140
	141	def plot(self):	141	def plot(self):
	142		142
	143	arrayParameters = numpy.concatenate(self.data['param'])	143	arrayParameters = numpy.concatenate(self.data['param'])
	144	error = arrayParameters[:, -1]	144	error = arrayParameters[:, -1]
	145	indValid = numpy.where(error == 0)[0]	145	indValid = numpy.where(error == 0)[0]
	146	finalMeteor = arrayParameters[indValid, :]	146	finalMeteor = arrayParameters[indValid, :]
	147	finalAzimuth = finalMeteor[:, 3]	147	finalAzimuth = finalMeteor[:, 3]
	148	finalZenith = finalMeteor[:, 4]	148	finalZenith = finalMeteor[:, 4]
	149		149
	150	x = finalAzimuth * numpy.pi / 180	150	x = finalAzimuth * numpy.pi / 180
	151	y = finalZenith	151	y = finalZenith
	152		152
	153	ax = self.axes[0]	153	ax = self.axes[0]
	154		154
	155	if ax.firsttime:	155	if ax.firsttime:
	156	ax.plot = ax.plot(x, y, 'bo', markersize=5)[0]	156	ax.plot = ax.plot(x, y, 'bo', markersize=5)[0]
	157	else:	157	else:
	158	ax.plot.set_data(x, y)	158	ax.plot.set_data(x, y)
	159		159
	160	dt1 = self.getDateTime(self.data.min_time).strftime('%y/%m/%d %H:%M:%S')	160	dt1 = self.getDateTime(self.data.min_time).strftime('%y/%m/%d %H:%M:%S')
	161	dt2 = self.getDateTime(self.data.max_time).strftime('%y/%m/%d %H:%M:%S')	161	dt2 = self.getDateTime(self.data.max_time).strftime('%y/%m/%d %H:%M:%S')
	162	title = 'Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n' % (dt1,	162	title = 'Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n' % (dt1,
	163	dt2,	163	dt2,
	164	len(x))	164	len(x))
	165	self.titles[0] = title	165	self.titles[0] = title
	166		166
	167		167
	168	class GenericRTIPlot(Plot):	168	class GenericRTIPlot(Plot):
	169	'''	169	'''
	170	Plot for data_xxxx object	170	Plot for data_xxxx object
	171	'''	171	'''
	172		172
	173	CODE = 'param'	173	CODE = 'param'
	174	colormap = 'viridis'	174	colormap = 'viridis'
	175	plot_type = 'pcolorbuffer'	175	plot_type = 'pcolorbuffer'
	176		176
	177	def setup(self):	177	def setup(self):
	178	self.xaxis = 'time'	178	self.xaxis = 'time'
	179	self.ncols = 1	179	self.ncols = 1
	180	self.nrows = self.data.shape('param')[0]	180	self.nrows = self.data.shape('param')[0]
	181	self.nplots = self.nrows	181	self.nplots = self.nrows
	182	self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.08, 'right':0.95, 'top': 0.95})	182	self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.08, 'right':0.95, 'top': 0.95})
	183		183
	184	if not self.xlabel:	184	if not self.xlabel:
	185	self.xlabel = 'Time'	185	self.xlabel = 'Time'
	186		186
	187	self.ylabel = 'Range [km]'	187	self.ylabel = 'Range [km]'
	188	if not self.titles:	188	if not self.titles:
	189	self.titles = ['Param {}'.format(x) for x in range(self.nrows)]	189	self.titles = ['Param {}'.format(x) for x in range(self.nrows)]
	190		190
	191	def update(self, dataOut):	191	def update(self, dataOut):
	192		192
	193	data = {	193	data = {
	194	'param' : numpy.concatenate([getattr(dataOut, attr) for attr in self.attr_data], axis=0)	194	'param' : numpy.concatenate([getattr(dataOut, attr) for attr in self.attr_data], axis=0)
	195	}	195	}
	196		196
	197	meta = {}	197	meta = {}
	198		198
	199	return data, meta	199	return data, meta
	200		200
	201	def plot(self):	201	def plot(self):
	202	# self.data.normalize_heights()	202	# self.data.normalize_heights()
	203	self.x = self.data.times	203	self.x = self.data.times
	204	self.y = self.data.yrange	204	self.y = self.data.yrange
	205	self.z = self.data['param']	205	self.z = self.data['param']
	206	self.z = 10*numpy.log10(self.z)	206	self.z = 10*numpy.log10(self.z)
	207	self.z = numpy.ma.masked_invalid(self.z)	207	self.z = numpy.ma.masked_invalid(self.z)
	208		208
	209	if self.decimation is None:	209	if self.decimation is None:
	210	x, y, z = self.fill_gaps(self.x, self.y, self.z)	210	x, y, z = self.fill_gaps(self.x, self.y, self.z)
	211	else:	211	else:
	212	x, y, z = self.fill_gaps(*self.decimate())	212	x, y, z = self.fill_gaps(*self.decimate())
	213		213
	214	for n, ax in enumerate(self.axes):	214	for n, ax in enumerate(self.axes):
	215		215
	216	self.zmax = self.zmax if self.zmax is not None else numpy.max(	216	self.zmax = self.zmax if self.zmax is not None else numpy.max(
	217	self.z[n])	217	self.z[n])
	218	self.zmin = self.zmin if self.zmin is not None else numpy.min(	218	self.zmin = self.zmin if self.zmin is not None else numpy.min(
	219	self.z[n])	219	self.z[n])
	220		220
	221	if ax.firsttime:	221	if ax.firsttime:
	222	if self.zlimits is not None:	222	if self.zlimits is not None:
	223	self.zmin, self.zmax = self.zlimits[n]	223	self.zmin, self.zmax = self.zlimits[n]
	224		224
	225	ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],	225	ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
	226	vmin=self.zmin,	226	vmin=self.zmin,
	227	vmax=self.zmax,	227	vmax=self.zmax,
	228	cmap=self.cmaps[n]	228	cmap=self.cmaps[n]
	229	)	229	)
	230	else:	230	else:
	231	if self.zlimits is not None:	231	if self.zlimits is not None:
	232	self.zmin, self.zmax = self.zlimits[n]	232	self.zmin, self.zmax = self.zlimits[n]
	233	ax.collections.remove(ax.collections[0])	233	ax.collections.remove(ax.collections[0])
	234	ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],	234	ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
	235	vmin=self.zmin,	235	vmin=self.zmin,
	236	vmax=self.zmax,	236	vmax=self.zmax,
	237	cmap=self.cmaps[n]	237	cmap=self.cmaps[n]
	238	)	238	)
	239		239
	240		240
	241	class PolarMapPlot(Plot):	241	class PolarMapPlot(Plot):
	242	'''	242	'''
	243	Plot for weather radar	243	Plot for weather radar
	244	'''	244	'''
	245		245
	246	CODE = 'param'	246	CODE = 'param'
	247	colormap = 'seismic'	247	colormap = 'seismic'
	248		248
	249	def setup(self):	249	def setup(self):
	250	self.ncols = 1	250	self.ncols = 1
	251	self.nrows = 1	251	self.nrows = 1
	252	self.width = 9	252	self.width = 9
	253	self.height = 8	253	self.height = 8
	254	self.mode = self.data.meta['mode']	254	self.mode = self.data.meta['mode']
	255	if self.channels is not None:	255	if self.channels is not None:
	256	self.nplots = len(self.channels)	256	self.nplots = len(self.channels)
	257	self.nrows = len(self.channels)	257	self.nrows = len(self.channels)
	258	else:	258	else:
	259	self.nplots = self.data.shape(self.CODE)[0]	259	self.nplots = self.data.shape(self.CODE)[0]
	260	self.nrows = self.nplots	260	self.nrows = self.nplots
	261	self.channels = list(range(self.nplots))	261	self.channels = list(range(self.nplots))
	262	if self.mode == 'E':	262	if self.mode == 'E':
	263	self.xlabel = 'Longitude'	263	self.xlabel = 'Longitude'
	264	self.ylabel = 'Latitude'	264	self.ylabel = 'Latitude'
	265	else:	265	else:
	266	self.xlabel = 'Range (km)'	266	self.xlabel = 'Range (km)'
	267	self.ylabel = 'Height (km)'	267	self.ylabel = 'Height (km)'
	268	self.bgcolor = 'white'	268	self.bgcolor = 'white'
	269	self.cb_labels = self.data.meta['units']	269	self.cb_labels = self.data.meta['units']
	270	self.lat = self.data.meta['latitude']	270	self.lat = self.data.meta['latitude']
	271	self.lon = self.data.meta['longitude']	271	self.lon = self.data.meta['longitude']
	272	self.xmin, self.xmax = float(	272	self.xmin, self.xmax = float(
	273	km2deg(self.xmin) + self.lon), float(km2deg(self.xmax) + self.lon)	273	km2deg(self.xmin) + self.lon), float(km2deg(self.xmax) + self.lon)
	274	self.ymin, self.ymax = float(	274	self.ymin, self.ymax = float(
	275	km2deg(self.ymin) + self.lat), float(km2deg(self.ymax) + self.lat)	275	km2deg(self.ymin) + self.lat), float(km2deg(self.ymax) + self.lat)
	276	# self.polar = True	276	# self.polar = True
	277		277
	278	def plot(self):	278	def plot(self):
	279		279
	280	for n, ax in enumerate(self.axes):	280	for n, ax in enumerate(self.axes):
	281	data = self.data['param'][self.channels[n]]	281	data = self.data['param'][self.channels[n]]
	282		282
	283	zeniths = numpy.linspace(	283	zeniths = numpy.linspace(
	284	0, self.data.meta['max_range'], data.shape[1])	284	0, self.data.meta['max_range'], data.shape[1])
	285	if self.mode == 'E':	285	if self.mode == 'E':
	286	azimuths = -numpy.radians(self.data.yrange)+numpy.pi/2	286	azimuths = -numpy.radians(self.data.yrange)+numpy.pi/2
	287	r, theta = numpy.meshgrid(zeniths, azimuths)	287	r, theta = numpy.meshgrid(zeniths, azimuths)
	288	x, y = rnumpy.cos(theta)numpy.cos(numpy.radians(self.data.meta['elevation'])), r*numpy.sin(	288	x, y = rnumpy.cos(theta)numpy.cos(numpy.radians(self.data.meta['elevation'])), r*numpy.sin(
	289	theta)*numpy.cos(numpy.radians(self.data.meta['elevation']))	289	theta)*numpy.cos(numpy.radians(self.data.meta['elevation']))
	290	x = km2deg(x) + self.lon	290	x = km2deg(x) + self.lon
	291	y = km2deg(y) + self.lat	291	y = km2deg(y) + self.lat
	292	else:	292	else:
	293	azimuths = numpy.radians(self.data.yrange)	293	azimuths = numpy.radians(self.data.yrange)
	294	r, theta = numpy.meshgrid(zeniths, azimuths)	294	r, theta = numpy.meshgrid(zeniths, azimuths)
	295	x, y = rnumpy.cos(theta), rnumpy.sin(theta)	295	x, y = rnumpy.cos(theta), rnumpy.sin(theta)
	296	self.y = zeniths	296	self.y = zeniths
	297		297
	298	if ax.firsttime:	298	if ax.firsttime:
	299	if self.zlimits is not None:	299	if self.zlimits is not None:
	300	self.zmin, self.zmax = self.zlimits[n]	300	self.zmin, self.zmax = self.zlimits[n]
	301	ax.plt = ax.pcolormesh( # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),	301	ax.plt = ax.pcolormesh( # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
	302	x, y, numpy.ma.array(data, mask=numpy.isnan(data)),	302	x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
	303	vmin=self.zmin,	303	vmin=self.zmin,
	304	vmax=self.zmax,	304	vmax=self.zmax,
	305	cmap=self.cmaps[n])	305	cmap=self.cmaps[n])
	306	else:	306	else:
	307	if self.zlimits is not None:	307	if self.zlimits is not None:
	308	self.zmin, self.zmax = self.zlimits[n]	308	self.zmin, self.zmax = self.zlimits[n]
	309	ax.collections.remove(ax.collections[0])	309	ax.collections.remove(ax.collections[0])
	310	ax.plt = ax.pcolormesh( # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),	310	ax.plt = ax.pcolormesh( # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
	311	x, y, numpy.ma.array(data, mask=numpy.isnan(data)),	311	x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
	312	vmin=self.zmin,	312	vmin=self.zmin,
	313	vmax=self.zmax,	313	vmax=self.zmax,
	314	cmap=self.cmaps[n])	314	cmap=self.cmaps[n])
	315		315
	316	if self.mode == 'A':	316	if self.mode == 'A':
	317	continue	317	continue
	318		318
	319	# plot district names	319	# plot district names
	320	f = open('/data/workspace/schain_scripts/distrito.csv')	320	f = open('/data/workspace/schain_scripts/distrito.csv')
	321	for line in f:	321	for line in f:
	322	label, lon, lat = [s.strip() for s in line.split(',') if s]	322	label, lon, lat = [s.strip() for s in line.split(',') if s]
	323	lat = float(lat)	323	lat = float(lat)
	324	lon = float(lon)	324	lon = float(lon)
	325	# ax.plot(lon, lat, '.b', ms=2)	325	# ax.plot(lon, lat, '.b', ms=2)
	326	ax.text(lon, lat, label.decode('utf8'), ha='center',	326	ax.text(lon, lat, label.decode('utf8'), ha='center',
	327	va='bottom', size='8', color='black')	327	va='bottom', size='8', color='black')
	328		328
	329	# plot limites	329	# plot limites
	330	limites = []	330	limites = []
	331	tmp = []	331	tmp = []
	332	for line in open('/data/workspace/schain_scripts/lima.csv'):	332	for line in open('/data/workspace/schain_scripts/lima.csv'):
	333	if '#' in line:	333	if '#' in line:
	334	if tmp:	334	if tmp:
	335	limites.append(tmp)	335	limites.append(tmp)
	336	tmp = []	336	tmp = []
	337	continue	337	continue
	338	values = line.strip().split(',')	338	values = line.strip().split(',')
	339	tmp.append((float(values[0]), float(values[1])))	339	tmp.append((float(values[0]), float(values[1])))
	340	for points in limites:	340	for points in limites:
	341	ax.add_patch(	341	ax.add_patch(
	342	Polygon(points, ec='k', fc='none', ls='--', lw=0.5))	342	Polygon(points, ec='k', fc='none', ls='--', lw=0.5))
	343		343
	344	# plot Cuencas	344	# plot Cuencas
	345	for cuenca in ('rimac', 'lurin', 'mala', 'chillon', 'chilca', 'chancay-huaral'):	345	for cuenca in ('rimac', 'lurin', 'mala', 'chillon', 'chilca', 'chancay-huaral'):
	346	f = open('/data/workspace/schain_scripts/{}.csv'.format(cuenca))	346	f = open('/data/workspace/schain_scripts/{}.csv'.format(cuenca))
	347	values = [line.strip().split(',') for line in f]	347	values = [line.strip().split(',') for line in f]
	348	points = [(float(s[0]), float(s[1])) for s in values]	348	points = [(float(s[0]), float(s[1])) for s in values]
	349	ax.add_patch(Polygon(points, ec='b', fc='none'))	349	ax.add_patch(Polygon(points, ec='b', fc='none'))
	350		350
	351	# plot grid	351	# plot grid
	352	for r in (15, 30, 45, 60):	352	for r in (15, 30, 45, 60):
	353	ax.add_artist(plt.Circle((self.lon, self.lat),	353	ax.add_artist(plt.Circle((self.lon, self.lat),
	354	km2deg(r), color='0.6', fill=False, lw=0.2))	354	km2deg(r), color='0.6', fill=False, lw=0.2))
	355	ax.text(	355	ax.text(
	356	self.lon + (km2deg(r))numpy.cos(60numpy.pi/180),	356	self.lon + (km2deg(r))numpy.cos(60numpy.pi/180),
	357	self.lat + (km2deg(r))numpy.sin(60numpy.pi/180),	357	self.lat + (km2deg(r))numpy.sin(60numpy.pi/180),
	358	'{}km'.format(r),	358	'{}km'.format(r),
	359	ha='center', va='bottom', size='8', color='0.6', weight='heavy')	359	ha='center', va='bottom', size='8', color='0.6', weight='heavy')
	360		360
	361	if self.mode == 'E':	361	if self.mode == 'E':
	362	title = 'El={}$^\circ$'.format(self.data.meta['elevation'])	362	title = 'El={}$^\circ$'.format(self.data.meta['elevation'])
	363	label = 'E{:02d}'.format(int(self.data.meta['elevation']))	363	label = 'E{:02d}'.format(int(self.data.meta['elevation']))
	364	else:	364	else:
	365	title = 'Az={}$^\circ$'.format(self.data.meta['azimuth'])	365	title = 'Az={}$^\circ$'.format(self.data.meta['azimuth'])
	366	label = 'A{:02d}'.format(int(self.data.meta['azimuth']))	366	label = 'A{:02d}'.format(int(self.data.meta['azimuth']))
	367		367
	368	self.save_labels = ['{}-{}'.format(lbl, label) for lbl in self.labels]	368	self.save_labels = ['{}-{}'.format(lbl, label) for lbl in self.labels]
	369	self.titles = ['{} {}'.format(	369	self.titles = ['{} {}'.format(
	370	self.data.parameters[x], title) for x in self.channels]	370	self.data.parameters[x], title) for x in self.channels]
	371		371
	372	class WeatherPlot(Plot):
	373	CODE = 'weather'
	374	plot_name = 'weather'
	375	plot_type = 'ppistyle'
	376	buffering = False
	377
	378	def setup(self):
	379	self.ncols = 1
	380	self.nrows = 1
	381	self.width =8
	382	self.height =8
	383	self.nplots= 1
	384	self.ylabel= 'Range [Km]'
	385	self.titles= ['Weather']
	386	self.colorbar=False
	387	self.ini =0
	388	self.len_azi =0
	389	self.buffer_ini = None
	390	self.buffer_azi = None
	391	self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
	392	self.flag =0
	393	self.indicador= 0
	394	self.last_data_azi = None
	395	self.val_mean = None
	396
	397	def update(self, dataOut):
	398
	399	data = {}
	400	meta = {}
	401	if hasattr(dataOut, 'dataPP_POWER'):
	402	factor = 1
	403	if hasattr(dataOut, 'nFFTPoints'):
	404	factor = dataOut.normFactor
	405	#print("DIME EL SHAPE PORFAVOR",dataOut.data_360.shape)
	406	data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
	407	data['azi'] = dataOut.data_azi
	408	data['ele'] = dataOut.data_ele
	409	return data, meta
	410
	411	def get2List(self,angulos):
	412	list1=[]
	413	list2=[]
	414	for i in reversed(range(len(angulos))):
	415	diff_ = angulos[i]-angulos[i-1]
	416	if diff_ >1.5:
	417	list1.append(i-1)
	418	list2.append(diff_)
	419	return list(reversed(list1)),list(reversed(list2))
	420
	421	def fixData360(self,list_,ang_):
	422	if list_[0]==-1:
	423	vec = numpy.where(ang_<ang_[0])
	424	ang_[vec] = ang_[vec]+360
	425	return ang_
	426	return ang_
	427
	428	def fixData360HL(self,angulos):
	429	vec = numpy.where(angulos>=360)
	430	angulos[vec]=angulos[vec]-360
	431	return angulos
	432
	433	def search_pos(self,pos,list_):
	434	for i in range(len(list_)):
	435	if pos == list_[i]:
	436	return True,i
	437	i=None
	438	return False,i
	439
	440	def fixDataComp(self,ang_,list1_,list2_):
	441	size = len(ang_)
	442	size2 = 0
	443	for i in range(len(list2_)):
	444	size2=size2+round(list2_[i])-1
	445	new_size= size+size2
	446	ang_new = numpy.zeros(new_size)
	447	ang_new2 = numpy.zeros(new_size)
	448
	449	tmp = 0
	450	c = 0
	451	for i in range(len(ang_)):
	452	ang_new[tmp +c] = ang_[i]
	453	ang_new2[tmp+c] = ang_[i]
	454	condition , value = self.search_pos(i,list1_)
	455	if condition:
	456	pos = tmp + c + 1
	457	for k in range(round(list2_[value])-1):
	458	ang_new[pos+k] = ang_new[pos+k-1]+1
	459	ang_new2[pos+k] = numpy.nan
	460	tmp = pos +k
	461	c = 0
	462	c=c+1
	463	return ang_new,ang_new2
	464
	465	def globalCheckPED(self,angulos):
	466	l1,l2 = self.get2List(angulos)
	467	if len(l1)>0:
	468	angulos2 = self.fixData360(list_=l1,ang_=angulos)
	469	l1,l2 = self.get2List(angulos2)
	470
	471	ang1_,ang2_ = self.fixDataComp(ang_=angulos2,list1_=l1,list2_=l2)
	472	ang1_ = self.fixData360HL(ang1_)
	473	ang2_ = self.fixData360HL(ang2_)
	474	else:
	475	ang1_= angulos
	476	ang2_= angulos
	477	return ang1_,ang2_
	478
	479	def analizeDATA(self,data_azi):
	480	list1 = []
	481	list2 = []
	482	dat = data_azi
	483	for i in reversed(range(1,len(dat))):
	484	if dat[i]>dat[i-1]:
	485	diff = int(dat[i])-int(dat[i-1])
	486	else:
	487	diff = 360+int(dat[i])-int(dat[i-1])
	488	if diff > 1:
	489	list1.append(i-1)
	490	list2.append(diff-1)
	491	return list1,list2
	492
	493	def fixDATANEW(self,data_azi,data_weather):
	494	list1,list2 = self.analizeDATA(data_azi)
	495	if len(list1)== 0:
	496	return data_azi,data_weather
	497	else:
	498	resize = 0
	499	for i in range(len(list2)):
	500	resize= resize + list2[i]
	501	new_data_azi = numpy.resize(data_azi,resize)
	502	new_data_weather= numpy.resize(date_weather,resize)
	503
	504	for i in range(len(list2)):
	505	j=0
	506	position=list1[i]+1
	507	for j in range(list2[i]):
	508	new_data_azi[position+j]=new_data_azi[position+j-1]+1
	509	return new_data_azi
	510
	511	def fixDATA(self,data_azi):
	512	data=data_azi
	513	for i in range(len(data)):
	514	if numpy.isnan(data[i]):
	515	data[i]=data[i-1]+1
	516	return data
	517
	518	def replaceNAN(self,data_weather,data_azi,val):
	519	data= data_azi
	520	data_T= data_weather
	521	if data.shape[0]> data_T.shape[0]:
	522	data_N = numpy.ones( [data.shape[0],data_T.shape[1]])
	523	c = 0
	524	for i in range(len(data)):
	525	if numpy.isnan(data[i]):
	526	data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
	527	else:
	528	data_N[i,:]=data_T[c,:]
	529	c=c+1
	530	return data_N
	531	else:
	532	for i in range(len(data)):
	533	if numpy.isnan(data[i]):
	534	data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
	535	return data_T
	536
	537	def const_ploteo(self,data_weather,data_azi,step,res):
	538	if self.ini==0:
	539	#-------
	540	n = (360/res)-len(data_azi)
	541	#--------------------- new -------------------------
	542	data_azi_new ,data_azi_old= self.globalCheckPED(data_azi)
	543	#------------------------
	544	start = data_azi_new[-1] + res
	545	end = data_azi_new[0] - res
	546	#------ new
	547	self.last_data_azi = end
	548	if start>end:
	549	end = end + 360
	550	azi_vacia = numpy.linspace(start,end,int(n))
	551	azi_vacia = numpy.where(azi_vacia>360,azi_vacia-360,azi_vacia)
	552	data_azi = numpy.hstack((data_azi_new,azi_vacia))
	553	# RADAR
	554	val_mean = numpy.mean(data_weather[:,-1])
	555	self.val_mean = val_mean
	556	data_weather_cmp = numpy.ones([(360-data_weather.shape[0]),data_weather.shape[1]])*val_mean
	557	data_weather = self.replaceNAN(data_weather=data_weather,data_azi=data_azi_old,val=self.val_mean)
	558	data_weather = numpy.vstack((data_weather,data_weather_cmp))
	559	else:
	560	# azimuth
	561	flag=0
	562	start_azi = self.res_azi[0]
	563	#-----------new------------
	564	data_azi ,data_azi_old= self.globalCheckPED(data_azi)
	565	data_weather = self.replaceNAN(data_weather=data_weather,data_azi=data_azi_old,val=self.val_mean)
	566	#--------------------------
	567	start = data_azi[0]
	568	end = data_azi[-1]
	569	self.last_data_azi= end
	570	if start< start_azi:
	571	start = start +360
	572	if end <start_azi:
	573	end = end +360
	574
	575	pos_ini = int((start-start_azi)/res)
	576	len_azi = len(data_azi)
	577	if (360-pos_ini)<len_azi:
	578	if pos_ini+1==360:
	579	pos_ini=0
	580	else:
	581	flag=1
	582	dif= 360-pos_ini
	583	comp= len_azi-dif
	584	#-----------------
	585	if flag==0:
	586	# AZIMUTH
	587	self.res_azi[pos_ini:pos_ini+len_azi] = data_azi
	588	# RADAR
	589	self.res_weather[pos_ini:pos_ini+len_azi,:] = data_weather
	590	else:
	591	# AZIMUTH
	592	self.res_azi[pos_ini:pos_ini+dif] = data_azi[0:dif]
	593	self.res_azi[0:comp] = data_azi[dif:]
	594	# RADAR
	595	self.res_weather[pos_ini:pos_ini+dif,:] = data_weather[0:dif,:]
	596	self.res_weather[0:comp,:] = data_weather[dif:,:]
	597	flag=0
	598	data_azi = self.res_azi
	599	data_weather = self.res_weather
	600
	601	return data_weather,data_azi
	602
	603	def plot(self):
	604	thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
	605	data = self.data[-1]
	606	r = self.data.yrange
	607	delta_height = r[1]-r[0]
	608	r_mask = numpy.where(r>=0)[0]
	609	r = numpy.arange(len(r_mask))*delta_height
	610	self.y = 2*r
	611	# RADAR
	612	#data_weather = data['weather']
	613	# PEDESTAL
	614	#data_azi = data['azi']
	615	res = 1
	616	# STEP
	617	step = (360/(res*data['weather'].shape[0]))
	618
	619	self.res_weather, self.res_azi = self.const_ploteo(data_weather=data['weather'][:,r_mask],data_azi=data['azi'],step=step,res=res)
	620	self.res_ele = numpy.mean(data['ele'])
	621	################# PLOTEO ###################
	622	for i,ax in enumerate(self.axes):
	623	self.zmin = self.zmin if self.zmin else 20
	624	self.zmax = self.zmax if self.zmax else 80
	625	if ax.firsttime:
	626	plt.clf()
	627	cgax, pm = wrl.vis.plot_ppi(self.res_weather,r=r,az=self.res_azi,fig=self.figures[0], proj='cg', vmin=self.zmin, vmax=self.zmax)
	628	else:
	629	plt.clf()
	630	cgax, pm = wrl.vis.plot_ppi(self.res_weather,r=r,az=self.res_azi,fig=self.figures[0], proj='cg', vmin=self.zmin, vmax=self.zmax)
	631	caax = cgax.parasites[0]
	632	paax = cgax.parasites[1]
	633	cbar = plt.gcf().colorbar(pm, pad=0.075)
	634	caax.set_xlabel('x_range [km]')
	635	caax.set_ylabel('y_range [km]')
	636	plt.text(1.0, 1.05, 'Azimuth '+str(thisDatetime)+" Step "+str(self.ini)+ " EL: "+str(round(self.res_ele, 1)), transform=caax.transAxes, va='bottom',ha='right')
	637
	638	self.ini= self.ini+1
	639
	640
	641	class WeatherRHIPlot(Plot):
	642	CODE = 'weather'
	643	plot_name = 'weather'
	644	plot_type = 'rhistyle'
	645	buffering = False
	646	data_ele_tmp = None
	647
	648	def setup(self):
	649	print("********************")
	650	print("********************")
	651	print("********************")
	652	print("SETUP WEATHER PLOT")
	653	self.ncols = 1
	654	self.nrows = 1
	655	self.nplots= 1
	656	self.ylabel= 'Range [Km]'
	657	self.titles= ['Weather']
	658	if self.channels is not None:
	659	self.nplots = len(self.channels)
	660	self.nrows = len(self.channels)
	661	else:
	662	self.nplots = self.data.shape(self.CODE)[0]
	663	self.nrows = self.nplots
	664	self.channels = list(range(self.nplots))
	665	print("channels",self.channels)
	666	print("que saldra", self.data.shape(self.CODE)[0])
	667	self.titles = ['{} Channel {}'.format(self.CODE.upper(), x) for x in range(self.nrows)]
	668	print("self.titles",self.titles)
	669	self.colorbar=False
	670	self.width =12
	671	self.height =8
	672	self.ini =0
	673	self.len_azi =0
	674	self.buffer_ini = None
	675	self.buffer_ele = None
	676	self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
	677	self.flag =0
	678	self.indicador= 0
	679	self.last_data_ele = None
	680	self.val_mean = None
	681
	682	def update(self, dataOut):
	683
	684	data = {}
	685	meta = {}
	686	if hasattr(dataOut, 'dataPP_POWER'):
	687	factor = 1
	688	if hasattr(dataOut, 'nFFTPoints'):
	689	factor = dataOut.normFactor
	690	print("dataOut",dataOut.data_360.shape)
	691	#
	692	data['weather'] = 10*numpy.log10(dataOut.data_360/(factor))
	693	#
	694	#data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
	695	data['azi'] = dataOut.data_azi
	696	data['ele'] = dataOut.data_ele
	697	#print("UPDATE")
	698	#print("data[weather]",data['weather'].shape)
	699	#print("data[azi]",data['azi'])
	700	return data, meta
	701
	702	def get2List(self,angulos):
	703	list1=[]
	704	list2=[]
	705	for i in reversed(range(len(angulos))):
	706	if not i==0:#el caso de i=0 evalula el primero de la lista con el ultimo y no es relevante
	707	diff_ = angulos[i]-angulos[i-1]
	708	if abs(diff_) >1.5:
	709	list1.append(i-1)
	710	list2.append(diff_)
	711	return list(reversed(list1)),list(reversed(list2))
	712
	713	def fixData90(self,list_,ang_):
	714	if list_[0]==-1:
	715	vec = numpy.where(ang_<ang_[0])
	716	ang_[vec] = ang_[vec]+90
	717	return ang_
	718	return ang_
	719
	720	def fixData90HL(self,angulos):
	721	vec = numpy.where(angulos>=90)
	722	angulos[vec]=angulos[vec]-90
	723	return angulos
	724
	725
	726	def search_pos(self,pos,list_):
	727	for i in range(len(list_)):
	728	if pos == list_[i]:
	729	return True,i
	730	i=None
	731	return False,i
	732
	733	def fixDataComp(self,ang_,list1_,list2_,tipo_case):
	734	size = len(ang_)
	735	size2 = 0
	736	for i in range(len(list2_)):
	737	size2=size2+round(abs(list2_[i]))-1
	738	new_size= size+size2
	739	ang_new = numpy.zeros(new_size)
	740	ang_new2 = numpy.zeros(new_size)
	741
	742	tmp = 0
	743	c = 0
	744	for i in range(len(ang_)):
	745	ang_new[tmp +c] = ang_[i]
	746	ang_new2[tmp+c] = ang_[i]
	747	condition , value = self.search_pos(i,list1_)
	748	if condition:
	749	pos = tmp + c + 1
	750	for k in range(round(abs(list2_[value]))-1):
	751	if tipo_case==0 or tipo_case==3:#subida
	752	ang_new[pos+k] = ang_new[pos+k-1]+1
	753	ang_new2[pos+k] = numpy.nan
	754	elif tipo_case==1 or tipo_case==2:#bajada
	755	ang_new[pos+k] = ang_new[pos+k-1]-1
	756	ang_new2[pos+k] = numpy.nan
	757
	758	tmp = pos +k
	759	c = 0
	760	c=c+1
	761	return ang_new,ang_new2
	762
	763	def globalCheckPED(self,angulos,tipo_case):
	764	l1,l2 = self.get2List(angulos)
	765	##print("l1",l1)
	766	##print("l2",l2)
	767	if len(l1)>0:
	768	#angulos2 = self.fixData90(list_=l1,ang_=angulos)
	769	#l1,l2 = self.get2List(angulos2)
	770	ang1_,ang2_ = self.fixDataComp(ang_=angulos,list1_=l1,list2_=l2,tipo_case=tipo_case)
	771	#ang1_ = self.fixData90HL(ang1_)
	772	#ang2_ = self.fixData90HL(ang2_)
	773	else:
	774	ang1_= angulos
	775	ang2_= angulos
	776	return ang1_,ang2_
	777
	778
	779	def replaceNAN(self,data_weather,data_ele,val):
	780	data= data_ele
	781	data_T= data_weather
	782	if data.shape[0]> data_T.shape[0]:
	783	data_N = numpy.ones( [data.shape[0],data_T.shape[1]])
	784	c = 0
	785	for i in range(len(data)):
	786	if numpy.isnan(data[i]):
	787	data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
	788	else:
	789	data_N[i,:]=data_T[c,:]
	790	c=c+1
	791	return data_N
	792	else:
	793	for i in range(len(data)):
	794	if numpy.isnan(data[i]):
	795	data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
	796	return data_T
	797
	798	def check_case(self,data_ele,ang_max,ang_min):
	799	start = data_ele[0]
	800	end = data_ele[-1]
	801	number = (end-start)
	802	len_ang=len(data_ele)
	803	print("start",start)
	804	print("end",end)
	805	print("number",number)
	806
	807	print("len_ang",len_ang)
	808
	809	#exit(1)
	810
	811	if start<end and (round(abs(number)+1)>=len_ang or (numpy.argmin(data_ele)==0)):#caso subida
	812	return 0
	813	#elif start>end and (round(abs(number)+1)>=len_ang or(numpy.argmax(data_ele)==0)):#caso bajada
	814	# return 1
	815	elif round(abs(number)+1)>=len_ang and (start>end or(numpy.argmax(data_ele)==0)):#caso bajada
	816	return 1
	817	elif round(abs(number)+1)<len_ang and data_ele[-2]>data_ele[-1]:# caso BAJADA CAMBIO ANG MAX
	818	return 2
	819	elif round(abs(number)+1)<len_ang and data_ele[-2]<data_ele[-1] :# caso SUBIDA CAMBIO ANG MIN
	820	return 3
	821
	822
	823	def const_ploteo(self,val_ch,data_weather,data_ele,step,res,ang_max,ang_min):
	824	ang_max= ang_max
	825	ang_min= ang_min
	826	data_weather=data_weather
	827	val_ch=val_ch
	828	##print("*******************DATA WEATHER************************************")
	829	##print(data_weather)
	830	if self.ini==0:
	831	'''
	832	print("**********************************************")
	833	print("**********************************************")
	834	print("*************ini************")
	835	print("**********************************************")
	836	print("**********************************************")
	837	'''
	838	#print("data_ele",data_ele)
	839	#----------------------------------------------------------
	840	tipo_case = self.check_case(data_ele,ang_max,ang_min)
	841	print("check_case",tipo_case)
	842	#exit(1)
	843	#--------------------- new -------------------------
	844	data_ele_new ,data_ele_old= self.globalCheckPED(data_ele,tipo_case)
	845
	846	#-------------------------CAMBIOS RHI---------------------------------
	847	start= ang_min
	848	end = ang_max
	849	n= (ang_max-ang_min)/res
	850	#------ new
	851	self.start_data_ele = data_ele_new[0]
	852	self.end_data_ele = data_ele_new[-1]
	853	if tipo_case==0 or tipo_case==3: # SUBIDA
	854	n1= round(self.start_data_ele)- start
	855	n2= end - round(self.end_data_ele)
	856	print(self.start_data_ele)
	857	print(self.end_data_ele)
	858	if n1>0:
	859	ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
	860	ele1_nan= numpy.ones(n1)*numpy.nan
	861	data_ele = numpy.hstack((ele1,data_ele_new))
	862	print("ele1_nan",ele1_nan.shape)
	863	print("data_ele_old",data_ele_old.shape)
	864	data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
	865	if n2>0:
	866	ele2= numpy.linspace(self.end_data_ele+1,end,n2)
	867	ele2_nan= numpy.ones(n2)*numpy.nan
	868	data_ele = numpy.hstack((data_ele,ele2))
	869	print("ele2_nan",ele2_nan.shape)
	870	print("data_ele_old",data_ele_old.shape)
	871	data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
	872
	873	if tipo_case==1 or tipo_case==2: # BAJADA
	874	data_ele_new = data_ele_new[::-1] # reversa
	875	data_ele_old = data_ele_old[::-1]# reversa
	876	data_weather = data_weather[::-1,:]# reversa
	877	vec= numpy.where(data_ele_new<ang_max)
	878	data_ele_new = data_ele_new[vec]
	879	data_ele_old = data_ele_old[vec]
	880	data_weather = data_weather[vec[0]]
	881	vec2= numpy.where(0<data_ele_new)
	882	data_ele_new = data_ele_new[vec2]
	883	data_ele_old = data_ele_old[vec2]
	884	data_weather = data_weather[vec2[0]]
	885	self.start_data_ele = data_ele_new[0]
	886	self.end_data_ele = data_ele_new[-1]
	887
	888	n1= round(self.start_data_ele)- start
	889	n2= end - round(self.end_data_ele)-1
	890	print(self.start_data_ele)
	891	print(self.end_data_ele)
	892	if n1>0:
	893	ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
	894	ele1_nan= numpy.ones(n1)*numpy.nan
	895	data_ele = numpy.hstack((ele1,data_ele_new))
	896	data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
	897	if n2>0:
	898	ele2= numpy.linspace(self.end_data_ele+1,end,n2)
	899	ele2_nan= numpy.ones(n2)*numpy.nan
	900	data_ele = numpy.hstack((data_ele,ele2))
	901	data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
	902	# RADAR
	903	# NOTA data_ele y data_weather es la variable que retorna
	904	val_mean = numpy.mean(data_weather[:,-1])
	905	self.val_mean = val_mean
	906	data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
	907	self.data_ele_tmp[val_ch]= data_ele_old
	908	else:
	909	#print("**********************************************")
	910	#print("**************VARIABLE********************")
	911	#-------------------------CAMBIOS RHI---------------------------------
	912	#---------------------------------------------------------------------
	913	##print("INPUT data_ele",data_ele)
	914	flag=0
	915	start_ele = self.res_ele[0]
	916	tipo_case = self.check_case(data_ele,ang_max,ang_min)
	917	#print("TIPO DE DATA",tipo_case)
	918	#-----------new------------
	919	data_ele ,data_ele_old = self.globalCheckPED(data_ele,tipo_case)
	920	data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
	921
	922	#-------------------------------NEW RHI ITERATIVO-------------------------
	923
	924	if tipo_case==0 : # SUBIDA
	925	vec = numpy.where(data_ele<ang_max)
	926	data_ele = data_ele[vec]
	927	data_ele_old = data_ele_old[vec]
	928	data_weather = data_weather[vec[0]]
	929
	930	vec2 = numpy.where(0<data_ele)
	931	data_ele= data_ele[vec2]
	932	data_ele_old= data_ele_old[vec2]
	933	##print(data_ele_new)
	934	data_weather= data_weather[vec2[0]]
	935
	936	new_i_ele = int(round(data_ele[0]))
	937	new_f_ele = int(round(data_ele[-1]))
	938	#print(new_i_ele)
	939	#print(new_f_ele)
	940	#print(data_ele,len(data_ele))
	941	#print(data_ele_old,len(data_ele_old))
	942	if new_i_ele< 2:
	943	self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
	944	self.res_weather[val_ch] = self.replaceNAN(data_weather=self.res_weather[val_ch],data_ele=self.data_ele_tmp[val_ch],val=self.val_mean)
	945	self.data_ele_tmp[val_ch][new_i_ele:new_i_ele+len(data_ele)]=data_ele_old
	946	self.res_ele[new_i_ele:new_i_ele+len(data_ele)]= data_ele
	947	self.res_weather[val_ch][new_i_ele:new_i_ele+len(data_ele),:]= data_weather
	948	data_ele = self.res_ele
	949	data_weather = self.res_weather[val_ch]
	950
	951	elif tipo_case==1 : #BAJADA
	952	data_ele = data_ele[::-1] # reversa
	953	data_ele_old = data_ele_old[::-1]# reversa
	954	data_weather = data_weather[::-1,:]# reversa
	955	vec= numpy.where(data_ele<ang_max)
	956	data_ele = data_ele[vec]
	957	data_ele_old = data_ele_old[vec]
	958	data_weather = data_weather[vec[0]]
	959	vec2= numpy.where(0<data_ele)
	960	data_ele = data_ele[vec2]
	961	data_ele_old = data_ele_old[vec2]
	962	data_weather = data_weather[vec2[0]]
	963
	964
	965	new_i_ele = int(round(data_ele[0]))
	966	new_f_ele = int(round(data_ele[-1]))
	967	#print(data_ele)
	968	#print(ang_max)
	969	#print(data_ele_old)
	970	if new_i_ele <= 1:
	971	new_i_ele = 1
	972	if round(data_ele[-1])>=ang_max-1:
	973	self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
	974	self.res_weather[val_ch] = self.replaceNAN(data_weather=self.res_weather[val_ch],data_ele=self.data_ele_tmp[val_ch],val=self.val_mean)
	975	self.data_ele_tmp[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1]=data_ele_old
	976	self.res_ele[new_i_ele-1:new_i_ele+len(data_ele)-1]= data_ele
	977	self.res_weather[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1,:]= data_weather
	978	data_ele = self.res_ele
	979	data_weather = self.res_weather[val_ch]
	980
	981	elif tipo_case==2: #bajada
	982	vec = numpy.where(data_ele<ang_max)
	983	data_ele = data_ele[vec]
	984	data_weather= data_weather[vec[0]]
	985
	986	len_vec = len(vec)
	987	data_ele_new = data_ele[::-1] # reversa
	988	data_weather = data_weather[::-1,:]
	989	new_i_ele = int(data_ele_new[0])
	990	new_f_ele = int(data_ele_new[-1])
	991
	992	n1= new_i_ele- ang_min
	993	n2= ang_max - new_f_ele-1
	994	if n1>0:
	995	ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
	996	ele1_nan= numpy.ones(n1)*numpy.nan
	997	data_ele = numpy.hstack((ele1,data_ele_new))
	998	data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
	999	if n2>0:
	1000	ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
	1001	ele2_nan= numpy.ones(n2)*numpy.nan
	1002	data_ele = numpy.hstack((data_ele,ele2))
	1003	data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
	1004
	1005	self.data_ele_tmp[val_ch] = data_ele_old
	1006	self.res_ele = data_ele
	1007	self.res_weather[val_ch] = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
	1008	data_ele = self.res_ele
	1009	data_weather = self.res_weather[val_ch]
	1010
	1011	elif tipo_case==3:#subida
	1012	vec = numpy.where(0<data_ele)
	1013	data_ele= data_ele[vec]
	1014	data_ele_new = data_ele
	1015	data_ele_old= data_ele_old[vec]
	1016	data_weather= data_weather[vec[0]]
	1017	pos_ini = numpy.argmin(data_ele)
	1018	if pos_ini>0:
	1019	len_vec= len(data_ele)
	1020	vec3 = numpy.linspace(pos_ini,len_vec-1,len_vec-pos_ini).astype(int)
	1021	#print(vec3)
	1022	data_ele= data_ele[vec3]
	1023	data_ele_new = data_ele
	1024	data_ele_old= data_ele_old[vec3]
	1025	data_weather= data_weather[vec3]
	1026
	1027	new_i_ele = int(data_ele_new[0])
	1028	new_f_ele = int(data_ele_new[-1])
	1029	n1= new_i_ele- ang_min
	1030	n2= ang_max - new_f_ele-1
	1031	if n1>0:
	1032	ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
	1033	ele1_nan= numpy.ones(n1)*numpy.nan
	1034	data_ele = numpy.hstack((ele1,data_ele_new))
	1035	data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
	1036	if n2>0:
	1037	ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
	1038	ele2_nan= numpy.ones(n2)*numpy.nan
	1039	data_ele = numpy.hstack((data_ele,ele2))
	1040	data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
	1041
	1042	self.data_ele_tmp[val_ch] = data_ele_old
	1043	self.res_ele = data_ele
	1044	self.res_weather[val_ch] = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
	1045	data_ele = self.res_ele
	1046	data_weather = self.res_weather[val_ch]
	1047	#print("self.data_ele_tmp",self.data_ele_tmp)
	1048	return data_weather,data_ele
	1049
	1050
	1051	def plot(self):
	1052	thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
	1053	data = self.data[-1]
	1054	r = self.data.yrange
	1055	delta_height = r[1]-r[0]
	1056	r_mask = numpy.where(r>=0)[0]
	1057	##print("delta_height",delta_height)
	1058	#print("r_mask",r_mask,len(r_mask))
	1059	r = numpy.arange(len(r_mask))*delta_height
	1060	self.y = 2*r
	1061	res = 1
	1062	###print("data['weather'].shape[0]",data['weather'].shape[0])
	1063	ang_max = self.ang_max
	1064	ang_min = self.ang_min
	1065	var_ang =ang_max - ang_min
	1066	step = (int(var_ang)/(res*data['weather'].shape[0]))
	1067	###print("step",step)
	1068	#--------------------------------------------------------
	1069	##print('weather',data['weather'].shape)
	1070	##print('ele',data['ele'].shape)
	1071
	1072	###self.res_weather, self.res_ele = self.const_ploteo(data_weather=data['weather'][:,r_mask],data_ele=data['ele'],step=step,res=res,ang_max=ang_max,ang_min=ang_min)
	1073	###self.res_azi = numpy.mean(data['azi'])
	1074	###print("self.res_ele",self.res_ele)
	1075	plt.clf()
	1076	subplots = [121, 122]
	1077	cg={'angular_spacing': 20.}
	1078	if self.ini==0:
	1079	self.data_ele_tmp = numpy.ones([self.nplots,int(var_ang)])*numpy.nan
	1080	self.res_weather= numpy.ones([self.nplots,int(var_ang),len(r_mask)])*numpy.nan
	1081	print("SHAPE",self.data_ele_tmp.shape)
	1082
	1083	for i,ax in enumerate(self.axes):
	1084	self.res_weather[i], self.res_ele = self.const_ploteo(val_ch=i, data_weather=data['weather'][i][:,r_mask],data_ele=data['ele'],step=step,res=res,ang_max=ang_max,ang_min=ang_min)
	1085	self.res_azi = numpy.mean(data['azi'])
	1086	if i==0:
	1087	print("***************************************************************************to plot************************",self.res_weather[i].shape)
	1088	self.zmin = self.zmin if self.zmin else 20
	1089	self.zmax = self.zmax if self.zmax else 80
	1090	if ax.firsttime:
	1091	#plt.clf()
	1092	cgax, pm = wrl.vis.plot_rhi(self.res_weather[i],r=r,th=self.res_ele,ax=subplots[i], proj=cg,vmin=self.zmin, vmax=self.zmax)
	1093	#fig=self.figures[0]
	1094	else:
	1095	#plt.clf()
	1096	if i==0:
	1097	print(self.res_weather[i])
	1098	print(self.res_ele)
	1099	cgax, pm = wrl.vis.plot_rhi(self.res_weather[i],r=r,th=self.res_ele,ax=subplots[i], proj=cg,vmin=self.zmin, vmax=self.zmax)
	1100	caax = cgax.parasites[0]
	1101	paax = cgax.parasites[1]
	1102	cbar = plt.gcf().colorbar(pm, pad=0.075)
	1103	caax.set_xlabel('x_range [km]')
	1104	caax.set_ylabel('y_range [km]')
	1105	plt.text(1.0, 1.05, 'Elevacion '+str(thisDatetime)+" Step "+str(self.ini)+ " Azi: "+str(round(self.res_azi,2)), transform=caax.transAxes, va='bottom',ha='right')
	1106	print("*************************self.ini**************************",self.ini)
	1107	self.ini= self.ini+1
	1108
	1109	class Weather_vRF_Plot(Plot):
	1110	CODE = 'PPI'
	1111	plot_name = 'PPI'
	1112	#plot_type = 'ppistyle'
	1113	buffering = False
	1114
	1115	def setup(self):
	1116
	1117	self.ncols = 1
	1118	self.nrows = 1
	1119	self.width =8
	1120	self.height =8
	1121	self.nplots= 1
	1122	self.ylabel= 'Range [Km]'
	1123	self.xlabel= 'Range [Km]'
	1124	self.titles= ['PPI']
	1125	self.polar = True
	1126	if self.channels is not None:
	1127	self.nplots = len(self.channels)
	1128	self.nrows = len(self.channels)
	1129	else:
	1130	self.nplots = self.data.shape(self.CODE)[0]
	1131	self.nrows = self.nplots
	1132	self.channels = list(range(self.nplots))
	1133
	1134	if self.CODE == 'POWER':
	1135	self.cb_label = r'Power (dB)'
	1136	elif self.CODE == 'DOPPLER':
	1137	self.cb_label = r'Velocity (m/s)'
	1138	self.colorbar=True
	1139	self.width = 9
	1140	self.height =8
	1141	self.ini =0
	1142	self.len_azi =0
	1143	self.buffer_ini = None
	1144	self.buffer_ele = None
	1145	self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.15, 'right': 0.9, 'bottom': 0.08})
	1146	self.flag =0
	1147	self.indicador= 0
	1148	self.last_data_ele = None
	1149	self.val_mean = None
	1150
	1151	def update(self, dataOut):
	1152
	1153	data = {}
	1154	meta = {}
	1155	if hasattr(dataOut, 'dataPP_POWER'):
	1156	factor = 1
	1157	if hasattr(dataOut, 'nFFTPoints'):
	1158	factor = dataOut.normFactor
	1159
	1160	if 'pow' in self.attr_data[0].lower():
	1161	data['data'] = 10*numpy.log10(getattr(dataOut, self.attr_data[0])/(factor))
	1162	else:
	1163	data['data'] = getattr(dataOut, self.attr_data[0])/(factor)
	1164
	1165	data['azi'] = dataOut.data_azi
	1166	data['ele'] = dataOut.data_ele
	1167
	1168	return data, meta
	1169
	1170	def plot(self):
	1171	data = self.data[-1]
	1172	r = self.data.yrange
	1173	delta_height = r[1]-r[0]
	1174	r_mask = numpy.where(r>=0)[0]
	1175	self.r_mask = r_mask
	1176	r = numpy.arange(len(r_mask))*delta_height
	1177	self.y = 2*r
	1178
	1179	try:
	1180	z = data['data'][self.channels[0]][:,r_mask]
	1181
	1182	except:
	1183	z = data['data'][0][:,r_mask]
	1184
	1185	self.titles = []
	1186
	1187	self.ymax = self.ymax if self.ymax else numpy.nanmax(r)
	1188	self.ymin = self.ymin if self.ymin else numpy.nanmin(r)
	1189	self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
	1190	self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
	1191	self.ang_min = self.ang_min if self.ang_min else 0
	1192	self.ang_max = self.ang_max if self.ang_max else 360
	1193
	1194	r, theta = numpy.meshgrid(r, numpy.radians(data['azi']) )
	1195
	1196	for i,ax in enumerate(self.axes):
	1197
	1198	if ax.firsttime:
	1199	ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
	1200	ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
	1201	ax.set_theta_direction(-1)
	1202
	1203	else:
	1204	ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
	1205	ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
	1206	ax.set_theta_direction(-1)
	1207
	1208	ax.grid(True)
	1209
	1210	if len(self.channels) !=1:
	1211	self.titles = ['PPI {} at EL: {} Channel {}'.format(self.self.labels[x], str(round(numpy.mean(data['ele']),1)), x) for x in range(self.nrows)]
	1212	else:
	1213	self.titles = ['PPI {} at EL: {} Channel {}'.format(self.labels[0], str(round(numpy.mean(data['ele']),1)), self.channels[0])]
	1214
	1215	class WeatherRHI_vRF2_Plot(Plot):
	1216	CODE = 'weather'
	1217	plot_name = 'weather'
	1218	plot_type = 'rhistyle'
	1219	buffering = False
	1220	data_ele_tmp = None
	1221
	1222	def setup(self):
	1223	print("********************")
	1224	print("********************")
	1225	print("********************")
	1226	print("SETUP WEATHER PLOT")
	1227	self.ncols = 1
	1228	self.nrows = 1
	1229	self.nplots= 1
	1230	self.ylabel= 'Range [Km]'
	1231	self.titles= ['Weather']
	1232	if self.channels is not None:
	1233	self.nplots = len(self.channels)
	1234	self.nrows = len(self.channels)
	1235	else:
	1236	self.nplots = self.data.shape(self.CODE)[0]
	1237	self.nrows = self.nplots
	1238	self.channels = list(range(self.nplots))
	1239	print("channels",self.channels)
	1240	print("que saldra", self.data.shape(self.CODE)[0])
	1241	self.titles = ['{} Channel {}'.format(self.CODE.upper(), x) for x in range(self.nrows)]
	1242	print("self.titles",self.titles)
	1243	self.colorbar=False
	1244	self.width =8
	1245	self.height =8
	1246	self.ini =0
	1247	self.len_azi =0
	1248	self.buffer_ini = None
	1249	self.buffer_ele = None
	1250	self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
	1251	self.flag =0
	1252	self.indicador= 0
	1253	self.last_data_ele = None
	1254	self.val_mean = None
	1255
	1256	def update(self, dataOut):
	1257
	1258	data = {}
	1259	meta = {}
	1260	if hasattr(dataOut, 'dataPP_POWER'):
	1261	factor = 1
	1262	if hasattr(dataOut, 'nFFTPoints'):
	1263	factor = dataOut.normFactor
	1264	print("dataOut",dataOut.data_360.shape)
	1265	#
	1266	data['weather'] = 10*numpy.log10(dataOut.data_360/(factor))
	1267	#
	1268	#data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
	1269	data['azi'] = dataOut.data_azi
	1270	data['ele'] = dataOut.data_ele
	1271	data['case_flag'] = dataOut.case_flag
	1272	#print("UPDATE")
	1273	#print("data[weather]",data['weather'].shape)
	1274	#print("data[azi]",data['azi'])
	1275	return data, meta
	1276
	1277	def get2List(self,angulos):
	1278	list1=[]
	1279	list2=[]
	1280	for i in reversed(range(len(angulos))):
	1281	if not i==0:#el caso de i=0 evalula el primero de la lista con el ultimo y no es relevante
	1282	diff_ = angulos[i]-angulos[i-1]
	1283	if abs(diff_) >1.5:
	1284	list1.append(i-1)
	1285	list2.append(diff_)
	1286	return list(reversed(list1)),list(reversed(list2))
	1287
	1288	def fixData90(self,list_,ang_):
	1289	if list_[0]==-1:
	1290	vec = numpy.where(ang_<ang_[0])
	1291	ang_[vec] = ang_[vec]+90
	1292	return ang_
	1293	return ang_
	1294
	1295	def fixData90HL(self,angulos):
	1296	vec = numpy.where(angulos>=90)
	1297	angulos[vec]=angulos[vec]-90
	1298	return angulos
	1299
	1300
	1301	def search_pos(self,pos,list_):
	1302	for i in range(len(list_)):
	1303	if pos == list_[i]:
	1304	return True,i
	1305	i=None
	1306	return False,i
	1307
	1308	def fixDataComp(self,ang_,list1_,list2_,tipo_case):
	1309	size = len(ang_)
	1310	size2 = 0
	1311	for i in range(len(list2_)):
	1312	size2=size2+round(abs(list2_[i]))-1
	1313	new_size= size+size2
	1314	ang_new = numpy.zeros(new_size)
	1315	ang_new2 = numpy.zeros(new_size)
	1316
	1317	tmp = 0
	1318	c = 0
	1319	for i in range(len(ang_)):
	1320	ang_new[tmp +c] = ang_[i]
	1321	ang_new2[tmp+c] = ang_[i]
	1322	condition , value = self.search_pos(i,list1_)
	1323	if condition:
	1324	pos = tmp + c + 1
	1325	for k in range(round(abs(list2_[value]))-1):
	1326	if tipo_case==0 or tipo_case==3:#subida
	1327	ang_new[pos+k] = ang_new[pos+k-1]+1
	1328	ang_new2[pos+k] = numpy.nan
	1329	elif tipo_case==1 or tipo_case==2:#bajada
	1330	ang_new[pos+k] = ang_new[pos+k-1]-1
	1331	ang_new2[pos+k] = numpy.nan
	1332
	1333	tmp = pos +k
	1334	c = 0
	1335	c=c+1
	1336	return ang_new,ang_new2
	1337
	1338	def globalCheckPED(self,angulos,tipo_case):
	1339	l1,l2 = self.get2List(angulos)
	1340	##print("l1",l1)
	1341	##print("l2",l2)
	1342	if len(l1)>0:
	1343	#angulos2 = self.fixData90(list_=l1,ang_=angulos)
	1344	#l1,l2 = self.get2List(angulos2)
	1345	ang1_,ang2_ = self.fixDataComp(ang_=angulos,list1_=l1,list2_=l2,tipo_case=tipo_case)
	1346	#ang1_ = self.fixData90HL(ang1_)
	1347	#ang2_ = self.fixData90HL(ang2_)
	1348	else:
	1349	ang1_= angulos
	1350	ang2_= angulos
	1351	return ang1_,ang2_
	1352
	1353
	1354	def replaceNAN(self,data_weather,data_ele,val):
	1355	data= data_ele
	1356	data_T= data_weather
	1357	if data.shape[0]> data_T.shape[0]:
	1358	data_N = numpy.ones( [data.shape[0],data_T.shape[1]])
	1359	c = 0
	1360	for i in range(len(data)):
	1361	if numpy.isnan(data[i]):
	1362	data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
	1363	else:
	1364	data_N[i,:]=data_T[c,:]
	1365	c=c+1
	1366	return data_N
	1367	else:
	1368	for i in range(len(data)):
	1369	if numpy.isnan(data[i]):
	1370	data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
	1371	return data_T
	1372
	1373	def check_case(self,data_ele,ang_max,ang_min):
	1374	start = data_ele[0]
	1375	end = data_ele[-1]
	1376	number = (end-start)
	1377	len_ang=len(data_ele)
	1378	print("start",start)
	1379	print("end",end)
	1380	print("number",number)
	1381
	1382	print("len_ang",len_ang)
	1383
	1384	#exit(1)
	1385
	1386	if start<end and (round(abs(number)+1)>=len_ang or (numpy.argmin(data_ele)==0)):#caso subida
	1387	return 0
	1388	#elif start>end and (round(abs(number)+1)>=len_ang or(numpy.argmax(data_ele)==0)):#caso bajada
	1389	# return 1
	1390	elif round(abs(number)+1)>=len_ang and (start>end or(numpy.argmax(data_ele)==0)):#caso bajada
	1391	return 1
	1392	elif round(abs(number)+1)<len_ang and data_ele[-2]>data_ele[-1]:# caso BAJADA CAMBIO ANG MAX
	1393	return 2
	1394	elif round(abs(number)+1)<len_ang and data_ele[-2]<data_ele[-1] :# caso SUBIDA CAMBIO ANG MIN
	1395	return 3
	1396
	1397
	1398	def const_ploteo(self,val_ch,data_weather,data_ele,step,res,ang_max,ang_min,case_flag):
	1399	ang_max= ang_max
	1400	ang_min= ang_min
	1401	data_weather=data_weather
	1402	val_ch=val_ch
	1403	##print("*******************DATA WEATHER************************************")
	1404	##print(data_weather)
	1405	if self.ini==0:
	1406	'''
	1407	print("**********************************************")
	1408	print("**********************************************")
	1409	print("*************ini************")
	1410	print("**********************************************")
	1411	print("**********************************************")
	1412	'''
	1413	#print("data_ele",data_ele)
	1414	#----------------------------------------------------------
	1415	tipo_case = case_flag[-1]
	1416	#tipo_case = self.check_case(data_ele,ang_max,ang_min)
	1417	print("check_case",tipo_case)
	1418	#exit(1)
	1419	#--------------------- new -------------------------
	1420	data_ele_new ,data_ele_old= self.globalCheckPED(data_ele,tipo_case)
	1421
	1422	#-------------------------CAMBIOS RHI---------------------------------
	1423	start= ang_min
	1424	end = ang_max
	1425	n= (ang_max-ang_min)/res
	1426	#------ new
	1427	self.start_data_ele = data_ele_new[0]
	1428	self.end_data_ele = data_ele_new[-1]
	1429	if tipo_case==0 or tipo_case==3: # SUBIDA
	1430	n1= round(self.start_data_ele)- start
	1431	n2= end - round(self.end_data_ele)
	1432	print(self.start_data_ele)
	1433	print(self.end_data_ele)
	1434	if n1>0:
	1435	ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
	1436	ele1_nan= numpy.ones(n1)*numpy.nan
	1437	data_ele = numpy.hstack((ele1,data_ele_new))
	1438	print("ele1_nan",ele1_nan.shape)
	1439	print("data_ele_old",data_ele_old.shape)
	1440	data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
	1441	if n2>0:
	1442	ele2= numpy.linspace(self.end_data_ele+1,end,n2)
	1443	ele2_nan= numpy.ones(n2)*numpy.nan
	1444	data_ele = numpy.hstack((data_ele,ele2))
	1445	print("ele2_nan",ele2_nan.shape)
	1446	print("data_ele_old",data_ele_old.shape)
	1447	data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
	1448
	1449	if tipo_case==1 or tipo_case==2: # BAJADA
	1450	data_ele_new = data_ele_new[::-1] # reversa
	1451	data_ele_old = data_ele_old[::-1]# reversa
	1452	data_weather = data_weather[::-1,:]# reversa
	1453	vec= numpy.where(data_ele_new<ang_max)
	1454	data_ele_new = data_ele_new[vec]
	1455	data_ele_old = data_ele_old[vec]
	1456	data_weather = data_weather[vec[0]]
	1457	vec2= numpy.where(0<data_ele_new)
	1458	data_ele_new = data_ele_new[vec2]
	1459	data_ele_old = data_ele_old[vec2]
	1460	data_weather = data_weather[vec2[0]]
	1461	self.start_data_ele = data_ele_new[0]
	1462	self.end_data_ele = data_ele_new[-1]
	1463
	1464	n1= round(self.start_data_ele)- start
	1465	n2= end - round(self.end_data_ele)-1
	1466	print(self.start_data_ele)
	1467	print(self.end_data_ele)
	1468	if n1>0:
	1469	ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
	1470	ele1_nan= numpy.ones(n1)*numpy.nan
	1471	data_ele = numpy.hstack((ele1,data_ele_new))
	1472	data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
	1473	if n2>0:
	1474	ele2= numpy.linspace(self.end_data_ele+1,end,n2)
	1475	ele2_nan= numpy.ones(n2)*numpy.nan
	1476	data_ele = numpy.hstack((data_ele,ele2))
	1477	data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
	1478	# RADAR
	1479	# NOTA data_ele y data_weather es la variable que retorna
	1480	val_mean = numpy.mean(data_weather[:,-1])
	1481	self.val_mean = val_mean
	1482	data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
	1483	print("eleold",data_ele_old)
	1484	print(self.data_ele_tmp[val_ch])
	1485	print(data_ele_old.shape[0])
	1486	print(self.data_ele_tmp[val_ch].shape[0])
	1487	if (data_ele_old.shape[0]==91 or self.data_ele_tmp[val_ch].shape[0]==91):
	1488	import sys
	1489	print("EXIT",self.ini)
	1490
	1491	sys.exit(1)
	1492	self.data_ele_tmp[val_ch]= data_ele_old
	1493	else:
	1494	#print("**********************************************")
	1495	#print("**************VARIABLE********************")
	1496	#-------------------------CAMBIOS RHI---------------------------------
	1497	#---------------------------------------------------------------------
	1498	##print("INPUT data_ele",data_ele)
	1499	flag=0
	1500	start_ele = self.res_ele[0]
	1501	#tipo_case = self.check_case(data_ele,ang_max,ang_min)
	1502	tipo_case = case_flag[-1]
	1503	#print("TIPO DE DATA",tipo_case)
	1504	#-----------new------------
	1505	data_ele ,data_ele_old = self.globalCheckPED(data_ele,tipo_case)
	1506	data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
	1507
	1508	#-------------------------------NEW RHI ITERATIVO-------------------------
	1509
	1510	if tipo_case==0 : # SUBIDA
	1511	vec = numpy.where(data_ele<ang_max)
	1512	data_ele = data_ele[vec]
	1513	data_ele_old = data_ele_old[vec]
	1514	data_weather = data_weather[vec[0]]
	1515
	1516	vec2 = numpy.where(0<data_ele)
	1517	data_ele= data_ele[vec2]
	1518	data_ele_old= data_ele_old[vec2]
	1519	##print(data_ele_new)
	1520	data_weather= data_weather[vec2[0]]
	1521
	1522	new_i_ele = int(round(data_ele[0]))
	1523	new_f_ele = int(round(data_ele[-1]))
	1524	#print(new_i_ele)
	1525	#print(new_f_ele)
	1526	#print(data_ele,len(data_ele))
	1527	#print(data_ele_old,len(data_ele_old))
	1528	if new_i_ele< 2:
	1529	self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
	1530	self.res_weather[val_ch] = self.replaceNAN(data_weather=self.res_weather[val_ch],data_ele=self.data_ele_tmp[val_ch],val=self.val_mean)
	1531	self.data_ele_tmp[val_ch][new_i_ele:new_i_ele+len(data_ele)]=data_ele_old
	1532	self.res_ele[new_i_ele:new_i_ele+len(data_ele)]= data_ele
	1533	self.res_weather[val_ch][new_i_ele:new_i_ele+len(data_ele),:]= data_weather
	1534	data_ele = self.res_ele
	1535	data_weather = self.res_weather[val_ch]
	1536
	1537	elif tipo_case==1 : #BAJADA
	1538	data_ele = data_ele[::-1] # reversa
	1539	data_ele_old = data_ele_old[::-1]# reversa
	1540	data_weather = data_weather[::-1,:]# reversa
	1541	vec= numpy.where(data_ele<ang_max)
	1542	data_ele = data_ele[vec]
	1543	data_ele_old = data_ele_old[vec]
	1544	data_weather = data_weather[vec[0]]
	1545	vec2= numpy.where(0<data_ele)
	1546	data_ele = data_ele[vec2]
	1547	data_ele_old = data_ele_old[vec2]
	1548	data_weather = data_weather[vec2[0]]
	1549
	1550
	1551	new_i_ele = int(round(data_ele[0]))
	1552	new_f_ele = int(round(data_ele[-1]))
	1553	#print(data_ele)
	1554	#print(ang_max)
	1555	#print(data_ele_old)
	1556	if new_i_ele <= 1:
	1557	new_i_ele = 1
	1558	if round(data_ele[-1])>=ang_max-1:
	1559	self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
	1560	self.res_weather[val_ch] = self.replaceNAN(data_weather=self.res_weather[val_ch],data_ele=self.data_ele_tmp[val_ch],val=self.val_mean)
	1561	self.data_ele_tmp[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1]=data_ele_old
	1562	self.res_ele[new_i_ele-1:new_i_ele+len(data_ele)-1]= data_ele
	1563	self.res_weather[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1,:]= data_weather
	1564	data_ele = self.res_ele
	1565	data_weather = self.res_weather[val_ch]
	1566
	1567	elif tipo_case==2: #bajada
	1568	vec = numpy.where(data_ele<ang_max)
	1569	data_ele = data_ele[vec]
	1570	data_weather= data_weather[vec[0]]
	1571
	1572	len_vec = len(vec)
	1573	data_ele_new = data_ele[::-1] # reversa
	1574	data_weather = data_weather[::-1,:]
	1575	new_i_ele = int(data_ele_new[0])
	1576	new_f_ele = int(data_ele_new[-1])
	1577
	1578	n1= new_i_ele- ang_min
	1579	n2= ang_max - new_f_ele-1
	1580	if n1>0:
	1581	ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
	1582	ele1_nan= numpy.ones(n1)*numpy.nan
	1583	data_ele = numpy.hstack((ele1,data_ele_new))
	1584	data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
	1585	if n2>0:
	1586	ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
	1587	ele2_nan= numpy.ones(n2)*numpy.nan
	1588	data_ele = numpy.hstack((data_ele,ele2))
	1589	data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
	1590
	1591	self.data_ele_tmp[val_ch] = data_ele_old
	1592	self.res_ele = data_ele
	1593	self.res_weather[val_ch] = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
	1594	data_ele = self.res_ele
	1595	data_weather = self.res_weather[val_ch]
	1596
	1597	elif tipo_case==3:#subida
	1598	vec = numpy.where(0<data_ele)
	1599	data_ele= data_ele[vec]
	1600	data_ele_new = data_ele
	1601	data_ele_old= data_ele_old[vec]
	1602	data_weather= data_weather[vec[0]]
	1603	pos_ini = numpy.argmin(data_ele)
	1604	if pos_ini>0:
	1605	len_vec= len(data_ele)
	1606	vec3 = numpy.linspace(pos_ini,len_vec-1,len_vec-pos_ini).astype(int)
	1607	#print(vec3)
	1608	data_ele= data_ele[vec3]
	1609	data_ele_new = data_ele
	1610	data_ele_old= data_ele_old[vec3]
	1611	data_weather= data_weather[vec3]
	1612
	1613	new_i_ele = int(data_ele_new[0])
	1614	new_f_ele = int(data_ele_new[-1])
	1615	n1= new_i_ele- ang_min
	1616	n2= ang_max - new_f_ele-1
	1617	if n1>0:
	1618	ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
	1619	ele1_nan= numpy.ones(n1)*numpy.nan
	1620	data_ele = numpy.hstack((ele1,data_ele_new))
	1621	data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
	1622	if n2>0:
	1623	ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
	1624	ele2_nan= numpy.ones(n2)*numpy.nan
	1625	data_ele = numpy.hstack((data_ele,ele2))
	1626	data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
	1627
	1628	self.data_ele_tmp[val_ch] = data_ele_old
	1629	self.res_ele = data_ele
	1630	self.res_weather[val_ch] = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
	1631	data_ele = self.res_ele
	1632	data_weather = self.res_weather[val_ch]
	1633	#print("self.data_ele_tmp",self.data_ele_tmp)
	1634	return data_weather,data_ele
	1635
	1636
	1637	def plot(self):
	1638	thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
	1639	data = self.data[-1]
	1640	r = self.data.yrange
	1641	delta_height = r[1]-r[0]
	1642	r_mask = numpy.where(r>=0)[0]
	1643	##print("delta_height",delta_height)
	1644	#print("r_mask",r_mask,len(r_mask))
	1645	r = numpy.arange(len(r_mask))*delta_height
	1646	self.y = 2*r
	1647	res = 1
	1648	###print("data['weather'].shape[0]",data['weather'].shape[0])
	1649	ang_max = self.ang_max
	1650	ang_min = self.ang_min
	1651	var_ang =ang_max - ang_min
	1652	step = (int(var_ang)/(res*data['weather'].shape[0]))
	1653	###print("step",step)
	1654	#--------------------------------------------------------
	1655	##print('weather',data['weather'].shape)
	1656	##print('ele',data['ele'].shape)
	1657
	1658	###self.res_weather, self.res_ele = self.const_ploteo(data_weather=data['weather'][:,r_mask],data_ele=data['ele'],step=step,res=res,ang_max=ang_max,ang_min=ang_min)
	1659	###self.res_azi = numpy.mean(data['azi'])
	1660	###print("self.res_ele",self.res_ele)
	1661	plt.clf()
	1662	subplots = [121, 122]
	1663	try:
	1664	if self.data[-2]['ele'].max()<data['ele'].max():
	1665	self.ini=0
	1666	except:
	1667	pass
	1668	if self.ini==0:
	1669	self.data_ele_tmp = numpy.ones([self.nplots,int(var_ang)])*numpy.nan
	1670	self.res_weather= numpy.ones([self.nplots,int(var_ang),len(r_mask)])*numpy.nan
	1671	print("SHAPE",self.data_ele_tmp.shape)
	1672
	1673	for i,ax in enumerate(self.axes):
	1674	self.res_weather[i], self.res_ele = self.const_ploteo(val_ch=i, data_weather=data['weather'][i][:,r_mask],data_ele=data['ele'],step=step,res=res,ang_max=ang_max,ang_min=ang_min,case_flag=self.data['case_flag'])
	1675	self.res_azi = numpy.mean(data['azi'])
	1676
	1677	if ax.firsttime:
	1678	#plt.clf()
	1679	print("Frist Plot")
	1680	cgax, pm = wrl.vis.plot_rhi(self.res_weather[i],r=r,th=self.res_ele,ax=subplots[i], proj='cg',vmin=20, vmax=80)
	1681	#fig=self.figures[0]
	1682	else:
	1683	#plt.clf()
	1684	print("ELSE PLOT")
	1685	cgax, pm = wrl.vis.plot_rhi(self.res_weather[i],r=r,th=self.res_ele,ax=subplots[i], proj='cg',vmin=20, vmax=80)
	1686	caax = cgax.parasites[0]
	1687	paax = cgax.parasites[1]
	1688	cbar = plt.gcf().colorbar(pm, pad=0.075)
	1689	caax.set_xlabel('x_range [km]')
	1690	caax.set_ylabel('y_range [km]')
	1691	plt.text(1.0, 1.05, 'Elevacion '+str(thisDatetime)+" Step "+str(self.ini)+ " Azi: "+str(round(self.res_azi,2)), transform=caax.transAxes, va='bottom',ha='right')
	1692	print("*************************self.ini**************************",self.ini)
	1693	self.ini= self.ini+1
	1694
	1695
	1696
	1697
	1698
	1699	class WeatherRHI_vRF4_Plot(Plot):
	1700	CODE = 'RHI'
	1701	plot_name = 'RHI'
	1702	#plot_type = 'rhistyle'
	1703	buffering = False
	1704
	1705	def setup(self):
	1706
	1707	self.ncols = 1
	1708	self.nrows = 1
	1709	self.nplots= 1
	1710	self.ylabel= 'Range [Km]'
	1711	self.xlabel= 'Range [Km]'
	1712	self.titles= ['RHI']
	1713	self.polar = True
	1714	self.grid = True
	1715	if self.channels is not None:
	1716	self.nplots = len(self.channels)
	1717	self.nrows = len(self.channels)
	1718	else:
	1719	self.nplots = self.data.shape(self.CODE)[0]
	1720	self.nrows = self.nplots
	1721	self.channels = list(range(self.nplots))
	1722
	1723	if self.CODE == 'Power':
	1724	self.cb_label = r'Power (dB)'
	1725	elif self.CODE == 'Doppler':
	1726	self.cb_label = r'Velocity (m/s)'
	1727	self.colorbar=True
	1728	self.width =8
	1729	self.height =8
	1730	self.ini =0
	1731	self.len_azi =0
	1732	self.buffer_ini = None
	1733	self.buffer_ele = None
	1734	self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
	1735	self.flag =0
	1736	self.indicador= 0
	1737	self.last_data_ele = None
	1738	self.val_mean = None
	1739
	1740	def update(self, dataOut):
	1741
	1742	data = {}
	1743	meta = {}
	1744	if hasattr(dataOut, 'dataPP_POWER'):
	1745	factor = 1
	1746	if hasattr(dataOut, 'nFFTPoints'):
	1747	factor = dataOut.normFactor
	1748
	1749	if 'pow' in self.attr_data[0].lower():
	1750	data['data'] = 10*numpy.log10(getattr(dataOut, self.attr_data[0])/(factor))
	1751	else:
	1752	data['data'] = getattr(dataOut, self.attr_data[0])/(factor)
	1753
	1754	data['azi'] = dataOut.data_azi
	1755	data['ele'] = dataOut.data_ele
	1756
	1757	return data, meta
	1758
	1759	def plot(self):
	1760	data = self.data[-1]
	1761	r = self.data.yrange
	1762	delta_height = r[1]-r[0]
	1763	r_mask = numpy.where(r>=0)[0]
	1764	self.r_mask =r_mask
	1765	r = numpy.arange(len(r_mask))*delta_height
	1766	self.y = 2*r
	1767
	1768	try:
	1769	z = data['data'][self.channels[0]][:,r_mask]
	1770	except:
	1771	z = data['data'][0][:,r_mask]
	1772
	1773	self.titles = []
	1774
	1775	self.ymax = self.ymax if self.ymax else numpy.nanmax(r)
	1776	self.ymin = self.ymin if self.ymin else numpy.nanmin(r)
	1777	self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
	1778	self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
	1779	self.ang_min = self.ang_min if self.ang_min else 0
	1780	self.ang_max = self.ang_max if self.ang_max else 90
	1781
	1782	r, theta = numpy.meshgrid(r, numpy.radians(data['ele']) )
	1783
	1784	for i,ax in enumerate(self.axes):
	1785
	1786	if ax.firsttime:
	1787	ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
	1788	ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
	1789
	1790	else:
	1791	ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
	1792	ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
	1793	ax.grid(True)
	1794	if len(self.channels) !=1:
	1795	self.titles = ['RHI {} at AZ: {} Channel {}'.format(self.labels[x], str(round(numpy.mean(data['azi']),1)), x) for x in range(self.nrows)]
	1796	else:
	1797	self.titles = ['RHI {} at AZ: {} Channel {}'.format(self.labels[0], str(round(numpy.mean(data['azi']),1)), self.channels[0])]
	1798
	1799	class WeatherParamsPlot(Plot):	372	class WeatherParamsPlot(Plot):
	1800	#CODE = 'RHI'	373	#CODE = 'RHI'
	1801	#plot_name = 'RHI'	374	#plot_name = 'RHI'
	1802	#plot_type = 'rhistyle'	375	#plot_type = 'rhistyle'
	1803	buffering = False	376	buffering = False
	1804		377
	1805	def setup(self):	378	def setup(self):
	1806		379
	1807	self.ncols = 1	380	self.ncols = 1
	1808	self.nrows = 1	381	self.nrows = 1
	1809	self.nplots= 1	382	self.nplots= 1
	1810	self.ylabel= 'Range [km]'	383	self.ylabel= 'Range [km]'
	1811	self.xlabel= 'Range [km]'	384	self.xlabel= 'Range [km]'
	1812	self.polar = True	385	self.polar = True
	1813	self.grid = True	386	self.grid = True
	1814	if self.channels is not None:	387	if self.channels is not None:
	1815	self.nplots = len(self.channels)	388	self.nplots = len(self.channels)
	1816	self.nrows = len(self.channels)	389	self.nrows = len(self.channels)
	1817	else:	390	else:
	1818	self.nplots = self.data.shape(self.CODE)[0]	391	self.nplots = self.data.shape(self.CODE)[0]
	1819	self.nrows = self.nplots	392	self.nrows = self.nplots
	1820	self.channels = list(range(self.nplots))	393	self.channels = list(range(self.nplots))
	1821		394
	1822	self.colorbar=True	395	self.colorbar=True
	1823	self.width =8	396	self.width =8
	1824	self.height =8	397	self.height =8
	1825	self.ini =0	398	self.ini =0
	1826	self.len_azi =0	399	self.len_azi =0
	1827	self.buffer_ini = None	400	self.buffer_ini = None
	1828	self.buffer_ele = None	401	self.buffer_ele = None
	1829	self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})	402	self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
	1830	self.flag =0	403	self.flag =0
	1831	self.indicador= 0	404	self.indicador= 0
	1832	self.last_data_ele = None	405	self.last_data_ele = None
	1833	self.val_mean = None	406	self.val_mean = None
	1834		407
	1835	def update(self, dataOut):	408	def update(self, dataOut):
	1836		409
	1837	data = {}	410	data = {}
	1838	meta = {}	411	meta = {}
	1839	if hasattr(dataOut, 'dataPP_POWER'):	412	if hasattr(dataOut, 'dataPP_POWER'):
	1840	factor = 1	413	factor = 1
	1841	if hasattr(dataOut, 'nFFTPoints'):	414	if hasattr(dataOut, 'nFFTPoints'):
	1842	factor = dataOut.normFactor	415	factor = dataOut.normFactor
	1843		416
	1844	if 'pow' in self.attr_data[0].lower():	417	if 'pow' in self.attr_data[0].lower():
	1845	data['data'] = 10*numpy.log10(getattr(dataOut, self.attr_data[0])/(factor))	418	data['data'] = 10*numpy.log10(getattr(dataOut, self.attr_data[0])/(factor))
	1846	else:	419	else:
	1847	data['data'] = getattr(dataOut, self.attr_data[0])/(factor)	420	data['data'] = getattr(dataOut, self.attr_data[0])/(factor)
	1848		421
	1849	if dataOut.mode_op == 'PPI':	422	if dataOut.mode_op == 'PPI':
	1850	self.CODE = 'PPI'	423	self.CODE = 'PPI'
	1851	self.title = self.CODE	424	self.title = self.CODE
	1852	elif dataOut.mode_op == 'RHI':	425	elif dataOut.mode_op == 'RHI':
	1853	self.CODE = 'RHI'	426	self.CODE = 'RHI'
	1854	self.title = self.CODE	427	self.title = self.CODE
	1855		428
	1856	data['azi'] = dataOut.data_azi	429	data['azi'] = dataOut.data_azi
	1857	data['ele'] = dataOut.data_ele	430	data['ele'] = dataOut.data_ele
	1858	data['mode_op'] = dataOut.mode_op	431	data['mode_op'] = dataOut.mode_op
	1859		432
	1860	return data, meta	433	return data, meta
	1861		434
	1862	def plot(self):	435	def plot(self):
	1863	data = self.data[-1]	436	data = self.data[-1]
	1864	r = self.data.yrange	437	r = self.data.yrange
	1865	delta_height = r[1]-r[0]	438	delta_height = r[1]-r[0]
	1866	r_mask = numpy.where(r>=0)[0]	439	r_mask = numpy.where(r>=0)[0]
	1867	self.r_mask =r_mask	440	self.r_mask =r_mask
	1868	r = numpy.arange(len(r_mask))*delta_height	441	r = numpy.arange(len(r_mask))*delta_height
	1869	self.y = 2*r	442	self.y = 2*r
	1870		443
	1871	try:	444	try:
	1872	z = data['data'][self.channels[0]][:,r_mask]	445	z = data['data'][self.channels[0]][:,r_mask]
	1873	except:	446	except:
	1874	z = data['data'][0][:,r_mask]	447	z = data['data'][0][:,r_mask]
	1875		448
	1876	self.titles = []	449	self.titles = []
	1877		450
	1878	self.ymax = self.ymax if self.ymax else numpy.nanmax(r)	451	self.ymax = self.ymax if self.ymax else numpy.nanmax(r)
	1879	self.ymin = self.ymin if self.ymin else numpy.nanmin(r)	452	self.ymin = self.ymin if self.ymin else numpy.nanmin(r)
	1880	self.zmax = self.zmax if self.zmax else numpy.nanmax(z)	453	self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
	1881	self.zmin = self.zmin if self.zmin else numpy.nanmin(z)	454	self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
	1882	print("mode inside plot",self.data['mode_op'],data['mode_op'])	455
	1883	if data['mode_op'] == 'RHI':	456	if data['mode_op'] == 'RHI':
	1884	try:	457	try:
	1885	if self.data['mode_op'][-2] == 'PPI':	458	if self.data['mode_op'][-2] == 'PPI':
	1886	self.ang_min = None	459	self.ang_min = None
	1887	self.ang_max = None	460	self.ang_max = None
	1888	except:	461	except:
	1889	pass	462	pass
	1890	self.ang_min = self.ang_min if self.ang_min else 0	463	self.ang_min = self.ang_min if self.ang_min else 0
	1891	self.ang_max = self.ang_max if self.ang_max else 90	464	self.ang_max = self.ang_max if self.ang_max else 90
	1892	r, theta = numpy.meshgrid(r, numpy.radians(data['ele']) )	465	r, theta = numpy.meshgrid(r, numpy.radians(data['ele']) )
	1893	elif data['mode_op'] == 'PPI':	466	elif data['mode_op'] == 'PPI':
	1894	try:	467	try:
	1895	if self.data['mode_op'][-2] == 'RHI':	468	if self.data['mode_op'][-2] == 'RHI':
	1896	self.ang_min = None	469	self.ang_min = None
	1897	self.ang_max = None	470	self.ang_max = None
	1898	except:	471	except:
	1899	pass	472	pass
	1900	self.ang_min = self.ang_min if self.ang_min else 0	473	self.ang_min = self.ang_min if self.ang_min else 0
	1901	self.ang_max = self.ang_max if self.ang_max else 360	474	self.ang_max = self.ang_max if self.ang_max else 360
	1902	r, theta = numpy.meshgrid(r, numpy.radians(data['azi']) )	475	r, theta = numpy.meshgrid(r, numpy.radians(data['azi']) )
	1903		476
	1904	self.clear_figures()	477	self.clear_figures()
	1905		478
	1906	for i,ax in enumerate(self.axes):	479	for i,ax in enumerate(self.axes):
	1907		480
	1908	if ax.firsttime:	481	if ax.firsttime:
	1909	ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))	482	ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
	1910	ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)	483	ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
	1911	if data['mode_op'] == 'PPI':	484	if data['mode_op'] == 'PPI':
	1912	ax.set_theta_direction(-1)	485	ax.set_theta_direction(-1)
	1913	ax.set_theta_offset(numpy.pi/2)	486	ax.set_theta_offset(numpy.pi/2)
	1914		487
	1915	else:	488	else:
	1916	ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))	489	ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
	1917	ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)	490	ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
	1918	if data['mode_op'] == 'PPI':	491	if data['mode_op'] == 'PPI':
	1919	ax.set_theta_direction(-1)	492	ax.set_theta_direction(-1)
	1920	ax.set_theta_offset(numpy.pi/2)	493	ax.set_theta_offset(numpy.pi/2)
	1921		494
	1922	ax.grid(True)	495	ax.grid(True)
	1923	if data['mode_op'] == 'RHI':	496	if data['mode_op'] == 'RHI':
	1924	len_aux = int(data['azi'].shape[0]/4)	497	len_aux = int(data['azi'].shape[0]/4)
	1925	mean = numpy.mean(data['azi'][len_aux:-len_aux])	498	mean = numpy.mean(data['azi'][len_aux:-len_aux])
	1926	if len(self.channels) !=1:	499	if len(self.channels) !=1:
	1927	self.titles = ['RHI {} at AZ: {} C~~hannel~~ {}'.format(self.labels[x], str(round(mean,1)), x) for x in range(self.nrows)]	500	self.titles = ['RHI {} at AZ: {} CH {}'.format(self.labels[x], str(round(mean,1)), x) for x in range(self.nrows)]
	1928	else:	501	else:
	1929	self.titles = ['RHI {} at AZ: {} C~~hannel~~ {}'.format(self.labels[0], str(round(mean,1)), self.channels[0])]	502	self.titles = ['RHI {} at AZ: {} CH {}'.format(self.labels[0], str(round(mean,1)), self.channels[0])]
	1930	elif data['mode_op'] == 'PPI':	503	elif data['mode_op'] == 'PPI':
	1931	len_aux = int(data['ele'].shape[0]/4)	504	len_aux = int(data['ele'].shape[0]/4)
	1932	mean = numpy.mean(data['ele'][len_aux:-len_aux])	505	mean = numpy.mean(data['ele'][len_aux:-len_aux])
	1933	if len(self.channels) !=1:	506	if len(self.channels) !=1:
	1934	self.titles = ['PPI {} at EL: {} C~~hannel~~ {}'.format(self.self.labels[x], str(round(mean,1)), x) for x in range(self.nrows)]	507	self.titles = ['PPI {} at EL: {} CH {}'.format(self.self.labels[x], str(round(mean,1)), x) for x in range(self.nrows)]
	1935	else:	508	else:
	1936	self.titles = ['PPI {} at EL: {} C~~hannel~~ {}'.format(self.labels[0], str(round(mean,1)), self.channels[0])]	509	self.titles = ['PPI {} at EL: {} CH {}'.format(self.labels[0], str(round(mean,1)), self.channels[0])]

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

schainpy/model/proc/jroproc_voltage.py +7 -2

             import sys
             import numpy,math
             from scipy import interpolate
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
             from schainpy.model.data.jrodata import Voltage,hildebrand_sekhon
             from schainpy.utils import log
             from time import time
             class VoltageProc(ProcessingUnit):
                 def __init__(self):
                     ProcessingUnit.__init__(self)
                     self.dataOut = Voltage()
                     self.flip = 1
                     self.setupReq = False
                 def run(self):
                     if self.dataIn.type == 'AMISR':
                         self.__updateObjFromAmisrInput()
                     if self.dataIn.type == 'Voltage':
                         self.dataOut.copy(self.dataIn)
                 def __updateObjFromAmisrInput(self):
                     self.dataOut.timeZone = self.dataIn.timeZone
                     self.dataOut.dstFlag = self.dataIn.dstFlag
                     self.dataOut.errorCount = self.dataIn.errorCount
                     self.dataOut.useLocalTime = self.dataIn.useLocalTime
                     self.dataOut.flagNoData = self.dataIn.flagNoData
                     self.dataOut.data = self.dataIn.data
                     self.dataOut.utctime = self.dataIn.utctime
                     self.dataOut.channelList = self.dataIn.channelList
                     #self.dataOut.timeInterval = self.dataIn.timeInterval
                     self.dataOut.heightList = self.dataIn.heightList
                     self.dataOut.nProfiles = self.dataIn.nProfiles
                     self.dataOut.nCohInt = self.dataIn.nCohInt
                     self.dataOut.ippSeconds = self.dataIn.ippSeconds
                     self.dataOut.frequency = self.dataIn.frequency
                     self.dataOut.azimuth = self.dataIn.azimuth
                     self.dataOut.zenith = self.dataIn.zenith
                     self.dataOut.beam.codeList = self.dataIn.beam.codeList
                     self.dataOut.beam.azimuthList = self.dataIn.beam.azimuthList
                     self.dataOut.beam.zenithList = self.dataIn.beam.zenithList
             class selectChannels(Operation):
                 def run(self, dataOut, channelList):
                     channelIndexList = []
                     self.dataOut = dataOut
                     for channel in channelList:
                         if channel not in self.dataOut.channelList:
                             raise ValueError("Channel %d is not in %s" %(channel, str(self.dataOut.channelList)))
                         index = self.dataOut.channelList.index(channel)
                         channelIndexList.append(index)
                     self.selectChannelsByIndex(channelIndexList)
                     return self.dataOut
                 def selectChannelsByIndex(self, channelIndexList):
                     """
                     Selecciona un bloque de datos en base a canales segun el channelIndexList
                     Input:
                         channelIndexList    :    lista sencilla de canales a seleccionar por ej. [2,3,7]
                     Affected:
                         self.dataOut.data
                         self.dataOut.channelIndexList
                         self.dataOut.nChannels
                         self.dataOut.m_ProcessingHeader.totalSpectra
                         self.dataOut.systemHeaderObj.numChannels
                         self.dataOut.m_ProcessingHeader.blockSize
                     Return:
                         None
                     """
                     for channelIndex in channelIndexList:
                         if channelIndex not in self.dataOut.channelIndexList:
                             raise ValueError("The value %d in channelIndexList is not valid" %channelIndex)
                     if self.dataOut.type == 'Voltage':
                         if self.dataOut.flagDataAsBlock:
                             """
                             Si la data es obtenida por bloques, dimension = [nChannels, nProfiles, nHeis]
                             """
                             data = self.dataOut.data[channelIndexList,:,:]
                         else:
                             data = self.dataOut.data[channelIndexList,:]
                         self.dataOut.data = data
                         # self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
                         self.dataOut.channelList = range(len(channelIndexList))
                     elif self.dataOut.type == 'Spectra':
                         data_spc = self.dataOut.data_spc[channelIndexList, :]
                         data_dc = self.dataOut.data_dc[channelIndexList, :]
                         self.dataOut.data_spc = data_spc
                         self.dataOut.data_dc = data_dc
                         # self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
                         self.dataOut.channelList = range(len(channelIndexList))
                         self.__selectPairsByChannel(channelIndexList)
                     return 1
                 def __selectPairsByChannel(self, channelList=None):
                     if channelList == None:
                         return
                     pairsIndexListSelected = []
                     for pairIndex in self.dataOut.pairsIndexList:
                         # First pair
                         if self.dataOut.pairsList[pairIndex][0] not in channelList:
                             continue
                         # Second pair
                         if self.dataOut.pairsList[pairIndex][1] not in channelList:
                             continue
                         pairsIndexListSelected.append(pairIndex)
                     if not pairsIndexListSelected:
                         self.dataOut.data_cspc = None
                         self.dataOut.pairsList = []
                         return
                     self.dataOut.data_cspc = self.dataOut.data_cspc[pairsIndexListSelected]
                     self.dataOut.pairsList = [self.dataOut.pairsList[i]
                                               for i in pairsIndexListSelected]
                     return
             class selectHeights(Operation):
                 def run(self, dataOut, minHei=None, maxHei=None, minIndex=None, maxIndex=None):
                     """
                     Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
                     minHei <= height <= maxHei
                     Input:
                         minHei    :    valor minimo de altura a considerar
                         maxHei    :    valor maximo de altura a considerar
                     Affected:
                         Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
                     Return:
 si el metodo se ejecuto con exito caso contrario devuelve 0
                     """
                     self.dataOut = dataOut
                     if minHei and maxHei:
                         if (minHei < self.dataOut.heightList[0]):
                             minHei = self.dataOut.heightList[0]
                         if (maxHei > self.dataOut.heightList[-1]):
                             maxHei = self.dataOut.heightList[-1]
                         minIndex = 0
                         maxIndex = 0
                         heights = self.dataOut.heightList
                         inda = numpy.where(heights >= minHei)
                         indb = numpy.where(heights <= maxHei)
                         try:
                             minIndex = inda[0][0]
                         except:
                             minIndex = 0
                         try:
                             maxIndex = indb[0][-1]
                         except:
                             maxIndex = len(heights)
                     self.selectHeightsByIndex(minIndex, maxIndex)
                     return self.dataOut
                 def selectHeightsByIndex(self, minIndex, maxIndex):
                     """
                     Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
                     minIndex <= index <= maxIndex
                     Input:
                         minIndex    :    valor de indice minimo de altura a considerar
                         maxIndex    :    valor de indice maximo de altura a considerar
                     Affected:
                         self.dataOut.data
                         self.dataOut.heightList
                     Return:
 si el metodo se ejecuto con exito caso contrario devuelve 0
                     """
                     if self.dataOut.type == 'Voltage':
                         if (minIndex < 0) or (minIndex > maxIndex):
                             raise ValueError("Height index range (%d,%d) is not valid" % (minIndex, maxIndex))
                         if (maxIndex >= self.dataOut.nHeights):
                             maxIndex = self.dataOut.nHeights
                         #print("shapeeee",self.dataOut.data.shape)
                         #voltage
                         if self.dataOut.flagDataAsBlock:
                             """
                             Si la data es obtenida por bloques, dimension = [nChannels, nProfiles, nHeis]
                             """
                             data = self.dataOut.data[:,:, minIndex:maxIndex]
                         else:
                             data = self.dataOut.data[:, minIndex:maxIndex]
                         #         firstHeight = self.dataOut.heightList[minIndex]
                         self.dataOut.data = data
                         self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex]
                         if self.dataOut.nHeights <= 1:
                             raise ValueError("selectHeights: Too few heights. Current number of heights is %d" %(self.dataOut.nHeights))
                     elif self.dataOut.type == 'Spectra':
                         if (minIndex < 0) or (minIndex > maxIndex):
                             raise ValueError("Error selecting heights: Index range (%d,%d) is not valid" % (
                                 minIndex, maxIndex))
                         if (maxIndex >= self.dataOut.nHeights):
                             maxIndex = self.dataOut.nHeights - 1
                         # Spectra
                         data_spc = self.dataOut.data_spc[:, :, minIndex:maxIndex + 1]
                         data_cspc = None
                         if self.dataOut.data_cspc is not None:
                             data_cspc = self.dataOut.data_cspc[:, :, minIndex:maxIndex + 1]
                         data_dc = None
                         if self.dataOut.data_dc is not None:
                             data_dc = self.dataOut.data_dc[:, minIndex:maxIndex + 1]
                         self.dataOut.data_spc = data_spc
                         self.dataOut.data_cspc = data_cspc
                         self.dataOut.data_dc = data_dc
                         self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex + 1]
                     return 1
             class filterByHeights(Operation):
                 def run(self, dataOut, window):
                     deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
                     if window == None:
                         window = (dataOut.radarControllerHeaderObj.txA/dataOut.radarControllerHeaderObj.nBaud) / deltaHeight
                     newdelta = deltaHeight * window
                     r = dataOut.nHeights % window
                     newheights = (dataOut.nHeights-r)/window
                     if newheights <= 1:
                         raise ValueError("filterByHeights: Too few heights. Current number of heights is %d and window is %d" %(dataOut.nHeights, window))
                     if dataOut.flagDataAsBlock:
                         """
                         Si la data es obtenida por bloques, dimension = [nChannels, nProfiles, nHeis]
                         """
                         buffer = dataOut.data[:, :, 0:int(dataOut.nHeights-r)]
                         buffer = buffer.reshape(dataOut.nChannels, dataOut.nProfiles, int(dataOut.nHeights/window), window)
                         buffer = numpy.sum(buffer,3)
                     else:
                         buffer = dataOut.data[:,0:int(dataOut.nHeights-r)]
                         buffer = buffer.reshape(dataOut.nChannels,int(dataOut.nHeights/window),int(window))
                         buffer = numpy.sum(buffer,2)
                     dataOut.data = buffer
                     dataOut.heightList = dataOut.heightList[0] + numpy.arange( newheights )*newdelta
                     dataOut.windowOfFilter = window
                     return dataOut
             class setH0(Operation):
                 def run(self, dataOut, h0, deltaHeight = None):
                     if not deltaHeight:
                         deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
                     nHeights = dataOut.nHeights
                     newHeiRange = h0 + numpy.arange(nHeights)*deltaHeight
                     dataOut.heightList = newHeiRange
                     dataOut.h0 = h0
                     return dataOut
             class deFlip(Operation):
                 def run(self, dataOut, channelList = []):
                     data = dataOut.data.copy()
                     if dataOut.flagDataAsBlock:
                         flip = self.flip
                         profileList = list(range(dataOut.nProfiles))
                         if not channelList:
                             for thisProfile in profileList:
                                 data[:,thisProfile,:] = data[:,thisProfile,:]*flip
                                 flip *= -1.0
                         else:
                             for thisChannel in channelList:
                                 if thisChannel not in dataOut.channelList:
                                     continue
                                 for thisProfile in profileList:
                                     data[thisChannel,thisProfile,:] = data[thisChannel,thisProfile,:]*flip
                                     flip *= -1.0
                         self.flip = flip
                     else:
                         if not channelList:
                             data[:,:] = data[:,:]*self.flip
                         else:
                             for thisChannel in channelList:
                                 if thisChannel not in dataOut.channelList:
                                     continue
                                 data[thisChannel,:] = data[thisChannel,:]*self.flip
                         self.flip *= -1.
                     dataOut.data = data
                     return dataOut
             class setAttribute(Operation):
                 '''
                 Set an arbitrary attribute(s) to dataOut
                 '''
                 def __init__(self):
                     Operation.__init__(self)
                     self._ready = False
                 def run(self, dataOut, **kwargs):
                     for key, value in kwargs.items():
                         setattr(dataOut, key, value)
                     return dataOut
             @MPDecorator
             class printAttribute(Operation):
                 '''
                 Print an arbitrary attribute of dataOut
                 '''
                 def __init__(self):
                     Operation.__init__(self)
                 def run(self, dataOut, attributes):
                     if isinstance(attributes, str):
                         attributes = [attributes]
                     for attr in attributes:
                         if hasattr(dataOut, attr):
                             log.log(getattr(dataOut, attr), attr)
             class interpolateHeights(Operation):
                 def run(self, dataOut, topLim, botLim):
                     #69 al 72 para julia
                     #82-84 para meteoros
                     if len(numpy.shape(dataOut.data))==2:
                         sampInterp = (dataOut.data[:,botLim-1] + dataOut.data[:,topLim+1])/2
                         sampInterp = numpy.transpose(numpy.tile(sampInterp,(topLim-botLim + 1,1)))
                         #dataOut.data[:,botLim:limSup+1] = sampInterp
                         dataOut.data[:,botLim:topLim+1] = sampInterp
                     else:
                         nHeights = dataOut.data.shape[2]
                         x = numpy.hstack((numpy.arange(botLim),numpy.arange(topLim+1,nHeights)))
                         y = dataOut.data[:,:,list(range(botLim))+list(range(topLim+1,nHeights))]
                         f = interpolate.interp1d(x, y, axis = 2)
                         xnew = numpy.arange(botLim,topLim+1)
                         ynew = f(xnew)
                         dataOut.data[:,:,botLim:topLim+1]  = ynew
                     return dataOut
             class CohInt(Operation):
                 isConfig = False
                 __profIndex = 0
                 __byTime = False
                 __initime = None
                 __lastdatatime = None
                 __integrationtime = None
                 __buffer = None
                 __bufferStride = []
                 __dataReady = False
                 __profIndexStride = 0
                 __dataToPutStride = False
                 n = None
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                 def setup(self, n=None, timeInterval=None, stride=None, overlapping=False, byblock=False):
                     """
                     Set the parameters of the integration class.
                     Inputs:
                         n               :    Number of coherent integrations
                         timeInterval    :    Time of integration. If the parameter "n" is selected this one does not work
                         overlapping     :
                     """
                     self.__initime = None
                     self.__lastdatatime = 0
                     self.__buffer = None
                     self.__dataReady = False
                     self.byblock = byblock
                     self.stride = stride
                     if n == None and timeInterval == None:
                         raise ValueError("n or timeInterval should be specified ...")
                     if n != None:
                         self.n = n
                         self.__byTime = False
                     else:
                         self.__integrationtime = timeInterval #* 60. #if (type(timeInterval)!=integer) -> change this line
                         self.n = 9999
                         self.__byTime = True
                     if overlapping:
                         self.__withOverlapping = True
                         self.__buffer = None
                     else:
                         self.__withOverlapping = False
                         self.__buffer = 0
                     self.__profIndex = 0
                 def putData(self, data):
                     """
                     Add a profile to the __buffer and increase in one the __profileIndex
                     """
                     if not self.__withOverlapping:
                         self.__buffer += data.copy()
                         self.__profIndex += 1
                         return
                     #Overlapping data
                     nChannels, nHeis = data.shape
                     data = numpy.reshape(data, (1, nChannels, nHeis))
                     #If the buffer is empty then it takes the data value
                     if self.__buffer is None:
                         self.__buffer = data
                         self.__profIndex += 1
                         return
                     #If the buffer length is lower than n then stakcing the data value
                     if self.__profIndex < self.n:
                         self.__buffer = numpy.vstack((self.__buffer, data))
                         self.__profIndex += 1
                         return
                     #If the buffer length is equal to n then replacing the last buffer value with the data value
                     self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
                     self.__buffer[self.n-1] = data
                     self.__profIndex = self.n
                     return
                 def pushData(self):
                     """
                     Return the sum of the last profiles and the profiles used in the sum.
                     Affected:
                     self.__profileIndex
                     """
                     if not self.__withOverlapping:
                         data = self.__buffer
                         n = self.__profIndex
                         self.__buffer = 0
                         self.__profIndex = 0
                         return data, n
                     #Integration with Overlapping
                     data = numpy.sum(self.__buffer, axis=0)
                     # print data
                     # raise
                     n = self.__profIndex
                     return data, n
                 def byProfiles(self, data):
                     self.__dataReady = False
                     avgdata = None
                     #         n = None
                     # print data
                     # raise
                     self.putData(data)
                     if self.__profIndex == self.n:
                         avgdata, n = self.pushData()
                         self.__dataReady = True
                     return avgdata
                 def byTime(self, data, datatime):
                     self.__dataReady = False
                     avgdata = None
                     n = None
                     self.putData(data)
                     if (datatime - self.__initime) >= self.__integrationtime:
                         avgdata, n = self.pushData()
                         self.n = n
                         self.__dataReady = True
                     return avgdata
                 def integrateByStride(self, data, datatime):
                     # print data
                     if self.__profIndex == 0:
                         self.__buffer = [[data.copy(), datatime]]
                     else:
                         self.__buffer.append([data.copy(),datatime])
                     self.__profIndex += 1
                     self.__dataReady = False
                     if self.__profIndex == self.n * self.stride :
                         self.__dataToPutStride = True
                         self.__profIndexStride = 0
                         self.__profIndex = 0
                         self.__bufferStride = []
                         for i in range(self.stride):
                             current = self.__buffer[i::self.stride]
                             data = numpy.sum([t[0] for t in current], axis=0)
                             avgdatatime = numpy.average([t[1] for t in current])
                             # print data
                             self.__bufferStride.append((data, avgdatatime))
                     if self.__dataToPutStride:
                         self.__dataReady = True
                         self.__profIndexStride += 1
                         if self.__profIndexStride == self.stride:
                             self.__dataToPutStride = False
                         # print self.__bufferStride[self.__profIndexStride - 1]
                         # raise
                         return self.__bufferStride[self.__profIndexStride - 1]
                     return None, None
                 def integrate(self, data, datatime=None):
                     if self.__initime == None:
                         self.__initime = datatime
                     if self.__byTime:
                         avgdata = self.byTime(data, datatime)
                     else:
                         avgdata = self.byProfiles(data)
                     self.__lastdatatime = datatime
                     if avgdata is None:
                         return None, None
                     avgdatatime = self.__initime
                     deltatime = datatime - self.__lastdatatime
                     if not self.__withOverlapping:
                         self.__initime = datatime
                     else:
                         self.__initime += deltatime
                     return avgdata, avgdatatime
                 def integrateByBlock(self, dataOut):
                     times = int(dataOut.data.shape[1]/self.n)
                     avgdata = numpy.zeros((dataOut.nChannels, times, dataOut.nHeights), dtype=numpy.complex)
                     id_min = 0
                     id_max = self.n
                     for i in range(times):
                         junk = dataOut.data[:,id_min:id_max,:]
                         avgdata[:,i,:] = junk.sum(axis=1)
                         id_min += self.n
                         id_max += self.n
                     timeInterval = dataOut.ippSeconds*self.n
                     avgdatatime = (times - 1) * timeInterval + dataOut.utctime
                     self.__dataReady = True
                     return avgdata, avgdatatime
                 def run(self, dataOut, n=None, timeInterval=None, stride=None, overlapping=False, byblock=False, **kwargs):
                     if not self.isConfig:
                         self.setup(n=n, stride=stride, timeInterval=timeInterval, overlapping=overlapping, byblock=byblock, **kwargs)
                         self.isConfig = True
                     if dataOut.flagDataAsBlock:
                         """
                         Si la data es leida por bloques, dimension = [nChannels, nProfiles, nHeis]
                         """
                         avgdata, avgdatatime = self.integrateByBlock(dataOut)
                         dataOut.nProfiles /= self.n
                     else:
                         if stride is None:
                             avgdata, avgdatatime = self.integrate(dataOut.data, dataOut.utctime)
                         else:
                             avgdata, avgdatatime = self.integrateByStride(dataOut.data, dataOut.utctime)
                     #   dataOut.timeInterval *= n
                     dataOut.flagNoData = True
                     if self.__dataReady:
                         dataOut.data = avgdata
                         if not dataOut.flagCohInt:
                             dataOut.nCohInt *= self.n
                             dataOut.flagCohInt = True
                         ####################################dataOut.utctime = avgdatatime
                         # print avgdata, avgdatatime
                         # raise
                         #   dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt
                         dataOut.flagNoData = False
                     return dataOut
             class Decoder(Operation):
                 isConfig = False
                 __profIndex = 0
                 code = None
                 nCode = None
                 nBaud = None
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                     self.times = None
                     self.osamp = None
                 #         self.__setValues = False
                     self.isConfig = False
                     self.setupReq = False
                 def setup(self, code, osamp, dataOut):
                     self.__profIndex = 0
                     self.code = code
                     self.nCode = len(code)
                     self.nBaud = len(code[0])
                     if (osamp != None) and (osamp >1):
                         self.osamp = osamp
                         self.code = numpy.repeat(code, repeats=self.osamp, axis=1)
                         self.nBaud = self.nBaud*self.osamp
                     self.__nChannels = dataOut.nChannels
                     self.__nProfiles = dataOut.nProfiles
                     self.__nHeis = dataOut.nHeights
                     if self.__nHeis < self.nBaud:
                         raise ValueError('Number of heights (%d) should be greater than number of bauds (%d)' %(self.__nHeis, self.nBaud))
                     #Frequency
                     __codeBuffer = numpy.zeros((self.nCode, self.__nHeis), dtype=numpy.complex)
                     __codeBuffer[:,0:self.nBaud] = self.code
                     self.fft_code = numpy.conj(numpy.fft.fft(__codeBuffer, axis=1))
                     if dataOut.flagDataAsBlock:
                         self.ndatadec = self.__nHeis #- self.nBaud + 1
                         self.datadecTime = numpy.zeros((self.__nChannels, self.__nProfiles, self.ndatadec), dtype=numpy.complex)
                     else:
                         #Time
                         self.ndatadec = self.__nHeis #- self.nBaud + 1
                         self.datadecTime = numpy.zeros((self.__nChannels, self.ndatadec), dtype=numpy.complex)
                 def __convolutionInFreq(self, data):
                     fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
                     fft_data = numpy.fft.fft(data, axis=1)
                     conv = fft_data*fft_code
                     data = numpy.fft.ifft(conv,axis=1)
                     return data
                 def __convolutionInFreqOpt(self, data):
                     raise NotImplementedError
                 def __convolutionInTime(self, data):
                     code = self.code[self.__profIndex]
                     for i in range(self.__nChannels):
                         self.datadecTime[i,:] = numpy.correlate(data[i,:], code, mode='full')[self.nBaud-1:]
                     return self.datadecTime
                 def __convolutionByBlockInTime(self, data):
                     repetitions = int(self.__nProfiles / self.nCode)
                     junk = numpy.lib.stride_tricks.as_strided(self.code, (repetitions, self.code.size), (0, self.code.itemsize))
                     junk = junk.flatten()
                     code_block = numpy.reshape(junk, (self.nCode*repetitions, self.nBaud))
                     profilesList = range(self.__nProfiles)
                     for i in range(self.__nChannels):
                         for j in profilesList:
                             self.datadecTime[i,j,:] = numpy.correlate(data[i,j,:], code_block[j,:], mode='full')[self.nBaud-1:]
                     return self.datadecTime
                 def __convolutionByBlockInFreq(self, data):
                     raise NotImplementedError("Decoder by frequency fro Blocks not implemented")
                     fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
                     fft_data = numpy.fft.fft(data, axis=2)
                     conv = fft_data*fft_code
                     data = numpy.fft.ifft(conv,axis=2)
                     return data
                 def run(self, dataOut, code=None, nCode=None, nBaud=None, mode = 0, osamp=None, times=None):
                     if dataOut.flagDecodeData:
                         print("This data is already decoded, recoding again ...")
                     if not self.isConfig:
                         if code is None:
                             if dataOut.code is None:
                                 raise ValueError("Code could not be read from %s instance. Enter a value in Code parameter" %dataOut.type)
                             code = dataOut.code
                         else:
                             code = numpy.array(code).reshape(nCode,nBaud)
                         self.setup(code, osamp, dataOut)
                         self.isConfig = True
                         if mode == 3:
                             sys.stderr.write("Decoder Warning: mode=%d is not valid, using mode=0\n" %mode)
                         if times != None:
                             sys.stderr.write("Decoder Warning: Argument 'times' in not used anymore\n")
                     if self.code is None:
                         print("Fail decoding: Code is not defined.")
                         return
                     self.__nProfiles = dataOut.nProfiles
                     datadec = None
                     if mode == 3:
                         mode = 0
                     if dataOut.flagDataAsBlock:
                         """
                         Decoding when data have been read as block,
                         """
                         if mode == 0:
                             datadec = self.__convolutionByBlockInTime(dataOut.data)
                         if mode == 1:
                             datadec = self.__convolutionByBlockInFreq(dataOut.data)
                     else:
                         """
                         Decoding when data have been read profile by profile
                         """
                         if mode == 0:
                             datadec = self.__convolutionInTime(dataOut.data)
                         if mode == 1:
                             datadec = self.__convolutionInFreq(dataOut.data)
                         if mode == 2:
                             datadec = self.__convolutionInFreqOpt(dataOut.data)
                     if datadec is None:
                         raise ValueError("Codification mode selected is not valid: mode=%d. Try selecting 0 or 1" %mode)
                     dataOut.code = self.code
                     dataOut.nCode = self.nCode
                     dataOut.nBaud = self.nBaud
                     dataOut.data = datadec
                     dataOut.heightList = dataOut.heightList[0:datadec.shape[-1]]
                     dataOut.flagDecodeData = True #asumo q la data esta decodificada
                     if self.__profIndex == self.nCode-1:
                         self.__profIndex = 0
                         return dataOut
                     self.__profIndex += 1
                     return dataOut
                 #        dataOut.flagDeflipData = True #asumo q la data no esta sin flip
             class ProfileConcat(Operation):
                 isConfig = False
                 buffer = None
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                     self.profileIndex = 0
                 def reset(self):
                     self.buffer = numpy.zeros_like(self.buffer)
                     self.start_index = 0
                     self.times = 1
                 def setup(self, data, m, n=1):
                     self.buffer = numpy.zeros((data.shape[0],data.shape[1]*m),dtype=type(data[0,0]))
                     self.nHeights = data.shape[1]#.nHeights
                     self.start_index = 0
                     self.times = 1
                 def concat(self, data):
                     self.buffer[:,self.start_index:self.nHeights*self.times] = data.copy()
                     self.start_index = self.start_index + self.nHeights
                 def run(self, dataOut, m):
                     dataOut.flagNoData = True
                     if not self.isConfig:
                         self.setup(dataOut.data, m, 1)
                         self.isConfig = True
                     if dataOut.flagDataAsBlock:
                         raise ValueError("ProfileConcat can only be used when voltage have been read profile by profile, getBlock = False")
                     else:
                         self.concat(dataOut.data)
                         self.times += 1
                         if self.times > m:
                             dataOut.data = self.buffer
                             self.reset()
                             dataOut.flagNoData = False
                             # se deben actualizar mas propiedades del header y del objeto dataOut, por ejemplo, las alturas
                             deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
                             xf = dataOut.heightList[0] + dataOut.nHeights * deltaHeight * m
                             dataOut.heightList = numpy.arange(dataOut.heightList[0], xf, deltaHeight)
                             dataOut.ippSeconds *= m
                     return dataOut
             class ProfileSelector(Operation):
                 profileIndex = None
                 # Tamanho total de los perfiles
                 nProfiles = None
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                     self.profileIndex = 0
                 def incProfileIndex(self):
                     self.profileIndex += 1
                     if self.profileIndex >= self.nProfiles:
                         self.profileIndex = 0
                 def isThisProfileInRange(self, profileIndex, minIndex, maxIndex):
                     if profileIndex < minIndex:
                         return False
                     if profileIndex > maxIndex:
                         return False
                     return True
                 def isThisProfileInList(self, profileIndex, profileList):
                     if profileIndex not in profileList:
                         return False
                     return True
                 def run(self, dataOut, profileList=None, profileRangeList=None, beam=None, byblock=False, rangeList = None, nProfiles=None):
                     #print("before",dataOut.data.shape)
                     """
                     ProfileSelector:
                     Inputs:
                         profileList        :    Index of profiles selected. Example: profileList = (0,1,2,7,8)
                         profileRangeList    :    Minimum and maximum profile indexes. Example: profileRangeList = (4, 30)
                         rangeList            :    List of profile ranges. Example: rangeList = ((4, 30), (32, 64), (128, 256))
                     """
                     if rangeList is not None:
                         if type(rangeList[0]) not in (tuple, list):
                             rangeList = [rangeList]
                     dataOut.flagNoData = True
                     if dataOut.flagDataAsBlock:
                         """
                         data dimension  = [nChannels, nProfiles, nHeis]
                         """
                         if profileList != None:
                             dataOut.data = dataOut.data[:,profileList,:]
                         if profileRangeList != None:
                             minIndex = profileRangeList[0]
                             maxIndex = profileRangeList[1]
                             profileList = list(range(minIndex, maxIndex+1))
                             dataOut.data = dataOut.data[:,minIndex:maxIndex+1,:]
                         if rangeList != None:
                             profileList = []
                             for thisRange in rangeList:
                                 minIndex = thisRange[0]
                                 maxIndex = thisRange[1]
                                 profileList.extend(list(range(minIndex, maxIndex+1)))
                             dataOut.data = dataOut.data[:,profileList,:]
                         dataOut.nProfiles = len(profileList)
                         dataOut.profileIndex = dataOut.nProfiles - 1
                         dataOut.flagNoData = False
                         #print(dataOut.data.shape)
                         return dataOut
                     """
                     data dimension  = [nChannels, nHeis]
                     """
                     if profileList != None:
                         if self.isThisProfileInList(dataOut.profileIndex, profileList):
                             self.nProfiles = len(profileList)
                             dataOut.nProfiles = self.nProfiles
                             dataOut.profileIndex = self.profileIndex
                             dataOut.flagNoData = False
                             self.incProfileIndex()
                         return dataOut
                     if profileRangeList != None:
                         minIndex = profileRangeList[0]
                         maxIndex = profileRangeList[1]
                         if self.isThisProfileInRange(dataOut.profileIndex, minIndex, maxIndex):
                             self.nProfiles = maxIndex - minIndex + 1
                             dataOut.nProfiles = self.nProfiles
                             dataOut.profileIndex = self.profileIndex
                             dataOut.flagNoData = False
                             self.incProfileIndex()
                         return dataOut
                     if rangeList != None:
                         nProfiles = 0
                         for thisRange in rangeList:
                             minIndex = thisRange[0]
                             maxIndex = thisRange[1]
                             nProfiles += maxIndex - minIndex + 1
                         for thisRange in rangeList:
                             minIndex = thisRange[0]
                             maxIndex = thisRange[1]
                             if self.isThisProfileInRange(dataOut.profileIndex, minIndex, maxIndex):
                                 self.nProfiles = nProfiles
                                 dataOut.nProfiles = self.nProfiles
                                 dataOut.profileIndex = self.profileIndex
                                 dataOut.flagNoData = False
                                 self.incProfileIndex()
                                 break
                         return dataOut
                     if beam != None: #beam is only for AMISR data
                         if self.isThisProfileInList(dataOut.profileIndex, dataOut.beamRangeDict[beam]):
                             dataOut.flagNoData = False
                             dataOut.profileIndex = self.profileIndex
                             self.incProfileIndex()
                         return dataOut
                     raise ValueError("ProfileSelector needs profileList, profileRangeList or rangeList parameter")
             class Reshaper(Operation):
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                     self.__buffer = None
                     self.__nitems = 0
                 def __appendProfile(self, dataOut, nTxs):
                     if self.__buffer is None:
                         shape = (dataOut.nChannels, int(dataOut.nHeights/nTxs) )
                         self.__buffer = numpy.empty(shape, dtype = dataOut.data.dtype)
                     ini = dataOut.nHeights * self.__nitems
                     end = ini + dataOut.nHeights
                     self.__buffer[:, ini:end] = dataOut.data
                     self.__nitems += 1
                     return int(self.__nitems*nTxs)
                 def __getBuffer(self):
                     if self.__nitems == int(1./self.__nTxs):
                         self.__nitems = 0
                         return self.__buffer.copy()
                     return None
                 def __checkInputs(self, dataOut, shape, nTxs):
                     if shape is None and nTxs is None:
                         raise ValueError("Reshaper: shape of factor should be defined")
                     if nTxs:
                         if nTxs < 0:
                             raise ValueError("nTxs should be greater than 0")
                         if nTxs < 1 and dataOut.nProfiles % (1./nTxs) != 0:
                             raise ValueError("nProfiles= %d is not divisibled by (1./nTxs) = %f" %(dataOut.nProfiles, (1./nTxs)))
                         shape = [dataOut.nChannels, dataOut.nProfiles*nTxs, dataOut.nHeights/nTxs]
                         return shape, nTxs
                     if len(shape) != 2 and len(shape) !=  3:
                         raise ValueError("shape dimension should be equal to 2 or 3. shape = (nProfiles, nHeis) or (nChannels, nProfiles, nHeis). Actually shape = (%d, %d, %d)" %(dataOut.nChannels, dataOut.nProfiles, dataOut.nHeights))
                     if len(shape) == 2:
                         shape_tuple = [dataOut.nChannels]
                         shape_tuple.extend(shape)
                     else:
                         shape_tuple = list(shape)
                     nTxs = 1.0*shape_tuple[1]/dataOut.nProfiles
                     return shape_tuple, nTxs
                 def run(self, dataOut, shape=None, nTxs=None):
                     shape_tuple, self.__nTxs = self.__checkInputs(dataOut, shape, nTxs)
                     dataOut.flagNoData = True
                     profileIndex = None
                     if dataOut.flagDataAsBlock:
                         dataOut.data = numpy.reshape(dataOut.data, shape_tuple)
                         dataOut.flagNoData = False
                         profileIndex = int(dataOut.nProfiles*self.__nTxs) - 1
                     else:
                         if self.__nTxs < 1:
                             self.__appendProfile(dataOut, self.__nTxs)
                             new_data = self.__getBuffer()
                             if new_data is not None:
                                 dataOut.data = new_data
                                 dataOut.flagNoData = False
                                 profileIndex = dataOut.profileIndex*nTxs
                         else:
                             raise ValueError("nTxs should be greater than 0 and lower than 1, or use VoltageReader(..., getblock=True)")
                     deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
                     dataOut.heightList = numpy.arange(dataOut.nHeights/self.__nTxs) * deltaHeight + dataOut.heightList[0]
                     dataOut.nProfiles = int(dataOut.nProfiles*self.__nTxs)
                     dataOut.profileIndex = profileIndex
                     dataOut.ippSeconds /= self.__nTxs
                     return dataOut
             class SplitProfiles(Operation):
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                 def run(self, dataOut, n):
                     dataOut.flagNoData = True
                     profileIndex = None
                     if dataOut.flagDataAsBlock:
                         #nchannels, nprofiles, nsamples
                         shape = dataOut.data.shape
                         if shape[2] % n != 0:
                             raise ValueError("Could not split the data, n=%d has to be multiple of %d" %(n, shape[2]))
                         new_shape = shape[0], shape[1]*n, int(shape[2]/n)
                         dataOut.data = numpy.reshape(dataOut.data, new_shape)
                         dataOut.flagNoData = False
                         profileIndex = int(dataOut.nProfiles/n) - 1
                     else:
                         raise ValueError("Could not split the data when is read Profile by Profile. Use VoltageReader(..., getblock=True)")
                     deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
                     dataOut.heightList = numpy.arange(dataOut.nHeights/n) * deltaHeight + dataOut.heightList[0]
                     dataOut.nProfiles = int(dataOut.nProfiles*n)
                     dataOut.profileIndex = profileIndex
                     dataOut.ippSeconds /= n
                     return dataOut
             class CombineProfiles(Operation):
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                     self.__remData = None
                     self.__profileIndex = 0
                 def run(self, dataOut, n):
                     dataOut.flagNoData = True
                     profileIndex = None
                     if dataOut.flagDataAsBlock:
                         #nchannels, nprofiles, nsamples
                         shape = dataOut.data.shape
                         new_shape = shape[0], shape[1]/n, shape[2]*n
                         if shape[1] % n != 0:
                             raise ValueError("Could not split the data, n=%d has to be multiple of %d" %(n, shape[1]))
                         dataOut.data = numpy.reshape(dataOut.data, new_shape)
                         dataOut.flagNoData = False
                         profileIndex = int(dataOut.nProfiles*n) - 1
                     else:
                         #nchannels, nsamples
                         if self.__remData is None:
                             newData = dataOut.data
                         else:
                             newData = numpy.concatenate((self.__remData, dataOut.data), axis=1)
                         self.__profileIndex += 1
                         if self.__profileIndex < n:
                             self.__remData = newData
                             #continue
                             return
                         self.__profileIndex = 0
                         self.__remData = None
                         dataOut.data = newData
                         dataOut.flagNoData = False
                         profileIndex = dataOut.profileIndex/n
                     deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
                     dataOut.heightList = numpy.arange(dataOut.nHeights*n) * deltaHeight + dataOut.heightList[0]
                     dataOut.nProfiles = int(dataOut.nProfiles/n)
                     dataOut.profileIndex = profileIndex
                     dataOut.ippSeconds *= n
                     return dataOut
             class PulsePair(Operation):
                 '''
                 Function PulsePair(Signal Power, Velocity)
                 The real component of Lag[0] provides Intensity Information
                 The imag component of Lag[1] Phase provides Velocity Information
                 Configuration Parameters:
                 nPRF = Number of Several PRF
                 theta = Degree Azimuth angel Boundaries
                 Input:
                       self.dataOut
                       lag[N]
                 Affected:
                       self.dataOut.spc
                 '''
                 isConfig       = False
                 __profIndex    = 0
                 __initime      = None
                 __lastdatatime = None
                 __buffer       = None
                 noise          = None
                 __dataReady    = False
                 n              = None
                 __nch          = 0
                 __nHeis        = 0
                 removeDC       = False
                 ipp            = None
                 lambda_        = 0
                 def __init__(self,**kwargs):
                     Operation.__init__(self,**kwargs)
                 def setup(self, dataOut, n = None, removeDC=False):
                     '''
                     n= Numero de PRF's de entrada
                     '''
                     self.__initime        = None
                     ####print("[INICIO]-setup  del METODO PULSE PAIR")
                     self.__lastdatatime   = 0
                     self.__dataReady      = False
                     self.__buffer         = 0
                     self.__profIndex      = 0
                     self.noise            = None
                     self.__nch            = dataOut.nChannels
                     self.__nHeis          = dataOut.nHeights
                     self.removeDC         = removeDC
                     self.lambda_          = 3.0e8/(9345.0e6)
                     self.ippSec           = dataOut.ippSeconds
                     self.nCohInt          = dataOut.nCohInt
                     ####print("IPPseconds",dataOut.ippSeconds)
                     ####print("ELVALOR DE n es:", n)
                     if n == None:
                         raise ValueError("n should be specified.")
                     if n != None:
                         if n<2:
                             raise ValueError("n should be greater than 2")
                     self.n       = n
                     self.__nProf = n
                     self.__buffer = numpy.zeros((dataOut.nChannels,
                                                        n,
                                                        dataOut.nHeights),
                                                       dtype='complex')
                 def putData(self,data):
                     '''
                     Add a profile to he __buffer and increase in one the __profiel Index
                     '''
                     self.__buffer[:,self.__profIndex,:]= data
                     self.__profIndex      += 1
                     return
                 def pushData(self,dataOut):
                     '''
                     Return the PULSEPAIR and the profiles used in the operation
                     Affected :  self.__profileIndex
                     '''
                     #----------------- Remove DC-----------------------------------
                     if self.removeDC==True:
                         mean    = numpy.mean(self.__buffer,1)
                         tmp     = mean.reshape(self.__nch,1,self.__nHeis)
                         dc= numpy.tile(tmp,[1,self.__nProf,1])
                         self.__buffer = self.__buffer -  dc
                     #------------------Calculo de Potencia ------------------------
                     pair0       = self.__buffer*numpy.conj(self.__buffer)
                     pair0       = pair0.real
                     lag_0       = numpy.sum(pair0,1)
                     #-----------------Calculo de Cscp------------------------------ New
                     cspc_pair01 = self.__buffer[0]*self.__buffer[1]
                     #------------------Calculo de Ruido x canal--------------------
                     self.noise  = numpy.zeros(self.__nch)
                     for i in range(self.__nch):
                         daux         = numpy.sort(pair0[i,:,:],axis= None)
                         self.noise[i]=hildebrand_sekhon( daux ,self.nCohInt)
                     self.noise       = self.noise.reshape(self.__nch,1)
                     self.noise       = numpy.tile(self.noise,[1,self.__nHeis])
                     noise_buffer     = self.noise.reshape(self.__nch,1,self.__nHeis)
                     noise_buffer     = numpy.tile(noise_buffer,[1,self.__nProf,1])
                     #------------------ Potencia recibida= P , Potencia senal = S , Ruido= N--
                     #------------------   P= S+N  ,P=lag_0/N ---------------------------------
                     #-------------------- Power --------------------------------------------------
                     data_power       = lag_0/(self.n*self.nCohInt)
                     #--------------------CCF------------------------------------------------------
                     data_ccf         =numpy.sum(cspc_pair01,axis=0)/(self.n*self.nCohInt)
                     #------------------  Senal  --------------------------------------------------
                     data_intensity   = pair0 - noise_buffer
                     data_intensity   = numpy.sum(data_intensity,axis=1)*(self.n*self.nCohInt)#*self.nCohInt)
                     #data_intensity   = (lag_0-self.noise*self.n)*(self.n*self.nCohInt)
                     for i in range(self.__nch):
                         for j in range(self.__nHeis):
                             if data_intensity[i][j]  < 0:
                                 data_intensity[i][j] = numpy.min(numpy.absolute(data_intensity[i][j]))
                     #----------------- Calculo de Frecuencia y Velocidad doppler--------
                     pair1            = self.__buffer[:,:-1,:]*numpy.conjugate(self.__buffer[:,1:,:])
                     lag_1            = numpy.sum(pair1,1)
                     data_freq        = (-1/(2.0*math.pi*self.ippSec*self.nCohInt))*numpy.angle(lag_1)
                     data_velocity    = (self.lambda_/2.0)*data_freq
                     #---------------- Potencia promedio estimada de la Senal-----------
                     lag_0            = lag_0/self.n
                     S                = lag_0-self.noise
                     #---------------- Frecuencia Doppler promedio ---------------------
                     lag_1            = lag_1/(self.n-1)
                     R1               = numpy.abs(lag_1)
                     #---------------- Calculo del SNR----------------------------------
                     data_snrPP       = S/self.noise
                     for i in range(self.__nch):
                         for j in range(self.__nHeis):
                             if data_snrPP[i][j]  < 1.e-20:
                                 data_snrPP[i][j] = 1.e-20
                     #----------------- Calculo del ancho espectral ----------------------
                     L                = S/R1
                     L                = numpy.where(L<0,1,L)
                     L                = numpy.log(L)
                     tmp              = numpy.sqrt(numpy.absolute(L))
                     data_specwidth   = (self.lambda_/(2*math.sqrt(2)*math.pi*self.ippSec*self.nCohInt))*tmp*numpy.sign(L)
                     n                = self.__profIndex
                     self.__buffer    = numpy.zeros((self.__nch, self.__nProf,self.__nHeis),  dtype='complex')
                     self.__profIndex = 0
                     return data_power,data_intensity,data_velocity,data_snrPP,data_specwidth,data_ccf,n
                 def pulsePairbyProfiles(self,dataOut):
                     self.__dataReady     =  False
                     data_power           =  None
                     data_intensity       =  None
                     data_velocity        =  None
                     data_specwidth       =  None
                     data_snrPP           =  None
                     data_ccf             =  None
                     self.putData(data=dataOut.data)
                     if self.__profIndex  == self.n:
                         data_power,data_intensity, data_velocity,data_snrPP,data_specwidth,data_ccf, n   = self.pushData(dataOut=dataOut)
                         self.__dataReady                   = True
                     return data_power, data_intensity, data_velocity, data_snrPP,data_specwidth,data_ccf
                 def pulsePairOp(self, dataOut, datatime= None):
                     if self.__initime == None:
                         self.__initime = datatime
                     data_power, data_intensity, data_velocity, data_snrPP,data_specwidth,data_ccf = self.pulsePairbyProfiles(dataOut)
                     self.__lastdatatime           = datatime
                     if data_power is None:
                         return None, None, None,None,None,None,None
                     avgdatatime    = self.__initime
                     deltatime      = datatime - self.__lastdatatime
                     self.__initime = datatime
                     return data_power, data_intensity, data_velocity, data_snrPP,data_specwidth,data_ccf, avgdatatime
                 def run(self, dataOut,n = None,removeDC= False, overlapping= False,**kwargs):
                     #print("hey")
                     #print(dataOut.data.shape)
                     #exit(1)
                     #print(self.__profIndex)
                     if not self.isConfig:
                         self.setup(dataOut = dataOut, n    = n , removeDC=removeDC , **kwargs)
                         self.isConfig   = True
                     data_power, data_intensity, data_velocity,data_snrPP,data_specwidth,data_ccf, avgdatatime = self.pulsePairOp(dataOut, dataOut.utctime)
                     dataOut.flagNoData                         = True
                     if self.__dataReady:
                         ###print("READY ----------------------------------")
                         dataOut.nCohInt        *= self.n
                         dataOut.dataPP_POW      = data_intensity # S
                         dataOut.dataPP_POWER    = data_power     # P valor que corresponde a POTENCIA MOMENTO
                         dataOut.dataPP_DOP      = data_velocity
                         dataOut.dataPP_SNR      = data_snrPP
                         dataOut.dataPP_WIDTH    = data_specwidth
                         dataOut.dataPP_CCF      = data_ccf
                         dataOut.PRFbyAngle      = self.n         #numero de PRF*cada angulo rotado que equivale a un tiempo.
                         dataOut.nProfiles       = int(dataOut.nProfiles/n)
                         dataOut.utctime         = avgdatatime
                         dataOut.flagNoData      = False
                     return dataOut
             class PulsePair_vRF(Operation):
                 '''
                 Function PulsePair(Signal Power, Velocity)
                 The real component of Lag[0] provides Intensity Information
                 The imag component of Lag[1] Phase provides Velocity Information
                 Configuration Parameters:
                 nPRF = Number of Several PRF
                 theta = Degree Azimuth angel Boundaries
                 Input:
                       self.dataOut
                       lag[N]
                 Affected:
                       self.dataOut.spc
                 '''
                 isConfig       = False
                 __profIndex    = 0
                 __initime      = None
                 __lastdatatime = None
                 __buffer       = None
                 noise          = None
                 __dataReady    = False
                 n              = None
                 __nch          = 0
                 __nHeis        = 0
                 removeDC       = False
                 ipp            = None
                 lambda_        = 0
                 def __init__(self,**kwargs):
                     Operation.__init__(self,**kwargs)
                 def setup(self, dataOut, n = None, removeDC=False):
                     '''
                     n= Numero de PRF's de entrada
                     '''
                     self.__initime        = None
                     ####print("[INICIO]-setup  del METODO PULSE PAIR")
                     self.__lastdatatime   = 0
                     self.__dataReady      = False
                     self.__buffer         = 0
                     self.__profIndex      = 0
                     self.noise            = None
                     self.__nch            = dataOut.nChannels
                     self.__nHeis          = dataOut.nHeights
                     self.removeDC         = removeDC
                     self.lambda_          = 3.0e8/(9345.0e6)
                     self.ippSec           = dataOut.ippSeconds
                     self.nCohInt          = dataOut.nCohInt
                     ####print("IPPseconds",dataOut.ippSeconds)
                     ####print("ELVALOR DE n es:", n)
                     if n == None:
                         raise ValueError("n should be specified.")
                     if n != None:
                         if n<2:
                             raise ValueError("n should be greater than 2")
                     self.n       = n
                     self.__nProf = n
                     self.__buffer = numpy.zeros((dataOut.nChannels,
                                                        n,
                                                        dataOut.nHeights),
                                                       dtype='complex')
                 def putData(self,data):
                     '''
                     Add a profile to he __buffer and increase in one the __profiel Index
                     '''
                     self.__buffer[:,self.__profIndex,:]= data
                     self.__profIndex      += 1
                     return
                 def putDataByBlock(self,data,n):
                     '''
                     Add a profile to he __buffer and increase in one the __profiel Index
                     '''
                     self.__buffer[:]= data
                     self.__profIndex      = n
                     return
                 def pushData(self,dataOut):
                     '''
                     Return the PULSEPAIR and the profiles used in the operation
                     Affected :  self.__profileIndex
                     NOTA:
 .)  Calculo de Potencia
                     PdBm = 10 *log10(10*(I**2  + Q**2)) Unidades dBm
                     self.__buffer = I + Qj
 .) Data decodificada
                     Se toma como referencia el factor estimado en jrodata.py y se adiciona
                     en PulsePair solo pwcode.
                     if self.flagDecodeData:
                         pwcode = numpy.sum(self.code[0]**2)
                     normFactor = self.nProfiles * self.nIncohInt * self.nCohInt * pwcode * self.windowOfFilter
 .) hildebrand_sekhon
                     Se pasa el arreglo de Potencia pair0 que contiene canales perfiles y altura dividiendole entre el
                     factor pwcode.
 .) data_power
                     Este parametro esta dividido por los factores: nro. perfiles, nro intCoh y pwcode
 .) lag_0
                     Este parametro esta dividido por los factores: nro. perfiles, nro intCoh y pwcode
                     Igual a data_power
                     '''
                     #----------------- Remove DC-----------------------------------
                     if self.removeDC==True:
                         mean    = numpy.mean(self.__buffer,1)
                         tmp     = mean.reshape(self.__nch,1,self.__nHeis)
                         dc= numpy.tile(tmp,[1,self.__nProf,1])
                         self.__buffer = self.__buffer -  dc
                     #------------------Calculo de Potencia ------------------------
                     pair0       = self.__buffer*numpy.conj(self.__buffer) * 10.0
                     pair0       = pair0.real
                     lag_0       = numpy.sum(pair0,1)
                     #-----------------Calculo de Cscp------------------------------ New
-                    cspc_pair01 = self.__buffer[0]*self.__buffer[1]
+                    if len(self.__buffer)>1:
+                        cspc_pair01 = self.__buffer[0]*self.__buffer[1]
                     #------------------  Data Decodificada------------------------
                     pwcode =  1
                     if dataOut.flagDecodeData == True:
                         pwcode = numpy.sum(dataOut.code[0]**2)
                     #------------------Calculo de Ruido x canal--------------------
                     self.noise  = numpy.zeros(self.__nch)
                     for i in range(self.__nch):
                         daux         = numpy.sort(pair0[i,:,:],axis= None)
                         self.noise[i]=hildebrand_sekhon( daux/pwcode ,self.nCohInt)
                     self.noise       = self.noise.reshape(self.__nch,1)
                     self.noise       = numpy.tile(self.noise,[1,self.__nHeis])
                     noise_buffer     = self.noise.reshape(self.__nch,1,self.__nHeis)
                     noise_buffer     = numpy.tile(noise_buffer,[1,self.__nProf,1])
                     #------------------ Potencia recibida= P , Potencia senal = S , Ruido= N--
                     #------------------   P= S+N  ,P=lag_0/N ---------------------------------
                     #-------------------- Power --------------------------------------------------
                     data_power       = lag_0/(self.n*self.nCohInt*pwcode)
                     #--------------------CCF------------------------------------------------------
-                    data_ccf         =numpy.sum(cspc_pair01,axis=0)/(self.n*self.nCohInt)
+                    if len(self.__buffer)>1:
+                        data_ccf         =numpy.sum(cspc_pair01,axis=0)/(self.n*self.nCohInt)
+                    else:
+                        data_ccf = 0
                     #------------------  Senal  --------------------------------------------------
                     data_intensity   = pair0 - noise_buffer
                     data_intensity   = numpy.sum(data_intensity,axis=1)*(self.n*self.nCohInt)#*self.nCohInt)
                     #data_intensity   = (lag_0-self.noise*self.n)*(self.n*self.nCohInt)
                     for i in range(self.__nch):
                         for j in range(self.__nHeis):
                             if data_intensity[i][j]  < 0:
                                 data_intensity[i][j] = numpy.min(numpy.absolute(data_intensity[i][j]))
                     #----------------- Calculo de Frecuencia y Velocidad doppler--------
                     pair1            = self.__buffer[:,:-1,:]*numpy.conjugate(self.__buffer[:,1:,:])
                     lag_1            = numpy.sum(pair1,1)
                     data_freq        = (-1/(2.0*math.pi*self.ippSec*self.nCohInt))*numpy.angle(lag_1)
                     data_velocity    = (self.lambda_/2.0)*data_freq
                     #---------------- Potencia promedio estimada de la Senal-----------
                     lag_0            = data_power
                     S                = lag_0-self.noise
                     #---------------- Frecuencia Doppler promedio ---------------------
                     lag_1            = lag_1/(self.n-1)
                     R1               = numpy.abs(lag_1)
                     #---------------- Calculo del SNR----------------------------------
                     data_snrPP       = S/self.noise
                     for i in range(self.__nch):
                         for j in range(self.__nHeis):
                             if data_snrPP[i][j]  < 1.e-20:
                                 data_snrPP[i][j] = 1.e-20
                     #----------------- Calculo del ancho espectral ----------------------
                     L                = S/R1
                     L                = numpy.where(L<0,1,L)
                     L                = numpy.log(L)
                     tmp              = numpy.sqrt(numpy.absolute(L))
                     data_specwidth   = (self.lambda_/(2*math.sqrt(2)*math.pi*self.ippSec*self.nCohInt))*tmp*numpy.sign(L)
                     n                = self.__profIndex
                     self.__buffer    = numpy.zeros((self.__nch, self.__nProf,self.__nHeis),  dtype='complex')
                     self.__profIndex = 0
                     return data_power,data_intensity,data_velocity,data_snrPP,data_specwidth,data_ccf,n
                 def pulsePairbyProfiles(self,dataOut,n):
                     self.__dataReady     =  False
                     data_power           =  None
                     data_intensity       =  None
                     data_velocity        =  None
                     data_specwidth       =  None
                     data_snrPP           =  None
                     data_ccf             =  None
                     if dataOut.flagDataAsBlock:
                         self.putDataByBlock(data=dataOut.data,n=n)
                     else:
                         self.putData(data=dataOut.data)
                     if self.__profIndex  == self.n:
                         data_power,data_intensity, data_velocity,data_snrPP,data_specwidth,data_ccf, n   = self.pushData(dataOut=dataOut)
                         self.__dataReady                   = True
                     return data_power, data_intensity, data_velocity, data_snrPP,data_specwidth,data_ccf
                 def pulsePairOp(self, dataOut, n, datatime= None):
                     if self.__initime == None:
                         self.__initime = datatime
                     data_power, data_intensity, data_velocity, data_snrPP,data_specwidth,data_ccf = self.pulsePairbyProfiles(dataOut,n)
                     self.__lastdatatime           = datatime
                     if data_power is None:
                         return None, None, None,None,None,None,None
                     avgdatatime    = self.__initime
                     deltatime      = datatime - self.__lastdatatime
                     self.__initime = datatime
                     return data_power, data_intensity, data_velocity, data_snrPP,data_specwidth,data_ccf, avgdatatime
                 def run(self, dataOut,n = None,removeDC= False, overlapping= False,**kwargs):
                     if dataOut.flagDataAsBlock:
                         n = int(dataOut.nProfiles)
                         #print("n",n)
                     if not self.isConfig:
                         self.setup(dataOut = dataOut, n    = n , removeDC=removeDC , **kwargs)
                         self.isConfig   = True
                     data_power, data_intensity, data_velocity,data_snrPP,data_specwidth,data_ccf, avgdatatime = self.pulsePairOp(dataOut, n, dataOut.utctime)
                     dataOut.flagNoData                         = True
                     if self.__dataReady:
                         ###print("READY ----------------------------------")
                         dataOut.nCohInt        *= self.n
                         dataOut.dataPP_POW      = data_intensity # S
                         dataOut.dataPP_POWER    = data_power     # P valor que corresponde a POTENCIA MOMENTO
                         dataOut.dataPP_DOP      = data_velocity
                         dataOut.dataPP_SNR      = data_snrPP
                         dataOut.dataPP_WIDTH    = data_specwidth
                         dataOut.dataPP_CCF      = data_ccf
                         dataOut.PRFbyAngle      = self.n         #numero de PRF*cada angulo rotado que equivale a un tiempo.
                         dataOut.nProfiles       = int(dataOut.nProfiles/n)
                         dataOut.utctime         = avgdatatime
                         dataOut.flagNoData      = False
                     return dataOut
             # import collections
             # from scipy.stats import mode
             #
             # class Synchronize(Operation):
             #
             #     isConfig = False
             #     __profIndex = 0
             #
             #     def __init__(self, **kwargs):
             #
             #         Operation.__init__(self, **kwargs)
             # #         self.isConfig = False
             #         self.__powBuffer = None
             #         self.__startIndex = 0
             #         self.__pulseFound = False
             #
             #     def __findTxPulse(self, dataOut, channel=0, pulse_with = None):
             #
             #         #Read data
             #
             #         powerdB = dataOut.getPower(channel = channel)
             #         noisedB = dataOut.getNoise(channel = channel)[0]
             #
             #         self.__powBuffer.extend(powerdB.flatten())
             #
             #         dataArray = numpy.array(self.__powBuffer)
             #
             #         filteredPower = numpy.correlate(dataArray, dataArray[0:self.__nSamples], "same")
             #
             #         maxValue = numpy.nanmax(filteredPower)
             #
             #         if maxValue < noisedB + 10:
             #             #No se encuentra ningun pulso de transmision
             #             return None
             #
             #         maxValuesIndex = numpy.where(filteredPower > maxValue - 0.1*abs(maxValue))[0]
             #
             #         if len(maxValuesIndex) < 2:
             #             #Solo se encontro un solo pulso de transmision de un baudio, esperando por el siguiente TX
             #             return None
             #
             #         phasedMaxValuesIndex = maxValuesIndex - self.__nSamples
             #
             #         #Seleccionar solo valores con un espaciamiento de nSamples
             #         pulseIndex = numpy.intersect1d(maxValuesIndex, phasedMaxValuesIndex)
             #
             #         if len(pulseIndex) < 2:
             #             #Solo se encontro un pulso de transmision con ancho mayor a 1
             #             return None
             #
             #         spacing = pulseIndex[1:] - pulseIndex[:-1]
             #
             #         #remover senales que se distancien menos de 10 unidades o muestras
             #         #(No deberian existir IPP menor a 10 unidades)
             #
             #         realIndex = numpy.where(spacing > 10 )[0]
             #
             #         if len(realIndex) < 2:
             #             #Solo se encontro un pulso de transmision con ancho mayor a 1
             #             return None
             #
             #         #Eliminar pulsos anchos (deja solo la diferencia entre IPPs)
             #         realPulseIndex = pulseIndex[realIndex]
             #
             #         period = mode(realPulseIndex[1:] - realPulseIndex[:-1])[0][0]
             #
             #         print "IPP = %d samples" %period
             #
             #         self.__newNSamples = dataOut.nHeights #int(period)
             #         self.__startIndex = int(realPulseIndex[0])
             #
             #         return 1
             #
             #
             #     def setup(self, nSamples, nChannels, buffer_size = 4):
             #
             #         self.__powBuffer = collections.deque(numpy.zeros( buffer_size*nSamples,dtype=numpy.float),
             #                                           maxlen = buffer_size*nSamples)
             #
             #         bufferList = []
             #
             #         for i in range(nChannels):
             #             bufferByChannel = collections.deque(numpy.zeros( buffer_size*nSamples, dtype=numpy.complex) +  numpy.NAN,
             #                                           maxlen = buffer_size*nSamples)
             #
             #             bufferList.append(bufferByChannel)
             #
             #         self.__nSamples = nSamples
             #         self.__nChannels = nChannels
             #         self.__bufferList = bufferList
             #
             #     def run(self, dataOut, channel = 0):
             #
             #         if not self.isConfig:
             #             nSamples = dataOut.nHeights
             #             nChannels = dataOut.nChannels
             #             self.setup(nSamples, nChannels)
             #             self.isConfig = True
             #
             #         #Append new data to internal buffer
             #         for thisChannel in range(self.__nChannels):
             #             bufferByChannel = self.__bufferList[thisChannel]
             #             bufferByChannel.extend(dataOut.data[thisChannel])
             #
             #         if self.__pulseFound:
             #             self.__startIndex -= self.__nSamples
             #
             #         #Finding Tx Pulse
             #         if not self.__pulseFound:
             #             indexFound = self.__findTxPulse(dataOut, channel)
             #
             #             if indexFound == None:
             #                 dataOut.flagNoData = True
             #                 return
             #
             #             self.__arrayBuffer = numpy.zeros((self.__nChannels, self.__newNSamples), dtype = numpy.complex)
             #             self.__pulseFound = True
             #             self.__startIndex = indexFound
             #
             #         #If pulse was found ...
             #         for thisChannel in range(self.__nChannels):
             #             bufferByChannel = self.__bufferList[thisChannel]
             #             #print self.__startIndex
             #             x = numpy.array(bufferByChannel)
             #             self.__arrayBuffer[thisChannel] = x[self.__startIndex:self.__startIndex+self.__newNSamples]
             #
             #         deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
             #         dataOut.heightList = numpy.arange(self.__newNSamples)*deltaHeight
             # #             dataOut.ippSeconds = (self.__newNSamples / deltaHeight)/1e6
             #
             #         dataOut.data = self.__arrayBuffer
             #
             #         self.__startIndex += self.__newNSamples
             #
             #         return

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