schain Commit - r1551:15bafdde09b9 · Jicamarca Repository

Fix zlimits when showprofile and flagSpreadF(Faraday) no needed

rflores -

r1551:15bafdde09b9

parent child

Context file:

r1551:15bafdde09b9

Collapse all files

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

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

             # Copyright (c) 2012-2020 Jicamarca Radio Observatory
             # All rights reserved.
             #
             # Distributed under the terms of the BSD 3-clause license.
             """Base class to create plot operations
             """
             import os
             import sys
             import zmq
             import time
             import numpy
             import datetime
             from collections import deque
             from functools import wraps
             from threading import Thread
             import matplotlib
             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.xlimits = kwargs.get('xlimits', None)
                     self.xstep_given = kwargs.get('xstep_given', None)
                     self.ystep_given = kwargs.get('ystep_given', None)
                     self.autoxticks = kwargs.get('autoxticks', True)
                     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.EEJtype = kwargs.get('EEJtype', 2)
                     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:
+                                if self.zlimits is not None:
+                                    self.zmin, self.zmax = self.zlimits[n]
                                 self.pf_axes[n].set_ylim(ymin, ymax)
-                                self.pf_axes[n].set_xlim(self.zmin[n], self.zmax[n])
+                                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_ylim(0, 90)
                             ax.set_yticks(numpy.arange(0, 90, 20))
                             ax.yaxis.labelpad = 40
                     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.data.max_time - self.save_time) <= self.save_period:
                         return
                     self.save_time = self.data.max_time
                     fig = self.figures[n]
                     if self.throttle == 0:
                         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'
                                     ),
                                 )
                             )
                         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,
                         #self.save_code,
                         '{}_{}.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)
+                    #print(last_time)
+                    #print(time.time())
+                    #exit(1)
                     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_spectra.py +18 -22

             # Copyright (c) 2012-2021 Jicamarca Radio Observatory
             # All rights reserved.
             #
             # Distributed under the terms of the BSD 3-clause license.
             """Classes to plot Spectra data
             """
             import os
             import numpy
             import collections.abc
             from schainpy.model.graphics.jroplot_base import Plot, plt, log
             class SpectraPlot(Plot):
                 '''
                 Plot for Spectra data
                 '''
                 CODE = 'spc'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 buffering = False
                 def setup(self):
                     self.nplots = len(self.data.channels)
                     self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
                     self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
                     self.height = 2.6 * self.nrows
                     self.cb_label = 'dB'
                     if self.showprofile:
                         self.width = 4 * self.ncols
                     else:
                         self.width = 3.5 * self.ncols
                     self.plots_adjust.update({'wspace': 0.8, 'hspace':0.2, 'left': 0.2, 'right': 0.9, 'bottom': 0.18})
                     self.ylabel = 'Range [km]'
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     spc = 10*numpy.log10(dataOut.data_spc/dataOut.normFactor)
                     #print("Spc: ",spc[0])
                     #exit(1)
                     data['spc'] = spc
                     data['rti'] = dataOut.getPower()
                     #print(data['rti'][0])
                     #exit(1)
                     #print("NormFactor: ",dataOut.normFactor)
                     #data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
                     if hasattr(dataOut, 'LagPlot'): #Double Pulse
                         max_hei_id = dataOut.nHeights - 2*dataOut.LagPlot
                         #data['noise'] = 10*numpy.log10(dataOut.getNoise(ymin_index=46,ymax_index=max_hei_id)/dataOut.normFactor)
                         #data['noise'] = 10*numpy.log10(dataOut.getNoise(ymin_index=40,ymax_index=max_hei_id)/dataOut.normFactor)
                         data['noise'] = 10*numpy.log10(dataOut.getNoise(ymin_index=53,ymax_index=max_hei_id)/dataOut.normFactor)
                         data['noise'][0] = 10*numpy.log10(dataOut.getNoise(ymin_index=53)[0]/dataOut.normFactor)
                         #data['noise'][1] = 22.035507
                     else:
                         data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
                     #data['noise'] = 10*numpy.log10(dataOut.getNoise(ymin_index=26,ymax_index=44)/dataOut.normFactor)
                     meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
                     if self.CODE == 'spc_moments':
                         data['moments'] = dataOut.moments
                     if self.CODE == 'gaussian_fit':
                         data['gaussfit'] = dataOut.DGauFitParams
                     return data, meta
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     if (self.CODE == 'spc_moments') | (self.CODE == 'gaussian_fit'):
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.yrange
                     self.y = y
                     data = self.data[-1]
                     z = data['spc']
                     self.CODE2 = 'spc_oblique'
-                    if not isinstance(self.zmin, collections.abc.Sequence):
-                        if not self.zmin:
-                            self.zmin = [numpy.min(self.z)]*len(self.axes)
-                        else:
-                            self.zmin = [self.zmin]*len(self.axes)
-                    if not isinstance(self.zmax, collections.abc.Sequence):
-                        if not self.zmax:
-                            self.zmax = [numpy.max(self.z)]*len(self.axes)
-                        else:
-                            self.zmax = [self.zmax]*len(self.axes)
                     for n, ax in enumerate(self.axes):
                         noise = data['noise'][n]
                         if self.CODE == 'spc_moments':
                             mean = data['moments'][n, 1]
                         if self.CODE == 'gaussian_fit':
                             gau0 = data['gaussfit'][n][2,:,0]
                             gau1 = data['gaussfit'][n][2,:,1]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else numpy.nanmin(x)#-self.xmax
                             #self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
                             #self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
+                            if self.zlimits is not None:
+                                self.zmin, self.zmax = self.zlimits[n]
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
-                                                   vmin=self.zmin[n],
+                                                   vmin=self.zmin,
-                                                   vmax=self.zmax[n],
+                                                   vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap),
                                                    )
                             if self.showprofile:
                                 ax.plt_profile = self.pf_axes[n].plot(
                                     data['rti'][n], y)[0]
                                 ax.plt_noise = self.pf_axes[n].plot(numpy.repeat(noise, len(y)), y,
                                                                     color="k", linestyle="dashed", lw=1)[0]
                             if self.CODE == 'spc_moments':
                                 ax.plt_mean = ax.plot(mean, y, color='k', lw=1)[0]
                             if self.CODE == 'gaussian_fit':
                                 ax.plt_gau0 = ax.plot(gau0, y, color='r', lw=1)[0]
                                 ax.plt_gau1 = ax.plot(gau1, y, color='y', lw=1)[0]
                         else:
+                            if self.zlimits is not None:
+                                self.zmin, self.zmax = self.zlimits[n]
                             ax.plt.set_array(z[n].T.ravel())
                             if self.showprofile:
                                 ax.plt_profile.set_data(data['rti'][n], y)
                                 ax.plt_noise.set_data(numpy.repeat(noise, len(y)), y)
                             if self.CODE == 'spc_moments':
                                 ax.plt_mean.set_data(mean, y)
                             if self.CODE == 'gaussian_fit':
                                 ax.plt_gau0.set_data(gau0, y)
                                 ax.plt_gau1.set_data(gau1, y)
                         self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
             class SpectraObliquePlot(Plot):
                 '''
                 Plot for Spectra data
                 '''
                 CODE = 'spc_oblique'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 def setup(self):
                     self.xaxis = "oblique"
                     self.nplots = len(self.data.channels)
                     self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
                     self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
                     self.height = 2.6 * self.nrows
                     self.cb_label = 'dB'
                     if self.showprofile:
                         self.width = 4 * self.ncols
                     else:
                         self.width = 3.5 * self.ncols
                     self.plots_adjust.update({'wspace': 0.8, 'hspace':0.2, 'left': 0.2, 'right': 0.9, 'bottom': 0.18})
                     self.ylabel = 'Range [km]'
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     spc = 10*numpy.log10(dataOut.data_spc/dataOut.normFactor)
                     data['spc'] = spc
                     data['rti'] = dataOut.getPower()
                     data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
                     meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
                     '''
                     data['shift1'] = dataOut.Oblique_params[0,-2,:]
                     data['shift2'] = dataOut.Oblique_params[0,-1,:]
                     data['shift1_error'] = dataOut.Oblique_param_errors[0,-2,:]
                     data['shift2_error'] = dataOut.Oblique_param_errors[0,-1,:]
                     '''
                     '''
                     data['shift1'] = dataOut.Oblique_params[0,1,:]
                     data['shift2'] = dataOut.Oblique_params[0,4,:]
                     data['shift1_error'] = dataOut.Oblique_param_errors[0,1,:]
                     data['shift2_error'] = dataOut.Oblique_param_errors[0,4,:]
                     '''
                     data['shift1'] = dataOut.Dop_EEJ_T1[0]
                     data['shift2'] = dataOut.Dop_EEJ_T2[0]
                     data['shift1_error'] = dataOut.Err_Dop_EEJ_T1[0]
                     data['shift2_error'] = dataOut.Err_Dop_EEJ_T2[0]
                     return data, meta
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.yrange
                     self.y = y
                     data = self.data[-1]
                     z = data['spc']
                     for n, ax in enumerate(self.axes):
                         noise = self.data['noise'][n][-1]
                         shift1 = data['shift1']
                         #print(shift1)
                         shift2 = data['shift2']
                         err1 = data['shift1_error']
                         err2 = data['shift2_error']
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
                                 ax.plt_profile = self.pf_axes[n].plot(
                                     self.data['rti'][n][-1], y)[0]
                                 ax.plt_noise = self.pf_axes[n].plot(numpy.repeat(noise, len(y)), y,
                                                                     color="k", linestyle="dashed", lw=1)[0]
                             self.ploterr1 = ax.errorbar(shift1, y, xerr=err1, fmt='k^', elinewidth=2.2, marker='o', linestyle='None',markersize=2.5,capsize=0.3,markeredgewidth=0.2)
                             self.ploterr2 = ax.errorbar(shift2, y, xerr=err2, fmt='m^',elinewidth=2.2,marker='o',linestyle='None',markersize=2.5,capsize=0.3,markeredgewidth=0.2)
                             #print("plotter1: ", self.ploterr1,shift1)
                         else:
                             #print("else plotter1: ", self.ploterr1,shift1)
                             self.ploterr1.remove()
                             self.ploterr2.remove()
                             ax.plt.set_array(z[n].T.ravel())
                             if self.showprofile:
                                 ax.plt_profile.set_data(self.data['rti'][n][-1], y)
                                 ax.plt_noise.set_data(numpy.repeat(noise, len(y)), y)
                             self.ploterr1 = ax.errorbar(shift1, y, xerr=err1, fmt='k^', elinewidth=2.2, marker='o', linestyle='None',markersize=2.5,capsize=0.3,markeredgewidth=0.2)
                             self.ploterr2 = ax.errorbar(shift2, y, xerr=err2, fmt='m^',elinewidth=2.2,marker='o',linestyle='None',markersize=2.5,capsize=0.3,markeredgewidth=0.2)
                         self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
             class CrossSpectraPlot(Plot):
                 CODE = 'cspc'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 zmin_coh = None
                 zmax_coh = None
                 zmin_phase = None
                 zmax_phase = None
                 def setup(self):
                     self.ncols = 4
                     self.nplots = len(self.data.pairs) * 2
                     self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
                     self.width = 3.1 * self.ncols
                     self.height = 5 * self.nrows
                     self.ylabel = 'Range [km]'
                     self.showprofile = False
                     self.plots_adjust.update({'left': 0.08, 'right': 0.92, 'wspace': 0.5, 'hspace':0.4, 'top':0.95, 'bottom': 0.08})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     spc = dataOut.data_spc
                     cspc = dataOut.data_cspc
                     meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
                     meta['pairs'] = dataOut.pairsList
                     tmp = []
                     for n, pair in enumerate(meta['pairs']):
                         out = cspc[n] / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
                         coh = numpy.abs(out)
                         phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
                         tmp.append(coh)
                         tmp.append(phase)
                     data['cspc'] = numpy.array(tmp)
                     return data, meta
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.yrange
                     self.y = y
                     data = self.data[-1]
                     cspc = data['cspc']
                     for n in range(len(self.data.pairs)):
                         pair = self.data.pairs[n]
                         coh = cspc[n*2]
                         phase = cspc[n*2+1]
                         ax = self.axes[2 * n]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, coh.T,
                                                    vmin=0,
                                                    vmax=1,
                                                    cmap=plt.get_cmap(self.colormap_coh)
                                                    )
                         else:
                             ax.plt.set_array(coh.T.ravel())
                         self.titles.append(
                             'Coherence Ch{} * Ch{}'.format(pair[0], pair[1]))
                         ax = self.axes[2 * n + 1]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, phase.T,
                                                    vmin=-180,
                                                    vmax=180,
                                                    cmap=plt.get_cmap(self.colormap_phase)
                                                    )
                         else:
                             ax.plt.set_array(phase.T.ravel())
                         self.titles.append('Phase CH{} * CH{}'.format(pair[0], pair[1]))
             class CrossSpectra4Plot(Plot):
                 CODE = 'cspc'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 zmin_coh = None
                 zmax_coh = None
                 zmin_phase = None
                 zmax_phase = None
                 def setup(self):
                     self.ncols = 4
                     self.nrows = len(self.data.pairs)
                     self.nplots = self.nrows * 4
                     self.width = 3.1 * self.ncols
                     self.height = 5 * self.nrows
                     self.ylabel = 'Range [km]'
                     self.showprofile = False
                     self.plots_adjust.update({'left': 0.08, 'right': 0.92, 'wspace': 0.5, 'hspace':0.4, 'top':0.95, 'bottom': 0.08})
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.heights
                     self.y = y
                     nspc = self.data['spc']
                     #print(numpy.shape(self.data['spc']))
                     spc = self.data['cspc'][0]
                     #print(numpy.shape(nspc))
                     #exit()
                     #nspc[1,:,:] = numpy.flip(nspc[1,:,:],axis=0)
                     #print(numpy.shape(spc))
                     #exit()
                     cspc = self.data['cspc'][1]
                     #xflip=numpy.flip(x)
                     #print(numpy.shape(cspc))
                     #exit()
                     for n in range(self.nrows):
                         noise = self.data['noise'][:,-1]
                         pair = self.data.pairs[n]
                         #print(pair)
                         #exit()
                         ax = self.axes[4 * n]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(nspc)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(nspc)
                             ax.plt = ax.pcolormesh(x , y , nspc[pair[0]].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             #print(numpy.shape(nspc[pair[0]].T))
                             #exit()
                             ax.plt.set_array(nspc[pair[0]].T.ravel())
                         self.titles.append('CH {}: {:3.2f}dB'.format(pair[0], noise[pair[0]]))
                         ax = self.axes[4 * n + 1]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x , y, numpy.flip(nspc[pair[1]],axis=0).T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(numpy.flip(nspc[pair[1]],axis=0).T.ravel())
                         self.titles.append('CH {}: {:3.2f}dB'.format(pair[1], noise[pair[1]]))
                         out = cspc[n] / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
                         coh = numpy.abs(out)
                         phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
                         ax = self.axes[4 * n + 2]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, numpy.flip(coh,axis=0).T,
                                                    vmin=0,
                                                    vmax=1,
                                                    cmap=plt.get_cmap(self.colormap_coh)
                                                    )
                         else:
                             ax.plt.set_array(numpy.flip(coh,axis=0).T.ravel())
                         self.titles.append(
                             'Coherence Ch{} * Ch{}'.format(pair[0], pair[1]))
                         ax = self.axes[4 * n + 3]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, numpy.flip(phase,axis=0).T,
                                                    vmin=-180,
                                                    vmax=180,
                                                    cmap=plt.get_cmap(self.colormap_phase)
                                                    )
                         else:
                             ax.plt.set_array(numpy.flip(phase,axis=0).T.ravel())
                         self.titles.append('Phase CH{} * CH{}'.format(pair[0], pair[1]))
             class CrossSpectra2Plot(Plot):
                 CODE = 'cspc'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 zmin_coh = None
                 zmax_coh = None
                 zmin_phase = None
                 zmax_phase = None
                 def setup(self):
                     self.ncols = 1
                     self.nrows = len(self.data.pairs)
                     self.nplots = self.nrows * 1
                     self.width = 3.1 * self.ncols
                     self.height = 5 * self.nrows
                     self.ylabel = 'Range [km]'
                     self.showprofile = False
                     self.plots_adjust.update({'left': 0.22, 'right': .90, 'wspace': 0.5, 'hspace':0.4, 'top':0.95, 'bottom': 0.08})
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.heights
                     self.y = y
                     #nspc = self.data['spc']
                     #print(numpy.shape(self.data['spc']))
                     #spc = self.data['cspc'][0]
                     #print(numpy.shape(spc))
                     #exit()
                     cspc = self.data['cspc'][1]
                     #print(numpy.shape(cspc))
                     #exit()
                     for n in range(self.nrows):
                         noise = self.data['noise'][:,-1]
                         pair = self.data.pairs[n]
                         #print(pair)            #exit()
                         out = cspc[n]# / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
                         #print(out[:,53])
                         #exit()
                         cross = numpy.abs(out)
                         z = cross/self.data.nFactor
                         #print("here")
                         #print(dataOut.data_spc[0,0,0])
                         #exit()
                         cross = 10*numpy.log10(z)
                         #print(numpy.shape(cross))
                         #print(cross[0,:])
                         #print(self.data.nFactor)
                         #exit()
                         #phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
                         ax = self.axes[1 * n]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(cross)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(cross)
                             ax.plt = ax.pcolormesh(x, y, cross.T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(cross.T.ravel())
                         self.titles.append(
                             'Cross Spectra Power Ch{} * Ch{}'.format(pair[0], pair[1]))
             class CrossSpectra3Plot(Plot):
                 CODE = 'cspc'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 zmin_coh = None
                 zmax_coh = None
                 zmin_phase = None
                 zmax_phase = None
                 def setup(self):
                     self.ncols = 3
                     self.nrows = len(self.data.pairs)
                     self.nplots = self.nrows * 3
                     self.width = 3.1 * self.ncols
                     self.height = 5 * self.nrows
                     self.ylabel = 'Range [km]'
                     self.showprofile = False
                     self.plots_adjust.update({'left': 0.22, 'right': .90, 'wspace': 0.5, 'hspace':0.4, 'top':0.95, 'bottom': 0.08})
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.heights
                     self.y = y
                     #nspc = self.data['spc']
                     #print(numpy.shape(self.data['spc']))
                     #spc = self.data['cspc'][0]
                     #print(numpy.shape(spc))
                     #exit()
                     cspc = self.data['cspc'][1]
                     #print(numpy.shape(cspc))
                     #exit()
                     for n in range(self.nrows):
                         noise = self.data['noise'][:,-1]
                         pair = self.data.pairs[n]
                         #print(pair)            #exit()
                         out = cspc[n]# / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
                         #print(out[:,53])
                         #exit()
                         cross = numpy.abs(out)
                         z = cross/self.data.nFactor
                         cross = 10*numpy.log10(z)
                         out_r= out.real/self.data.nFactor
                         #out_r = 10*numpy.log10(out_r)
                         out_i= out.imag/self.data.nFactor
                         #out_i = 10*numpy.log10(out_i)
                         #print(numpy.shape(cross))
                         #print(cross[0,:])
                         #print(self.data.nFactor)
                         #exit()
                         #phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
                         ax = self.axes[3 * n]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(cross)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(cross)
                             ax.plt = ax.pcolormesh(x, y, cross.T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(cross.T.ravel())
                         self.titles.append(
                             'Cross Spectra Power Ch{} * Ch{}'.format(pair[0], pair[1]))
                         ax = self.axes[3 * n + 1]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(cross)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(cross)
                             ax.plt = ax.pcolormesh(x, y, out_r.T,
                                                    vmin=-1.e6,
                                                    vmax=0,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(out_r.T.ravel())
                         self.titles.append(
                             'Cross Spectra Real Ch{} * Ch{}'.format(pair[0], pair[1]))
                         ax = self.axes[3 * n + 2]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(cross)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(cross)
                             ax.plt = ax.pcolormesh(x, y, out_i.T,
                                                    vmin=-1.e6,
                                                    vmax=1.e6,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(out_i.T.ravel())
                         self.titles.append(
                             'Cross Spectra Imag Ch{} * Ch{}'.format(pair[0], pair[1]))
             class RTIPlot(Plot):
                 '''
                 Plot for RTI data
                 '''
                 CODE = 'rti'
                 colormap = 'jet'
                 plot_type = 'pcolorbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = len(self.data.channels)
                     self.nplots = len(self.data.channels)
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Time'
                     self.cb_label = 'dB'
                     self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.1, 'right':0.95})
                     self.titles = ['{} Channel {}'.format(
                         self.CODE.upper(), x) for x in range(self.nrows)]
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['rti'] = dataOut.getPower()
                     #print(numpy.shape(data['rti']))
                     data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
                     return data, meta
                 def plot(self):
                     self.x = self.data.times
                     self.y = self.data.yrange
                     self.z = self.data[self.CODE]
                     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())
+                    '''
                     if not isinstance(self.zmin, collections.abc.Sequence):
                         if not self.zmin:
                             self.zmin = [numpy.min(self.z)]*len(self.axes)
                         else:
                             self.zmin = [self.zmin]*len(self.axes)
                     if not isinstance(self.zmax, collections.abc.Sequence):
                         if not self.zmax:
                             self.zmax = [numpy.max(self.z)]*len(self.axes)
                         else:
                             self.zmax = [self.zmax]*len(self.axes)
+                            '''
                     for n, ax in enumerate(self.axes):
-                        #self.zmin = self.zmin if self.zmin else numpy.min(self.z)
+                        self.zmin = self.zmin if self.zmin else numpy.min(self.z)
-                        #self.zmax = self.zmax if self.zmax else numpy.max(self.z)
+                        self.zmax = self.zmax if self.zmax else numpy.max(self.z)
                         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,
-                                                   vmin=self.zmin[n],
+                                                   vmin=self.zmin,
-                                                   vmax=self.zmax[n],
+                                                   vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
                                 ax.plot_profile = self.pf_axes[n].plot(
                                     self.data['rti'][n][-1], self.y)[0]
                                 ax.plot_noise = self.pf_axes[n].plot(numpy.repeat(self.data['noise'][n][-1], len(self.y)), self.y,
                                                                      color="k", linestyle="dashed", lw=1)[0]
                         else:
+                            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,
-                                                   vmin=self.zmin[n],
+                                                   vmin=self.zmin,
-                                                   vmax=self.zmax[n],
+                                                   vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
                                 ax.plot_profile.set_data(self.data['rti'][n][-1], self.y)
                                 ax.plot_noise.set_data(numpy.repeat(
                                     self.data['noise'][n][-1], len(self.y)), self.y)
             class SpectrogramPlot(Plot):
                 '''
                 Plot for Spectrogram data
                 '''
                 CODE = 'Spectrogram_Profile'
                 colormap = 'binary'
                 plot_type = 'pcolorbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = len(self.data.channels)
                     self.nplots = len(self.data.channels)
                     self.xlabel = 'Time'
                     #self.cb_label = 'dB'
                     self.plots_adjust.update({'hspace':1.2, 'left': 0.1, 'bottom': 0.12, 'right':0.95})
                     self.titles = []
                     #self.titles = ['{} Channel {} \n H = {} km ({} - {})'.format(
                         #self.CODE.upper(), x, self.data.heightList[self.data.hei], self.data.heightList[self.data.hei],self.data.heightList[self.data.hei]+(self.data.DH*self.data.nProfiles)) for x in range(self.nrows)]
                     self.titles = ['{} Channel {}'.format(
                         self.CODE.upper(), x) for x in range(self.nrows)]
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     maxHei = 1620#+12000
                     indb = numpy.where(dataOut.heightList <= maxHei)
                     hei = indb[0][-1]
                     #print(dataOut.heightList)
                     factor = dataOut.nIncohInt
                     z = dataOut.data_spc[:,:,hei] / factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     #buffer = 10 * numpy.log10(z)
                     meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
                     #self.hei = hei
                     #self.heightList = dataOut.heightList
                     #self.DH = (dataOut.heightList[1] - dataOut.heightList[0])/dataOut.step
                     #self.nProfiles = dataOut.nProfiles
                     data['Spectrogram_Profile'] = 10 * numpy.log10(z)
                     data['hei'] = hei
                     data['DH'] = (dataOut.heightList[1] - dataOut.heightList[0])/dataOut.step
                     data['nProfiles'] = dataOut.nProfiles
                     #meta['yrange'] = dataOut.heightList[0:dataOut.NSHTS]
                     '''
                     import matplotlib.pyplot as plt
                     plt.plot(10 * numpy.log10(z[0,:]))
                     plt.show()
                     from time import sleep
                     sleep(10)
                     '''
                     return data, meta
                 def plot(self):
                     self.x = self.data.times
                     self.z = self.data[self.CODE]
                     self.y = self.data.xrange[0]
                     hei = self.data['hei'][-1]
                     DH = self.data['DH'][-1]
                     nProfiles = self.data['nProfiles'][-1]
                     self.ylabel = "Frequency (kHz)"
                     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.zmin = self.zmin if self.zmin else numpy.min(self.z)
                         self.zmax = self.zmax if self.zmax else numpy.max(self.z)
                         data = self.data[-1]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.collections.remove(ax.collections[0])
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                     #self.titles.append('Spectrogram')
                     #self.titles.append('{} Channel {} \n H = {} km ({} - {})'.format(
                         #self.CODE.upper(), x, y[hei], y[hei],y[hei]+(DH*nProfiles)))
             class CoherencePlot(RTIPlot):
                 '''
                 Plot for Coherence data
                 '''
                 CODE = 'coh'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = len(self.data.pairs)
                     self.nplots = len(self.data.pairs)
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Time'
                     self.plots_adjust.update({'hspace':0.6, 'left': 0.1, 'bottom': 0.1,'right':0.95})
                     if self.CODE == 'coh':
                         self.cb_label = ''
                         self.titles = [
                             'Coherence Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
                     else:
                         self.cb_label = 'Degrees'
                         self.titles = [
                             'Phase Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['coh'] = dataOut.getCoherence()
                     meta['pairs'] = dataOut.pairsList
                     return data, meta
             class PhasePlot(CoherencePlot):
                 '''
                 Plot for Phase map data
                 '''
                 CODE = 'phase'
                 colormap = 'seismic'
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['phase'] = dataOut.getCoherence(phase=True)
                     meta['pairs'] = dataOut.pairsList
                     return data, meta
             class NoisePlot(Plot):
                 '''
                 Plot for noise
                 '''
                 CODE = 'noise'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Intensity [dB]'
                     self.xlabel = 'Time'
                     self.titles = ['Noise']
                     self.colorbar = False
                     self.plots_adjust.update({'right': 0.85 })
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor).reshape(dataOut.nChannels, 1)
                     meta['yrange'] = numpy.array([])
                     return data, meta
                 def plot(self):
                     x = self.data.times
                     xmin = self.data.min_time
                     xmax = xmin + self.xrange * 60 * 60
                     Y = self.data['noise']
                     if self.axes[0].firsttime:
                         self.ymin = numpy.nanmin(Y) - 5
                         self.ymax = numpy.nanmax(Y) + 5
                         for ch in self.data.channels:
                             y = Y[ch]
                             self.axes[0].plot(x, y, lw=1, label='Ch{}'.format(ch))
                         plt.legend(bbox_to_anchor=(1.18, 1.0))
                     else:
                         for ch in self.data.channels:
                             y = Y[ch]
                             self.axes[0].lines[ch].set_data(x, y)
                     self.ymin = numpy.nanmin(Y) - 5
                     self.ymax = numpy.nanmax(Y) + 10
             class PowerProfilePlot(Plot):
                 CODE = 'pow_profile'
                 plot_type = 'scatter'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.height = 4
                     self.width = 3
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Intensity [dB]'
                     self.titles = ['Power Profile']
                     self.colorbar = False
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data[self.CODE] = dataOut.getPower()
                     return data, meta
                 def plot(self):
                     y = self.data.yrange
                     self.y = y
                     x = self.data[-1][self.CODE]
                     if self.xmin is None: self.xmin = numpy.nanmin(x)*0.9
                     if self.xmax is None: self.xmax = numpy.nanmax(x)*1.1
                     if self.axes[0].firsttime:
                         for ch in self.data.channels:
                             self.axes[0].plot(x[ch], y, lw=1, label='Ch{}'.format(ch))
                         plt.legend()
                     else:
                         for ch in self.data.channels:
                             self.axes[0].lines[ch].set_data(x[ch], y)
             class SpectraCutPlot(Plot):
                 CODE = 'spc_cut'
                 plot_type = 'scatter'
                 buffering = False
                 def setup(self):
                     self.nplots = len(self.data.channels)
                     self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
                     self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
                     self.width = 3.4 * self.ncols + 1.5
                     self.height = 3 * self.nrows
                     self.ylabel = 'Power [dB]'
                     self.colorbar = False
                     self.plots_adjust.update({'left':0.1, 'hspace':0.3, 'right': 0.75, 'bottom':0.08})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     spc = 10*numpy.log10(dataOut.data_spc/dataOut.normFactor)
                     data['spc'] = spc
                     meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
                     if self.CODE == 'cut_gaussian_fit':
                         data['gauss_fit0'] = 10*numpy.log10(dataOut.GaussFit0/dataOut.normFactor)
                         data['gauss_fit1'] = 10*numpy.log10(dataOut.GaussFit1/dataOut.normFactor)
                     return data, meta
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0][1:]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2][:-1]
                         self.xlabel = "Velocity (m/s)"
                     if self.CODE == 'cut_gaussian_fit':
                         x = self.data.xrange[2][:-1]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.yrange
                     data = self.data[-1]
                     z = data['spc']
                     if self.height_index:
                         index = numpy.array(self.height_index)
                     else:
                         index = numpy.arange(0, len(y), int((len(y))/9))
                     for n, ax in enumerate(self.axes):
                         if self.CODE == 'cut_gaussian_fit':
                             gau0 = data['gauss_fit0']
                             gau1 = data['gauss_fit1']
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.ymin = self.ymin if self.ymin else numpy.nanmin(z[:,:,index])
                             self.ymax = self.ymax if self.ymax else numpy.nanmax(z[:,:,index])
                             #print(self.ymax)
                             #print(z[n, :, index])
                             ax.plt = ax.plot(x, z[n, :, index].T, lw=0.25)
                             if self.CODE == 'cut_gaussian_fit':
                                 ax.plt_gau0 = ax.plot(x, gau0[n, :, index].T, lw=1, linestyle='-.')
                                 for i, line in enumerate(ax.plt_gau0):
                                     line.set_color(ax.plt[i].get_color())
                                 ax.plt_gau1 = ax.plot(x, gau1[n, :, index].T, lw=1, linestyle='--')
                                 for i, line in enumerate(ax.plt_gau1):
                                     line.set_color(ax.plt[i].get_color())
                             labels = ['Range = {:2.1f}km'.format(y[i]) for i in index]
                             self.figures[0].legend(ax.plt, labels, loc='center right')
                         else:
                             for i, line in enumerate(ax.plt):
                                 line.set_data(x, z[n, :, index[i]].T)
                             for i, line in enumerate(ax.plt_gau0):
                                 line.set_data(x, gau0[n, :, index[i]].T)
                                 line.set_color(ax.plt[i].get_color())
                             for i, line in enumerate(ax.plt_gau1):
                                 line.set_data(x, gau1[n, :, index[i]].T)
                                 line.set_color(ax.plt[i].get_color())
                         self.titles.append('CH {}'.format(n))
             class BeaconPhase(Plot):
                 __isConfig = None
                 __nsubplots = None
                 PREFIX = 'beacon_phase'
                 def __init__(self):
                     Plot.__init__(self)
                     self.timerange = 24*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.counter_imagwr = 0
                     self.WIDTH = 800
                     self.HEIGHT = 400
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.xdata = None
                     self.ydata = None
                     self.PLOT_CODE = BEACON_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.filename_phase = None
                     self.figfile = None
                     self.xmin = None
                     self.xmax = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 7
                     colspan = 6
                     self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH+self.WIDTHPROF,
                                       heightplot = self.HEIGHT+self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
                 def save_phase(self, filename_phase):
                     f = open(filename_phase,'w+')
                     f.write('\n\n')
                     f.write('JICAMARCA RADIO OBSERVATORY - Beacon Phase \n')
                     f.write('DD MM YYYY  HH MM SS   pair(2,0) pair(2,1) pair(2,3) pair(2,4)\n\n' )
                     f.close()
                 def save_data(self, filename_phase, data, data_datetime):
                     f=open(filename_phase,'a')
                     timetuple_data = data_datetime.timetuple()
                     day = str(timetuple_data.tm_mday)
                     month = str(timetuple_data.tm_mon)
                     year = str(timetuple_data.tm_year)
                     hour = str(timetuple_data.tm_hour)
                     minute = str(timetuple_data.tm_min)
                     second = str(timetuple_data.tm_sec)
                     f.write(day+' '+month+' '+year+'  '+hour+' '+minute+' '+second+'   '+str(data[0])+'   '+str(data[1])+'   '+str(data[2])+'   '+str(data[3])+'\n')
                     f.close()
                 def plot(self):
                     log.warning('TODO: Not yet implemented...')
                 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None, hmin=None, hmax=None,
                         timerange=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     if dataOut.flagNoData:
                         return dataOut
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                         return
                     if pairsList == None:
                         pairsIndexList = dataOut.pairsIndexList[:10]
                     else:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in dataOut.pairsList:
                                 raise ValueError("Pair %s is not in dataOut.pairsList" %(pair))
                             pairsIndexList.append(dataOut.pairsList.index(pair))
                     if pairsIndexList == []:
                         return
              #         if len(pairsIndexList) > 4:
              #             pairsIndexList = pairsIndexList[0:4]
                     hmin_index = None
                     hmax_index = None
                     if hmin != None and hmax != None:
                         indexes = numpy.arange(dataOut.nHeights)
                         hmin_list = indexes[dataOut.heightList >= hmin]
                         hmax_list = indexes[dataOut.heightList <= hmax]
                         if hmin_list.any():
                             hmin_index = hmin_list[0]
                         if hmax_list.any():
                             hmax_index = hmax_list[-1]+1
                     x = dataOut.getTimeRange()
                     thisDatetime = dataOut.datatime
                     title = wintitle + " Signal Phase" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = "Local Time"
                     ylabel = "Phase (degrees)"
                     update_figfile = False
                     nplots = len(pairsIndexList)
                     #phase = numpy.zeros((len(pairsIndexList),len(dataOut.beacon_heiIndexList)))
                     phase_beacon = numpy.zeros(len(pairsIndexList))
                     for i in range(nplots):
                         pair = dataOut.pairsList[pairsIndexList[i]]
                         ccf = numpy.average(dataOut.data_cspc[pairsIndexList[i], :, hmin_index:hmax_index], axis=0)
                         powa = numpy.average(dataOut.data_spc[pair[0], :, hmin_index:hmax_index], axis=0)
                         powb = numpy.average(dataOut.data_spc[pair[1], :, hmin_index:hmax_index], axis=0)
                         avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
                         phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
                         if dataOut.beacon_heiIndexList:
                             phase_beacon[i] = numpy.average(phase[dataOut.beacon_heiIndexList])
                         else:
                             phase_beacon[i] = numpy.average(phase)
                     if not self.isConfig:
                         nplots = len(pairsIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = 0
                         if ymax == None: ymax = 360
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         self.xdata = numpy.array([])
                         self.ydata = numpy.array([])
                         update_figfile = True
                         #open file beacon phase
                         path = '%s%03d' %(self.PREFIX, self.id)
                         beacon_file = os.path.join(path,'%s.txt'%self.name)
                         self.filename_phase = os.path.join(figpath,beacon_file)
                         #self.save_phase(self.filename_phase)
                     #store data beacon phase
                     #self.save_data(self.filename_phase, phase_beacon, thisDatetime)
                     self.setWinTitle(title)
                     title = "Phase Plot %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                     legendlabels = ["Pair (%d,%d)"%(pair[0], pair[1]) for pair in dataOut.pairsList]
                     axes = self.axesList[0]
                     self.xdata = numpy.hstack((self.xdata, x[0:1]))
                     if len(self.ydata)==0:
                         self.ydata = phase_beacon.reshape(-1,1)
                     else:
                         self.ydata = numpy.hstack((self.ydata, phase_beacon.reshape(-1,1)))
                     axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
                                 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
                                 XAxisAsTime=True, grid='both'
                                 )
                     self.draw()
                     if dataOut.ltctime >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
                     return dataOut

schainpy/model/graphics/jroplot_voltage_lags.py +10 -22

             import os
             import time
             import math
             import datetime
             import numpy
             import collections.abc
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator  #YONG
             from .jroplot_spectra import RTIPlot, NoisePlot
             from schainpy.utils import log
             from .plotting_codes import *
             from schainpy.model.graphics.jroplot_base import Plot, plt
             import matplotlib.pyplot as plt
             import matplotlib.colors as colors
             from matplotlib.ticker import MultipleLocator
             class RTIDPPlot(RTIPlot):
                 '''Plot for RTI Double Pulse Experiment
                 '''
                 CODE = 'RTIDP'
                 colormap = 'jet'
                 plot_name = 'RTI'
                 plot_type = 'pcolorbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = 3
                     self.nplots = self.nrows
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Time (LT)'
                     self.cb_label = 'Intensity (dB)'
                     self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.1, 'right':0.95})
                     self.titles = ['{} Channel {}'.format(
                         self.plot_name.upper(), '0x1'),'{} Channel {}'.format(
                             self.plot_name.upper(), '0'),'{} Channel {}'.format(
                                 self.plot_name.upper(), '1')]
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['rti'] = dataOut.data_for_RTI_DP
                     data['NDP'] = dataOut.NDP
                     return data, meta
                 def plot(self):
                     NDP = self.data['NDP'][-1]
                     self.x = self.data.times
                     self.y = self.data.yrange[0:NDP]
                     self.z = self.data['rti']
                     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[1][0,12:40])
                         self.zmin = self.zmin if self.zmin is not None else numpy.min(
                             self.z[1][0,12:40])
                         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,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         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,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
             class RTILPPlot(RTIPlot):
                 '''
                    Plot for RTI Long Pulse
                 '''
                 CODE = 'RTILP'
                 colormap = 'jet'
                 plot_name = 'RTI LP'
                 plot_type = 'pcolorbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = 2
                     self.nplots = self.nrows
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Time (LT)'
                     self.cb_label = 'Intensity (dB)'
                     self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.1, 'right':0.95})
                     self.titles = ['{} Channel {}'.format(
                         self.plot_name.upper(), '0'),'{} Channel {}'.format(
                             self.plot_name.upper(), '1'),'{} Channel {}'.format(
                                 self.plot_name.upper(), '2'),'{} Channel {}'.format(
                                     self.plot_name.upper(), '3')]
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['rti'] = dataOut.data_for_RTI_LP
                     data['NRANGE'] = dataOut.NRANGE
                     return data, meta
                 def plot(self):
                     NRANGE = self.data['NRANGE'][-1]
                     self.x = self.data.times
                     self.y = self.data.yrange[0:NRANGE]
                     self.z = self.data['rti']
                     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())
-                    if not isinstance(self.zmin, collections.abc.Sequence):
-                        if not self.zmin:
-                            self.zmin = [numpy.min(self.z)]*len(self.axes)
-                        else:
-                            self.zmin = [self.zmin]*len(self.axes)
-                    if not isinstance(self.zmax, collections.abc.Sequence):
-                        if not self.zmax:
-                            self.zmax = [numpy.max(self.z)]*len(self.axes)
-                        else:
-                            self.zmax = [self.zmax]*len(self.axes)
                     for n, ax in enumerate(self.axes):
-                        #self.zmax = self.zmax if self.zmax is not None else numpy.max(
+                        self.zmax = self.zmax if self.zmax is not None else numpy.max(
-                            #self.z[1][0,12:40])
+                            self.z[1][0,12:40])
-                        #self.zmin = self.zmin if self.zmin is not None else numpy.min(
+                        self.zmin = self.zmin if self.zmin is not None else numpy.min(
-                            #self.z[1][0,12:40])
+                            self.z[1][0,12:40])
                         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,
-                                                   vmin=self.zmin[n],
+                                                   vmin=self.zmin,
-                                                   vmax=self.zmax[n],
+                                                   vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
-                            #if self.zlimits is not None:
+                            if self.zlimits is not None:
-                                #self.zmin, self.zmax = self.zlimits[n]
+                                self.zmin, self.zmax = self.zlimits[n]
                             ax.collections.remove(ax.collections[0])
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
-                                                   vmin=self.zmin[n],
+                                                   vmin=self.zmin,
-                                                   vmax=self.zmax[n],
+                                                   vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
             class DenRTIPlot(RTIPlot):
                 '''
                    Plot for Den
                 '''
                 CODE = 'denrti'
                 colormap = 'jet'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = self.data.shape(self.CODE)[0]
                     self.nplots = self.nrows
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Time (LT)'
                     self.plots_adjust.update({'wspace': 0.8, 'hspace':0.2, 'left': 0.2, 'right': 0.9, 'bottom': 0.18})
                     if self.CODE == 'denrti':
                         self.cb_label = r'$\mathrm{N_e}$ Electron Density ($\mathrm{1/cm^3}$)'
                     self.titles = ['Electron Density RTI']
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['denrti'] = dataOut.DensityFinal*1.e-6 #To Plot in cm^-3
                     return data, meta
                 def plot(self):
                     self.x = self.data.times
                     self.y = self.data.yrange
                     self.z = self.data[self.CODE]
                     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]
                             if numpy.log10(self.zmin)<0:
                                 self.zmin=1
                             ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n],
                                                    norm=colors.LogNorm()
                                                    )
                         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],
                                                    norm=colors.LogNorm()
                                                    )
             class ETempRTIPlot(RTIPlot):
                 '''
                    Plot for Electron Temperature
                 '''
                 CODE = 'ETemp'
                 colormap = 'jet'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = self.data.shape(self.CODE)[0]
                     self.nplots = self.nrows
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Time (LT)'
                     self.plots_adjust.update({'wspace': 0.8, 'hspace':0.2, 'left': 0.2, 'right': 0.9, 'bottom': 0.18})
                     if self.CODE == 'ETemp':
                         self.cb_label = 'Electron Temperature (K)'
                         self.titles = ['Electron Temperature RTI']
                     if self.CODE == 'ITemp':
                         self.cb_label = 'Ion Temperature (K)'
                         self.titles = ['Ion Temperature RTI']
                     if self.CODE == 'HeFracLP':
                         self.cb_label='He+ Fraction'
                         self.titles = ['He+ Fraction RTI']
                         self.zmax=0.16
                     if self.CODE== 'HFracLP':
                         self.cb_label='H+ Fraction'
                         self.titles = ['H+ Fraction RTI']
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['ETemp'] = dataOut.ElecTempFinal
                     return data, meta
                 def plot(self):
                     self.x = self.data.times
                     self.y = self.data.yrange
                     self.z = self.data[self.CODE]
                     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]
                                                    )
                             #plt.tight_layout()
                         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 ITempRTIPlot(ETempRTIPlot):
                 '''
                    Plot for Ion Temperature
                 '''
                 CODE = 'ITemp'
                 colormap = 'jet'
                 plot_name = 'Ion Temperature'
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['ITemp'] = dataOut.IonTempFinal
                     return data, meta
             class HFracRTIPlot(ETempRTIPlot):
                 '''
                    Plot for H+ LP
                 '''
                 CODE = 'HFracLP'
                 colormap = 'jet'
                 plot_name = 'H+ Frac'
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['HFracLP'] = dataOut.PhyFinal
                     return data, meta
             class HeFracRTIPlot(ETempRTIPlot):
                 '''
                    Plot for He+ LP
                 '''
                 CODE = 'HeFracLP'
                 colormap = 'jet'
                 plot_name = 'He+ Frac'
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['HeFracLP'] = dataOut.PheFinal
                     return data, meta
             class TempsDPPlot(Plot):
                 '''
                 Plot for Electron - Ion Temperatures
                 '''
                 CODE = 'tempsDP'
                 #plot_name = 'Temperatures'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Temperature (K)'
                     self.titles = ['Electron/Ion Temperatures']
                     self.width = 3.5
                     self.height = 5.5
                     self.colorbar = False
                     self.plots_adjust.update({'left': 0.17, 'right': 0.88, 'bottom': 0.1})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['Te'] = dataOut.te2
                     data['Ti'] = dataOut.ti2
                     data['Te_error'] = dataOut.ete2
                     data['Ti_error'] = dataOut.eti2
                     meta['yrange'] = dataOut.heightList[0:dataOut.NSHTS]
                     return data, meta
                 def plot(self):
                     y = self.data.yrange
                     self.xmin = -100
                     self.xmax = 5000
                     ax = self.axes[0]
                     data = self.data[-1]
                     Te = data['Te']
                     Ti = data['Ti']
                     errTe = data['Te_error']
                     errTi = data['Ti_error']
                     if ax.firsttime:
                         ax.errorbar(Te, y, xerr=errTe, fmt='r^',elinewidth=1.0,color='b',linewidth=2.0, label='Te')
                         ax.errorbar(Ti, y, fmt='k^', xerr=errTi,elinewidth=1.0,color='b',linewidth=2.0, label='Ti')
                         plt.legend(loc='lower right')
                         self.ystep_given = 50
                         ax.yaxis.set_minor_locator(MultipleLocator(15))
                         ax.grid(which='minor')
                     else:
                         self.clear_figures()
                         ax.errorbar(Te, y, xerr=errTe, fmt='r^',elinewidth=1.0,color='b',linewidth=2.0, label='Te')
                         ax.errorbar(Ti, y, fmt='k^', xerr=errTi,elinewidth=1.0,color='b',linewidth=2.0, label='Ti')
                         plt.legend(loc='lower right')
                         ax.yaxis.set_minor_locator(MultipleLocator(15))
             class TempsHPPlot(Plot):
                 '''
                 Plot for Temperatures Hybrid Experiment
                 '''
                 CODE = 'temps_LP'
                 #plot_name = 'Temperatures'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Temperature (K)'
                     self.titles = ['Electron/Ion Temperatures']
                     self.width = 3.5
                     self.height = 6.5
                     self.colorbar = False
                     self.plots_adjust.update({'left': 0.17, 'right': 0.88, 'bottom': 0.1})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['Te'] = numpy.concatenate((dataOut.te2[:dataOut.cut],dataOut.te[dataOut.cut:]))
                     data['Ti'] = numpy.concatenate((dataOut.ti2[:dataOut.cut],dataOut.ti[dataOut.cut:]))
                     data['Te_error'] = numpy.concatenate((dataOut.ete2[:dataOut.cut],dataOut.ete[dataOut.cut:]))
                     data['Ti_error'] = numpy.concatenate((dataOut.eti2[:dataOut.cut],dataOut.eti[dataOut.cut:]))
                     meta['yrange'] = dataOut.heightList[0:dataOut.NACF]
                     return data, meta
                 def plot(self):
                     self.y = self.data.yrange
                     self.xmin = -100
                     self.xmax = 4500
                     ax = self.axes[0]
                     data = self.data[-1]
                     Te = data['Te']
                     Ti = data['Ti']
                     errTe = data['Te_error']
                     errTi = data['Ti_error']
                     if ax.firsttime:
                         ax.errorbar(Te, self.y, xerr=errTe, fmt='r^',elinewidth=1.0,color='b',linewidth=2.0, label='Te')
                         ax.errorbar(Ti, self.y, fmt='k^', xerr=errTi,elinewidth=1.0,color='b',linewidth=2.0, label='Ti')
                         plt.legend(loc='lower right')
                         self.ystep_given = 200
                         ax.yaxis.set_minor_locator(MultipleLocator(15))
                         ax.grid(which='minor')
                     else:
                         self.clear_figures()
                         ax.errorbar(Te, self.y, xerr=errTe, fmt='r^',elinewidth=1.0,color='b',linewidth=2.0, label='Te')
                         ax.errorbar(Ti, self.y, fmt='k^', xerr=errTi,elinewidth=1.0,color='b',linewidth=2.0, label='Ti')
                         plt.legend(loc='lower right')
                         ax.yaxis.set_minor_locator(MultipleLocator(15))
                         ax.grid(which='minor')
             class FracsHPPlot(Plot):
                 '''
                 Plot for Composition LP
                 '''
                 CODE = 'fracs_LP'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Frac'
                     self.titles = ['Composition']
                     self.width = 3.5
                     self.height = 6.5
                     self.colorbar = False
                     self.plots_adjust.update({'left': 0.17, 'right': 0.88, 'bottom': 0.1})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     #aux_nan=numpy.zeros(dataOut.cut,'float32')
                     #aux_nan[:]=numpy.nan
                     #data['ph'] = numpy.concatenate((aux_nan,dataOut.ph[dataOut.cut:]))
                     #data['eph'] = numpy.concatenate((aux_nan,dataOut.eph[dataOut.cut:]))
                     data['ph'] = dataOut.ph[dataOut.cut:]
                     data['eph'] = dataOut.eph[dataOut.cut:]
                     data['phe'] = dataOut.phe[dataOut.cut:]
                     data['ephe'] = dataOut.ephe[dataOut.cut:]
                     data['cut'] = dataOut.cut
                     meta['yrange'] = dataOut.heightList[0:dataOut.NACF]
                     return data, meta
                 def plot(self):
                     data = self.data[-1]
                     ph = data['ph']
                     eph = data['eph']
                     phe = data['phe']
                     ephe = data['ephe']
                     cut = data['cut']
                     self.y = self.data.yrange
                     self.xmin = 0
                     self.xmax = 1
                     ax = self.axes[0]
                     if ax.firsttime:
                         ax.errorbar(ph, self.y[cut:], xerr=eph, fmt='r^',elinewidth=1.0,color='b',linewidth=2.0, label='H+')
                         ax.errorbar(phe, self.y[cut:], fmt='k^', xerr=ephe,elinewidth=1.0,color='b',linewidth=2.0, label='He+')
                         plt.legend(loc='lower right')
                         self.xstep_given = 0.2
                         self.ystep_given = 200
                         ax.yaxis.set_minor_locator(MultipleLocator(15))
                         ax.grid(which='minor')
                     else:
                         self.clear_figures()
                         ax.errorbar(ph, self.y[cut:], xerr=eph, fmt='r^',elinewidth=1.0,color='b',linewidth=2.0, label='H+')
                         ax.errorbar(phe, self.y[cut:], fmt='k^', xerr=ephe,elinewidth=1.0,color='b',linewidth=2.0, label='He+')
                         plt.legend(loc='lower right')
                         ax.yaxis.set_minor_locator(MultipleLocator(15))
                         ax.grid(which='minor')
             class EDensityPlot(Plot):
                 '''
                 Plot for electron density
                 '''
                 CODE = 'den'
                 #plot_name = 'Electron Density'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Range [km]'
                     self.xlabel = r'$\mathrm{N_e}$ Electron Density ($\mathrm{1/cm^3}$)'
                     self.titles = ['Electron Density']
                     self.width = 3.5
                     self.height = 5.5
                     self.colorbar = False
                     self.plots_adjust.update({'left': 0.17, 'right': 0.88, 'bottom': 0.1})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['den_power'] = dataOut.ph2[:dataOut.NSHTS]
                     data['den_Faraday'] = dataOut.dphi[:dataOut.NSHTS]
                     data['den_error'] = dataOut.sdp2[:dataOut.NSHTS]
                     #data['err_Faraday'] = dataOut.sdn1[:dataOut.NSHTS]
                     data['NSHTS'] = dataOut.NSHTS
                     meta['yrange'] = dataOut.heightList[0:dataOut.NSHTS]
                     return data, meta
                 def plot(self):
                     y = self.data.yrange
                     self.xmin = 1e3
                     self.xmax = 1e7
                     ax = self.axes[0]
                     data = self.data[-1]
                     DenPow = data['den_power']
                     DenFar = data['den_Faraday']
                     errDenPow = data['den_error']
                     #errFaraday = data['err_Faraday']
                     NSHTS = data['NSHTS']
                     if self.CODE == 'denLP':
                         DenPowLP = data['den_LP']
                         errDenPowLP = data['den_LP_error']
                         cut = data['cut']
                     if ax.firsttime:
                         self.autoxticks=False
                         #ax.errorbar(DenFar, y[:NSHTS], xerr=1, fmt='h-',elinewidth=1.0,color='g',linewidth=1.0, label='Faraday Profile',markersize=2)
                         ax.errorbar(DenFar, y[:NSHTS], xerr=1, fmt='h-',elinewidth=1.0,color='g',linewidth=1.0, label='Faraday',markersize=2)
                         #ax.errorbar(DenPow, y[:NSHTS], fmt='k^-', xerr=errDenPow,elinewidth=1.0,color='b',linewidth=1.0, label='Power Profile',markersize=2)
                         ax.errorbar(DenPow, y[:NSHTS], fmt='k^-', xerr=errDenPow,elinewidth=1.0,color='b',linewidth=1.0, label='Power',markersize=2)
                         if self.CODE=='denLP':
                             ax.errorbar(DenPowLP[cut:], y[cut:], xerr=errDenPowLP[cut:], fmt='r^-',elinewidth=1.0,color='r',linewidth=1.0, label='LP Profile',markersize=2)
                         plt.legend(loc='upper left',fontsize=8.5)
                         #plt.legend(loc='lower left',fontsize=8.5)
                         ax.set_xscale("log", nonposx='clip')
                         grid_y_ticks=numpy.arange(numpy.nanmin(y),numpy.nanmax(y),50)
                         self.ystep_given=100
                         if self.CODE=='denLP':
                             self.ystep_given=200
                         ax.set_yticks(grid_y_ticks,minor=True)
                         ax.grid(which='minor')
                     else:
                         dataBefore = self.data[-2]
                         DenPowBefore = dataBefore['den_power']
                         self.clear_figures()
                         #ax.errorbar(DenFar, y[:NSHTS], xerr=1, fmt='h-',elinewidth=1.0,color='g',linewidth=1.0, label='Faraday Profile',markersize=2)
                         ax.errorbar(DenFar, y[:NSHTS], xerr=1, fmt='h-',elinewidth=1.0,color='g',linewidth=1.0, label='Faraday',markersize=2)
                         #ax.errorbar(DenPow, y[:NSHTS], fmt='k^-', xerr=errDenPow,elinewidth=1.0,color='b',linewidth=1.0, label='Power Profile',markersize=2)
                         ax.errorbar(DenPow, y[:NSHTS], fmt='k^-', xerr=errDenPow,elinewidth=1.0,color='b',linewidth=1.0, label='Power',markersize=2)
                         ax.errorbar(DenPowBefore, y[:NSHTS], elinewidth=1.0,color='r',linewidth=0.5,linestyle="dashed")
                         if self.CODE=='denLP':
                             ax.errorbar(DenPowLP[cut:], y[cut:], fmt='r^-', xerr=errDenPowLP[cut:],elinewidth=1.0,color='r',linewidth=1.0, label='LP Profile',markersize=2)
                         ax.set_xscale("log", nonposx='clip')
                         grid_y_ticks=numpy.arange(numpy.nanmin(y),numpy.nanmax(y),50)
                         ax.set_yticks(grid_y_ticks,minor=True)
                         ax.grid(which='minor')
                         plt.legend(loc='upper left',fontsize=8.5)
                         #plt.legend(loc='lower left',fontsize=8.5)
             class FaradayAnglePlot(Plot):
                 '''
                 Plot for electron density
                 '''
                 CODE = 'angle'
                 plot_name = 'Faraday Angle'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Faraday Angle (º)'
                     self.titles = ['Electron Density']
                     self.width = 3.5
                     self.height = 5.5
                     self.colorbar = False
                     self.plots_adjust.update({'left': 0.17, 'right': 0.88, 'bottom': 0.1})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['angle'] = numpy.degrees(dataOut.phi)
                     #'''
                     print(dataOut.phi_uwrp)
                     print(data['angle'])
                     exit(1)
                     #'''
                     data['dphi'] = dataOut.dphi_uc*10
                     #print(dataOut.dphi)
                     #data['NSHTS'] = dataOut.NSHTS
                     #meta['yrange'] = dataOut.heightList[0:dataOut.NSHTS]
                     return data, meta
                 def plot(self):
                     data = self.data[-1]
                     self.x = data[self.CODE]
                     dphi = data['dphi']
                     self.y = self.data.yrange
                     self.xmin = -360#-180
                     self.xmax = 360#180
                     ax = self.axes[0]
                     if ax.firsttime:
                         self.autoxticks=False
                         #if self.CODE=='den':
                         ax.plot(self.x, self.y,marker='o',color='g',linewidth=1.0,markersize=2)
                         ax.plot(dphi, self.y,marker='o',color='blue',linewidth=1.0,markersize=2)
                         grid_y_ticks=numpy.arange(numpy.nanmin(self.y),numpy.nanmax(self.y),50)
                         self.ystep_given=100
                         if self.CODE=='denLP':
                             self.ystep_given=200
                         ax.set_yticks(grid_y_ticks,minor=True)
                         ax.grid(which='minor')
                         #plt.tight_layout()
                     else:
                         self.clear_figures()
                         #if self.CODE=='den':
                         #print(numpy.shape(self.x))
                         ax.plot(self.x, self.y, marker='o',color='g',linewidth=1.0, markersize=2)
                         ax.plot(dphi, self.y,marker='o',color='blue',linewidth=1.0,markersize=2)
                         grid_y_ticks=numpy.arange(numpy.nanmin(self.y),numpy.nanmax(self.y),50)
                         ax.set_yticks(grid_y_ticks,minor=True)
                         ax.grid(which='minor')
             class EDensityHPPlot(EDensityPlot):
                 '''
                    Plot for Electron Density Hybrid Experiment
                 '''
                 CODE = 'denLP'
                 plot_name = 'Electron Density'
                 plot_type = 'scatterbuffer'
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['den_power'] = dataOut.ph2[:dataOut.NSHTS]
                     data['den_Faraday']=dataOut.dphi[:dataOut.NSHTS]
                     data['den_error']=dataOut.sdp2[:dataOut.NSHTS]
                     data['den_LP']=dataOut.ne[:dataOut.NACF]
                     data['den_LP_error']=dataOut.ene[:dataOut.NACF]*dataOut.ne[:dataOut.NACF]*0.434
                     #self.ene=10**dataOut.ene[:dataOut.NACF]
                     data['NSHTS']=dataOut.NSHTS
                     data['cut']=dataOut.cut
                     return data, meta
             class ACFsPlot(Plot):
                 '''
                 Plot for ACFs Double Pulse Experiment
                 '''
                 CODE = 'acfs'
                 #plot_name = 'ACF'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Lag (ms)'
                     self.titles = ['ACFs']
                     self.width = 3.5
                     self.height = 5.5
                     self.colorbar = False
                     self.plots_adjust.update({'left': 0.17, 'right': 0.88, 'bottom': 0.1})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['ACFs'] = dataOut.acfs_to_plot
                     data['ACFs_error'] = dataOut.acfs_error_to_plot
                     data['lags'] = dataOut.lags_to_plot
                     data['Lag_contaminated_1'] = dataOut.x_igcej_to_plot
                     data['Lag_contaminated_2'] = dataOut.x_ibad_to_plot
                     data['Height_contaminated_1'] = dataOut.y_igcej_to_plot
                     data['Height_contaminated_2'] = dataOut.y_ibad_to_plot
                     meta['yrange'] = numpy.array([])
                     #meta['NSHTS'] = dataOut.NSHTS
                     #meta['DPL'] = dataOut.DPL
                     data['NSHTS'] = dataOut.NSHTS #This is metadata
                     data['DPL'] = dataOut.DPL #This is metadata
                     return data, meta
                 def plot(self):
                     data = self.data[-1]
                     #NSHTS = self.meta['NSHTS']
                     #DPL = self.meta['DPL']
                     NSHTS = data['NSHTS'] #This is metadata
                     DPL = data['DPL'] #This is metadata
                     lags = data['lags']
                     ACFs = data['ACFs']
                     errACFs = data['ACFs_error']
                     BadLag1 = data['Lag_contaminated_1']
                     BadLag2 = data['Lag_contaminated_2']
                     BadHei1 = data['Height_contaminated_1']
                     BadHei2 = data['Height_contaminated_2']
                     self.xmin = 0.0
                     self.xmax = 2.0
                     self.y = ACFs
                     ax = self.axes[0]
                     if ax.firsttime:
                         for i in range(NSHTS):
                             x_aux = numpy.isfinite(lags[i,:])
                             y_aux = numpy.isfinite(ACFs[i,:])
                             yerr_aux = numpy.isfinite(errACFs[i,:])
                             x_igcej_aux = numpy.isfinite(BadLag1[i,:])
                             y_igcej_aux = numpy.isfinite(BadHei1[i,:])
                             x_ibad_aux = numpy.isfinite(BadLag2[i,:])
                             y_ibad_aux = numpy.isfinite(BadHei2[i,:])
                             if lags[i,:][~numpy.isnan(lags[i,:])].shape[0]>2:
                                 ax.errorbar(lags[i,x_aux], ACFs[i,y_aux], yerr=errACFs[i,x_aux],color='b',marker='o',linewidth=1.0,markersize=2)
                             ax.plot(BadLag1[i,x_igcej_aux],BadHei1[i,y_igcej_aux],'x',color='red',markersize=2)
                             ax.plot(BadLag2[i,x_ibad_aux],BadHei2[i,y_ibad_aux],'X',color='red',markersize=2)
                         self.xstep_given = (self.xmax-self.xmin)/(DPL-1)
                         self.ystep_given = 50
                         ax.yaxis.set_minor_locator(MultipleLocator(15))
                         ax.grid(which='minor')
                     else:
                         self.clear_figures()
                         for i in range(NSHTS):
                             x_aux = numpy.isfinite(lags[i,:])
                             y_aux = numpy.isfinite(ACFs[i,:])
                             yerr_aux = numpy.isfinite(errACFs[i,:])
                             x_igcej_aux = numpy.isfinite(BadLag1[i,:])
                             y_igcej_aux = numpy.isfinite(BadHei1[i,:])
                             x_ibad_aux = numpy.isfinite(BadLag2[i,:])
                             y_ibad_aux = numpy.isfinite(BadHei2[i,:])
                             if lags[i,:][~numpy.isnan(lags[i,:])].shape[0]>2:
                                 ax.errorbar(lags[i,x_aux], ACFs[i,y_aux], yerr=errACFs[i,x_aux],linewidth=1.0,markersize=2,color='b',marker='o')
                             ax.plot(BadLag1[i,x_igcej_aux],BadHei1[i,y_igcej_aux],'x',color='red',markersize=2)
                             ax.plot(BadLag2[i,x_ibad_aux],BadHei2[i,y_ibad_aux],'X',color='red',markersize=2)
                         ax.yaxis.set_minor_locator(MultipleLocator(15))
             class ACFsLPPlot(Plot):
                 '''
                 Plot for ACFs Double Pulse Experiment
                 '''
                 CODE = 'acfs_LP'
                 #plot_name = 'ACF'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Lag (ms)'
                     self.titles = ['ACFs']
                     self.width = 3.5
                     self.height = 5.5
                     self.colorbar = False
                     self.plots_adjust.update({'left': 0.17, 'right': 0.88, 'bottom': 0.1})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     aux=numpy.zeros((dataOut.NACF,dataOut.IBITS),'float32')
                     errors=numpy.zeros((dataOut.NACF,dataOut.IBITS),'float32')
                     lags_LP_to_plot=numpy.zeros((dataOut.NACF,dataOut.IBITS),'float32')
                     for i in range(dataOut.NACF):
                         for j in range(dataOut.IBITS):
                             if numpy.abs(dataOut.errors[j,i]/dataOut.output_LP_integrated.real[0,i,0])<1.0:
                                 aux[i,j]=dataOut.output_LP_integrated.real[j,i,0]/dataOut.output_LP_integrated.real[0,i,0]
                                 aux[i,j]=max(min(aux[i,j],1.0),-1.0)*dataOut.DH+dataOut.heightList[i]
                                 lags_LP_to_plot[i,j]=dataOut.lags_LP[j]
                                 errors[i,j]=dataOut.errors[j,i]/dataOut.output_LP_integrated.real[0,i,0]*dataOut.DH
                             else:
                                 aux[i,j]=numpy.nan
                                 lags_LP_to_plot[i,j]=numpy.nan
                                 errors[i,j]=numpy.nan
                     data['ACFs'] = aux
                     data['ACFs_error'] = errors
                     data['lags'] = lags_LP_to_plot
                     meta['yrange'] = numpy.array([])
                     #meta['NACF'] = dataOut.NACF
                     #meta['NLAG'] = dataOut.NLAG
                     data['NACF'] = dataOut.NACF #This is metadata
                     data['NLAG'] = dataOut.NLAG #This is metadata
                     return data, meta
                 def plot(self):
                     data = self.data[-1]
                     #NACF = self.meta['NACF']
                     #NLAG = self.meta['NLAG']
                     NACF = data['NACF'] #This is metadata
                     NLAG = data['NLAG'] #This is metadata
                     lags = data['lags']
                     ACFs = data['ACFs']
                     errACFs = data['ACFs_error']
                     self.xmin = 0.0
                     self.xmax = 1.5
                     self.y = ACFs
                     ax = self.axes[0]
                     if ax.firsttime:
                         for i in range(NACF):
                             x_aux = numpy.isfinite(lags[i,:])
                             y_aux = numpy.isfinite(ACFs[i,:])
                             yerr_aux = numpy.isfinite(errACFs[i,:])
                             if lags[i,:][~numpy.isnan(lags[i,:])].shape[0]>2:
                                 ax.errorbar(lags[i,x_aux], ACFs[i,y_aux], yerr=errACFs[i,x_aux],color='b',linewidth=1.0,markersize=2,ecolor='r')
                         #self.xstep_given = (self.xmax-self.xmin)/(self.data.NLAG-1)
                         self.xstep_given=0.3
                         self.ystep_given = 200
                         ax.yaxis.set_minor_locator(MultipleLocator(15))
                         ax.grid(which='minor')
                     else:
                         self.clear_figures()
                         for i in range(NACF):
                             x_aux = numpy.isfinite(lags[i,:])
                             y_aux = numpy.isfinite(ACFs[i,:])
                             yerr_aux = numpy.isfinite(errACFs[i,:])
                             if lags[i,:][~numpy.isnan(lags[i,:])].shape[0]>2:
                                 ax.errorbar(lags[i,x_aux], ACFs[i,y_aux], yerr=errACFs[i,x_aux],color='b',linewidth=1.0,markersize=2,ecolor='r')
                         ax.yaxis.set_minor_locator(MultipleLocator(15))
             class CrossProductsPlot(Plot):
                 '''
                 Plot for cross products
                 '''
                 CODE = 'crossprod'
                 plot_name = 'Cross Products'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.ncols = 3
                     self.nrows = 1
                     self.nplots = 3
                     self.ylabel = 'Range [km]'
                     self.titles = []
                     self.width = 3.5*self.nplots
                     self.height = 5.5
                     self.colorbar = False
                     self.plots_adjust.update({'wspace':.3, 'left': 0.12, 'right': 0.92, 'bottom': 0.1})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['crossprod'] = dataOut.crossprods
                     data['NDP'] = dataOut.NDP
                     return data, meta
                 def plot(self):
                     NDP = self.data['NDP'][-1]
                     x = self.data['crossprod'][:,-1,:,:,:,:]
                     y = self.data.yrange[0:NDP]
                     for n, ax in enumerate(self.axes):
                         self.xmin=numpy.min(numpy.concatenate((x[n][0,20:30,0,0],x[n][1,20:30,0,0],x[n][2,20:30,0,0],x[n][3,20:30,0,0])))
                         self.xmax=numpy.max(numpy.concatenate((x[n][0,20:30,0,0],x[n][1,20:30,0,0],x[n][2,20:30,0,0],x[n][3,20:30,0,0])))
                         if ax.firsttime:
                             self.autoxticks=False
                             if n==0:
                                 label1='kax'
                                 label2='kay'
                                 label3='kbx'
                                 label4='kby'
                                 self.xlimits=[(self.xmin,self.xmax)]
                             elif n==1:
                                 label1='kax2'
                                 label2='kay2'
                                 label3='kbx2'
                                 label4='kby2'
                                 self.xlimits.append((self.xmin,self.xmax))
                             elif n==2:
                                 label1='kaxay'
                                 label2='kbxby'
                                 label3='kaxbx'
                                 label4='kaxby'
                                 self.xlimits.append((self.xmin,self.xmax))
                             ax.plotline1 = ax.plot(x[n][0,:,0,0], y, color='r',linewidth=2.0, label=label1)
                             ax.plotline2 = ax.plot(x[n][1,:,0,0], y, color='k',linewidth=2.0, label=label2)
                             ax.plotline3 = ax.plot(x[n][2,:,0,0], y, color='b',linewidth=2.0, label=label3)
                             ax.plotline4 = ax.plot(x[n][3,:,0,0], y, color='m',linewidth=2.0, label=label4)
                             ax.legend(loc='upper right')
                             ax.set_xlim(self.xmin, self.xmax)
                             self.titles.append('{}'.format(self.plot_name.upper()))
                         else:
                             if n==0:
                                 self.xlimits=[(self.xmin,self.xmax)]
                             else:
                                 self.xlimits.append((self.xmin,self.xmax))
                             ax.set_xlim(self.xmin, self.xmax)
                             ax.plotline1[0].set_data(x[n][0,:,0,0],y)
                             ax.plotline2[0].set_data(x[n][1,:,0,0],y)
                             ax.plotline3[0].set_data(x[n][2,:,0,0],y)
                             ax.plotline4[0].set_data(x[n][3,:,0,0],y)
                             self.titles.append('{}'.format(self.plot_name.upper()))
             class CrossProductsLPPlot(Plot):
                 '''
                 Plot for cross products LP
                 '''
                 CODE = 'crossprodslp'
                 plot_name = 'Cross Products LP'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.ncols = 2
                     self.nrows = 1
                     self.nplots = 2
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'dB'
                     self.width = 3.5*self.nplots
                     self.height = 5.5
                     self.colorbar = False
                     self.titles = []
                     self.plots_adjust.update({'wspace': .8 ,'left': 0.17, 'right': 0.88, 'bottom': 0.1})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['crossprodslp'] = 10*numpy.log10(numpy.abs(dataOut.output_LP))
                     data['NRANGE'] = dataOut.NRANGE #This is metadata
                     data['NLAG'] = dataOut.NLAG #This is metadata
                     return data, meta
                 def plot(self):
                     NRANGE = self.data['NRANGE'][-1]
                     NLAG = self.data['NLAG'][-1]
                     x = self.data[self.CODE][:,-1,:,:]
                     self.y = self.data.yrange[0:NRANGE]
                     label_array=numpy.array(['lag '+ str(x) for x in range(NLAG)])
                     color_array=['r','k','g','b','c','m','y','orange','steelblue','purple','peru','darksalmon','grey','limegreen','olive','midnightblue']
                     for n, ax in enumerate(self.axes):
                         self.xmin=28#30
                         self.xmax=70#70
                         #self.xmin=numpy.min(numpy.concatenate((self.x[0,:,n],self.x[1,:,n])))
                         #self.xmax=numpy.max(numpy.concatenate((self.x[0,:,n],self.x[1,:,n])))
                         if ax.firsttime:
                             self.autoxticks=False
                             if n == 0:
                                 self.plotline_array=numpy.zeros((2,NLAG),dtype=object)
                             for i in range(NLAG):
                                 self.plotline_array[n,i], = ax.plot(x[i,:,n], self.y, color=color_array[i],linewidth=1.0, label=label_array[i])
                             ax.legend(loc='upper right')
                             ax.set_xlim(self.xmin, self.xmax)
                             if n==0:
                                 self.titles.append('{} CH0'.format(self.plot_name.upper()))
                             if n==1:
                                 self.titles.append('{} CH1'.format(self.plot_name.upper()))
                         else:
                             for i in range(NLAG):
                                 self.plotline_array[n,i].set_data(x[i,:,n],self.y)
                             if n==0:
                                 self.titles.append('{} CH0'.format(self.plot_name.upper()))
                             if n==1:
                                 self.titles.append('{} CH1'.format(self.plot_name.upper()))
             class NoiseDPPlot(NoisePlot):
                 '''
                 Plot for noise Double Pulse
                 '''
                 CODE = 'noise'
                 #plot_name = 'Noise'
                 #plot_type = 'scatterbuffer'
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['noise'] = 10*numpy.log10(dataOut.noise_final)
                     return data, meta
             class XmitWaveformPlot(Plot):
                 '''
                 Plot for xmit waveform
                 '''
                 CODE = 'xmit'
                 plot_name = 'Xmit Waveform'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = ''
                     self.xlabel = 'Number of Lag'
                     self.width = 5.5
                     self.height = 3.5
                     self.colorbar = False
                     self.plots_adjust.update({'right': 0.85 })
                     self.titles = [self.plot_name]
                     #self.plots_adjust.update({'left': 0.17, 'right': 0.88, 'bottom': 0.1})
                     #if not self.titles:
                         #self.titles = self.data.parameters \
                             #if self.data.parameters else ['{}'.format(self.plot_name.upper())]
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     y_1=numpy.arctan2(dataOut.output_LP[:,0,2].imag,dataOut.output_LP[:,0,2].real)* 180 / (numpy.pi*10)
                     y_2=numpy.abs(dataOut.output_LP[:,0,2])
                     norm=numpy.max(y_2)
                     norm=max(norm,0.1)
                     y_2=y_2/norm
                     meta['yrange'] = numpy.array([])
                     data['xmit'] = numpy.vstack((y_1,y_2))
                     data['NLAG'] = dataOut.NLAG
                     return data, meta
                 def plot(self):
                     data = self.data[-1]
                     NLAG = data['NLAG']
                     x = numpy.arange(0,NLAG,1,'float32')
                     y = data['xmit']
                     self.xmin = 0
                     self.xmax = NLAG-1
                     self.ymin = -1.0
                     self.ymax = 1.0
                     ax = self.axes[0]
                     if ax.firsttime:
                         ax.plotline0=ax.plot(x,y[0,:],color='blue')
                         ax.plotline1=ax.plot(x,y[1,:],color='red')
                         secax=ax.secondary_xaxis(location=0.5)
                         secax.xaxis.tick_bottom()
                         secax.tick_params( labelleft=False, labeltop=False,
                                   labelright=False, labelbottom=False)
                         self.xstep_given = 3
                         self.ystep_given = .25
                         secax.set_xticks(numpy.linspace(self.xmin, self.xmax, 6)) #only works on matplotlib.version>3.2
                     else:
                         ax.plotline0[0].set_data(x,y[0,:])
                         ax.plotline1[0].set_data(x,y[1,:])

schainpy/model/proc/jroproc_voltage.py 0 0

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

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages