Two contour plots in single viewer- Python FiPy

Question

I am trying to solve two independent variables varying geometrically over a given domain. I want to plot their variance in a single viewer display. How can I get two different contour plots one each for the independent variable in single viewer box? I have used the following code for double contour but cannot get different contours for both the variables (phasegamma and phasesigma in my case). Please suggest how it can be corrected or any other possible way to get two contours in one plot.

import pylab
class PhaseViewer(Matplotlib2DGridViewer):
   def __init__(self, phasesigma, phasegamma, title = None, limits ={}, **kwlimits):
       self.phasesigma = phasesigma
       self.contour1 = None
       self.phasegamma = phasegamma
       self.contour2 = None

       Matplotlib2DGridViewer.__init__(self, vars=(1-phasegamma-phasesigma),title=title,cmap=pylab.cm.hot,limits ={}, **kwlimits)
   def _plot(self):
       Matplotlib2DGridViewer._plot(self)

       if self.contour1 is not None or self.contour2 is not None:
          for Ccr in self.contour1.collections:
                  Ccr.remove()
          for Cni in self.contour1.collections:
                  Cni.remove()    
       mesh = self.phasesigma.getMesh()
       mesh2 = self.phasegamma.getMesh()
       shape = mesh.getShape()
       shape2 = mesh2.getShape()
       x, y = mesh.getCellCenters()
       z = self.phasesigma.getValue()
       x, y, z = [a.reshape(shape, order="FORTRAN") for a in (x, y, z)]
       self.contour1 = pylab.contour(x, y, z, (0.5,))
       l, m = mesh1.getCellCenters()
       w = self.phasegamma.getValue()
       l, m, w = [b.reshape(shape, order ="FORTRAN") for b in (l, m, w)]
       self.contour2 = pylab.contour(l, m, w, (0.5,))
       raw_input("check2")

viewer = PhaseViewer(phasesigma=phasesigma, phasegamma=phasegamma,\
            title = r"%s & %s" % (phasegamma.name, phasesigma.name), datamin=0., datamax=1.)

except ImportError: viewer = MultiViewer(viewers=(Viewer(vars=phasesigma,datamin=0.,datamax=1),Viewer(vars=phasegamma,datamin=0.,datamax=1.)))

Answer 1

I just saw this, so hopefully it's still useful to you. I'm not sure why your version didn't work, although I generally find that pylab works at too high a level and does too many things automatically.

I based the following on Matplotlib2DContourViewer and it seems to do what you want:

class PhaseViewer(Matplotlib2DGridViewer):
   def __init__(self, phasesigma, phasegamma, title = None, limits ={}, **kwlimits):
       self.phasesigma = phasesigma
       self.contour1 = None
       self.phasegamma = phasegamma
       self.contour2 = None
       self.number = 10
       self.levels = None

       Matplotlib2DGridViewer.__init__(self, vars=(1-phasegamma-phasesigma),title=title,cmap=pylab.cm.hot,limits ={}, **kwlimits)
   def _plot(self):
       Matplotlib2DGridViewer._plot(self)

       if hasattr(self, "_contourSet"):
           for countourSet in self._contourSet:
               for collection in ccontourSet.collections:
                   try:
                       ix = self.axes.collections.index(collection)
                   except ValueError, e:
                       ix = None

                   if ix is not None:
                       del self.axes.collections[ix]
       self._contourSet = []

       for var in (self.phasesigma, self.phasegamma):
           mesh = var.mesh
           x, y = mesh.cellCenters
           z = var.value

           xmin, ymin = mesh.extents['min']
           xmax, ymax = mesh.extents['max']

           from matplotlib.mlab import griddata

           xi = fp.numerix.linspace(xmin, xmax, 1000)
           yi = fp.numerix.linspace(ymin, ymax, 1000)
           # grid the data.
           zi = griddata(x, y, z, xi, yi, interp='linear')


           zmin, zmax = self._autoscale(vars=[var],
                                        datamin=self._getLimit(('datamin', 'zmin')),
                                        datamax=self._getLimit(('datamax', 'zmax')))

           self.norm.vmin = zmin
           self.norm.vmax = zmax

           if self.levels is not None:
               levels = self.levels
           else:
               levels = fp.numerix.arange(self.number + 1) * (zmax - zmin) / self.number + zmin


           self._contourSet.append(self.axes.contour(xi, yi, zi, levels=levels, cmap=self.cmap))

       self.axes.set_xlim(xmin=self._getLimit('xmin'),
                          xmax=self._getLimit('xmax'))

       self.axes.set_ylim(ymin=self._getLimit('ymin'),
                          ymax=self._getLimit('ymax'))

       if self.colorbar is not None:
               self.colorbar.plot()