docs: def movie(self, cycles, plotstyle='',movname='',fps=12,**kwargs):
          from matplotlib import animation
          '''
              Make an interactive movie in the matplotlib window for a number of
              different plot types:
  
              Plot types
              ----------
              'iso_abund' : abundance distribution a la se.iso_abund()
              'abu_chart' : abundance chart a la se.abu_chart()
              'plot'      : plot any number of y_items against an x_item
  
              Parameters
              ----------
              cycles : list
                  Which cycles do you want to plot as movie frames?
              plotstyle : string
                  What type of plot should the movie show? Currently supported is
                  'iso_abund', 'abu_chart' and 'plot'
              movname : string, optional
                  Name of movie (+ extension, e.g. .mp4 or .avi) if the movie is
                  to be saved
                  The default is ''
              args : list
                  Arguments to should be passed to the plotting function. These are
                  the arguments of the respective methods that make the frames. See
                  the docstrings of those functions for details
  
              'plot' Parameters
              -----------------
              'xlims'    : tuple, optional
              'ylims'    : tuple, optional
              'xlabel'   : string, optional
              'ylabel'   : string, optional
              'legend'   : boolean, optional
                  The default is False
              'loc'      : string or integer, optional
                  Set the legend location if legend is True.
                  The default is 'best'
              'interval' : frame interval in ms
  
              FAQ:
              ----
              If ffmpeg is not installed on OSX (and you don't want to wait for port to do it) check out
              these binaries:
              http://stackoverflow.com/questions/18833731/how-to-set-ffmpeg-for-matplotlib-in-mac-os-x
  
              '''
  
          modelself=self
          supported_styles=['iso_abund','abu_chart','plot']
          class mov(object):
  
              def __init__(self,cyc,style,movname,fps,**kwargs):
                  self.fig = None
                  self.ax = None
                  self.ani = None
                  self.cyc = cyc
                  self.movname=movname
                  self.fps = fps
                  self.style=style
                  if self.style in supported_styles:
                      animateFunc=draw_frame
                  else:
                      raise IOError("this type of movie is not available yet! Sorry!")
                  if self.style=='plot':
                      self.y_ditems=kwargs['y_items']
                      self.data=kwargs['data']
                  self._init_animation(animateFunc)
  
              def _init_animation(self, animateFunc):
                  if self.style=='plot':
                      fsize=14
                      params = {'axes.labelsize':  fsize,
                          'text.fontsize':   fsize,
                          'legend.fontsize': fsize*0.8,
                          'xtick.labelsize': fsize,
                          'ytick.labelsize': fsize,
                          'text.usetex': False,
                          'figure.facecolor': 'white',
                          'ytick.minor.pad': 8,
                          'ytick.major.pad': 8,
                          'xtick.minor.pad': 8,
                          'xtick.major.pad': 8,
                          'figure.subplot.bottom' : 0.15,
                          'lines.markersize': 8}
                      matplotlib.rcParams.update(params)
  
                      self.fig, self.ax = pl.subplots()
                      tmp=[]
                      for i in range(len(self.y_ditems)):
                          tmp.append(self.data[0][0])
                          tmp.append(self.data[0][i+1])
                      self.lines = self.ax.plot(*tmp)
                      if 'ylims' in kwargs:
                          pl.ylim(kwargs['ylims'])
                      if 'xlims' in kwargs:
                          pl.xlim(kwargs['xlims'])
                      if 'xlabel' in kwargs:
                          pl.xlabel(kwargs['xlabel'])
                      else:
                          pl.xlabel(kwargs['x_item'])
                      if 'ylabel' in kwargs:
                          pl.ylabel(kwargs['ylabel'])
                      else:
                          if type(y_items) is str:
                              lab=y_items
                          elif type(y_items) is list and len(y_items) == 1:
                              lab=y_items[0]
                          else:
                              lab=''
                              for el in kwargs['y_items']:
                                  lab+=el+', '
                              lab=lab[:-2]
                          pl.ylabel(lab)
                      if 'legend' in kwargs and kwargs['legend']:
                          if 'loc' in kwargs:
                              pl.legend([line for line in self.lines], self.y_ditems,
                                        loc=kwargs['loc']).draw_frame(False)
                          else:
                              pl.legend([line for line in self.lines], self.y_ditems,
                                        loc='best').draw_frame(False)
  
                  self._animation(animateFunc)
  
              def _animation(self, animateFunc):
                  if plotstyle=='plot' and 'interval' in kwargs:
                      self.ani = animation.FuncAnimation(self.fig, animateFunc, arange(0, len(self.cyc)), interval=kwargs['interval'], blit=False, fargs=[self])
                  elif plotstyle=='iso_abund':
                      self.fig, self.ax = pl.subplots()
                      ims=[]
                      for i in arange(0,len(self.cyc)):
                          im=draw_frame(i,self)
                          ims.append(im)
                      self.ani = animation.ArtistAnimation(self.fig,ims,interval=50,
                                                               blit=False)
                      self.fig.canvas.draw()
                  elif plotstyle=='abu_chart':
                      self.fig=pl.figure()
                      axx = 0.10
                      axy = 0.10
                      axw = 0.85
                      axh = 0.8
                      self.ax=pl.axes([axx,axy,axw,axh])
                      ims=[]
                      for i in arange(0,len(self.cyc)):
                          im=draw_frame(i,self)
                          # draw_frame here returns the patch for the abundance squares
                          # im[0] as well as the artists im[1], so that the colorbar
                          # can be plotted only once (on the first plot)
                          ims.append(im[1])
                          if i==0:
                              cb=pl.colorbar(im[0])
                              cb.set_label('log$_{10}$(X)',fontsize='x-large')
                      self.ani = animation.ArtistAnimation(self.fig,ims,interval=50,
                                                           blit=False)
                      self.fig.canvas.draw()
  
                  if self.movname is not '':
                      print('\n generating animation: '+self.movname)
                      self.ani.save(self.movname,fps=self.fps)
                      print('animation '+self.movname+' saved with '+str(self.fps)+' frames per second')
  
          plotType=self._classTest()
  
          if plotType=='se':
              if plotstyle == 'iso_abund':
                  data = self.se.get(cycles,['iso_massf','mass'])
                  def draw_frame(i,self=None):
                      artists=modelself.iso_abund(self.cyc[i],stable=True,show=False,
                                               data_provided=True,thedata=data[i],
                                               verbose=False,drawfig=self.fig,drawax=self.ax,
                                               mov=True,**kwargs)
                      return artists
              if plotstyle == 'abu_chart':
                  data = self.se.get(cycles,['iso_massf','mass'])
                  def draw_frame(i,self=None):
                      artists=modelself.abu_chart(self.cyc[i],show=False,data_provided=True,
                                          thedata=data[i],lbound=(-12, -6),drawfig=self.fig,
                                          drawax=self.ax,mov=True,**kwargs)
                      return artists
              if plotstyle=='plot':
                  if 'x_item' not in kwargs or 'y_items' not in kwargs:
                      raise IOError("Please specify both x_item and y_items")
                  x_item = kwargs['x_item']
                  y_items = kwargs['y_items']
                  tx, ty = type(x_item), type(y_items)
                  if tx is list and ty is list:
                      data=self.se.get(cycles,x_item+y_items)
                  elif tx is str and ty is list:
                      data=self.se.get(cycles,[x_item]+y_items)
                  elif tx is str and ty is str:
                      data=self.se.get(cycles,[x_item]+[y_items])
                  def draw_frame(i, self=None):
  #                    pl.title("cycle: " + self.cyc[i])
                      for j in range(len(self.lines)):
                          if 'logy' in kwargs and kwargs['logy']:
                              self.lines[j].set_data(self.data[i][0],
                                                     np.log10(self.data[i][j+1]))
                          else:
                              self.lines[j].set_data(self.data[i][0],
                                                     self.data[i][j+1])
                      return  self.lines
  
          if plotstyle=='plot':
              return mov(cycles,plotstyle,movname,fps,data=data,**kwargs).ani
          else:
              return mov(cycles,plotstyle,movname,fps).ani