schain Commit - r1461:773419e042d4 · Jicamarca Repository

PPI or RHI mode Detection/GeneralPlot

rflores -

r1461:773419e042d4

parent child

Context file:

r1461:773419e042d4

Collapse all files

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

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

             # 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
             if 'BACKEND' in os.environ:
                 matplotlib.use(os.environ['BACKEND'])
             elif 'linux' in sys.platform:
                 matplotlib.use("TkAgg")
             elif 'darwin' in sys.platform:
                 matplotlib.use('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)
             CMAPS = [plt.get_cmap(s) for s in ('jro', 'jet', 'viridis',
                                                'plasma', 'inferno', 'Greys', 'seismic', 'bwr', 'coolwarm')]
             EARTH_RADIUS = 6.3710e3
             def ll2xy(lat1, lon1, lat2, lon2):
                 p = 0.017453292519943295
                 a = 0.5 - numpy.cos((lat2 - lat1) * p)/2 + numpy.cos(lat1 * p) * \
                     numpy.cos(lat2 * p) * (1 - numpy.cos((lon2 - lon1) * p)) / 2
                 r = 12742 * numpy.arcsin(numpy.sqrt(a))
                 theta = numpy.arctan2(numpy.sin((lon2-lon1)*p)*numpy.cos(lat2*p), numpy.cos(lat1*p)
                                       * numpy.sin(lat2*p)-numpy.sin(lat1*p)*numpy.cos(lat2*p)*numpy.cos((lon2-lon1)*p))
                 theta = -theta + numpy.pi/2
                 return r*numpy.cos(theta), r*numpy.sin(theta)
             def km2deg(km):
                 '''
                 Convert distance in km to degrees
                 '''
                 return numpy.rad2deg(km/EARTH_RADIUS)
             def figpause(interval):
                 backend = plt.rcParams['backend']
                 if backend in matplotlib.rcsetup.interactive_bk:
                     figManager = matplotlib._pylab_helpers.Gcf.get_active()
                     if figManager is not None:
                         canvas = figManager.canvas
                         if canvas.figure.stale:
                             canvas.draw()
                         try:
                             canvas.start_event_loop(interval)
                         except:
                             pass
                         return
             def popup(message):
                 '''
                 '''
                 fig = plt.figure(figsize=(12, 8), facecolor='r')
                 text = '\n'.join([s.strip() for s in message.split(':')])
                 fig.text(0.01, 0.5, text, ha='left', va='center',
                          size='20', weight='heavy', color='w')
                 fig.show()
                 figpause(1000)
             class Throttle(object):
                 '''
                 Decorator that prevents a function from being called more than once every
                 time period.
                 To create a function that cannot be called more than once a minute, but
                 will sleep until it can be called:
                 @Throttle(minutes=1)
                 def foo():
                   pass
                 for i in range(10):
                   foo()
                   print "This function has run %s times." % i
                 '''
                 def __init__(self, seconds=0, minutes=0, hours=0):
                     self.throttle_period = datetime.timedelta(
                         seconds=seconds, minutes=minutes, hours=hours
                     )
                     self.time_of_last_call = datetime.datetime.min
                 def __call__(self, fn):
                     @wraps(fn)
                     def wrapper(*args, **kwargs):
                         coerce = kwargs.pop('coerce', None)
                         if coerce:
                             self.time_of_last_call = datetime.datetime.now()
                             return fn(*args, **kwargs)
                         else:
                             now = datetime.datetime.now()
                             time_since_last_call = now - self.time_of_last_call
                             time_left = self.throttle_period - time_since_last_call
                             if time_left > datetime.timedelta(seconds=0):
                                 return
                         self.time_of_last_call = datetime.datetime.now()
                         return fn(*args, **kwargs)
                     return wrapper
             def apply_throttle(value):
                 @Throttle(seconds=value)
                 def fnThrottled(fn):
                     fn()
                 return fnThrottled
             @MPDecorator
             class Plot(Operation):
                 """Base class for Schain plotting operations
                 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.02, aspect=10)
                                 ax.cbar.ax.tick_params(labelsize=8)
                                 ax.cbar.ax.press = None
                                 if self.cb_label:
                                     ax.cbar.set_label(self.cb_label, size=8)
                                 elif self.cb_labels:
                                     ax.cbar.set_label(self.cb_labels[n], size=8)
                             else:
                                 ax.cbar = None
                             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 = 20
                     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:
                             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):
                     '''
                     '''
                     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]
+                    print("save_code",self.save_code)
                     if self.throttle == 0:
                         if self.oneFigure:
                             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 +140 -1

             import os
             import datetime
             import numpy
             from mpl_toolkits.axisartist.grid_finder import FixedLocator, DictFormatter
             from schainpy.model.graphics.jroplot_base import Plot, plt
             from schainpy.model.graphics.jroplot_spectra import SpectraPlot, RTIPlot, CoherencePlot, SpectraCutPlot
             from schainpy.utils import log
             # libreria wradlib
-            import wradlib as wrl
+            #import wradlib as wrl
             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)
             class SpectralMomentsPlot(SpectraPlot):
                 '''
                 Plot for Spectral Moments
                 '''
                 CODE = 'spc_moments'
                 # colormap = 'jet'
                 # plot_type = 'pcolor'
             class DobleGaussianPlot(SpectraPlot):
                 '''
                 Plot for Double Gaussian Plot
                 '''
                 CODE = 'gaussian_fit'
                 # colormap = 'jet'
                 # plot_type = 'pcolor'
             class DoubleGaussianSpectraCutPlot(SpectraCutPlot):
                 '''
                 Plot SpectraCut with Double Gaussian Fit
                 '''
                 CODE = 'cut_gaussian_fit'
             class SnrPlot(RTIPlot):
                 '''
                 Plot for SNR Data
                 '''
                 CODE = 'snr'
                 colormap = 'jet'
                 def update(self, dataOut):
                     data = {
                         'snr': 10*numpy.log10(dataOut.data_snr)
                     }
                     return data, {}
             class DopplerPlot(RTIPlot):
                 '''
                 Plot for DOPPLER Data (1st moment)
                 '''
                 CODE = 'dop'
                 colormap = 'jet'
                 def update(self, dataOut):
                     data = {
                         'dop': 10*numpy.log10(dataOut.data_dop)
                     }
                     return data, {}
             class PowerPlot(RTIPlot):
                 '''
                 Plot for Power Data (0 moment)
                 '''
                 CODE = 'pow'
                 colormap = 'jet'
                 def update(self, dataOut):
                     data = {
                         'pow': 10*numpy.log10(dataOut.data_pow/dataOut.normFactor)
                     }
                     return data, {}
             class SpectralWidthPlot(RTIPlot):
                 '''
                 Plot for Spectral Width Data (2nd moment)
                 '''
                 CODE = 'width'
                 colormap = 'jet'
                 def update(self, dataOut):
                     data = {
                         'width': dataOut.data_width
                     }
                     return data, {}
             class SkyMapPlot(Plot):
                 '''
                 Plot for meteors detection data
                 '''
                 CODE = 'param'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.width = 7.2
                     self.height = 7.2
                     self.nplots = 1
                     self.xlabel = 'Zonal Zenith Angle (deg)'
                     self.ylabel = 'Meridional Zenith Angle (deg)'
                     self.polar = True
                     self.ymin = -180
                     self.ymax = 180
                     self.colorbar = False
                 def plot(self):
                     arrayParameters = numpy.concatenate(self.data['param'])
                     error = arrayParameters[:, -1]
                     indValid = numpy.where(error == 0)[0]
                     finalMeteor = arrayParameters[indValid, :]
                     finalAzimuth = finalMeteor[:, 3]
                     finalZenith = finalMeteor[:, 4]
                     x = finalAzimuth * numpy.pi / 180
                     y = finalZenith
                     ax = self.axes[0]
                     if ax.firsttime:
                         ax.plot = ax.plot(x, y, 'bo', markersize=5)[0]
                     else:
                         ax.plot.set_data(x, y)
                     dt1 = self.getDateTime(self.data.min_time).strftime('%y/%m/%d %H:%M:%S')
                     dt2 = self.getDateTime(self.data.max_time).strftime('%y/%m/%d %H:%M:%S')
                     title = 'Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n' % (dt1,
                                                                                                  dt2,
                                                                                                  len(x))
                     self.titles[0] = title
             class GenericRTIPlot(Plot):
                 '''
                 Plot for data_xxxx object
                 '''
                 CODE = 'param'
                 colormap = 'viridis'
                 plot_type = 'pcolorbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = self.data.shape('param')[0]
                     self.nplots = self.nrows
                     self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.08, 'right':0.95, 'top': 0.95})
                     if not self.xlabel:
                         self.xlabel = 'Time'
                     self.ylabel = 'Range [km]'
                     if not self.titles:
                         self.titles = ['Param {}'.format(x) for x in range(self.nrows)]
                 def update(self, dataOut):
                     data = {
                         'param' : numpy.concatenate([getattr(dataOut, attr) for attr in self.attr_data], axis=0)
                     }
                     meta = {}
                     return data, meta
                 def plot(self):
                     # self.data.normalize_heights()
                     self.x = self.data.times
                     self.y = self.data.yrange
                     self.z = self.data['param']
                     self.z = 10*numpy.log10(self.z)
                     self.z = numpy.ma.masked_invalid(self.z)
                     if self.decimation is None:
                         x, y, z = self.fill_gaps(self.x, self.y, self.z)
                     else:
                         x, y, z = self.fill_gaps(*self.decimate())
                     for n, ax in enumerate(self.axes):
                         self.zmax = self.zmax if self.zmax is not None else numpy.max(
                             self.z[n])
                         self.zmin = self.zmin if self.zmin is not None else numpy.min(
                             self.z[n])
                         if ax.firsttime:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n]
                                                    )
                         else:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.collections.remove(ax.collections[0])
                             ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n]
                                                    )
             class PolarMapPlot(Plot):
                 '''
                 Plot for weather radar
                 '''
                 CODE = 'param'
                 colormap = 'seismic'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.width = 9
                     self.height = 8
                     self.mode = self.data.meta['mode']
                     if self.channels is not None:
                         self.nplots = len(self.channels)
                         self.nrows = len(self.channels)
                     else:
                         self.nplots = self.data.shape(self.CODE)[0]
                         self.nrows = self.nplots
                         self.channels = list(range(self.nplots))
                     if self.mode == 'E':
                         self.xlabel = 'Longitude'
                         self.ylabel = 'Latitude'
                     else:
                         self.xlabel = 'Range (km)'
                         self.ylabel = 'Height (km)'
                     self.bgcolor = 'white'
                     self.cb_labels = self.data.meta['units']
                     self.lat = self.data.meta['latitude']
                     self.lon = self.data.meta['longitude']
                     self.xmin, self.xmax = float(
                         km2deg(self.xmin) + self.lon), float(km2deg(self.xmax) + self.lon)
                     self.ymin, self.ymax = float(
                         km2deg(self.ymin) + self.lat), float(km2deg(self.ymax) + self.lat)
                     #  self.polar = True
                 def plot(self):
                     for n, ax in enumerate(self.axes):
                         data = self.data['param'][self.channels[n]]
                         zeniths = numpy.linspace(
 , self.data.meta['max_range'], data.shape[1])
                         if self.mode == 'E':
                             azimuths = -numpy.radians(self.data.yrange)+numpy.pi/2
                             r, theta = numpy.meshgrid(zeniths, azimuths)
                             x, y = r*numpy.cos(theta)*numpy.cos(numpy.radians(self.data.meta['elevation'])), r*numpy.sin(
                                 theta)*numpy.cos(numpy.radians(self.data.meta['elevation']))
                             x = km2deg(x) + self.lon
                             y = km2deg(y) + self.lat
                         else:
                             azimuths = numpy.radians(self.data.yrange)
                             r, theta = numpy.meshgrid(zeniths, azimuths)
                             x, y = r*numpy.cos(theta), r*numpy.sin(theta)
                         self.y = zeniths
                         if ax.firsttime:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt = ax.pcolormesh(  # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 vmin=self.zmin,
                                 vmax=self.zmax,
                                 cmap=self.cmaps[n])
                         else:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.collections.remove(ax.collections[0])
                             ax.plt = ax.pcolormesh(  # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 vmin=self.zmin,
                                 vmax=self.zmax,
                                 cmap=self.cmaps[n])
                         if self.mode == 'A':
                             continue
                         # plot district names
                         f = open('/data/workspace/schain_scripts/distrito.csv')
                         for line in f:
                             label, lon, lat = [s.strip() for s in line.split(',') if s]
                             lat = float(lat)
                             lon = float(lon)
                             # ax.plot(lon, lat, '.b', ms=2)
                             ax.text(lon, lat, label.decode('utf8'), ha='center',
                                     va='bottom', size='8', color='black')
                         # plot limites
                         limites = []
                         tmp = []
                         for line in open('/data/workspace/schain_scripts/lima.csv'):
                             if '#' in line:
                                 if tmp:
                                     limites.append(tmp)
                                 tmp = []
                                 continue
                             values = line.strip().split(',')
                             tmp.append((float(values[0]), float(values[1])))
                         for points in limites:
                             ax.add_patch(
                                 Polygon(points, ec='k', fc='none', ls='--', lw=0.5))
                         # plot Cuencas
                         for cuenca in ('rimac', 'lurin', 'mala', 'chillon', 'chilca', 'chancay-huaral'):
                             f = open('/data/workspace/schain_scripts/{}.csv'.format(cuenca))
                             values = [line.strip().split(',') for line in f]
                             points = [(float(s[0]), float(s[1])) for s in values]
                             ax.add_patch(Polygon(points, ec='b', fc='none'))
                         # plot grid
                         for r in (15, 30, 45, 60):
                             ax.add_artist(plt.Circle((self.lon, self.lat),
                                                      km2deg(r), color='0.6', fill=False, lw=0.2))
                             ax.text(
                                 self.lon + (km2deg(r))*numpy.cos(60*numpy.pi/180),
                                 self.lat + (km2deg(r))*numpy.sin(60*numpy.pi/180),
                                 '{}km'.format(r),
                                 ha='center', va='bottom', size='8', color='0.6', weight='heavy')
                     if self.mode == 'E':
                         title = 'El={}$^\circ$'.format(self.data.meta['elevation'])
                         label = 'E{:02d}'.format(int(self.data.meta['elevation']))
                     else:
                         title = 'Az={}$^\circ$'.format(self.data.meta['azimuth'])
                         label = 'A{:02d}'.format(int(self.data.meta['azimuth']))
                     self.save_labels = ['{}-{}'.format(lbl, label) for lbl in self.labels]
                     self.titles = ['{} {}'.format(
                         self.data.parameters[x], title) for x in self.channels]
             class WeatherPlot(Plot):
                 CODE = 'weather'
                 plot_name = 'weather'
                 plot_type = 'ppistyle'
                 buffering = False
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.width   =8
                     self.height  =8
                     self.nplots= 1
                     self.ylabel= 'Range [Km]'
                     self.titles= ['Weather']
                     self.colorbar=False
                     self.ini     =0
                     self.len_azi =0
                     self.buffer_ini  = None
                     self.buffer_azi   = None
                     self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
                     self.flag    =0
                     self.indicador= 0
                     self.last_data_azi = None
                     self.val_mean      = None
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     if hasattr(dataOut, 'dataPP_POWER'):
                         factor = 1
                     if hasattr(dataOut, 'nFFTPoints'):
                         factor = dataOut.normFactor
                     #print("DIME EL SHAPE PORFAVOR",dataOut.data_360.shape)
                     data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
                     data['azi']     = dataOut.data_azi
                     data['ele']     = dataOut.data_ele
                     return data, meta
                 def get2List(self,angulos):
                     list1=[]
                     list2=[]
                     for i in reversed(range(len(angulos))):
                         diff_ = angulos[i]-angulos[i-1]
                         if diff_ >1.5:
                             list1.append(i-1)
                             list2.append(diff_)
                     return list(reversed(list1)),list(reversed(list2))
                 def fixData360(self,list_,ang_):
                     if list_[0]==-1:
                         vec = numpy.where(ang_<ang_[0])
                         ang_[vec] = ang_[vec]+360
                         return ang_
                     return ang_
                 def fixData360HL(self,angulos):
                     vec = numpy.where(angulos>=360)
                     angulos[vec]=angulos[vec]-360
                     return angulos
                 def search_pos(self,pos,list_):
                     for i in range(len(list_)):
                         if pos == list_[i]:
                             return True,i
                     i=None
                     return False,i
                 def fixDataComp(self,ang_,list1_,list2_):
                     size  = len(ang_)
                     size2 = 0
                     for i in range(len(list2_)):
                         size2=size2+round(list2_[i])-1
                     new_size= size+size2
                     ang_new = numpy.zeros(new_size)
                     ang_new2 = numpy.zeros(new_size)
                     tmp = 0
                     c   = 0
                     for i in range(len(ang_)):
                         ang_new[tmp +c] = ang_[i]
                         ang_new2[tmp+c] = ang_[i]
                         condition , value = self.search_pos(i,list1_)
                         if condition:
                             pos = tmp + c + 1
                             for k in range(round(list2_[value])-1):
                                 ang_new[pos+k]  = ang_new[pos+k-1]+1
                                 ang_new2[pos+k] = numpy.nan
                             tmp = pos +k
                             c   = 0
                         c=c+1
                     return ang_new,ang_new2
                 def globalCheckPED(self,angulos):
                     l1,l2 = self.get2List(angulos)
                     if len(l1)>0:
                         angulos2 = self.fixData360(list_=l1,ang_=angulos)
                         l1,l2 = self.get2List(angulos2)
                         ang1_,ang2_ = self.fixDataComp(ang_=angulos2,list1_=l1,list2_=l2)
                         ang1_ = self.fixData360HL(ang1_)
                         ang2_ = self.fixData360HL(ang2_)
                     else:
                         ang1_= angulos
                         ang2_= angulos
                     return ang1_,ang2_
                 def analizeDATA(self,data_azi):
                     list1 = []
                     list2 = []
                     dat   = data_azi
                     for i in reversed(range(1,len(dat))):
                         if dat[i]>dat[i-1]:
                             diff = int(dat[i])-int(dat[i-1])
                         else:
                             diff = 360+int(dat[i])-int(dat[i-1])
                         if diff > 1:
                             list1.append(i-1)
                             list2.append(diff-1)
                     return list1,list2
                 def fixDATANEW(self,data_azi,data_weather):
                     list1,list2 = self.analizeDATA(data_azi)
                     if len(list1)== 0:
                         return data_azi,data_weather
                     else:
                         resize = 0
                         for i in range(len(list2)):
                             resize=  resize + list2[i]
                         new_data_azi = numpy.resize(data_azi,resize)
                         new_data_weather= numpy.resize(date_weather,resize)
                         for i in range(len(list2)):
                             j=0
                             position=list1[i]+1
                             for j in range(list2[i]):
                                 new_data_azi[position+j]=new_data_azi[position+j-1]+1
                     return new_data_azi
                 def fixDATA(self,data_azi):
                     data=data_azi
                     for i in range(len(data)):
                         if numpy.isnan(data[i]):
                            data[i]=data[i-1]+1
                     return data
                 def replaceNAN(self,data_weather,data_azi,val):
                     data= data_azi
                     data_T= data_weather
                     if data.shape[0]> data_T.shape[0]:
                         data_N = numpy.ones( [data.shape[0],data_T.shape[1]])
                         c      = 0
                         for i in range(len(data)):
                             if numpy.isnan(data[i]):
                                 data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
                             else:
                                 data_N[i,:]=data_T[c,:]
                                 c=c+1
                         return data_N
                     else:
                         for i in range(len(data)):
                             if numpy.isnan(data[i]):
                                data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
                         return data_T
                 def const_ploteo(self,data_weather,data_azi,step,res):
                     if self.ini==0:
                         #-------
                         n     = (360/res)-len(data_azi)
                         #--------------------- new -------------------------
                         data_azi_new ,data_azi_old= self.globalCheckPED(data_azi)
                         #------------------------
                         start = data_azi_new[-1] + res
                         end   = data_azi_new[0]  - res
                         #------ new
                         self.last_data_azi = end
                         if start>end:
                             end        = end + 360
                         azi_vacia = numpy.linspace(start,end,int(n))
                         azi_vacia = numpy.where(azi_vacia>360,azi_vacia-360,azi_vacia)
                         data_azi  = numpy.hstack((data_azi_new,azi_vacia))
                         # RADAR
                         val_mean         = numpy.mean(data_weather[:,-1])
                         self.val_mean    = val_mean
                         data_weather_cmp = numpy.ones([(360-data_weather.shape[0]),data_weather.shape[1]])*val_mean
                         data_weather     = self.replaceNAN(data_weather=data_weather,data_azi=data_azi_old,val=self.val_mean)
                         data_weather     = numpy.vstack((data_weather,data_weather_cmp))
                     else:
                         # azimuth
                         flag=0
                         start_azi = self.res_azi[0]
                         #-----------new------------
                         data_azi ,data_azi_old= self.globalCheckPED(data_azi)
                         data_weather = self.replaceNAN(data_weather=data_weather,data_azi=data_azi_old,val=self.val_mean)
                         #--------------------------
                         start = data_azi[0]
                         end   = data_azi[-1]
                         self.last_data_azi= end
                         if start< start_azi:
                             start = start +360
                         if end <start_azi:
                             end  = end +360
                         pos_ini = int((start-start_azi)/res)
                         len_azi = len(data_azi)
                         if (360-pos_ini)<len_azi:
                             if pos_ini+1==360:
                                 pos_ini=0
                             else:
                                 flag=1
                                 dif= 360-pos_ini
                                 comp= len_azi-dif
                         #-----------------
                         if flag==0:
                             # AZIMUTH
                             self.res_azi[pos_ini:pos_ini+len_azi] = data_azi
                             # RADAR
                             self.res_weather[pos_ini:pos_ini+len_azi,:] = data_weather
                         else:
                             # AZIMUTH
                             self.res_azi[pos_ini:pos_ini+dif] = data_azi[0:dif]
                             self.res_azi[0:comp]              = data_azi[dif:]
                             # RADAR
                             self.res_weather[pos_ini:pos_ini+dif,:] = data_weather[0:dif,:]
                             self.res_weather[0:comp,:]              = data_weather[dif:,:]
                             flag=0
                         data_azi                                    = self.res_azi
                         data_weather                                = self.res_weather
                     return data_weather,data_azi
                 def plot(self):
                     thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
                     data         = self.data[-1]
                     r            = self.data.yrange
                     delta_height = r[1]-r[0]
                     r_mask       = numpy.where(r>=0)[0]
                     r            = numpy.arange(len(r_mask))*delta_height
                     self.y       = 2*r
                     # RADAR
                     #data_weather = data['weather']
                     # PEDESTAL
                     #data_azi  = data['azi']
                     res          = 1
                     # STEP
                     step         = (360/(res*data['weather'].shape[0]))
                     self.res_weather, self.res_azi = self.const_ploteo(data_weather=data['weather'][:,r_mask],data_azi=data['azi'],step=step,res=res)
                     self.res_ele = numpy.mean(data['ele'])
                     #################    PLOTEO           ###################
                     for i,ax in enumerate(self.axes):
                         self.zmin = self.zmin if self.zmin else 20
                         self.zmax = self.zmax if self.zmax else 80
                         if ax.firsttime:
                             plt.clf()
                             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)
                         else:
                             plt.clf()
                             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)
                     caax = cgax.parasites[0]
                     paax = cgax.parasites[1]
                     cbar = plt.gcf().colorbar(pm, pad=0.075)
                     caax.set_xlabel('x_range [km]')
                     caax.set_ylabel('y_range [km]')
                     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')
                     self.ini= self.ini+1
             class WeatherRHIPlot(Plot):
                 CODE = 'weather'
                 plot_name = 'weather'
                 plot_type = 'rhistyle'
                 buffering = False
                 data_ele_tmp = None
                 def setup(self):
                     print("********************")
                     print("********************")
                     print("********************")
                     print("SETUP WEATHER PLOT")
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots= 1
                     self.ylabel= 'Range [Km]'
                     self.titles= ['Weather']
                     if self.channels is not None:
                         self.nplots = len(self.channels)
                         self.nrows = len(self.channels)
                     else:
                         self.nplots = self.data.shape(self.CODE)[0]
                         self.nrows = self.nplots
                         self.channels = list(range(self.nplots))
                     print("channels",self.channels)
                     print("que saldra", self.data.shape(self.CODE)[0])
                     self.titles = ['{} Channel {}'.format(self.CODE.upper(), x) for x in range(self.nrows)]
                     print("self.titles",self.titles)
                     self.colorbar=False
                     self.width   =12
                     self.height  =8
                     self.ini     =0
                     self.len_azi =0
                     self.buffer_ini  = None
                     self.buffer_ele   = None
                     self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
                     self.flag    =0
                     self.indicador= 0
                     self.last_data_ele = None
                     self.val_mean      = None
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     if hasattr(dataOut, 'dataPP_POWER'):
                         factor = 1
                     if hasattr(dataOut, 'nFFTPoints'):
                         factor = dataOut.normFactor
                     print("dataOut",dataOut.data_360.shape)
                     #
                     data['weather'] = 10*numpy.log10(dataOut.data_360/(factor))
                     #
                     #data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
                     data['azi']     = dataOut.data_azi
                     data['ele']     = dataOut.data_ele
                     #print("UPDATE")
                     #print("data[weather]",data['weather'].shape)
                     #print("data[azi]",data['azi'])
                     return data, meta
                 def get2List(self,angulos):
                     list1=[]
                     list2=[]
                     for i in reversed(range(len(angulos))):
                         if not i==0:#el caso de i=0 evalula el primero de la lista con el ultimo y no es relevante
                             diff_ = angulos[i]-angulos[i-1]
                             if abs(diff_) >1.5:
                                 list1.append(i-1)
                                 list2.append(diff_)
                     return list(reversed(list1)),list(reversed(list2))
                 def fixData90(self,list_,ang_):
                     if list_[0]==-1:
                         vec = numpy.where(ang_<ang_[0])
                         ang_[vec] = ang_[vec]+90
                         return ang_
                     return ang_
                 def fixData90HL(self,angulos):
                     vec = numpy.where(angulos>=90)
                     angulos[vec]=angulos[vec]-90
                     return angulos
                 def search_pos(self,pos,list_):
                     for i in range(len(list_)):
                         if pos == list_[i]:
                             return True,i
                     i=None
                     return False,i
                 def fixDataComp(self,ang_,list1_,list2_,tipo_case):
                     size  = len(ang_)
                     size2 = 0
                     for i in range(len(list2_)):
                         size2=size2+round(abs(list2_[i]))-1
                     new_size= size+size2
                     ang_new = numpy.zeros(new_size)
                     ang_new2 = numpy.zeros(new_size)
                     tmp = 0
                     c   = 0
                     for i in range(len(ang_)):
                         ang_new[tmp +c] = ang_[i]
                         ang_new2[tmp+c] = ang_[i]
                         condition , value = self.search_pos(i,list1_)
                         if condition:
                             pos = tmp + c + 1
                             for k in range(round(abs(list2_[value]))-1):
                                 if tipo_case==0 or tipo_case==3:#subida
                                     ang_new[pos+k]  = ang_new[pos+k-1]+1
                                     ang_new2[pos+k] = numpy.nan
                                 elif tipo_case==1 or tipo_case==2:#bajada
                                     ang_new[pos+k]  = ang_new[pos+k-1]-1
                                     ang_new2[pos+k] = numpy.nan
                             tmp = pos +k
                             c   = 0
                         c=c+1
                     return ang_new,ang_new2
                 def globalCheckPED(self,angulos,tipo_case):
                     l1,l2 = self.get2List(angulos)
                     ##print("l1",l1)
                     ##print("l2",l2)
                     if len(l1)>0:
                         #angulos2 = self.fixData90(list_=l1,ang_=angulos)
                         #l1,l2 = self.get2List(angulos2)
                         ang1_,ang2_ = self.fixDataComp(ang_=angulos,list1_=l1,list2_=l2,tipo_case=tipo_case)
                         #ang1_ = self.fixData90HL(ang1_)
                         #ang2_ = self.fixData90HL(ang2_)
                     else:
                         ang1_= angulos
                         ang2_= angulos
                     return ang1_,ang2_
                 def replaceNAN(self,data_weather,data_ele,val):
                     data= data_ele
                     data_T= data_weather
                     if data.shape[0]> data_T.shape[0]:
                         data_N = numpy.ones( [data.shape[0],data_T.shape[1]])
                         c      = 0
                         for i in range(len(data)):
                             if numpy.isnan(data[i]):
                                 data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
                             else:
                                 data_N[i,:]=data_T[c,:]
                                 c=c+1
                         return data_N
                     else:
                         for i in range(len(data)):
                             if numpy.isnan(data[i]):
                                data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
                         return data_T
                 def check_case(self,data_ele,ang_max,ang_min):
                     start  = data_ele[0]
                     end    = data_ele[-1]
                     number = (end-start)
                     len_ang=len(data_ele)
                     print("start",start)
                     print("end",end)
                     print("number",number)
                     print("len_ang",len_ang)
                     #exit(1)
                     if start<end and (round(abs(number)+1)>=len_ang or (numpy.argmin(data_ele)==0)):#caso subida
                         return 0
                     #elif start>end and (round(abs(number)+1)>=len_ang or(numpy.argmax(data_ele)==0)):#caso bajada
                     #    return 1
                     elif round(abs(number)+1)>=len_ang and (start>end or(numpy.argmax(data_ele)==0)):#caso bajada
                         return 1
                     elif round(abs(number)+1)<len_ang and data_ele[-2]>data_ele[-1]:# caso BAJADA CAMBIO ANG MAX
                         return 2
                     elif round(abs(number)+1)<len_ang and data_ele[-2]<data_ele[-1] :# caso SUBIDA CAMBIO ANG MIN
                         return 3
                 def const_ploteo(self,val_ch,data_weather,data_ele,step,res,ang_max,ang_min):
                     ang_max= ang_max
                     ang_min= ang_min
                     data_weather=data_weather
                     val_ch=val_ch
                     ##print("*********************DATA WEATHER**************************************")
                     ##print(data_weather)
                     if self.ini==0:
                         '''
                         print("**********************************************")
                         print("**********************************************")
                         print("***************ini**************")
                         print("**********************************************")
                         print("**********************************************")
                         '''
                         #print("data_ele",data_ele)
                         #----------------------------------------------------------
                         tipo_case = self.check_case(data_ele,ang_max,ang_min)
                         print("check_case",tipo_case)
                         #exit(1)
                         #--------------------- new -------------------------
                         data_ele_new ,data_ele_old= self.globalCheckPED(data_ele,tipo_case)
                         #-------------------------CAMBIOS RHI---------------------------------
                         start= ang_min
                         end  = ang_max
                         n= (ang_max-ang_min)/res
                         #------ new
                         self.start_data_ele = data_ele_new[0]
                         self.end_data_ele  = data_ele_new[-1]
                         if tipo_case==0  or tipo_case==3: # SUBIDA
                             n1= round(self.start_data_ele)- start
                             n2= end - round(self.end_data_ele)
                             print(self.start_data_ele)
                             print(self.end_data_ele)
                             if n1>0:
                                 ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
                                 ele1_nan= numpy.ones(n1)*numpy.nan
                                 data_ele = numpy.hstack((ele1,data_ele_new))
                                 print("ele1_nan",ele1_nan.shape)
                                 print("data_ele_old",data_ele_old.shape)
                                 data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
                             if n2>0:
                                 ele2= numpy.linspace(self.end_data_ele+1,end,n2)
                                 ele2_nan= numpy.ones(n2)*numpy.nan
                                 data_ele = numpy.hstack((data_ele,ele2))
                                 print("ele2_nan",ele2_nan.shape)
                                 print("data_ele_old",data_ele_old.shape)
                                 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
                         if tipo_case==1  or tipo_case==2: # BAJADA
                             data_ele_new       = data_ele_new[::-1] #  reversa
                             data_ele_old   = data_ele_old[::-1]# reversa
                             data_weather   = data_weather[::-1,:]# reversa
                             vec= numpy.where(data_ele_new<ang_max)
                             data_ele_new = data_ele_new[vec]
                             data_ele_old = data_ele_old[vec]
                             data_weather  = data_weather[vec[0]]
                             vec2= numpy.where(0<data_ele_new)
                             data_ele_new = data_ele_new[vec2]
                             data_ele_old = data_ele_old[vec2]
                             data_weather  = data_weather[vec2[0]]
                             self.start_data_ele = data_ele_new[0]
                             self.end_data_ele  = data_ele_new[-1]
                             n1= round(self.start_data_ele)- start
                             n2= end - round(self.end_data_ele)-1
                             print(self.start_data_ele)
                             print(self.end_data_ele)
                             if n1>0:
                                 ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
                                 ele1_nan= numpy.ones(n1)*numpy.nan
                                 data_ele = numpy.hstack((ele1,data_ele_new))
                                 data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
                             if n2>0:
                                 ele2= numpy.linspace(self.end_data_ele+1,end,n2)
                                 ele2_nan= numpy.ones(n2)*numpy.nan
                                 data_ele = numpy.hstack((data_ele,ele2))
                                 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
                         # RADAR
                         # NOTA data_ele y data_weather es la variable que retorna
                         val_mean         = numpy.mean(data_weather[:,-1])
                         self.val_mean    = val_mean
                         data_weather     = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
                         self.data_ele_tmp[val_ch]= data_ele_old
                     else:
                         #print("**********************************************")
                         #print("****************VARIABLE**********************")
                         #-------------------------CAMBIOS RHI---------------------------------
                         #---------------------------------------------------------------------
                         ##print("INPUT data_ele",data_ele)
                         flag=0
                         start_ele = self.res_ele[0]
                         tipo_case = self.check_case(data_ele,ang_max,ang_min)
                         #print("TIPO DE DATA",tipo_case)
                         #-----------new------------
                         data_ele ,data_ele_old = self.globalCheckPED(data_ele,tipo_case)
                         data_weather           = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
                         #-------------------------------NEW RHI ITERATIVO-------------------------
                         if tipo_case==0 : # SUBIDA
                             vec = numpy.where(data_ele<ang_max)
                             data_ele = data_ele[vec]
                             data_ele_old = data_ele_old[vec]
                             data_weather  = data_weather[vec[0]]
                             vec2 = numpy.where(0<data_ele)
                             data_ele= data_ele[vec2]
                             data_ele_old= data_ele_old[vec2]
                             ##print(data_ele_new)
                             data_weather= data_weather[vec2[0]]
                             new_i_ele  = int(round(data_ele[0]))
                             new_f_ele  = int(round(data_ele[-1]))
                             #print(new_i_ele)
                             #print(new_f_ele)
                             #print(data_ele,len(data_ele))
                             #print(data_ele_old,len(data_ele_old))
                             if new_i_ele< 2:
                                 self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
                                 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)
                             self.data_ele_tmp[val_ch][new_i_ele:new_i_ele+len(data_ele)]=data_ele_old
                             self.res_ele[new_i_ele:new_i_ele+len(data_ele)]= data_ele
                             self.res_weather[val_ch][new_i_ele:new_i_ele+len(data_ele),:]= data_weather
                             data_ele                                    = self.res_ele
                             data_weather                                = self.res_weather[val_ch]
                         elif tipo_case==1 : #BAJADA
                             data_ele       = data_ele[::-1] #  reversa
                             data_ele_old   = data_ele_old[::-1]# reversa
                             data_weather   = data_weather[::-1,:]# reversa
                             vec= numpy.where(data_ele<ang_max)
                             data_ele = data_ele[vec]
                             data_ele_old = data_ele_old[vec]
                             data_weather  = data_weather[vec[0]]
                             vec2= numpy.where(0<data_ele)
                             data_ele = data_ele[vec2]
                             data_ele_old = data_ele_old[vec2]
                             data_weather  = data_weather[vec2[0]]
                             new_i_ele  = int(round(data_ele[0]))
                             new_f_ele  = int(round(data_ele[-1]))
                             #print(data_ele)
                             #print(ang_max)
                             #print(data_ele_old)
                             if new_i_ele <= 1:
                                 new_i_ele = 1
                             if round(data_ele[-1])>=ang_max-1:
                                 self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
                                 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)
                             self.data_ele_tmp[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1]=data_ele_old
                             self.res_ele[new_i_ele-1:new_i_ele+len(data_ele)-1]= data_ele
                             self.res_weather[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1,:]= data_weather
                             data_ele     = self.res_ele
                             data_weather = self.res_weather[val_ch]
                         elif tipo_case==2:  #bajada
                             vec = numpy.where(data_ele<ang_max)
                             data_ele = data_ele[vec]
                             data_weather= data_weather[vec[0]]
                             len_vec = len(vec)
                             data_ele_new     = data_ele[::-1] #  reversa
                             data_weather =  data_weather[::-1,:]
                             new_i_ele  = int(data_ele_new[0])
                             new_f_ele  = int(data_ele_new[-1])
                             n1= new_i_ele- ang_min
                             n2= ang_max - new_f_ele-1
                             if n1>0:
                                 ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
                                 ele1_nan= numpy.ones(n1)*numpy.nan
                                 data_ele = numpy.hstack((ele1,data_ele_new))
                                 data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
                             if n2>0:
                                 ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
                                 ele2_nan= numpy.ones(n2)*numpy.nan
                                 data_ele = numpy.hstack((data_ele,ele2))
                                 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
                             self.data_ele_tmp[val_ch] = data_ele_old
                             self.res_ele      = data_ele
                             self.res_weather[val_ch]  = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
                             data_ele                                    = self.res_ele
                             data_weather                                = self.res_weather[val_ch]
                         elif tipo_case==3:#subida
                             vec = numpy.where(0<data_ele)
                             data_ele= data_ele[vec]
                             data_ele_new = data_ele
                             data_ele_old= data_ele_old[vec]
                             data_weather= data_weather[vec[0]]
                             pos_ini = numpy.argmin(data_ele)
                             if pos_ini>0:
                                 len_vec= len(data_ele)
                                 vec3  = numpy.linspace(pos_ini,len_vec-1,len_vec-pos_ini).astype(int)
                                 #print(vec3)
                                 data_ele= data_ele[vec3]
                                 data_ele_new = data_ele
                                 data_ele_old= data_ele_old[vec3]
                                 data_weather= data_weather[vec3]
                             new_i_ele  = int(data_ele_new[0])
                             new_f_ele  = int(data_ele_new[-1])
                             n1= new_i_ele- ang_min
                             n2= ang_max - new_f_ele-1
                             if n1>0:
                                 ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
                                 ele1_nan= numpy.ones(n1)*numpy.nan
                                 data_ele = numpy.hstack((ele1,data_ele_new))
                                 data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
                             if n2>0:
                                 ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
                                 ele2_nan= numpy.ones(n2)*numpy.nan
                                 data_ele = numpy.hstack((data_ele,ele2))
                                 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
                             self.data_ele_tmp[val_ch] = data_ele_old
                             self.res_ele      = data_ele
                             self.res_weather[val_ch]  = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
                             data_ele                                    = self.res_ele
                             data_weather                                = self.res_weather[val_ch]
                     #print("self.data_ele_tmp",self.data_ele_tmp)
                     return data_weather,data_ele
                 def plot(self):
                     thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
                     data         = self.data[-1]
                     r            = self.data.yrange
                     delta_height = r[1]-r[0]
                     r_mask       = numpy.where(r>=0)[0]
                     ##print("delta_height",delta_height)
                     #print("r_mask",r_mask,len(r_mask))
                     r            = numpy.arange(len(r_mask))*delta_height
                     self.y       = 2*r
                     res          = 1
                     ###print("data['weather'].shape[0]",data['weather'].shape[0])
                     ang_max = self.ang_max
                     ang_min = self.ang_min
                     var_ang      =ang_max -  ang_min
                     step         = (int(var_ang)/(res*data['weather'].shape[0]))
                     ###print("step",step)
                     #--------------------------------------------------------
                     ##print('weather',data['weather'].shape)
                     ##print('ele',data['ele'].shape)
                     ###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)
                     ###self.res_azi                   = numpy.mean(data['azi'])
                     ###print("self.res_ele",self.res_ele)
                     plt.clf()
                     subplots = [121, 122]
                     cg={'angular_spacing': 20.}
                     if self.ini==0:
                         self.data_ele_tmp = numpy.ones([self.nplots,int(var_ang)])*numpy.nan
                         self.res_weather= numpy.ones([self.nplots,int(var_ang),len(r_mask)])*numpy.nan
                         print("SHAPE",self.data_ele_tmp.shape)
                     for i,ax in enumerate(self.axes):
                         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)
                         self.res_azi                   = numpy.mean(data['azi'])
                         if i==0:
                             print("*****************************************************************************to plot**************************",self.res_weather[i].shape)
                         self.zmin = self.zmin if self.zmin else 20
                         self.zmax = self.zmax if self.zmax else 80
                         if ax.firsttime:
                             #plt.clf()
                             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)
                             #fig=self.figures[0]
                         else:
                             #plt.clf()
                             if i==0:
                                 print(self.res_weather[i])
                                 print(self.res_ele)
                             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)
                         caax = cgax.parasites[0]
                         paax = cgax.parasites[1]
                         cbar = plt.gcf().colorbar(pm, pad=0.075)
                         caax.set_xlabel('x_range [km]')
                         caax.set_ylabel('y_range [km]')
                         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')
                     print("***************************self.ini****************************",self.ini)
                     self.ini= self.ini+1
             class Weather_vRF_Plot(Plot):
                 CODE = 'PPI'
                 plot_name = 'PPI'
                 #plot_type = 'ppistyle'
                 buffering = False
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.width   =8
                     self.height  =8
                     self.nplots= 1
                     self.ylabel= 'Range [Km]'
                     self.xlabel= 'Range [Km]'
                     self.titles= ['PPI']
                     self.polar = True
                     if self.channels is not None:
                         self.nplots = len(self.channels)
                         self.nrows = len(self.channels)
                     else:
                         self.nplots = self.data.shape(self.CODE)[0]
                         self.nrows = self.nplots
                         self.channels = list(range(self.nplots))
                     if self.CODE == 'POWER':
                         self.cb_label = r'Power (dB)'
                     elif self.CODE == 'DOPPLER':
                         self.cb_label = r'Velocity (m/s)'
                     self.colorbar=True
                     self.width  = 9
                     self.height  =8
                     self.ini  =0
                     self.len_azi =0
                     self.buffer_ini  = None
                     self.buffer_ele   = None
                     self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.15, 'right': 0.9, 'bottom': 0.08})
                     self.flag    =0
                     self.indicador= 0
                     self.last_data_ele = None
                     self.val_mean      = None
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     if hasattr(dataOut, 'dataPP_POWER'):
                         factor = 1
                     if hasattr(dataOut, 'nFFTPoints'):
                         factor = dataOut.normFactor
                     if 'pow' in self.attr_data[0].lower():
                         data['data'] = 10*numpy.log10(getattr(dataOut, self.attr_data[0])/(factor))
                     else:
                         data['data'] = getattr(dataOut, self.attr_data[0])/(factor)
                     data['azi']     = dataOut.data_azi
                     data['ele']     = dataOut.data_ele
                     return data, meta
                 def plot(self):
                     data         = self.data[-1]
                     r            = self.data.yrange
                     delta_height = r[1]-r[0]
                     r_mask       = numpy.where(r>=0)[0]
                     self.r_mask = r_mask
                     r            = numpy.arange(len(r_mask))*delta_height
                     self.y       = 2*r
+                    try:
                         z = data['data'][self.channels[0]][:,r_mask]
+                    except:
+                        z = data['data'][0][:,r_mask]
                     self.titles = []
                     self.ymax = self.ymax if self.ymax else numpy.nanmax(r)
                     self.ymin = self.ymin if self.ymin else numpy.nanmin(r)
                     self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
                     self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
                     self.ang_min = self.ang_min if self.ang_min else 0
                     self.ang_max = self.ang_max if self.ang_max else 360
                     r, theta = numpy.meshgrid(r, numpy.radians(data['azi']) )
                     for i,ax in enumerate(self.axes):
                         if ax.firsttime:
                             ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
                             ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
                             ax.set_theta_direction(-1)
                         else:
                             ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
                             ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
                             ax.set_theta_direction(-1)
                         ax.grid(True)
                         if len(self.channels) !=1:
                             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)]
                         else:
                             self.titles = ['PPI {} at EL: {} Channel {}'.format(self.labels[0], str(round(numpy.mean(data['ele']),1)), self.channels[0])]
             class WeatherRHI_vRF2_Plot(Plot):
                 CODE = 'weather'
                 plot_name = 'weather'
                 plot_type = 'rhistyle'
                 buffering = False
                 data_ele_tmp = None
                 def setup(self):
                     print("********************")
                     print("********************")
                     print("********************")
                     print("SETUP WEATHER PLOT")
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots= 1
                     self.ylabel= 'Range [Km]'
                     self.titles= ['Weather']
                     if self.channels is not None:
                         self.nplots = len(self.channels)
                         self.nrows = len(self.channels)
                     else:
                         self.nplots = self.data.shape(self.CODE)[0]
                         self.nrows = self.nplots
                         self.channels = list(range(self.nplots))
                     print("channels",self.channels)
                     print("que saldra", self.data.shape(self.CODE)[0])
                     self.titles = ['{} Channel {}'.format(self.CODE.upper(), x) for x in range(self.nrows)]
                     print("self.titles",self.titles)
                     self.colorbar=False
                     self.width   =8
                     self.height  =8
                     self.ini     =0
                     self.len_azi =0
                     self.buffer_ini  = None
                     self.buffer_ele   = None
                     self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
                     self.flag    =0
                     self.indicador= 0
                     self.last_data_ele = None
                     self.val_mean      = None
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     if hasattr(dataOut, 'dataPP_POWER'):
                         factor = 1
                     if hasattr(dataOut, 'nFFTPoints'):
                         factor = dataOut.normFactor
                     print("dataOut",dataOut.data_360.shape)
                     #
                     data['weather'] = 10*numpy.log10(dataOut.data_360/(factor))
                     #
                     #data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
                     data['azi']     = dataOut.data_azi
                     data['ele']     = dataOut.data_ele
                     data['case_flag']     = dataOut.case_flag
                     #print("UPDATE")
                     #print("data[weather]",data['weather'].shape)
                     #print("data[azi]",data['azi'])
                     return data, meta
                 def get2List(self,angulos):
                     list1=[]
                     list2=[]
                     for i in reversed(range(len(angulos))):
                         if not i==0:#el caso de i=0 evalula el primero de la lista con el ultimo y no es relevante
                             diff_ = angulos[i]-angulos[i-1]
                             if abs(diff_) >1.5:
                                 list1.append(i-1)
                                 list2.append(diff_)
                     return list(reversed(list1)),list(reversed(list2))
                 def fixData90(self,list_,ang_):
                     if list_[0]==-1:
                         vec = numpy.where(ang_<ang_[0])
                         ang_[vec] = ang_[vec]+90
                         return ang_
                     return ang_
                 def fixData90HL(self,angulos):
                     vec = numpy.where(angulos>=90)
                     angulos[vec]=angulos[vec]-90
                     return angulos
                 def search_pos(self,pos,list_):
                     for i in range(len(list_)):
                         if pos == list_[i]:
                             return True,i
                     i=None
                     return False,i
                 def fixDataComp(self,ang_,list1_,list2_,tipo_case):
                     size  = len(ang_)
                     size2 = 0
                     for i in range(len(list2_)):
                         size2=size2+round(abs(list2_[i]))-1
                     new_size= size+size2
                     ang_new = numpy.zeros(new_size)
                     ang_new2 = numpy.zeros(new_size)
                     tmp = 0
                     c   = 0
                     for i in range(len(ang_)):
                         ang_new[tmp +c] = ang_[i]
                         ang_new2[tmp+c] = ang_[i]
                         condition , value = self.search_pos(i,list1_)
                         if condition:
                             pos = tmp + c + 1
                             for k in range(round(abs(list2_[value]))-1):
                                 if tipo_case==0 or tipo_case==3:#subida
                                     ang_new[pos+k]  = ang_new[pos+k-1]+1
                                     ang_new2[pos+k] = numpy.nan
                                 elif tipo_case==1 or tipo_case==2:#bajada
                                     ang_new[pos+k]  = ang_new[pos+k-1]-1
                                     ang_new2[pos+k] = numpy.nan
                             tmp = pos +k
                             c   = 0
                         c=c+1
                     return ang_new,ang_new2
                 def globalCheckPED(self,angulos,tipo_case):
                     l1,l2 = self.get2List(angulos)
                     ##print("l1",l1)
                     ##print("l2",l2)
                     if len(l1)>0:
                         #angulos2 = self.fixData90(list_=l1,ang_=angulos)
                         #l1,l2 = self.get2List(angulos2)
                         ang1_,ang2_ = self.fixDataComp(ang_=angulos,list1_=l1,list2_=l2,tipo_case=tipo_case)
                         #ang1_ = self.fixData90HL(ang1_)
                         #ang2_ = self.fixData90HL(ang2_)
                     else:
                         ang1_= angulos
                         ang2_= angulos
                     return ang1_,ang2_
                 def replaceNAN(self,data_weather,data_ele,val):
                     data= data_ele
                     data_T= data_weather
                     if data.shape[0]> data_T.shape[0]:
                         data_N = numpy.ones( [data.shape[0],data_T.shape[1]])
                         c      = 0
                         for i in range(len(data)):
                             if numpy.isnan(data[i]):
                                 data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
                             else:
                                 data_N[i,:]=data_T[c,:]
                                 c=c+1
                         return data_N
                     else:
                         for i in range(len(data)):
                             if numpy.isnan(data[i]):
                                data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
                         return data_T
                 def check_case(self,data_ele,ang_max,ang_min):
                     start  = data_ele[0]
                     end    = data_ele[-1]
                     number = (end-start)
                     len_ang=len(data_ele)
                     print("start",start)
                     print("end",end)
                     print("number",number)
                     print("len_ang",len_ang)
                     #exit(1)
                     if start<end and (round(abs(number)+1)>=len_ang or (numpy.argmin(data_ele)==0)):#caso subida
                         return 0
                     #elif start>end and (round(abs(number)+1)>=len_ang or(numpy.argmax(data_ele)==0)):#caso bajada
                     #    return 1
                     elif round(abs(number)+1)>=len_ang and (start>end or(numpy.argmax(data_ele)==0)):#caso bajada
                         return 1
                     elif round(abs(number)+1)<len_ang and data_ele[-2]>data_ele[-1]:# caso BAJADA CAMBIO ANG MAX
                         return 2
                     elif round(abs(number)+1)<len_ang and data_ele[-2]<data_ele[-1] :# caso SUBIDA CAMBIO ANG MIN
                         return 3
                 def const_ploteo(self,val_ch,data_weather,data_ele,step,res,ang_max,ang_min,case_flag):
                     ang_max= ang_max
                     ang_min= ang_min
                     data_weather=data_weather
                     val_ch=val_ch
                     ##print("*********************DATA WEATHER**************************************")
                     ##print(data_weather)
                     if self.ini==0:
                         '''
                         print("**********************************************")
                         print("**********************************************")
                         print("***************ini**************")
                         print("**********************************************")
                         print("**********************************************")
                         '''
                         #print("data_ele",data_ele)
                         #----------------------------------------------------------
                         tipo_case = case_flag[-1]
                         #tipo_case = self.check_case(data_ele,ang_max,ang_min)
                         print("check_case",tipo_case)
                         #exit(1)
                         #--------------------- new -------------------------
                         data_ele_new ,data_ele_old= self.globalCheckPED(data_ele,tipo_case)
                         #-------------------------CAMBIOS RHI---------------------------------
                         start= ang_min
                         end  = ang_max
                         n= (ang_max-ang_min)/res
                         #------ new
                         self.start_data_ele = data_ele_new[0]
                         self.end_data_ele  = data_ele_new[-1]
                         if tipo_case==0  or tipo_case==3: # SUBIDA
                             n1= round(self.start_data_ele)- start
                             n2= end - round(self.end_data_ele)
                             print(self.start_data_ele)
                             print(self.end_data_ele)
                             if n1>0:
                                 ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
                                 ele1_nan= numpy.ones(n1)*numpy.nan
                                 data_ele = numpy.hstack((ele1,data_ele_new))
                                 print("ele1_nan",ele1_nan.shape)
                                 print("data_ele_old",data_ele_old.shape)
                                 data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
                             if n2>0:
                                 ele2= numpy.linspace(self.end_data_ele+1,end,n2)
                                 ele2_nan= numpy.ones(n2)*numpy.nan
                                 data_ele = numpy.hstack((data_ele,ele2))
                                 print("ele2_nan",ele2_nan.shape)
                                 print("data_ele_old",data_ele_old.shape)
                                 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
                         if tipo_case==1  or tipo_case==2: # BAJADA
                             data_ele_new       = data_ele_new[::-1] #  reversa
                             data_ele_old   = data_ele_old[::-1]# reversa
                             data_weather   = data_weather[::-1,:]# reversa
                             vec= numpy.where(data_ele_new<ang_max)
                             data_ele_new = data_ele_new[vec]
                             data_ele_old = data_ele_old[vec]
                             data_weather  = data_weather[vec[0]]
                             vec2= numpy.where(0<data_ele_new)
                             data_ele_new = data_ele_new[vec2]
                             data_ele_old = data_ele_old[vec2]
                             data_weather  = data_weather[vec2[0]]
                             self.start_data_ele = data_ele_new[0]
                             self.end_data_ele  = data_ele_new[-1]
                             n1= round(self.start_data_ele)- start
                             n2= end - round(self.end_data_ele)-1
                             print(self.start_data_ele)
                             print(self.end_data_ele)
                             if n1>0:
                                 ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
                                 ele1_nan= numpy.ones(n1)*numpy.nan
                                 data_ele = numpy.hstack((ele1,data_ele_new))
                                 data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
                             if n2>0:
                                 ele2= numpy.linspace(self.end_data_ele+1,end,n2)
                                 ele2_nan= numpy.ones(n2)*numpy.nan
                                 data_ele = numpy.hstack((data_ele,ele2))
                                 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
                         # RADAR
                         # NOTA data_ele y data_weather es la variable que retorna
                         val_mean         = numpy.mean(data_weather[:,-1])
                         self.val_mean    = val_mean
                         data_weather     = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
                         print("eleold",data_ele_old)
                         print(self.data_ele_tmp[val_ch])
                         print(data_ele_old.shape[0])
                         print(self.data_ele_tmp[val_ch].shape[0])
                         if (data_ele_old.shape[0]==91 or self.data_ele_tmp[val_ch].shape[0]==91):
                             import sys
                             print("EXIT",self.ini)
                             sys.exit(1)
                         self.data_ele_tmp[val_ch]= data_ele_old
                     else:
                         #print("**********************************************")
                         #print("****************VARIABLE**********************")
                         #-------------------------CAMBIOS RHI---------------------------------
                         #---------------------------------------------------------------------
                         ##print("INPUT data_ele",data_ele)
                         flag=0
                         start_ele = self.res_ele[0]
                         #tipo_case = self.check_case(data_ele,ang_max,ang_min)
                         tipo_case = case_flag[-1]
                         #print("TIPO DE DATA",tipo_case)
                         #-----------new------------
                         data_ele ,data_ele_old = self.globalCheckPED(data_ele,tipo_case)
                         data_weather           = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
                         #-------------------------------NEW RHI ITERATIVO-------------------------
                         if tipo_case==0 : # SUBIDA
                             vec = numpy.where(data_ele<ang_max)
                             data_ele = data_ele[vec]
                             data_ele_old = data_ele_old[vec]
                             data_weather  = data_weather[vec[0]]
                             vec2 = numpy.where(0<data_ele)
                             data_ele= data_ele[vec2]
                             data_ele_old= data_ele_old[vec2]
                             ##print(data_ele_new)
                             data_weather= data_weather[vec2[0]]
                             new_i_ele  = int(round(data_ele[0]))
                             new_f_ele  = int(round(data_ele[-1]))
                             #print(new_i_ele)
                             #print(new_f_ele)
                             #print(data_ele,len(data_ele))
                             #print(data_ele_old,len(data_ele_old))
                             if new_i_ele< 2:
                                 self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
                                 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)
                             self.data_ele_tmp[val_ch][new_i_ele:new_i_ele+len(data_ele)]=data_ele_old
                             self.res_ele[new_i_ele:new_i_ele+len(data_ele)]= data_ele
                             self.res_weather[val_ch][new_i_ele:new_i_ele+len(data_ele),:]= data_weather
                             data_ele                                    = self.res_ele
                             data_weather                                = self.res_weather[val_ch]
                         elif tipo_case==1 : #BAJADA
                             data_ele       = data_ele[::-1] #  reversa
                             data_ele_old   = data_ele_old[::-1]# reversa
                             data_weather   = data_weather[::-1,:]# reversa
                             vec= numpy.where(data_ele<ang_max)
                             data_ele = data_ele[vec]
                             data_ele_old = data_ele_old[vec]
                             data_weather  = data_weather[vec[0]]
                             vec2= numpy.where(0<data_ele)
                             data_ele = data_ele[vec2]
                             data_ele_old = data_ele_old[vec2]
                             data_weather  = data_weather[vec2[0]]
                             new_i_ele  = int(round(data_ele[0]))
                             new_f_ele  = int(round(data_ele[-1]))
                             #print(data_ele)
                             #print(ang_max)
                             #print(data_ele_old)
                             if new_i_ele <= 1:
                                 new_i_ele = 1
                             if round(data_ele[-1])>=ang_max-1:
                                 self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
                                 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)
                             self.data_ele_tmp[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1]=data_ele_old
                             self.res_ele[new_i_ele-1:new_i_ele+len(data_ele)-1]= data_ele
                             self.res_weather[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1,:]= data_weather
                             data_ele     = self.res_ele
                             data_weather = self.res_weather[val_ch]
                         elif tipo_case==2:  #bajada
                             vec = numpy.where(data_ele<ang_max)
                             data_ele = data_ele[vec]
                             data_weather= data_weather[vec[0]]
                             len_vec = len(vec)
                             data_ele_new     = data_ele[::-1] #  reversa
                             data_weather =  data_weather[::-1,:]
                             new_i_ele  = int(data_ele_new[0])
                             new_f_ele  = int(data_ele_new[-1])
                             n1= new_i_ele- ang_min
                             n2= ang_max - new_f_ele-1
                             if n1>0:
                                 ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
                                 ele1_nan= numpy.ones(n1)*numpy.nan
                                 data_ele = numpy.hstack((ele1,data_ele_new))
                                 data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
                             if n2>0:
                                 ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
                                 ele2_nan= numpy.ones(n2)*numpy.nan
                                 data_ele = numpy.hstack((data_ele,ele2))
                                 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
                             self.data_ele_tmp[val_ch] = data_ele_old
                             self.res_ele      = data_ele
                             self.res_weather[val_ch]  = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
                             data_ele                                    = self.res_ele
                             data_weather                                = self.res_weather[val_ch]
                         elif tipo_case==3:#subida
                             vec = numpy.where(0<data_ele)
                             data_ele= data_ele[vec]
                             data_ele_new = data_ele
                             data_ele_old= data_ele_old[vec]
                             data_weather= data_weather[vec[0]]
                             pos_ini = numpy.argmin(data_ele)
                             if pos_ini>0:
                                 len_vec= len(data_ele)
                                 vec3  = numpy.linspace(pos_ini,len_vec-1,len_vec-pos_ini).astype(int)
                                 #print(vec3)
                                 data_ele= data_ele[vec3]
                                 data_ele_new = data_ele
                                 data_ele_old= data_ele_old[vec3]
                                 data_weather= data_weather[vec3]
                             new_i_ele  = int(data_ele_new[0])
                             new_f_ele  = int(data_ele_new[-1])
                             n1= new_i_ele- ang_min
                             n2= ang_max - new_f_ele-1
                             if n1>0:
                                 ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
                                 ele1_nan= numpy.ones(n1)*numpy.nan
                                 data_ele = numpy.hstack((ele1,data_ele_new))
                                 data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
                             if n2>0:
                                 ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
                                 ele2_nan= numpy.ones(n2)*numpy.nan
                                 data_ele = numpy.hstack((data_ele,ele2))
                                 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
                             self.data_ele_tmp[val_ch] = data_ele_old
                             self.res_ele      = data_ele
                             self.res_weather[val_ch]  = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
                             data_ele                                    = self.res_ele
                             data_weather                                = self.res_weather[val_ch]
                     #print("self.data_ele_tmp",self.data_ele_tmp)
                     return data_weather,data_ele
                 def plot(self):
                     thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
                     data         = self.data[-1]
                     r            = self.data.yrange
                     delta_height = r[1]-r[0]
                     r_mask       = numpy.where(r>=0)[0]
                     ##print("delta_height",delta_height)
                     #print("r_mask",r_mask,len(r_mask))
                     r            = numpy.arange(len(r_mask))*delta_height
                     self.y       = 2*r
                     res          = 1
                     ###print("data['weather'].shape[0]",data['weather'].shape[0])
                     ang_max = self.ang_max
                     ang_min = self.ang_min
                     var_ang      =ang_max -  ang_min
                     step         = (int(var_ang)/(res*data['weather'].shape[0]))
                     ###print("step",step)
                     #--------------------------------------------------------
                     ##print('weather',data['weather'].shape)
                     ##print('ele',data['ele'].shape)
                     ###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)
                     ###self.res_azi                   = numpy.mean(data['azi'])
                     ###print("self.res_ele",self.res_ele)
                     plt.clf()
                     subplots = [121, 122]
                     try:
                         if self.data[-2]['ele'].max()<data['ele'].max():
                             self.ini=0
                     except:
                         pass
                     if self.ini==0:
                         self.data_ele_tmp = numpy.ones([self.nplots,int(var_ang)])*numpy.nan
                         self.res_weather= numpy.ones([self.nplots,int(var_ang),len(r_mask)])*numpy.nan
                         print("SHAPE",self.data_ele_tmp.shape)
                     for i,ax in enumerate(self.axes):
                         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'])
                         self.res_azi                   = numpy.mean(data['azi'])
                         if ax.firsttime:
                             #plt.clf()
                             print("Frist Plot")
                             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)
                             #fig=self.figures[0]
                         else:
                             #plt.clf()
                             print("ELSE PLOT")
                             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)
                         caax = cgax.parasites[0]
                         paax = cgax.parasites[1]
                         cbar = plt.gcf().colorbar(pm, pad=0.075)
                         caax.set_xlabel('x_range [km]')
                         caax.set_ylabel('y_range [km]')
                         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')
                     print("***************************self.ini****************************",self.ini)
                     self.ini= self.ini+1
             class WeatherRHI_vRF4_Plot(Plot):
                 CODE = 'RHI'
                 plot_name = 'RHI'
                 #plot_type = 'rhistyle'
                 buffering = False
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots= 1
                     self.ylabel= 'Range [Km]'
                     self.xlabel= 'Range [Km]'
                     self.titles= ['RHI']
                     self.polar = True
                     self.grid = True
                     if self.channels is not None:
                         self.nplots = len(self.channels)
                         self.nrows = len(self.channels)
                     else:
                         self.nplots = self.data.shape(self.CODE)[0]
                         self.nrows = self.nplots
                         self.channels = list(range(self.nplots))
                     if self.CODE == 'Power':
                         self.cb_label = r'Power (dB)'
                     elif self.CODE == 'Doppler':
                         self.cb_label = r'Velocity (m/s)'
                     self.colorbar=True
                     self.width   =8
                     self.height  =8
                     self.ini     =0
                     self.len_azi =0
                     self.buffer_ini  = None
                     self.buffer_ele   = None
                     self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
                     self.flag    =0
                     self.indicador= 0
                     self.last_data_ele = None
                     self.val_mean      = None
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     if hasattr(dataOut, 'dataPP_POWER'):
                         factor = 1
                     if hasattr(dataOut, 'nFFTPoints'):
                         factor = dataOut.normFactor
                     if 'pow' in self.attr_data[0].lower():
                         data['data'] = 10*numpy.log10(getattr(dataOut, self.attr_data[0])/(factor))
                     else:
                         data['data'] = getattr(dataOut, self.attr_data[0])/(factor)
                     data['azi']     = dataOut.data_azi
                     data['ele']     = dataOut.data_ele
                     return data, meta
                 def plot(self):
                     data         = self.data[-1]
                     r            = self.data.yrange
                     delta_height = r[1]-r[0]
                     r_mask       = numpy.where(r>=0)[0]
                     self.r_mask =r_mask
                     r            = numpy.arange(len(r_mask))*delta_height
                     self.y       = 2*r
                     try:
                         z = data['data'][self.channels[0]][:,r_mask]
                     except:
                         z = data['data'][0][:,r_mask]
                     self.titles = []
                     self.ymax = self.ymax if self.ymax else numpy.nanmax(r)
                     self.ymin = self.ymin if self.ymin else numpy.nanmin(r)
                     self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
                     self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
                     self.ang_min = self.ang_min if self.ang_min else 0
                     self.ang_max = self.ang_max if self.ang_max else 90
                     r, theta = numpy.meshgrid(r, numpy.radians(data['ele']) )
                     for i,ax in enumerate(self.axes):
                         if ax.firsttime:
                             ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
                             ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
                         else:
                             ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
                             ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
                         ax.grid(True)
                         if len(self.channels) !=1:
                             self.titles = ['RHI {} at AZ: {} Channel {}'.format(self.labels[x], str(round(numpy.mean(data['azi']),1)), x) for x in range(self.nrows)]
                         else:
                             self.titles = ['RHI {} at AZ: {} Channel {}'.format(self.labels[0], str(round(numpy.mean(data['azi']),1)), self.channels[0])]
+            class WeatherParamsPlot(Plot):
+                #CODE = 'RHI'
+                #plot_name = 'RHI'
+                #plot_type = 'rhistyle'
+                buffering = False
+                def setup(self):
+                    self.ncols = 1
+                    self.nrows = 1
+                    self.nplots= 1
+                    self.ylabel= 'Range [Km]'
+                    self.xlabel= 'Range [Km]'
+                    self.polar = True
+                    self.grid = True
+                    if self.channels is not None:
+                        self.nplots = len(self.channels)
+                        self.nrows = len(self.channels)
+                    else:
+                        self.nplots = self.data.shape(self.CODE)[0]
+                        self.nrows = self.nplots
+                        self.channels = list(range(self.nplots))
+                    self.colorbar=True
+                    self.width   =8
+                    self.height  =8
+                    self.ini     =0
+                    self.len_azi =0
+                    self.buffer_ini  = None
+                    self.buffer_ele   = None
+                    self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
+                    self.flag    =0
+                    self.indicador= 0
+                    self.last_data_ele = None
+                    self.val_mean      = None
+                def update(self, dataOut):
+                    data = {}
+                    meta = {}
+                    if hasattr(dataOut, 'dataPP_POWER'):
+                        factor = 1
+                    if hasattr(dataOut, 'nFFTPoints'):
+                        factor = dataOut.normFactor
+                    if 'pow' in self.attr_data[0].lower():
+                        data['data'] = 10*numpy.log10(getattr(dataOut, self.attr_data[0])/(factor))
+                    else:
+                        data['data'] = getattr(dataOut, self.attr_data[0])/(factor)
+                    if dataOut.mode_op == 'PPI':
+                        self.CODE = 'PPI'
+                        self.title = self.CODE
+                    elif dataOut.mode_op == 'RHI':
+                        self.CODE = 'RHI'
+                        self.title = self.CODE
+                    data['azi']     = dataOut.data_azi
+                    data['ele']     = dataOut.data_ele
+                    data['mode_op'] = dataOut.mode_op
+                    return data, meta
+                def plot(self):
+                    data         = self.data[-1]
+                    r            = self.data.yrange
+                    delta_height = r[1]-r[0]
+                    r_mask       = numpy.where(r>=0)[0]
+                    self.r_mask =r_mask
+                    r            = numpy.arange(len(r_mask))*delta_height
+                    self.y       = 2*r
+                    try:
+                        z = data['data'][self.channels[0]][:,r_mask]
+                    except:
+                        z = data['data'][0][:,r_mask]
+                    self.titles = []
+                    self.ymax = self.ymax if self.ymax else numpy.nanmax(r)
+                    self.ymin = self.ymin if self.ymin else numpy.nanmin(r)
+                    self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
+                    self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
+                    print("mode inside plot",self.data['mode_op'],data['mode_op'])
+                    if data['mode_op'] == 'RHI':
+                        try:
+                            if self.data['mode_op'][-2] == 'PPI':
+                                self.ang_min = None
+                                self.ang_max = None
+                        except:
+                            pass
+                        self.ang_min = self.ang_min if self.ang_min else 0
+                        self.ang_max = self.ang_max if self.ang_max else 90
+                        r, theta = numpy.meshgrid(r, numpy.radians(data['ele']) )
+                    elif data['mode_op'] == 'PPI':
+                        try:
+                            if self.data['mode_op'][-2] == 'RHI':
+                                self.ang_min = None
+                                self.ang_max = None
+                        except:
+                            pass
+                        self.ang_min = self.ang_min if self.ang_min else 0
+                        self.ang_max = self.ang_max if self.ang_max else 360
+                        r, theta = numpy.meshgrid(r, numpy.radians(data['azi']) )
+                    self.clear_figures()
+                    for i,ax in enumerate(self.axes):
+                        if ax.firsttime:
+                            ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
+                            ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
+                            if data['mode_op'] == 'PPI':
+                                ax.set_theta_direction(-1)
+                        else:
+                            ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
+                            ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
+                            if data['mode_op'] == 'PPI':
+                                ax.set_theta_direction(-1)
+                        ax.grid(True)
+                        if data['mode_op'] == 'RHI':
+                            len_aux = int(data['azi'].shape[0]/4)
+                            mean = numpy.mean(data['azi'][len_aux:-len_aux])
+                            if len(self.channels) !=1:
+                                self.titles = ['RHI {} at AZ: {} Channel {}'.format(self.labels[x], str(round(mean,1)), x) for x in range(self.nrows)]
+                            else:
+                                self.titles = ['RHI {} at AZ: {} Channel {}'.format(self.labels[0], str(round(mean,1)), self.channels[0])]
+                        elif data['mode_op'] == 'PPI':
+                            len_aux = int(data['ele'].shape[0]/4)
+                            mean = numpy.mean(data['ele'][len_aux:-len_aux])
+                            if len(self.channels) !=1:
+                                self.titles = ['PPI {} at EL: {} Channel {}'.format(self.self.labels[x], str(round(mean,1)), x) for x in range(self.nrows)]
+                            else:
+                                self.titles = ['PPI {} at EL: {} Channel {}'.format(self.labels[0], str(round(mean,1)), self.channels[0])]

schainpy/model/io/jroIO_digitalRF.py 0 -4

             '''
             Created on Jul 3, 2014
             @author: roj-idl71
             '''
             # SUBCHANNELS EN VEZ DE CHANNELS
             # BENCHMARKS -> PROBLEMAS CON ARCHIVOS GRANDES -> INCONSTANTE EN EL TIEMPO
             # ACTUALIZACION DE VERSION
             # HEADERS
             # MODULO DE ESCRITURA
             # METADATA
             import os
             import time
             import datetime
             import numpy
             import timeit
             from fractions import Fraction
             from time import time
             from time import sleep
             import schainpy.admin
             from schainpy.model.data.jroheaderIO import RadarControllerHeader, SystemHeader
             from schainpy.model.data.jrodata import Voltage
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
             import pickle
             try:
                 import digital_rf
             except:
                 pass
             class DigitalRFReader(ProcessingUnit):
                 '''
                 classdocs
                 '''
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     ProcessingUnit.__init__(self)
                     self.dataOut                  = Voltage()
                     self.__printInfo              = True
                     self.__flagDiscontinuousBlock = False
                     self.__bufferIndex = 9999999
                     self.__codeType    = 0
                     self.__ippKm       = None
                     self.__nCode       = None
                     self.__nBaud       = None
                     self.__code        = None
                     self.dtype         = None
                     self.oldAverage    = None
                     self.path          = None
                 def close(self):
                     print('Average of writing to digital rf format is ', self.oldAverage * 1000)
                     return
                 def __getCurrentSecond(self):
                     return self.__thisUnixSample / self.__sample_rate
                 thisSecond = property(__getCurrentSecond, "I'm the 'thisSecond' property.")
                 def __setFileHeader(self):
                     '''
                     In this method will be initialized every parameter of dataOut object (header, no data)
                     '''
                     ippSeconds = 1.0 * self.__nSamples / self.__sample_rate
                     if not self.getByBlock:
                         nProfiles = 1.0 / ippSeconds  # Number of profiles in one second
                     else:
                         nProfiles = self.nProfileBlocks # Number of profiles in one block
                     try:
                         self.dataOut.radarControllerHeaderObj = RadarControllerHeader(
                             self.__radarControllerHeader)
                     except:
                         self.dataOut.radarControllerHeaderObj = RadarControllerHeader(
                             txA=0,
                             txB=0,
                             nWindows=1,
                             nHeights=self.__nSamples,
                             firstHeight=self.__firstHeigth,
                             deltaHeight=self.__deltaHeigth,
                             codeType=self.__codeType,
                             nCode=self.__nCode, nBaud=self.__nBaud,
                             code=self.__code)
                     try:
                         self.dataOut.systemHeaderObj = SystemHeader(self.__systemHeader)
                     except:
                         self.dataOut.systemHeaderObj = SystemHeader(nSamples=self.__nSamples,
                                                                     nProfiles=nProfiles,
                                                                     nChannels=len(
                                                                         self.__channelList),
                                                                     adcResolution=14)
                     self.dataOut.type  = "Voltage"
                     self.dataOut.data  = None
                     self.dataOut.dtype = self.dtype
                     # self.dataOut.nChannels = 0
                     # self.dataOut.nHeights = 0
                     self.dataOut.nProfiles   = int(nProfiles)
                     self.dataOut.heightList  = self.__firstHeigth + \
                         numpy.arange(self.__nSamples, dtype=numpy.float) * \
                         self.__deltaHeigth
                     #self.dataOut.channelList = list(range(self.__num_subchannels))
                     self.dataOut.channelList = list(range(len(self.__channelList)))
                     if not self.getByBlock:
                         self.dataOut.blocksize   = self.dataOut.nChannels * self.dataOut.nHeights
                     else:
                         self.dataOut.blocksize   = self.dataOut.nChannels * self.dataOut.nHeights*self.nProfileBlocks
                     # self.dataOut.channelIndexList = None
                     self.dataOut.flagNoData      = True
                     if not self.getByBlock:
                         self.dataOut.flagDataAsBlock = False
                     else:
                         self.dataOut.flagDataAsBlock = True
                     # Set to TRUE if the data is discontinuous
                     self.dataOut.flagDiscontinuousBlock = False
                     self.dataOut.utctime     = None
                     # timezone like jroheader, difference in minutes between UTC and localtime
                     self.dataOut.timeZone    = self.__timezone / 60
                     self.dataOut.dstFlag     = 0
                     self.dataOut.errorCount  = 0
                     try:
                         self.dataOut.nCohInt = self.fixed_metadata_dict.get(
                             'nCohInt', self.nCohInt)
                         # asumo que la data esta decodificada
                         self.dataOut.flagDecodeData = self.fixed_metadata_dict.get(
                             'flagDecodeData', self.flagDecodeData)
                         # asumo que la data esta sin flip
                         self.dataOut.flagDeflipData = self.fixed_metadata_dict['flagDeflipData']
                         self.dataOut.flagShiftFFT   = self.fixed_metadata_dict['flagShiftFFT']
                         self.dataOut.useLocalTime   = self.fixed_metadata_dict['useLocalTime']
                     except:
                         pass
                     self.dataOut.ippSeconds = ippSeconds
                     # Time interval between profiles
                     # self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt
                     self.dataOut.frequency  = self.__frequency
                     self.dataOut.realtime   = self.__online
                 def findDatafiles(self, path, startDate=None, endDate=None):
                     if not os.path.isdir(path):
                         return []
                     try:
                         digitalReadObj = digital_rf.DigitalRFReader(
                             path, load_all_metadata=True)
                     except:
                         digitalReadObj = digital_rf.DigitalRFReader(path)
                     channelNameList    = digitalReadObj.get_channels()
                     if not channelNameList:
                         return []
                     metadata_dict      = digitalReadObj.get_rf_file_metadata(channelNameList[0])
                     sample_rate        = metadata_dict['sample_rate'][0]
                     this_metadata_file = digitalReadObj.get_metadata(channelNameList[0])
                     try:
                         timezone       = this_metadata_file['timezone'].value
                     except:
                         timezone       = 0
                     startUTCSecond, endUTCSecond = digitalReadObj.get_bounds(
                         channelNameList[0]) / sample_rate - timezone
                     startDatetime      = datetime.datetime.utcfromtimestamp(startUTCSecond)
                     endDatatime        = datetime.datetime.utcfromtimestamp(endUTCSecond)
                     if not startDate:
                         startDate      = startDatetime.date()
                     if not endDate:
                         endDate        = endDatatime.date()
                     dateList           = []
                     thisDatetime       = startDatetime
                     while(thisDatetime <= endDatatime):
                         thisDate        = thisDatetime.date()
                         if thisDate     < startDate:
                             continue
                         if thisDate     > endDate:
                             break
                         dateList.append(thisDate)
                         thisDatetime += datetime.timedelta(1)
                     return dateList
                 def setup(self, path=None,
                           startDate=None,
                           endDate=None,
                           startTime=datetime.time(0, 0, 0),
                           endTime=datetime.time(23, 59, 59),
                           channelList=None,
                           nSamples=None,
                           online=False,
                           delay=60,
                           buffer_size=1024,
                           ippKm=None,
                           nCohInt=1,
                           nCode=1,
                           nBaud=1,
                           flagDecodeData=False,
                           code=numpy.ones((1, 1), dtype=numpy.int),
                           getByBlock=0,
                           nProfileBlocks=1,
                           **kwargs):
                     '''
                     In this method we should set all initial parameters.
                     Inputs:
                         path
                         startDate
                         endDate
                         startTime
                         endTime
                         set
                         expLabel
                         ext
                         online
                         delay
                     '''
                     self.path           = path
                     self.nCohInt        = nCohInt
                     self.flagDecodeData = flagDecodeData
                     self.i              = 0
                     self.getByBlock     = getByBlock
                     self.nProfileBlocks = nProfileBlocks
                     if not os.path.isdir(path):
                         raise ValueError("[Reading] Directory %s does not exist" % path)
                     try:
                         self.digitalReadObj = digital_rf.DigitalRFReader(
                             path, load_all_metadata=True)
                     except:
                         self.digitalReadObj = digital_rf.DigitalRFReader(path)
                     channelNameList         = self.digitalReadObj.get_channels()
                     if not channelNameList:
                         raise ValueError("[Reading] Directory %s does not have any files" % path)
                     if not channelList:
                         channelList = list(range(len(channelNameList)))
                     ##########  Reading metadata ######################
                     top_properties           = self.digitalReadObj.get_properties(
                         channelNameList[channelList[0]])
                     self.__num_subchannels   = top_properties['num_subchannels']
                     self.__sample_rate       = 1.0 * \
                         top_properties['sample_rate_numerator'] / \
                         top_properties['sample_rate_denominator']
                     # self.__samples_per_file = top_properties['samples_per_file'][0]
                     self.__deltaHeigth       = 1e6 * 0.15 / self.__sample_rate  # why 0.15?
                     this_metadata_file       = self.digitalReadObj.get_digital_metadata(
                         channelNameList[channelList[0]])
                     metadata_bounds          = this_metadata_file.get_bounds()
                     self.fixed_metadata_dict = this_metadata_file.read(
                         metadata_bounds[0])[metadata_bounds[0]]  # GET FIRST HEADER
                     try:
                         self.__processingHeader      = self.fixed_metadata_dict['processingHeader']
                         self.__radarControllerHeader = self.fixed_metadata_dict['radarControllerHeader']
                         self.__systemHeader          = self.fixed_metadata_dict['systemHeader']
                         self.dtype                   = pickle.loads(self.fixed_metadata_dict['dtype'])
                     except:
                         pass
                     self.__frequency = None
                     self.__frequency = self.fixed_metadata_dict.get('frequency', 1)
                     self.__timezone = self.fixed_metadata_dict.get('timezone', 18000)
                     try:
                         nSamples = self.fixed_metadata_dict['nSamples']
                     except:
                         nSamples = None
                     self.__firstHeigth = 0
                     try:
                         codeType       = self.__radarControllerHeader['codeType']
                     except:
                         codeType       = 0
                     try:
                         if codeType:
                             nCode = self.__radarControllerHeader['nCode']
                             nBaud = self.__radarControllerHeader['nBaud']
                             code  = self.__radarControllerHeader['code']
                     except:
                         pass
                     if not ippKm:
                         try:
                             # seconds to km
                             ippKm = self.__radarControllerHeader['ipp']
                         except:
                             ippKm = None
                     ####################################################
                     self.__ippKm   = ippKm
                     startUTCSecond = None
                     endUTCSecond   = None
                     if startDate:
                         startDatetime  = datetime.datetime.combine(startDate, startTime)
                         startUTCSecond = (
                             startDatetime - datetime.datetime(1970, 1, 1)).total_seconds() + self.__timezone
                     if endDate:
                         endDatetime   = datetime.datetime.combine(endDate, endTime)
                         endUTCSecond  = (endDatetime - datetime.datetime(1970,
 , 1)).total_seconds() + self.__timezone
                     #print(startUTCSecond,endUTCSecond)
                     start_index, end_index = self.digitalReadObj.get_bounds(
                         channelNameList[channelList[0]])
                     #print("*****",start_index,end_index)
                     if not startUTCSecond:
                         startUTCSecond = start_index / self.__sample_rate
                     if start_index     > startUTCSecond * self.__sample_rate:
                         startUTCSecond = start_index / self.__sample_rate
                     if not endUTCSecond:
                         endUTCSecond   = end_index / self.__sample_rate
                     if end_index       < endUTCSecond * self.__sample_rate:
                         endUTCSecond   = end_index / self.__sample_rate #Check UTC and LT time
                     if not nSamples:
                         if not ippKm:
                             raise ValueError("[Reading] nSamples or ippKm should be defined")
                         nSamples            = int(ippKm / (1e6 * 0.15 / self.__sample_rate))
                     channelBoundList        = []
                     channelNameListFiltered = []
                     for thisIndexChannel in channelList:
                         thisChannelName        = channelNameList[thisIndexChannel]
                         start_index, end_index = self.digitalReadObj.get_bounds(
                             thisChannelName)
                         channelBoundList.append((start_index, end_index))
                         channelNameListFiltered.append(thisChannelName)
                     self.profileIndex = 0
                     self.i            = 0
                     self.__delay      = delay
                     self.__codeType   = codeType
                     self.__nCode      = nCode
                     self.__nBaud      = nBaud
                     self.__code       = code
                     self.__datapath         = path
                     self.__online           = online
                     self.__channelList      = channelList
                     self.__channelNameList  = channelNameListFiltered
                     self.__channelBoundList = channelBoundList
                     self.__nSamples         = nSamples
                     if self.getByBlock:
                         nSamples = nSamples*nProfileBlocks
                     self.__samples_to_read  = int(nSamples)  # FIJO: AHORA 40
-                    #self.__samples_to_read  = int(1000000)  # FIJO: AHORA 40
                     self.__nChannels        = len(self.__channelList)
                     #print("------------------------------------------")
                     #print("self.__samples_to_read",self.__samples_to_read)
                     #print("self.__nSamples",self.__nSamples)
                     # son iguales y el buffer_index da 0
                     self.__startUTCSecond   = startUTCSecond
                     self.__endUTCSecond     = endUTCSecond
                     self.__timeInterval     = 1.0 * self.__samples_to_read / \
                         self.__sample_rate  # Time interval
                     if online:
                         # self.__thisUnixSample = int(endUTCSecond*self.__sample_rate - 4*self.__samples_to_read)
                         startUTCSecond = numpy.floor(endUTCSecond)
                     # por que en el otro metodo lo primero q se hace es sumar samplestoread
                     self.__thisUnixSample = int(startUTCSecond * self.__sample_rate) - self.__samples_to_read
                     #self.__data_buffer    = numpy.zeros(
                     #    (self.__num_subchannels, self.__samples_to_read), dtype=numpy.complex)
                     self.__data_buffer    = numpy.zeros((int(len(channelList)), self.__samples_to_read), dtype=numpy.complex)
                     self.__setFileHeader()
                     self.isConfig = True
                     print("[Reading] Digital RF Data was found from %s to %s " % (
                         datetime.datetime.utcfromtimestamp(
                             self.__startUTCSecond - self.__timezone),
                         datetime.datetime.utcfromtimestamp(
                             self.__endUTCSecond - self.__timezone)
                     ))
                     print("[Reading] Starting process from %s to %s" % (datetime.datetime.utcfromtimestamp(startUTCSecond - self.__timezone),
                                                                         datetime.datetime.utcfromtimestamp(
                         endUTCSecond - self.__timezone)
                     ))
                     self.oldAverage    = None
                     self.count         = 0
                     self.executionTime = 0
                 def __reload(self):
                     #         print
                     #         print "%s not in range [%s, %s]" %(
                     #                                           datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
                     #                                           datetime.datetime.utcfromtimestamp(self.__startUTCSecond - self.__timezone),
                     #                                           datetime.datetime.utcfromtimestamp(self.__endUTCSecond - self.__timezone)
                     #                                           )
                     print("[Reading] reloading metadata ...")
                     try:
                         self.digitalReadObj.reload(complete_update=True)
                     except:
                         self.digitalReadObj = digital_rf.DigitalRFReader(self.path)
                     start_index, end_index  = self.digitalReadObj.get_bounds(
                         self.__channelNameList[self.__channelList[0]])
                     if start_index          > self.__startUTCSecond * self.__sample_rate:
                         self.__startUTCSecond = 1.0 * start_index / self.__sample_rate
                     if end_index            > self.__endUTCSecond * self.__sample_rate:
                         self.__endUTCSecond = 1.0 * end_index / self.__sample_rate
                         print()
                         print("[Reading] New timerange found [%s, %s] " % (
                             datetime.datetime.utcfromtimestamp(
                                 self.__startUTCSecond - self.__timezone),
                             datetime.datetime.utcfromtimestamp(
                                 self.__endUTCSecond - self.__timezone)
                         ))
                         return True
                     return False
                 def timeit(self, toExecute):
                     t0                  = time.time()
                     toExecute()
                     self.executionTime  = time.time() - t0
                     if self.oldAverage is None:
                         self.oldAverage = self.executionTime
                     self.oldAverage     = (self.executionTime + self.count *
                                        self.oldAverage) / (self.count + 1.0)
                     self.count          = self.count + 1.0
                     return
                 def __readNextBlock(self, seconds=30, volt_scale=1):
                     '''
                     '''
                     # Set the next data
                     self.__flagDiscontinuousBlock = False
                     self.__thisUnixSample        += self.__samples_to_read
                     if self.__thisUnixSample + 2 * self.__samples_to_read > self.__endUTCSecond * self.__sample_rate:
                         print ("[Reading] There are no more data into selected time-range")
                         if self.__online:
                             sleep(3)
                             self.__reload()
                         else:
                             return False
                         if self.__thisUnixSample + 2 * self.__samples_to_read > self.__endUTCSecond * self.__sample_rate:
                             return False
                             self.__thisUnixSample -= self.__samples_to_read
                     indexChannel = 0
                     dataOk = False
                     for thisChannelName in self.__channelNameList:  # TODO VARIOS CHANNELS?
                         for indexSubchannel in range(self.__num_subchannels):
                             try:
                                 t0     = time()
-                                #print("Unitindex",self.__thisUnixSample)
-                                #print("__samples_to_read",self.__samples_to_read)
                                 result = self.digitalReadObj.read_vector_c81d(self.__thisUnixSample,
                                                                               self.__samples_to_read,
                                                                               thisChannelName, sub_channel=indexSubchannel)
                                 self.executionTime  = time() - t0
                                 if self.oldAverage is None:
                                     self.oldAverage = self.executionTime
                                 self.oldAverage     = (
                                     self.executionTime + self.count * self.oldAverage) / (self.count + 1.0)
                                 self.count = self.count + 1.0
                             except IOError as e:
                                 # read next profile
                                 self.__flagDiscontinuousBlock = True
                                 print("[Reading] %s" % datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone), e)
                                 break
                             if result.shape[0] != self.__samples_to_read:
                                 self.__flagDiscontinuousBlock = True
                                 print("[Reading] %s: Too few samples were found, just %d/%d  samples" % (datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
                                                                                                          result.shape[0],
                                                                                                          self.__samples_to_read))
                                 break
                             self.__data_buffer[indexChannel, :] = result * volt_scale
                             indexChannel+=1
                             dataOk       = True
                     self.__utctime       = self.__thisUnixSample / self.__sample_rate
                     if not dataOk:
                         return False
                     print("[Reading] %s: %d samples <> %f sec" % (datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
                                                                   self.__samples_to_read,
                                                                   self.__timeInterval))
                     self.__bufferIndex   = 0
                     return True
                 def __isBufferEmpty(self):
                     return self.__bufferIndex > self.__samples_to_read - self.__nSamples  # 40960 - 40
                 def getData(self, seconds=30, nTries=5):
                     '''
                         This method gets the data from files and put the data into the dataOut object
                         In addition, increase el the buffer counter in one.
                         Return:
                             data    :    retorna un perfil de voltages (alturas * canales) copiados desde el
                                         buffer. Si no hay mas archivos a leer retorna None.
                         Affected:
                             self.dataOut
                             self.profileIndex
                             self.flagDiscontinuousBlock
                             self.flagIsNewBlock
                     '''
                     #print("getdata")
                     err_counter = 0
                     self.dataOut.flagNoData = True
                     if self.__isBufferEmpty():
                         #print("hi")
                         self.__flagDiscontinuousBlock = False
                         while True:
                             if self.__readNextBlock():
                                 break
                             if self.__thisUnixSample > self.__endUTCSecond * self.__sample_rate:
                                 raise schainpy.admin.SchainError('Error')
                                 return
                             if self.__flagDiscontinuousBlock:
                                 raise schainpy.admin.SchainError('discontinuous block found')
                                 return
                             if not self.__online:
                                 raise schainpy.admin.SchainError('Online?')
                                 return
                             err_counter += 1
                             if err_counter > nTries:
                                 raise schainpy.admin.SchainError('Max retrys reach')
                                 return
                             print('[Reading] waiting %d seconds to read a new block' % seconds)
                             sleep(seconds)
                         if not self.getByBlock:
                             #print("self.__bufferIndex",self.__bufferIndex)# este valor siempre es cero aparentemente
                             self.dataOut.data = self.__data_buffer[:, self.__bufferIndex:self.__bufferIndex + self.__nSamples]
                             self.dataOut.utctime = ( self.__thisUnixSample + self.__bufferIndex) / self.__sample_rate
                             self.dataOut.flagNoData = False
                             self.dataOut.flagDiscontinuousBlock = self.__flagDiscontinuousBlock
                             self.dataOut.profileIndex = self.profileIndex
                             self.__bufferIndex += self.__nSamples
                             self.profileIndex  += 1
                             if self.profileIndex == self.dataOut.nProfiles:
                                 self.profileIndex = 0
                         else:
                             # ojo debo anadir el readNextBLock y el  __isBufferEmpty(
                             self.dataOut.flagNoData             = False
                             buffer = self.__data_buffer[:,self.__bufferIndex:self.__bufferIndex + self.__samples_to_read]
-                            #print("test",self.__bufferIndex)
                             buffer = buffer.reshape((self.__nChannels, self.nProfileBlocks, int(self.__samples_to_read/self.nProfileBlocks)))
                             self.dataOut.nProfileBlocks = self.nProfileBlocks
                             self.dataOut.data = buffer
                             self.dataOut.utctime = ( self.__thisUnixSample + self.__bufferIndex) / self.__sample_rate
                             self.profileIndex  += self.__samples_to_read
                             self.__bufferIndex += self.__samples_to_read
                             self.dataOut.flagDiscontinuousBlock = self.__flagDiscontinuousBlock
                         return True
                 def printInfo(self):
                     '''
                     '''
                     if self.__printInfo == False:
                         return
                     # self.systemHeaderObj.printInfo()
                     # self.radarControllerHeaderObj.printInfo()
                     self.__printInfo = False
                 def printNumberOfBlock(self):
                     '''
                     '''
                     return
                     # print self.profileIndex
                 def run(self, **kwargs):
                     '''
                     This method will be called many times so here you should put all your code
                     '''
                     if not self.isConfig:
                         self.setup(**kwargs)
                     self.getData(seconds=self.__delay)
                     return
             @MPDecorator
             class DigitalRFWriter(Operation):
                 '''
                 classdocs
                 '''
                 def __init__(self, **kwargs):
                     '''
                     Constructor
                     '''
                     Operation.__init__(self, **kwargs)
                     self.metadata_dict = {}
                     self.dataOut       = None
                     self.dtype         = None
                     self.oldAverage    = 0
                 def setHeader(self):
                     self.metadata_dict['frequency']      = self.dataOut.frequency
                     self.metadata_dict['timezone']       = self.dataOut.timeZone
                     self.metadata_dict['dtype']          = pickle.dumps(self.dataOut.dtype)
                     self.metadata_dict['nProfiles']      = self.dataOut.nProfiles
                     self.metadata_dict['heightList']     = self.dataOut.heightList
                     self.metadata_dict['channelList']    = self.dataOut.channelList
                     self.metadata_dict['flagDecodeData'] = self.dataOut.flagDecodeData
                     self.metadata_dict['flagDeflipData'] = self.dataOut.flagDeflipData
                     self.metadata_dict['flagShiftFFT']   = self.dataOut.flagShiftFFT
                     self.metadata_dict['useLocalTime']   = self.dataOut.useLocalTime
                     self.metadata_dict['nCohInt']        = self.dataOut.nCohInt
                     self.metadata_dict['type']           = self.dataOut.type
                     self.metadata_dict['flagDataAsBlock']= getattr(
                         self.dataOut, 'flagDataAsBlock', None)  # chequear
                 def setup(self, dataOut, path, frequency, fileCadence, dirCadence, metadataCadence, set=0, metadataFile='metadata', ext='.h5'):
                     '''
                     In this method we should set all initial parameters.
                     Input:
                         dataOut: Input data will also be outputa data
                     '''
                     self.setHeader()
                     self.__ippSeconds  = dataOut.ippSeconds
                     self.__deltaH      = dataOut.getDeltaH()
                     self.__sample_rate = 1e6 * 0.15 / self.__deltaH
                     self.__dtype       = dataOut.dtype
                     if len(dataOut.dtype) == 2:
                         self.__dtype = dataOut.dtype[0]
                     self.__nSamples  = dataOut.systemHeaderObj.nSamples
                     self.__nProfiles = dataOut.nProfiles
                     if self.dataOut.type != 'Voltage':
                         raise 'Digital RF cannot be used with this data type'
                         self.arr_data = numpy.ones((1, dataOut.nFFTPoints * len(
                             self.dataOut.channelList)), dtype=[('r', self.__dtype), ('i', self.__dtype)])
                     else:
                         self.arr_data = numpy.ones((self.__nSamples, len(
                             self.dataOut.channelList)), dtype=[('r', self.__dtype), ('i', self.__dtype)])
                     file_cadence_millisecs  = 1000
                     sample_rate_fraction    = Fraction(self.__sample_rate).limit_denominator()
                     sample_rate_numerator   = int(sample_rate_fraction.numerator)
                     sample_rate_denominator = int(sample_rate_fraction.denominator)
                     start_global_index      = dataOut.utctime * self.__sample_rate
                     uuid              = 'prueba'
                     compression_level = 0
                     checksum          = False
                     is_complex        = True
                     num_subchannels   = len(dataOut.channelList)
                     is_continuous     = True
                     marching_periods  = False
                     self.digitalWriteObj = digital_rf.DigitalRFWriter(path, self.__dtype, dirCadence,
                                                                       fileCadence, start_global_index,
                                                                       sample_rate_numerator, sample_rate_denominator, uuid, compression_level, checksum,
                                                                       is_complex, num_subchannels, is_continuous, marching_periods)
                     metadata_dir         = os.path.join(path, 'metadata')
                     os.system('mkdir %s' % (metadata_dir))
                     self.digitalMetadataWriteObj = digital_rf.DigitalMetadataWriter(metadata_dir, dirCadence, 1,  # 236, file_cadence_millisecs / 1000
                                                                                     sample_rate_numerator, sample_rate_denominator,
                                                                                     metadataFile)
                     self.isConfig      = True
                     self.currentSample = 0
                     self.oldAverage    = 0
                     self.count         = 0
                     return
                 def writeMetadata(self):
                     start_idx                                   = self.__sample_rate * self.dataOut.utctime
                     self.metadata_dict['processingHeader']      = self.dataOut.processingHeaderObj.getAsDict(
                     )
                     self.metadata_dict['radarControllerHeader'] = self.dataOut.radarControllerHeaderObj.getAsDict(
                     )
                     self.metadata_dict['systemHeader']          = self.dataOut.systemHeaderObj.getAsDict(
                     )
                     self.digitalMetadataWriteObj.write(start_idx, self.metadata_dict)
                     return
                 def timeit(self, toExecute):
                     t0 = time()
                     toExecute()
                     self.executionTime  = time() - t0
                     if self.oldAverage is None:
                         self.oldAverage = self.executionTime
                     self.oldAverage     = (self.executionTime + self.count *
                                        self.oldAverage) / (self.count + 1.0)
                     self.count          = self.count + 1.0
                     return
                 def writeData(self):
                     if self.dataOut.type != 'Voltage':
                         raise 'Digital RF cannot be used with this data type'
                         for channel in self.dataOut.channelList:
                             for i in range(self.dataOut.nFFTPoints):
                                 self.arr_data[1][channel * self.dataOut.nFFTPoints +
                                                  i]['r'] = self.dataOut.data[channel][i].real
                                 self.arr_data[1][channel * self.dataOut.nFFTPoints +
                                                  i]['i'] = self.dataOut.data[channel][i].imag
                     else:
                         for i in range(self.dataOut.systemHeaderObj.nSamples):
                             for channel in self.dataOut.channelList:
                                 self.arr_data[i][channel]['r'] = self.dataOut.data[channel][i].real
                                 self.arr_data[i][channel]['i'] = self.dataOut.data[channel][i].imag
                     def f(): return self.digitalWriteObj.rf_write(self.arr_data)
                     self.timeit(f)
                     return
                 def run(self, dataOut, frequency=49.92e6, path=None, fileCadence=1000, dirCadence=36000, metadataCadence=1, **kwargs):
                     '''
                     This method will be called many times so here you should put all your code
                     Inputs:
                         dataOut: object with the data
                     '''
                     # print dataOut.__dict__
                     self.dataOut = dataOut
                     if not self.isConfig:
                         self.setup(dataOut, path, frequency, fileCadence,
                                    dirCadence, metadataCadence, **kwargs)
                         self.writeMetadata()
                     self.writeData()
                     ## self.currentSample += 1
                     # if self.dataOut.flagDataAsBlock or self.currentSample == 1:
                     # self.writeMetadata()
                     ## if self.currentSample == self.__nProfiles: self.currentSample = 0
                     return dataOut# en la version 2.7 no aparece este return
                 def close(self):
                     print('[Writing] - Closing files ')
                     print('Average of writing to digital rf format is ', self.oldAverage * 1000)
                     try:
                         self.digitalWriteObj.close()
                     except:
                         pass

schainpy/model/io/jroIO_param.py +7 -3

             import os
             import time
             import datetime
             import numpy
             import h5py
             import schainpy.admin
             from schainpy.model.data.jrodata import *
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
             from schainpy.model.io.jroIO_base import *
             from schainpy.utils import log
             class HDFReader(Reader, ProcessingUnit):
                 """Processing unit to read HDF5 format files
                 This unit reads HDF5 files created with `HDFWriter` operation contains
                 by default two groups Data and Metadata all variables would be saved as `dataOut`
                 attributes.
                 It is possible to read any HDF5 file by given the structure in the `description`
                 parameter, also you can add extra values to metadata with the parameter `extras`.
                 Parameters:
                 -----------
                 path : str
                     Path where files are located.
                 startDate : date
                     Start date of the files
                 endDate : list
                     End date of the files
                 startTime : time
                     Start time of the files
                 endTime : time
                     End time of the files
                 description : dict, optional
                     Dictionary with the description of the HDF5 file
                 extras : dict, optional
                     Dictionary with extra metadata to be be added to `dataOut`
                 Examples
                 --------
                 desc = {
                     'Data': {
                         'data_output': ['u', 'v', 'w'],
                         'utctime': 'timestamps',
                     }  ,
                     'Metadata': {
                         'heightList': 'heights'
                     }
                 }
                 desc = {
                     'Data': {
                         'data_output': 'winds',
                         'utctime': 'timestamps'
                     },
                     'Metadata': {
                         'heightList': 'heights'
                     }
                 }
                 extras = {
                     'timeZone': 300
                 }
                 reader = project.addReadUnit(
                     name='HDFReader',
                     path='/path/to/files',
                     startDate='2019/01/01',
                     endDate='2019/01/31',
                     startTime='00:00:00',
                     endTime='23:59:59',
                     # description=json.dumps(desc),
                     # extras=json.dumps(extras),
                     )
                 """
                 __attrs__ = ['path', 'startDate', 'endDate', 'startTime', 'endTime', 'description', 'extras']
                 def __init__(self):
                     ProcessingUnit.__init__(self)
                     self.dataOut = Parameters()
                     self.ext = ".hdf5"
                     self.optchar = "D"
                     self.meta = {}
                     self.data = {}
                     self.open_file = h5py.File
                     self.open_mode = 'r'
                     self.description = {}
                     self.extras = {}
                     self.filefmt = "*%Y%j***"
                     self.folderfmt = "*%Y%j"
                     self.utcoffset = 0
                 def setup(self, **kwargs):
                     self.set_kwargs(**kwargs)
                     if not self.ext.startswith('.'):
                         self.ext = '.{}'.format(self.ext)
                     if self.online:
                         log.log("Searching files in online mode...", self.name)
                         for nTries in range(self.nTries):
                             fullpath = self.searchFilesOnLine(self.path, self.startDate,
                                 self.endDate, self.expLabel, self.ext, self.walk,
                                 self.filefmt, self.folderfmt)
                             try:
                                 fullpath = next(fullpath)
                             except:
                                 fullpath = None
                             if fullpath:
                                 break
                             log.warning(
                                 'Waiting {} sec for a valid file in {}: try {} ...'.format(
                                     self.delay, self.path, nTries + 1),
                                 self.name)
                             time.sleep(self.delay)
                         if not(fullpath):
                             raise schainpy.admin.SchainError(
                                 'There isn\'t any valid file in {}'.format(self.path))
                         pathname, filename = os.path.split(fullpath)
                         self.year = int(filename[1:5])
                         self.doy = int(filename[5:8])
                         self.set = int(filename[8:11]) - 1
                     else:
                         log.log("Searching files in {}".format(self.path), self.name)
                         self.filenameList = self.searchFilesOffLine(self.path, self.startDate,
                             self.endDate, self.expLabel, self.ext, self.walk, self.filefmt, self.folderfmt)
                     self.setNextFile()
                     return
                 def readFirstHeader(self):
                     '''Read metadata and data'''
                     self.__readMetadata()
                     self.__readData()
                     self.__setBlockList()
                     if 'type' in self.meta:
                         self.dataOut = eval(self.meta['type'])()
                     for attr in self.meta:
                         setattr(self.dataOut, attr, self.meta[attr])
                     self.blockIndex = 0
                     return
                 def __setBlockList(self):
                     '''
                     Selects the data within the times defined
                     self.fp
                     self.startTime
                     self.endTime
                     self.blockList
                     self.blocksPerFile
                     '''
                     startTime = self.startTime
                     endTime = self.endTime
                     thisUtcTime = self.data['utctime'] + self.utcoffset
                     self.interval = numpy.min(thisUtcTime[1:] - thisUtcTime[:-1])
                     thisDatetime = datetime.datetime.utcfromtimestamp(thisUtcTime[0])
                     thisDate = thisDatetime.date()
                     thisTime = thisDatetime.time()
                     startUtcTime = (datetime.datetime.combine(thisDate, startTime) - datetime.datetime(1970, 1, 1)).total_seconds()
                     endUtcTime = (datetime.datetime.combine(thisDate, endTime) - datetime.datetime(1970, 1, 1)).total_seconds()
                     ind = numpy.where(numpy.logical_and(thisUtcTime >= startUtcTime, thisUtcTime < endUtcTime))[0]
                     self.blockList = ind
                     self.blocksPerFile = len(ind)
                     return
                 def __readMetadata(self):
                     '''
                     Reads Metadata
                     '''
                     meta = {}
                     if self.description:
                         for key, value in self.description['Metadata'].items():
                             meta[key] = self.fp[value][()]
                     else:
                         grp = self.fp['Metadata']
                         for name in grp:
                             meta[name] = grp[name][()]
                     if self.extras:
                         for key, value in self.extras.items():
                             meta[key] = value
                     self.meta = meta
                     return
                 def __readData(self):
                     data = {}
                     if self.description:
                         for key, value in self.description['Data'].items():
                             if isinstance(value, str):
                                 if isinstance(self.fp[value], h5py.Dataset):
                                     data[key] = self.fp[value][()]
                                 elif isinstance(self.fp[value], h5py.Group):
                                     array = []
                                     for ch in self.fp[value]:
                                         array.append(self.fp[value][ch][()])
                                     data[key] = numpy.array(array)
                             elif isinstance(value, list):
                                 array = []
                                 for ch in value:
                                     array.append(self.fp[ch][()])
                                 data[key] = numpy.array(array)
                     else:
                         grp = self.fp['Data']
                         for name in grp:
                             if isinstance(grp[name], h5py.Dataset):
                                 array = grp[name][()]
                             elif isinstance(grp[name], h5py.Group):
                                 array = []
                                 for ch in grp[name]:
                                     array.append(grp[name][ch][()])
                                 array = numpy.array(array)
                             else:
                                 log.warning('Unknown type: {}'.format(name))
                             if name in self.description:
                                 key = self.description[name]
                             else:
                                 key = name
                             data[key] = array
                     self.data = data
                     return
                 def getData(self):
                     for attr in self.data:
                         if self.data[attr].ndim == 1:
                             setattr(self.dataOut, attr, self.data[attr][self.blockIndex])
                         else:
                             setattr(self.dataOut, attr, self.data[attr][:, self.blockIndex])
                     self.dataOut.flagNoData = False
                     self.blockIndex += 1
                     log.log("Block No. {}/{} -> {}".format(
                         self.blockIndex,
                         self.blocksPerFile,
                         self.dataOut.datatime.ctime()), self.name)
                     return
                 def run(self, **kwargs):
                     if not(self.isConfig):
                         self.setup(**kwargs)
                         self.isConfig = True
                     if self.blockIndex == self.blocksPerFile:
                         self.setNextFile()
                     self.getData()
                     return
             @MPDecorator
             class HDFWriter(Operation):
                 """Operation to write HDF5 files.
                 The HDF5 file contains by default two groups Data and Metadata where
                 you can save any `dataOut` attribute specified by `dataList` and `metadataList`
                 parameters, data attributes are normaly time dependent where the metadata
                 are not.
                 It is possible to customize the structure of the HDF5 file with the
                 optional description parameter see the examples.
                 Parameters:
                 -----------
                 path : str
                     Path where files will be saved.
                 blocksPerFile : int
                     Number of blocks per file
                 metadataList : list
                     List of the dataOut attributes that will be saved as metadata
                 dataList : int
                     List of the dataOut attributes that will be saved as data
                 setType : bool
                     If True the name of the files corresponds to the timestamp of the data
                 description : dict, optional
                     Dictionary with the desired description of the HDF5 file
                 Examples
                 --------
                 desc = {
                     'data_output': {'winds': ['z', 'w', 'v']},
                     'utctime': 'timestamps',
                     'heightList': 'heights'
                 }
                 desc = {
                     'data_output': ['z', 'w', 'v'],
                     'utctime': 'timestamps',
                     'heightList': 'heights'
                 }
                 desc = {
                     'Data': {
                         'data_output': 'winds',
                         'utctime': 'timestamps'
                     },
                     'Metadata': {
                         'heightList': 'heights'
                     }
                 }
                 writer = proc_unit.addOperation(name='HDFWriter')
                 writer.addParameter(name='path', value='/path/to/file')
                 writer.addParameter(name='blocksPerFile', value='32')
                 writer.addParameter(name='metadataList', value='heightList,timeZone')
                 writer.addParameter(name='dataList',value='data_output,utctime')
                 # writer.addParameter(name='description',value=json.dumps(desc))
                 """
                 ext = ".hdf5"
                 optchar = "D"
                 filename = None
                 path = None
                 setFile = None
                 fp = None
                 firsttime = True
                 #Configurations
                 blocksPerFile = None
                 blockIndex = None
                 dataOut = None
                 #Data Arrays
                 dataList = None
                 metadataList = None
                 currentDay = None
                 lastTime = None
                 last_Azipos = None
                 last_Elepos = None
                 mode       = None
                 #-----------------------
                 Typename = None
                 def __init__(self):
                     Operation.__init__(self)
                     return
                 def set_kwargs(self, **kwargs):
                     for key, value in kwargs.items():
                         setattr(self, key, value)
                 def set_kwargs_obj(self,obj, **kwargs):
                     for key, value in kwargs.items():
                         setattr(obj, key, value)
                 def generalFlag(self):
                     ####rint("GENERALFLAG")
                     if self.mode== "weather":
                         if self.last_Azipos == None:
                             tmp = self.dataOut.azimuth
                             ####print("ang azimuth writer",tmp)
                             self.last_Azipos = tmp
                             flag = False
                             return flag
                         ####print("ang_azimuth writer",self.dataOut.azimuth)
                         result = self.dataOut.azimuth - self.last_Azipos
                         self.last_Azipos = self.dataOut.azimuth
                         if result<0:
                             flag = True
                             return flag
                 def generalFlag_vRF(self):
                     ####rint("GENERALFLAG")
                     try:
                         self.dataOut.flagBlock360Done
                         return self.dataOut.flagBlock360Done
                     except:
                         return 0
                 def setup(self, path=None, blocksPerFile=10, metadataList=None, dataList=None, setType=None, description=None,type_data=None,**kwargs):
                     self.path = path
                     self.blocksPerFile = blocksPerFile
                     self.metadataList = metadataList
                     self.dataList = [s.strip() for s in dataList]
                     self.setType = setType
                     if self.mode == "weather":
                         self.setType = "weather"
                         self.set_kwargs(**kwargs)
                         self.set_kwargs_obj(self.dataOut,**kwargs)
                     self.description = description
                     self.type_data=type_data
                     if self.metadataList is None:
                         self.metadataList = self.dataOut.metadata_list
                     tableList = []
                     dsList = []
                     for i in range(len(self.dataList)):
                         dsDict = {}
                         if hasattr(self.dataOut, self.dataList[i]):
                             dataAux = getattr(self.dataOut, self.dataList[i])
                             dsDict['variable'] = self.dataList[i]
                         else:
                             log.warning('Attribute {} not found in dataOut', self.name)
                             continue
                         if dataAux is None:
                             continue
                         elif isinstance(dataAux, (int, float, numpy.integer, numpy.float)):
                             dsDict['nDim'] = 0
                         else:
                             dsDict['nDim'] = len(dataAux.shape)
                             dsDict['shape'] = dataAux.shape
                             dsDict['dsNumber'] = dataAux.shape[0]
                             dsDict['dtype'] = dataAux.dtype
                         dsList.append(dsDict)
                     self.dsList = dsList
                     self.currentDay = self.dataOut.datatime.date()
                 def timeFlag(self):
                     currentTime = self.dataOut.utctime
                     timeTuple = time.localtime(currentTime)
                     dataDay = timeTuple.tm_yday
                     if self.lastTime is None:
                         self.lastTime = currentTime
                         self.currentDay = dataDay
                         return False
                     timeDiff = currentTime - self.lastTime
                     #Si el dia es diferente o si la diferencia entre un dato y otro supera la hora
                     if dataDay != self.currentDay:
                         self.currentDay = dataDay
                         return True
                     elif timeDiff > 3*60*60:
                         self.lastTime = currentTime
                         return True
                     else:
                         self.lastTime = currentTime
                         return False
                 def run(self, dataOut, path, blocksPerFile=10, metadataList=None,
                         dataList=[], setType=None, description={},mode= None,type_data=None,Reset = False,**kwargs):
                     if Reset:
                         self.isConfig = False
                         self.closeFile()
                         self.lastTime = None
                         self.blockIndex = 0
                     self.dataOut = dataOut
                     self.mode    = mode
                     self.var = dataList[0]
                     if not(self.isConfig):
                         self.setup(path=path, blocksPerFile=blocksPerFile,
                                    metadataList=metadataList, dataList=dataList,
                                    setType=setType, description=description,type_data=type_data,**kwargs)
                         self.isConfig = True
                         self.setNextFile()
                     self.putData()
                     return
                 def setNextFile(self):
                     ###print("HELLO WORLD--------------------------------")
                     ext = self.ext
                     path = self.path
                     setFile = self.setFile
                     type_data = self.type_data
                     timeTuple = time.localtime(self.dataOut.utctime)
                     subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
                     fullpath = os.path.join(path, subfolder)
                     if os.path.exists(fullpath):
                         filesList = os.listdir(fullpath)
                         filesList = [k for k in filesList if k.startswith(self.optchar)]
                         if len( filesList ) > 0:
                             filesList = sorted(filesList, key=str.lower)
                             filen = filesList[-1]
                             # el filename debera tener el siguiente formato
                             # 0 1234 567 89A BCDE (hex)
                             # x YYYY DDD SSS .ext
                             if isNumber(filen[8:11]):
                                 setFile = int(filen[8:11]) #inicializo mi contador de seteo al seteo del ultimo file
                             else:
                                 setFile = -1
                         else:
                             setFile = -1 #inicializo mi contador de seteo
                     else:
                         os.makedirs(fullpath)
                         setFile = -1 #inicializo mi contador de seteo
                     ###print("**************************",self.setType)
                     if self.setType is None:
                         setFile += 1
                         file = '%s%4.4d%3.3d%03d%s' % (self.optchar,
                                                        timeTuple.tm_year,
                                                        timeTuple.tm_yday,
                                                        setFile,
                                                        ext )
                     elif self.setType == "weather":
                         if self.var.lower() == 'Zdb'.lower():
                             wr_type = 'Z'
                         elif self.var.lower() == 'Zdb_D'.lower():
                             wr_type = 'D'
                         elif self.var.lower() == 'PhiD_P'.lower():
                             wr_type = 'P'
                         elif self.var.lower() == 'RhoHV_R'.lower():
                             wr_type = 'R'
                         elif self.var.lower() == 'velRadial_V'.lower():
                             wr_type = 'V'
                         elif self.var.lower() == 'Sigmav_W'.lower():
                             wr_type = 'S'
                         elif self.var.lower() == 'dataPP_POWER'.lower():
                             wr_type = 'Pow'
                         elif self.var.lower() == 'dataPP_DOP'.lower():
                             wr_type = 'Dop'
                         #Z_SOPHy_El10.0_20200505_14:02:15.h5
                         #Z_SOPHy_Az40.0_20200505_14:02:15.h5
                         if self.dataOut.flagMode == 1: #'AZI' #PPI
                             ang_type = 'El'
-                            ang_    = round(numpy.mean(self.dataOut.data_ele),1)
+                            len_aux = int(self.dataOut.data_ele.shape[0]/4)
+                            mean = numpy.mean(self.dataOut.data_ele[len_aux:-len:aux])
+                            ang_    = round(mean,1)
                         elif self.dataOut.flagMode == 0: #'ELE' #RHI
                             ang_type = 'Az'
-                            ang_    = round(numpy.mean(self.dataOut.data_azi),1)
+                            len_aux = int(self.dataOut.data_azi.shape[0]/4)
+                            mean = numpy.mean(self.dataOut.data_azi[len_aux:-len:aux])
+                            ang_    = round(mean,1)
                         file = '%s%s%s%2.1f%s%2.2d%2.2d%2.2d%s%2.2d%2.2d%2.2d%s' % (wr_type,
                                                        '_SOPHy_',
                                                        ang_type,
                                                        ang_,
                                                        '_',
                                                        timeTuple.tm_year,
                                                        timeTuple.tm_mon,
                                                        timeTuple.tm_mday,
                                                        '_',
                                                        timeTuple.tm_hour,
                                                        timeTuple.tm_min,
                                                        timeTuple.tm_sec,
                                                        ext )
                     else:
                         setFile = timeTuple.tm_hour*60+timeTuple.tm_min
                         file = '%s%4.4d%3.3d%04d%s' % (self.optchar,
                                                        timeTuple.tm_year,
                                                        timeTuple.tm_yday,
                                                        setFile,
                                                        ext )
                     self.filename = os.path.join( path, subfolder, file )
                     #Setting HDF5 File
-                    print("filename",self.filename)
+                    #print("filename",self.filename)
                     self.fp = h5py.File(self.filename, 'w')
                     #write metadata
                     self.writeMetadata(self.fp)
                     #Write data
                     self.writeData(self.fp)
                 def getLabel(self, name, x=None):
                     if x is None:
                         if 'Data' in self.description:
                             data = self.description['Data']
                             if 'Metadata' in self.description:
                                 data.update(self.description['Metadata'])
                         else:
                             data = self.description
                         if name in data:
                             if isinstance(data[name], str):
                                 return data[name]
                             elif isinstance(data[name], list):
                                 return None
                             elif isinstance(data[name], dict):
                                 for key, value in data[name].items():
                                     return key
                         return name
                     else:
                         if 'Metadata' in self.description:
                             meta = self.description['Metadata']
                         else:
                             meta = self.description
                         if name in meta:
                             if isinstance(meta[name], list):
                                 return meta[name][x]
                             elif isinstance(meta[name], dict):
                                 for key, value in meta[name].items():
                                     return value[x]
                         if 'cspc' in name:
                             return 'pair{:02d}'.format(x)
                         else:
                             return 'channel{:02d}'.format(x)
                 def writeMetadata(self, fp):
                     if self.description:
                         if 'Metadata' in self.description:
                             grp = fp.create_group('Metadata')
                         else:
                             grp = fp
                     else:
                         grp = fp.create_group('Metadata')
                     for i in range(len(self.metadataList)):
                         if not hasattr(self.dataOut, self.metadataList[i]):
                             log.warning('Metadata: `{}` not found'.format(self.metadataList[i]), self.name)
                             continue
                         value = getattr(self.dataOut, self.metadataList[i])
                         if isinstance(value, bool):
                             if value is True:
                                 value = 1
                             else:
                                 value = 0
                         grp.create_dataset(self.getLabel(self.metadataList[i]), data=value)
                     return
                 def writeData(self, fp):
                     if self.description:
                         if 'Data' in self.description:
                             grp = fp.create_group('Data')
                         else:
                             grp = fp
                     else:
                         grp = fp.create_group('Data')
                     dtsets = []
                     data = []
                     for dsInfo in self.dsList:
                         if dsInfo['nDim'] == 0:
                             ds = grp.create_dataset(
                                 self.getLabel(dsInfo['variable']),
                                 (self.blocksPerFile, ),
                                 chunks=True,
                                 dtype=numpy.float64)
                             dtsets.append(ds)
                             data.append((dsInfo['variable'], -1))
                         else:
                             label = self.getLabel(dsInfo['variable'])
                             if label is not None:
                                 sgrp = grp.create_group(label)
                             else:
                                 sgrp = grp
                             for i in range(dsInfo['dsNumber']):
                                 ds = sgrp.create_dataset(
                                     self.getLabel(dsInfo['variable'], i),
                                     (self.blocksPerFile, ) + dsInfo['shape'][1:],
                                     chunks=True,
                                     dtype=dsInfo['dtype'])
                                 dtsets.append(ds)
                                 data.append((dsInfo['variable'], i))
                     fp.flush()
                     log.log('Creating file: {}'.format(fp.filename), self.name)
                     self.ds = dtsets
                     self.data = data
                     self.firsttime = True
                     self.blockIndex = 0
                     return
                 def putData(self):
                     if (self.blockIndex == self.blocksPerFile) or self.timeFlag():# or self.generalFlag_vRF():
                         self.closeFile()
                         self.setNextFile()
                     for i, ds in enumerate(self.ds):
                         attr, ch = self.data[i]
                         if ch == -1:
                             ds[self.blockIndex] = getattr(self.dataOut, attr)
                         else:
                             ds[self.blockIndex] = getattr(self.dataOut, attr)[ch]
                     self.fp.flush()
                     self.blockIndex += 1
                     log.log('Block No. {}/{}'.format(self.blockIndex, self.blocksPerFile), self.name)
                     return
                 def closeFile(self):
                     if self.blockIndex != self.blocksPerFile:
                         for ds in self.ds:
                             ds.resize(self.blockIndex, axis=0)
                     if self.fp:
                         self.fp.flush()
                         self.fp.close()
                 def close(self):
                     self.closeFile()

schainpy/model/proc/jroproc_parameters.py 755 ➡ 644 0 0

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

schainpy/scripts/sophy_proc_tmp.py +2 -2

             # SOPHY PROC script
             import os, sys, json, argparse
             import datetime
             import time
             PATH = '/DATA_RM/DATA'
             # PATH = '/Users/jespinoza/workspace/data/'
             PARAM = {
-                'P': {'name': 'dataPP_POWER', 'zmin': 35, 'zmax': 60, 'colormap': 'viridis', 'label': 'Power', 'cb_label': 'dB'},
+                'P': {'name': 'dataPP_POWER', 'zmin': 35, 'zmax': 60, 'colormap': 'jet', 'label': 'Power', 'cb_label': 'dB'},
                 'V': {'name': 'dataPP_DOP', 'zmin': -20, 'zmax': 20, 'colormap': 'seismic', 'label': 'Velocity', 'cb_label': 'm/s'},
                 'RH': {'name': 'RhoHV_R', 'zmin': 0, 'zmax': 1, 'colormap': 'jet', 'label': 'CoeficienteCorrelacion', 'cb_label': '*'},
                 'FD': {'name': 'PhiD_P', 'zmin': -180, 'zmax': 180, 'colormap': 'RdBu_r', 'label': 'Fase Diferencial', 'cb_label': 'º'},
                 'ZD': {'name': 'Zdb_D', 'zmin': -20, 'zmax': 80, 'colormap': 'viridis', 'label': 'ReflectividadDiferencial', 'cb_label': 'dB'},
-                'Z': {'name': 'Zdb', 'zmin': 100, 'zmax': 200, 'colormap': 'viridis', 'label': 'Reflectividad', 'cb_label': 'dB'},
+                'Z': {'name': 'Zdb', 'zmin': -20, 'zmax': 60, 'colormap': 'viridis', 'label': 'Reflectividad', 'cb_label': 'dB'},
                 'W': {'name': 'Sigmav_W', 'zmin': -20, 'zmax': 60, 'colormap': 'viridis', 'label': 'AnchoEspectral', 'cb_label': 'hz'}
             }
             #Z,ZD 'mm^6/m^3'
             PATH = '/home/soporte/Downloads/data_WR_RHI'
             def main(args):
                 experiment = args.experiment
                 fp = open(os.path.join(PATH, experiment, 'experiment.conf'))
                 conf = json.loads(fp.read())
                 ipp_km = conf['usrp_tx']['ipp']
                 ipp = ipp_km * 2 /300000
                 samp_rate  = conf['usrp_rx']['sample_rate']
                 #axis = ['0' if x=='elevation' else '1' for x in conf['pedestal']['speed']]      # AZIMUTH 1 ELEVACION 0
                 axis = ['0' if x=='elevation' else '1' for x in conf['pedestal']['axis']]      # AZIMUTH 1 ELEVACION 0
                 speed_axis = conf['pedestal']['speed']
                 steeps = conf['pedestal']['table']
                 time_offset = args.time_offset
                 parameters = args.parameters
                 #start_date = experiment.split('@')[1].split('T')[0].replace('-', '/')
                 start_date = '2022/04/22'
                 end_date = start_date
                 #start_time = experiment.split('@')[1].split('T')[1]
                 start_time = '00:00:01'
                 end_time = '23:59:59'
                 max_index  = int(samp_rate*ipp*1e6 * args.range / 60) + int(samp_rate*ipp*1e6 * 1.2 / 60)
                 N = int(1/(speed_axis[0]*ipp))                                               # 1 GRADO DE RESOLUCION
                 path = os.path.join(PATH, experiment, 'rawdata')
                 path_ped = os.path.join(PATH, experiment, 'position')
                 path_plots = os.path.join(PATH, experiment, 'plots')
                 path_save = os.path.join(PATH, experiment, 'param')
                 dBmin = 35
                 dBmax = 60
                 Vmin = -20
                 Vmax = 20
                 from schainpy.controller import Project
                 project = Project()
                 project.setup(id='1', name='Sophy', description='sophy proc')
                 reader = project.addReadUnit(datatype='DigitalRFReader',
                     path=path,
                     startDate=start_date,
                     endDate=end_date,
                     startTime=start_time,
                     endTime=end_time,
                     delay=0,
                     online=0,
                     walk=1,
                     ippKm = ipp_km,
                     getByBlock = 1,
                     nProfileBlocks = N,
                 )
                 voltage = project.addProcUnit(datatype='VoltageProc', inputId=reader.getId())
                 op = voltage.addOperation(name='setH0')
                 op.addParameter(name='h0', value='-1.2')
                 if args.range > 0:
                     op = voltage.addOperation(name='selectHeights')
                     op.addParameter(name='minIndex', value='0', format='int')
                     op.addParameter(name='maxIndex', value=max_index, format='int')
                 op = voltage.addOperation(name='PulsePair_vRF', optype='other')
                 op.addParameter(name='n', value=int(N), format='int')
                 proc = project.addProcUnit(datatype='ParametersProc', inputId=voltage.getId())
                 #-----------------------new--------- variables polarimetricas---------------
                 opObj10 = proc.addOperation(name="WeatherRadar")
                 opObj10.addParameter(name='variableList',value='Reflectividad,ReflectividadDiferencial,CoeficienteCorrelacion,FaseDiferencial,VelocidadRadial,AnchoEspectral')
                 #---------------------------------------------------------------------------
                 op = proc.addOperation(name='PedestalInformation')
                 op.addParameter(name='path', value=path_ped, format='str')
                 op.addParameter(name='interval', value='0.04', format='float')
                 op.addParameter(name='time_offset', value=time_offset)
                 for param in parameters:
                     op = proc.addOperation(name='Block360_vRF4')
                     op.addParameter(name='axis', value=','.join(axis))
                     op.addParameter(name='attr_data', value=PARAM[param]['name'])
                     if axis[0] == '1':
                         path_fig = '/PPI-{}km'.format(args.range)
                         op= proc.addOperation(name='Weather_vRF_Plot')
                         op.addParameter(name='save', value=path_plots+path_fig, format='str')
                         op.addParameter(name='save_period', value=-1)
                         op.addParameter(name='show', value=args.show)
                         op.addParameter(name='channels', value='1,')
                         op.addParameter(name='zmin', value=PARAM[param]['zmin'])
                         op.addParameter(name='zmax', value=PARAM[param]['zmax'])
                         op.addParameter(name='attr_data', value=PARAM[param]['name'], format='str')
                         op.addParameter(name='labels', value=[PARAM[param]['label']])
                         op.addParameter(name='save_code', value=param)
                         op.addParameter(name='cb_label', value=PARAM[param]['cb_label'])
                         op.addParameter(name='colormap', value=PARAM[param]['colormap'])
                     if axis[0] == '0':
                         path_fig = '/RHI{}km'.format(args.range)
                         op= proc.addOperation(name='WeatherRHI_vRF4_Plot')
                         op.addParameter(name='save', value=path_plots+path_fig, format='str')
                         op.addParameter(name='save_period', value=-1)
                         op.addParameter(name='show', value=args.show)
                         op.addParameter(name='channels', value='(1,)')
                         op.addParameter(name='zmin', value=PARAM[param]['zmin'])
                         op.addParameter(name='zmax', value=PARAM[param]['zmax'])
                         op.addParameter(name='attr_data', value=PARAM[param]['name'], format='str')
                         op.addParameter(name='labels', value=[PARAM[param]['label']])
                         op.addParameter(name='save_code', value=param)
                         op.addParameter(name='cb_label', value=PARAM[param]['cb_label'])
                         op.addParameter(name='colormap', value=PARAM[param]['colormap'])
                     if args.save:
                         opObj10 = proc.addOperation(name='HDFWriter')
                         opObj10.addParameter(name='path',value=path_save, format='str')
                         opObj10.addParameter(name='Reset',value=True)
                         opObj10.addParameter(name='blocksPerFile',value='1',format='int')
                         opObj10.addParameter(name='metadataList',value='heightList,data_azi,data_ele')
                         opObj10.addParameter(name='dataList',value='dataPP_POWER,utctime')
                 project.start()
             if __name__ == '__main__':
                 parser = argparse.ArgumentParser(description='Script to process SOPHy data.')
                 parser.add_argument('experiment',
                                     help='Experiment name')
                 parser.add_argument('--parameters', nargs='*', default=['P'],
                                     help='Variables to process: P, Z, V')
                 parser.add_argument('--time_offset', default=0,
                                     help='Fix time offset')
                 parser.add_argument('--range', default=0, type=int,
                                     help='Max range to plot')
                 parser.add_argument('--save', action='store_true',
                                     help='Create output files')
                 parser.add_argument('--show', action='store_true',
                                     help='Show matplotlib plot.')
                 args = parser.parse_args()
                 print (args)
                 main(args)

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