Task #5049: make parmdbplot more user friendly, add some features

CEP/Calibration/BBSControl/scripts/parmdbplot.py

@@ -20,13 +20,7 @@
 #
 # $Id$
 
-import sys
-import lofar.parmdb as parmdb
-import copy
-import math
-import numpy
-
-import matplotlib
+import sys, copy, math, numpy, signal
 from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg as FigureCanvas
 from matplotlib.backends.backend_qt4agg import NavigationToolbar2QTAgg as NavigationToolbar
 from matplotlib.figure import Figure
@@ -35,6 +29,9 @@ from matplotlib.font_manager import FontProperties
 from PyQt4.QtCore import *
 from PyQt4.QtGui import *
 
+import lofar.parmdb as parmdb
+
+signal.signal(signal.SIGINT, signal.SIG_DFL)
 __styles = ["%s%s" % (x, y) for y in ["-", ":"] for x in ["b", "g", "r", "c",
     "m", "y", "k"]]
 
@@ -51,7 +48,7 @@ def common_domain(parms):
     domain = [-1e30, 1e30, -1e30, 1e30]
     for parm in parms:
         tmp = parm.domain()
-        domain = [max(domain[0], tmp[0]), min(domain[1], tmp[1]), max(domain[2], tmp[2]), min(domain, tmp[3])]
+        domain = [max(domain[0], tmp[0]), min(domain[1], tmp[1]), max(domain[2], tmp[2]), min(domain[3], tmp[3])]
 
     if domain[0] >= domain[1] or domain[2] >= domain[3]:
         return None
@@ -178,7 +175,7 @@ def plot(fig, y, x=None, clf=True, sub=None, scatter=False, stack=False,
     The 'labels' argument can be set to a list of labels and 'show_legend' can
     be set to True to show a legend inside the plot.
 
-    The figure number of the figure used to plot in is returned.
+    The min/max/median of the plotted points are returned is returned.
     """
     global __styles
 
@@ -199,7 +196,8 @@ def plot(fig, y, x=None, clf=True, sub=None, scatter=False, stack=False,
     if x is None:
         x = [range(len(yi)) for yi in y]
 
-    offset = 0.0
+    offset = 0.
+    med = 0.
     for i in range(0,len(y)):
         if labels is None:
             if scatter:
@@ -216,7 +214,8 @@ def plot(fig, y, x=None, clf=True, sub=None, scatter=False, stack=False,
                 axes.plot(x[i], y[i] + offset, __styles[i % len(__styles)],
                     label=labels[i])
 
-        if stack:
+        med += numpy.median(y[i] + offset)
+        if stack and i != len(y)-1:
             if sep_abs:
                 offset += sep
             else:
@@ -225,73 +224,120 @@ def plot(fig, y, x=None, clf=True, sub=None, scatter=False, stack=False,
     if not labels is None and show_legend:
         axes.legend(prop=FontProperties(size="x-small"), markerscale=0.5)
 
+    # return min max median values
+    if stack:
+        return numpy.min(y[0]), numpy.max(y[-1]+offset), med/len(y)
+    else:
+        return numpy.min(y), numpy.max(y), med/len(y)
+
 class Parm:
-    def __init__(self, db, name, elements=None, isPolar=False):
+    """
+    Each entry in the parmdb is an instance of this class
+    """
+    def __init__(self, db, name, elements=None, isPolar=True):
         self._db = db
         self._name = name
         self._elements = elements
         self._isPolar = isPolar
         self._value = None
+        self._freq = None
         self._value_domain = None
         self._value_resolution = None
+        self._calType = self._name.split(':')[0]
+
+        if self._calType == 'DirectionalGain' or self._calType == 'RotationAngle': self._antenna = self._name.split(':')[-2]
+        else: self._antenna = self._name.split(':')[-1]
+
+        # modifiers for some phase outputs
+        if self._calType == 'Clock':
+            self.mod = lambda Clock: 2. * numpy.pi * Clock * self._freq
+        elif self._calType == 'TEC':
+            self.mod = lambda TEC: -8.44797245e9 * TEC / self._freq
+        elif self._calType == 'RM':
+            self.mod = lambda RM: RM / (299792458.*self._freq*299792458.*self._freq)
+        else:
+            # everything else is plain
+            self.mod = lambda ph: ph
             
         self._readDomain()
 
-    def name(self):
-        return self._name
-
-    def isPolar(self):
-        return self._isPolar
-
     def empty(self):
         return self._empty
 
     def domain(self):
         return self._domain
 
-    def value(self, domain=None, resolution=None, asPolar=True, unwrap_phase=False, phase_reference=None):
-        if self.empty():
-            return (numpy.zeros((1,1)), numpy.zeros((1,1)))
-
-        if self._value is None or self._value_domain != domain or self._value_resolution != resolution:
-            self._readValue(domain, resolution)
+    def color(self):
+        if self._calType == 'Gain': return QColor('#ffbfca')
+        if self._calType == 'DirectionalGain': return QColor('#ebbfff')
+        if self._calType == 'CommonRotationAngle': return QColor('#bfcdff')
+        if self._calType == 'RotationAngle': return QColor('#bfe5ff')
+        if self._calType == 'Clock': return QColor('#fff1bf')
+        if self._calType == 'TEC': return QColor('#bfffda')
+        if self._calType == 'CommonScalarPhase': return QColor('#ffbfbf')
+        if self._calType == 'RM': return QColor('#84f0aa')
 
-            # Correct negative amplitude solutions by taking the absolute value
-            # of the amplitude and rotating the phase by 180 deg.
-            if self.isPolar():
-                self._value[1][self._value[0] < 0.0] += numpy.pi
-                self._value[0] = numpy.abs(self._value[0])
+    def valueAmp(self, domain=None, resolution=None, asPolar=True):
+        self.updateValue(domain, resolution)
 
         if asPolar:
-            if self.isPolar():
+            if self._isPolar:
                 ampl = self._value[0]
-                phase = normalize(self._value[1])
             else:
                 ampl = numpy.sqrt(numpy.power(self._value[0], 2) + numpy.power(self._value[1], 2))
+
+            return ampl
+
+        if not self._isPolar:
+            re = self._value[0]
+        else:
+            re = self._value[0] * numpy.cos(self._value[1])
+
+        return re
+
+    def valuePhase(self, domain=None, resolution=None, asPolar=True, unwrap_phase=False, \
+            reference_parm=None, sum_parms=[], mod=True):
+        self.updateValue(domain, resolution)
+
+        if asPolar:
+            if self._isPolar:
+                phase = self._value[1]
+            else:
                 phase = numpy.arctan2(self._value[1], self._value[0])
 
-            if not phase_reference is None:
-                assert(phase_reference.shape == phase.shape)
-                phase = normalize(phase - phase_reference)
+            # apply modifiers for some solution types (e.g. clock, TEC, RM)
+            phase = self.mod(phase)
+
+            if not reference_parm is None:
+                reference_val = reference_parm.valuePhase(domain, resolution)
+                assert(reference_val.shape == phase.shape)
+                phase = normalize(phase - reference_val)
+
+            for sum_parm in sum_parms:
+                sum_val = sum_parm[0].valuePhase(domain, resolution)
+                sum_reference_val = sum_parm[1].valuePhase(domain, resolution)
+                assert(sum_val.shape == phase.shape)
+                assert(sum_reference_val.shape == phase.shape)
+                phase = normalize(phase + sum_val - sum_reference_val)
+
+            if mod: phase = normalize(phase)
 
             if unwrap_phase:
                 for i in range(0, phase.shape[1]):
                     phase[:, i] = unwrap(phase[:, i])
 
-            return [ampl, phase]
+            return phase
 
-        if not self.isPolar():
-            re = self._value[0]
+        if not self._isPolar:
             im = self._value[1]
         else:
-            re = self._value[0] * numpy.cos(self._value[1])
             im = self._value[0] * numpy.sin(self._value[1])
 
-        return [re, im]
+        return im
 
     def _readDomain(self):
         if self._elements is None:
-            self._domain = self._db.getRange(self.name())
+            self._domain = self._db.getRange(self._name)
         else:
             if self._elements[0] is None:
                 self._domain = self._db.getRange(self._elements[1])
@@ -304,10 +350,24 @@ class Parm:
 
         self._empty = (self._domain[0] >= self._domain[1]) or (self._domain[2] >= self._domain[3])
 
+    def updateValue(self, domain=None, resolution=None):
+        if self.empty():
+            return (numpy.zeros((1,1)), numpy.zeros((1,1)))
+
+        # if nothig changes, use cache
+        if self._value is None or self._value_domain != domain or self._value_resolution != resolution:
+            self._readValue(domain, resolution)
+
+            # Correct negative amplitude solutions by taking the absolute value
+            # of the amplitude and rotating the phase by 180 deg.
+            if self._isPolar and (self._calType == 'Gain' or self._calType == 'DirectionalGain'):
+                self._value[1][self._value[0] < 0.0] += numpy.pi
+                self._value[0] = numpy.abs(self._value[0])
+
     def _readValue(self, domain=None, resolution=None):
         if self._elements is None:
-            value = numpy.array(self.__fetch_value(self.name(), domain, resolution))
-            self._value = (value, numpy.zeros(value.shape))
+            value = numpy.array(self.__fetch_value(self._name, domain, resolution))
+            self._value = (numpy.zeros(value.shape), value)
         else:
             el0 = None
             if not self._elements[0] is None:
@@ -335,15 +395,17 @@ class Parm:
             tmp = self._db.getValuesGrid(name)[name]
         else:
             if resolution is None:
-                tmp = self._db.getValues(name, domain[0], domain[1], domain[2], domain[3])[name]
+                tmp = self._db.getValuesGrid(name, domain[0], domain[1], domain[2], domain[3])[name]
             else:
                 tmp = self._db.getValuesStep(name, domain[0], domain[1], resolution[0], domain[2], domain[3], resolution[1])[name]
         
-        if type(tmp) is dict:
-            return tmp["values"]
+        # store frequencies
+        self._freq = numpy.array([tmp["freqs"]] * len(tmp["values"]))
 
-        # Old parmdb interface.
-        return tmp
+        # store times and frequencies
+        self._freqs = numpy.array(tmp["freqs"])
+        self._times = numpy.array(tmp["times"])
+        return tmp["values"]
 
 class PlotWindow(QFrame):
     def __init__(self, parms, selection, resolution=None, parent=None, title=None):
@@ -355,15 +417,23 @@ class PlotWindow(QFrame):
         self.parms = parms
         self.selected_parms = [self.parms[i] for i in selection]
 
+        self.calType = self.selected_parms[0]._calType
+
         self.fig = Figure((5, 4), dpi=100)
 
         self.canvas = FigureCanvas(self.fig)
         self.canvas.setParent(self)
 
-        self.toolbar = NavigationToolbar(self.canvas, self)
-
         self.axis = 0
         self.index = 0
+        self.zoom = 0
+        self.valminmax = [[],[]]
+        self.blocked_valminmax = [[],[]]
+
+        self.xminmax =[]
+
+        self.toolbar = NavigationToolbar(self.canvas, self)
+
         self.axisSelector = QComboBox()
         self.axisSelector.addItem("Frequency")
         self.axisSelector.addItem("Time")
@@ -372,15 +442,33 @@ class PlotWindow(QFrame):
         self.spinner = QSpinBox()
         self.connect(self.spinner, SIGNAL('valueChanged(int)'), self.handle_spinner)
 
-#        self.slider = QSlider(Qt.Horizontal)
-#        self.slider.setMinimum(0)
-#        self.slider.setMaximum(159)
-#        self.connect(self.slider, SIGNAL('sliderReleased()'), self.handle_slider)
+        self.slider = QSlider(Qt.Vertical)
+        self.slider.setMinimum(0)
+        self.slider.setMaximum(100)
+        self.slider.setTracking(False)
+        self.slider.setToolTip('Zoom in on the median of amplitude')
+        self.connect(self.slider, SIGNAL('valueChanged(int)'), self.handle_slider)
 
         self.show_legend = False
         self.legendCheck = QCheckBox("Legend")
         self.connect(self.legendCheck, SIGNAL('stateChanged(int)'), self.handle_legend)
 
+        self.block_axis = False
+        self.blockaxisCheck = QCheckBox("Block y-axis")
+        self.blockaxisCheck.setToolTip('Block y-axis when stepping through time or frequency')
+        self.connect(self.blockaxisCheck, SIGNAL('stateChanged(int)'), self.handle_blockaxis)
+
+        self.use_points = False
+        self.usepointsCheck = QCheckBox("Use points")
+        self.usepointsCheck.setToolTip('Use points for plotting amplitude')
+        self.connect(self.usepointsCheck, SIGNAL('stateChanged(int)'), self.handle_usepoints)
+
+        self.valuesonxaxis = False
+        self.valuesonxaxisCheck = QCheckBox("Values on x-axis")
+        self.valuesonxaxisCheck.setChecked(False)
+        self.valuesonxaxisCheck.setToolTip('Plot the value of time / frequency on x-axis (if unchecked, the sample number is shown)')
+        self.connect(self.valuesonxaxisCheck, SIGNAL('stateChanged(int)'), self.handle_valuesonxaxis)
+
         self.polar = True
         self.polarCheck = QCheckBox("Polar")
         self.polarCheck.setChecked(True)
@@ -390,34 +478,34 @@ class PlotWindow(QFrame):
         self.unwrapCheck = QCheckBox("Unwrap phase")
         self.connect(self.unwrapCheck, SIGNAL('stateChanged(int)'), self.handle_unwrap)
 
-        self.reference = None
+        self.sum_parm = []
+        self.sum_index = []
+        self.sumSelector = QComboBox()
+        self.sumSelector.setToolTip('Show the sum of multiple phase effects (\'+\': include in sum)')
+        self.sumSelector.addItem('+'+self.selected_parms[0]._name)
+        # select only parm with the same antenna, exclude *RotationAngle: that's no phase
+        self.idxParmsSameAnt = [i for i, parm in enumerate(self.parms) if parm._antenna in \
+                [parm2._antenna for parm2 in self.selected_parms] \
+                and parm._calType!="CommonRotationAngle" and parm._calType!="RotationAngle"
+                and parm._name!=self.selected_parms[0]._name]
+        for idx in self.idxParmsSameAnt:
+            self.sumSelector.addItem(parms[idx]._name)
+        self.connect(self.sumSelector, SIGNAL('activated(int)'), self.handle_sum)
+        self.sumSelector.setEnabled(False)
+
+        self.sumLabel = QLabel("Phase sum:")
+        self.sumLabel.setEnabled(False)
+
+        self.reference_parm = None
         self.reference_index = 0
         self.referenceSelector = QComboBox()
         self.referenceSelector.addItem("None")
-        for parm in self.parms:
-            if parm.isPolar():
-                self.referenceSelector.addItem("%s (polar)" % parm.name())
-            else:
-                self.referenceSelector.addItem(parm.name())
+        self.idxParmsSameType = [i for i, parm in enumerate(self.parms) if parm._calType == self.calType]
+        for idx in self.idxParmsSameType:
+            self.referenceSelector.addItem(parms[idx]._name)
         self.connect(self.referenceSelector, SIGNAL('activated(int)'), self.handle_reference)
 
-        self.referenceLabel = QLabel("Phase reference")
-
-        hbox = QHBoxLayout()
-        hbox.addWidget(self.axisSelector)
-        hbox.addWidget(self.spinner)
-        hbox.addWidget(self.legendCheck)
-        hbox.addWidget(self.polarCheck)
-        hbox.addWidget(self.unwrapCheck)
-        hbox.addWidget(self.referenceSelector)
-        hbox.addWidget(self.referenceLabel)
-        hbox.addStretch(1)
-
-        layout = QVBoxLayout()
-        layout.addLayout(hbox);
-        layout.addWidget(self.canvas, 1)
-        layout.addWidget(self.toolbar)
-        self.setLayout(layout)
+        self.referenceLabel = QLabel("Phase reference:")
 
         self.domain = common_domain(self.selected_parms)
 
@@ -428,51 +516,63 @@ class PlotWindow(QFrame):
 
         self.shape = (1, 1)
         if not self.domain is None:
-            self.shape = (self.selected_parms[0].value(self.domain, self.resolution)[0].shape)
+            self.shape = (self.selected_parms[0].valueAmp(self.domain, self.resolution).shape)
             assert(len(self.shape) == 2)
 
         self.spinner.setRange(0, self.shape[1 - self.axis] - 1)
-        self.plot()
 
-    def plot(self):
-        el0 = []
-        el1 = []
-        labels = []
+        # display widgets
+        hbox = QHBoxLayout()
+        hbox.addWidget(self.axisSelector)
+        hbox.addWidget(self.spinner)
+        hbox.addWidget(self.legendCheck)
 
-        if not self.domain is None:
-            for parm in self.selected_parms:
-                value = parm.value(self.domain, self.resolution, self.polar, self.unwrap_phase, self.reference)
-                if value[0].shape != self.shape or value[1].shape != self.shape:
-                    print "warning: inconsistent shape; will skip parameter:", parm.name()
-                    continue
-
-                if self.axis == 0:
-                    el0.append(value[0][:, self.index])
-                    el1.append(value[1][:, self.index])
-                else:
-                    el0.append(value[0][self.index, :])
-                    el1.append(value[1][self.index, :])
-                labels.append(parm.name())
+        # Re/Imag or Ampl/Phase only relevant for gains
+        if self.calType=="Gain" or self.calType=="DirectionalGain":
+            hbox.addWidget(self.polarCheck)
+        hbox.addWidget(self.unwrapCheck)
+        hbox.addWidget(self.blockaxisCheck)
 
-        legend = self.show_legend and len(labels) > 0
-        xlabel = ["Time (sample)", "Freq (sample)"][self.axis]
-        if self.polar:
-            plot(self.fig, el0, sub="211", labels=labels, show_legend=legend, xlabel=xlabel, ylabel="Amplitude")
-            plot(self.fig, el1, clf=False, sub="212", stack=True, scatter=True, labels=labels, show_legend=legend, xlabel=xlabel, ylabel="Phase (rad)")
-        else:
-            plot(self.fig, el0, sub="211", labels=labels, show_legend=legend, xlabel=xlabel, ylabel="Real")
-            plot(self.fig, el1, clf=False, sub="212", labels=labels, show_legend=legend, xlabel=xlabel, ylabel="Imaginary")
+        # Phases are always points, amplitudes (gains) are lines by default
+        if self.calType=="Gain" or self.calType=="DirectionalGain":
+            hbox.addWidget(self.usepointsCheck)
+        hbox.addWidget(self.valuesonxaxisCheck)
+        hbox.addStretch(1)
+        hbox2 = QHBoxLayout()
+        hbox2.addWidget(self.referenceLabel)
+        hbox2.addWidget(self.referenceSelector)
+        # For now, phase sum only works when only one parameter is shown
+        if len(self.selected_parms)==1:
+            hbox2.addWidget(self.sumLabel)
+            hbox2.addWidget(self.sumSelector)
+        hbox2.addStretch(1)
+        hbox3 = QHBoxLayout()
+   
+        # Zooming in only possible on amplitudes (gains)
+        if self.calType=="Gain" or self.calType=="DirectionalGain":
+            hbox3.addWidget(self.slider)
+        hbox3.addWidget(self.canvas)
+        layout = QVBoxLayout()
+        layout.addLayout(hbox)
         
-        # Set x-axis scale in number of samples.
-        for ax in self.fig.axes:
-            ax.set_xlim(0, self.shape[self.axis] - 1)
+        # RotationAngles do not have phase sum 
+        if self.calType!="CommonRotationAngle" and self.calType!="RotationAngle":
+            layout.addLayout(hbox2)
+        layout.addLayout(hbox3)
+        layout.addWidget(self.toolbar)
+        self.setLayout(layout)
 
-        self.canvas.draw()
+        self.plot()
 
     def handle_spinner(self, index):
         self.index = index
         self.plot()
 
+    def handle_slider(self, zoom):
+        self.zoom = zoom
+        self.resize_plot()
+        self.canvas.draw()
+
     def handle_axis(self, axis):
         if axis != self.axis:
             self.axis = axis
@@ -480,6 +580,47 @@ class PlotWindow(QFrame):
             self.spinner.setValue(0)
             self.plot()
 
+    def find_reference(self, parm, ant_parm):
+        """
+        find the parm which is a suitable reference for "parm".
+        The reference antenna is taken from ant_parm
+        """
+        reference_antenna = ant_parm._antenna
+        reference_name = parm._name.replace(parm._antenna, reference_antenna)
+        reference_parm = next((p for p in self.parms if p._name == reference_name), None)
+        if reference_parm == None:
+            print "ERROR: cannot find a suitable reference (", reference_name ,") for", parm._name
+            return  None
+        else:
+#            print "DEBUG: using reference ", reference_name ," for", parm._name
+            return reference_parm
+
+    def handle_sum(self, index):
+        if index == 0:
+            a=3 #do nothing
+            # self.sum_parm = []
+            # remove all the "+" from the drop down menu
+            # for sum_index in self.sum_index:
+            #    parm = self.parms[self.idxParmsSameAnt[sum_index-1]]
+            #    self.sumSelector.setItemText(sum_index, parm._name)
+            # self.sum_index = []
+        elif index in self.sum_index:
+            parm = self.parms[self.idxParmsSameAnt[index-1]]
+            self.sum_parm.pop(self.sum_index.index(index))
+            self.sum_index.remove(index)
+            # remove "+" from the selected element
+            self.sumSelector.setItemText(index, parm._name)
+        else:
+            parm = self.parms[self.idxParmsSameAnt[index-1]]
+            ant_parm = self.parms[self.idxParmsSameType[self.reference_index-1]]
+            sum_reference_parm = self.find_reference(parm, ant_parm)
+            # add a tuple of the parm to sum and its reference
+            self.sum_parm.append( (parm, sum_reference_parm) )
+            self.sum_index.append(index)
+            # add "+" to the selected element
+            self.sumSelector.setItemText(index, '+'+parm._name)
+        self.plot()
+
     def handle_legend(self, state):
         self.show_legend = (state == 2)
         self.plot()
@@ -488,29 +629,153 @@ class PlotWindow(QFrame):
         self.unwrap_phase = (state == 2)
         self.plot()
 
+    def handle_blockaxis(self, state):
+        self.block_axis = (state == 2)
+        if self.block_axis:
+            self.slider.setEnabled(False)
+            for i, ax in enumerate(self.fig.axes):
+                self.blocked_valminmax[i] = (ax.axis()[2], ax.axis()[3], 0)
+        else:
+            self.slider.setEnabled(True)
+            self.plot()
+
+    def handle_usepoints(self, state):
+        self.use_points = (state == 2)
+        self.plot()
+
+    def handle_valuesonxaxis(self, state):
+        self.valuesonxaxis = (state == 2)
+        self.plot()
+
     def handle_polar(self, state):
         self.polar = (state == 2)
         self.referenceSelector.setEnabled(self.polar)
         self.referenceLabel.setEnabled(self.polar)
+        self.sumSelector.setEnabled(self.polar)
+        self.sumLabel.setEnabled(self.polar)
         self.unwrapCheck.setEnabled(self.polar)
         self.plot()
 
     def handle_reference(self, index):
         if index != self.reference_index:
             if index == 0:
-                reference = None
+                self.reference_parm = None
+                self.sum_parm = []
+                # remove all the "+" from the drop down menu
+                for sum_index in self.sum_index:
+                    parm = self.parms[self.idxParmsSameAnt[sum_index-1]]
+                    self.sumSelector.setItemText(sum_index, parm._name)
+                self.sum_index = []
             else:
-                parm = self.parms[index - 1]
-                value = parm.value(self.domain, self.resolution)
-                if value[1].shape != self.shape:
-                    print "warning: inconsistent shape; will not change phase reference to parameter:", parm.name()
-                    return
-                reference = value[1]
+                self.reference_parm = self.parms[self.idxParmsSameType[index-1]]
+
+                # update all the sums to use the new reference
+                for i, sum_parm in enumerate(self.sum_parm):
+                    sum_reference_parm = self.find_reference(sum_parm[0], self.reference_parm)
+                    # add a tuple of the parm to sum and its reference
+                    self.sum_parm[i] = (sum_parm[0], sum_reference_parm)
 
+            self.sumSelector.setEnabled((index != 0))
+            self.sumLabel.setEnabled((index != 0))
             self.reference_index = index
-            self.reference = reference
             self.plot()
 
+    def resize_plot(self):
+        """
+        Set y-axis scale looking the slider and the number of samples.
+        """
+        for i, ax in enumerate(self.fig.axes):
+            # handle single x value (typically one freq)
+            if self.shape[self.axis] != 1:
+                #ax.set_xlim(0, self.shape[self.axis] - 1)
+                ax.set_xlim(self.xminmax[0],self.xminmax[1])
+            if self.block_axis == True:
+                ax.set_ylim(self.blocked_valminmax[i][0], self.blocked_valminmax[i][1])
+            else:
+                # handle single y value (typically y=0)
+                if self.valminmax[i][0] == self.valminmax[i][1]:
+                    ax.set_ylim(self.valminmax[i][0]-1, self.valminmax[i][0]+1)
+                elif self.zoom == 0 or (self.polar and i>0):
+                    ax.set_ylim(self.valminmax[i][0], self.valminmax[i][1])
+                else:
+                    rng = (self.valminmax[i][1] - self.valminmax[i][0])/numpy.exp(self.zoom/10.)
+                    ax.set_ylim(ymin = self.valminmax[i][2] - rng/2., \
+                                ymax = self.valminmax[i][2] + rng/2.)
+
+    def plot(self):
+        """
+        Prepare the plotting space, double makes a double plot (only [Directional]Gain)
+        """
+
+        phase = []
+        amp = []
+        labels = []
+        xvalues = []
+
+        # Selector for double plot
+        if self.calType == 'Gain' or self.calType == 'DirectionalGain':
+            double = True
+        else:
+            self.usepointsCheck.setEnabled(False)
+            double = False
+
+        if not self.domain is None:
+            for parm in self.selected_parms:
+
+                valuePhase = parm.valuePhase(self.domain, self.resolution, asPolar = self.polar, \
+                        unwrap_phase=self.unwrap_phase, reference_parm=self.reference_parm, sum_parms=self.sum_parm)
+
+                if self.axis == 0: # time on x-axis
+                    phase.append(valuePhase[:, self.index])
+                else:              # freq on x-axis
+                    phase.append(valuePhase[self.index, :])
+
+                if self.valuesonxaxis:
+                    if self.axis == 0: # time on x-axis 
+                        xvalues.append((parm._times-parm._times[0])/60.) 
+                    else:              # freq on x-axis
+                        xvalues.append(parm._freqs/1.e6)
+                else:
+                    xvalues.append(range(len(phase[0])))
+
+                self.xminmax=[xvalues[0][0],xvalues[0][-1]]
+
+                if double:
+                    valueAmp = parm.valueAmp(self.domain, self.resolution, asPolar = self.polar)
+
+                    if self.axis == 0: # time on x-axis
+                        amp.append(valueAmp[:, self.index])
+                    else:              # freq on x-axis
+                        amp.append(valueAmp[self.index, :])
+               
+                labels.append(parm._name)
+
+        legend = self.show_legend and len(labels) > 0
+        if self.valuesonxaxis:
+            xlabel = ["Time (minutes since start)", "Freq (MHz)"][self.axis]
+        else:
+            xlabel = ["Time (sample)", "Freq (sample)"][self.axis]
+
+        if self.calType == "CommonRotationAngle" or self.calType == "RotationAngle":
+            phaselabel = "Rotation angle (rad)"
+        else:
+            phaselabel = "Phase (rad)"
+
+
+        if double:
+            if self.polar:
+                    self.valminmax[0] = plot(self.fig, amp, x=xvalues, sub="211", labels=labels, show_legend=legend, xlabel=xlabel, ylabel="Amplitude",scatter=self.use_points)
+                    self.valminmax[1] = plot(self.fig, phase, x=xvalues, clf=False, sub="212", stack=True, scatter=True, labels=labels, show_legend=legend, xlabel=xlabel, ylabel=phaselabel)
+            else:
+                    self.valminmax[0] = plot(self.fig, amp, x=xvalues, sub="211", labels=labels, show_legend=legend, xlabel=xlabel, ylabel="Real",scatter=self.use_points)
+                    self.valminmax[1] = plot(self.fig, phase, x=xvalues, clf=False, sub="212", labels=labels, show_legend=legend, xlabel=xlabel, ylabel="Imaginary",scatter=self.use_points)
+        else:
+            self.valminmax[0] = plot(self.fig, phase, x=xvalues, sub="111", stack=True, scatter=True, labels=labels, show_legend=legend, xlabel=xlabel, ylabel=phaselabel)
+
+        self.resize_plot()
+        self.canvas.draw()
+
+
 class MainWindow(QFrame):
     def __init__(self, db):
         QFrame.__init__(self)
@@ -524,15 +789,12 @@ class MainWindow(QFrame):
         self.list.setSelectionMode(QAbstractItemView.ExtendedSelection)
         layout.addWidget(self.list, 1)
 
-        self.useResolution = True
+        self.useResolution = False
         checkResolution = QCheckBox("Use resolution")
-        checkResolution.setChecked(True)
+        checkResolution.setChecked(False)
         self.connect(checkResolution, SIGNAL('stateChanged(int)'), self.handle_resolution)
 
         self.resolution = [QLineEdit(), QLineEdit()]
-#        validator = QDoubleValidator(self.resolution[0])
-#        validator.setRange(1.0, 2.0)
-#        self.resolution[0].setValidator(validator)
         self.resolution[0].setAlignment(Qt.AlignRight)
         self.resolution[1].setAlignment(Qt.AlignRight)
 
@@ -563,6 +825,7 @@ class MainWindow(QFrame):
             parm = names.pop()
             split = parm.split(":")
 
+            # just one entry for Real/Imag or Amp/Ph
             if contains(split, "Real") or contains(split, "Imag"):
                 if contains(split, "Real"):
                     idx = split.index("Real")
@@ -584,7 +847,7 @@ class MainWindow(QFrame):
                     elements = [other, parm]
 
                 split.pop(idx)
-                self.parms.append(Parm(self.db, ":".join(split), elements))
+                self.parms.append(Parm(self.db, ":".join(split), elements, isPolar = False))
 
             elif contains(split, "Ampl") or contains(split, "Phase"):
                 if contains(split, "Ampl"):
@@ -607,24 +870,25 @@ class MainWindow(QFrame):
                     elements = [other, parm]
 
                 split.pop(idx)
-                self.parms.append(Parm(self.db, ":".join(split), elements, True))
+                self.parms.append(Parm(self.db, ":".join(split), elements, isPolar = True))
             else:
                 self.parms.append(Parm(self.db, parm))
 
         self.parms = [parm for parm in self.parms if not parm.empty()]
-        self.parms.sort(cmp=lambda x, y: cmp(x.name(), y.name()))
+        self.parms.sort(cmp=lambda x, y: cmp(x._name, y._name))
 
         domain = common_domain(self.parms)
         if not domain is None:
-            self.resolution[0].setText("%.6f" % ((domain[1] - domain[0]) / 100.0))
-            self.resolution[1].setText("%.6f" % ((domain[3] - domain[2]) / 100.0))
+            self.resolution[0].setText("%.3f" % ((domain[1] - domain[0]) / 100.0))
+            self.resolution[1].setText("%.3f" % ((domain[3] - domain[2]) / 100.0))
 
         for parm in self.parms:
-            name = parm.name()
-            if parm.isPolar():
+            name = parm._name
+            if parm._isPolar and (parm._calType == 'Gain' or parm._calType == 'DirectionalGain'):
                 name = "%s (polar)" % name
 
-            QListWidgetItem(name, self.list)
+            it = QListWidgetItem(name, self.list)
+            it.setBackground(parm.color())
 
     def close_all_figures(self):
         for figure in self.figures:
@@ -643,7 +907,13 @@ class MainWindow(QFrame):
         if self.useResolution:
             resolution = [float(item.text()) for item in self.resolution]
 
-        self.figures.append(PlotWindow(self.parms, selection, resolution, title="Figure %d" % (len(self.figures) + 1)))
+        # plot together only parms of the same type
+        calTypes = set([self.parms[idx]._calType for idx in selection])
+        for calType in calTypes:
+            this_selection = [idx for idx in selection if self.parms[idx]._calType == calType]
+
+            self.figures.append(PlotWindow(self.parms, this_selection, resolution, title="Figure %d" % (len(self.figures) + 1)))
+            
             self.figures[-1].show()
 
     def handle_close(self):
@@ -659,7 +929,11 @@ if __name__ == "__main__":
         print "usage: parmdbplot.py <parmdb>"
         sys.exit(1)
 
+    try:
         db = parmdb.parmdb(sys.argv[1])
+    except:
+        print "ERROR:", sys.argv[1], "is not a valid parmdb."
+        sys.exit(1)
 
     app = QApplication(sys.argv)
     window = MainWindow(db)