docs: def patch(*args,**kwargs):
    '''
  Add patches to plot. The color of the patches is indexed according to a specified color-index.
  
  :example:
  
    Plot a finite element mesh: the outline of the undeformed configuration, and the deformed
    configuration for which the elements get a color e.g. based on stress::
  
      import matplotlib.pyplot as plt
      import goosempl          as gplt
  
      fig,ax = plt.subplots()
  
      p = gplt.patch(coor=coor+disp,conn=conn,axis=ax,cindex=stress,cmap='YlOrRd',edgecolor=None)
      _ = gplt.patch(coor=coor     ,conn=conn,axis=ax)
  
      cbar = fig.colorbar(p,axis=ax,aspect=10)
  
      plt.show()
  
  :arguments - option 1/2:
  
    **patches** (``<list>``)
      List with patch objects. Can be replaced by specifying ``coor`` and ``conn``.
  
  :arguments - option 2/2:
  
    **coor** (``<numpy.ndarray>`` | ``<list>`` (nested))
      Matrix with on each row the coordinates (positions) of each node.
  
    **conn** (``<numpy.ndarray>`` | ``<list>`` (nested))
      Matrix with on each row the number numbers (rows in ``coor``) which form an element (patch).
  
  :options:
  
    **cindex** (``<numpy.ndarray>``)
      Array with, for each patch, the value that should be indexed to a color.
  
    **axis** (``<matplotlib>``)
      Specify an axis to include to plot in. By default the current axis is used.
  
    **autoscale** ([``True``] | ``False``)
      Automatically update the limits of the plot (currently automatic limits of Collections are not
      supported by matplotlib).
  
  :recommended options:
  
    **cmap** (``<str>`` | ...)
      Specify a colormap.
  
    **linewidth** (``<float>``)
      Width of the edges.
  
    **edgecolor** (``<str>`` | ...)
      Color of the edges.
  
    **clim** (``(<float>,<float>)``)
      Lower and upper limit of the color-axis.
  
  :returns:
  
    **handle** (``<matplotlib>``)
      Handle of the patch objects.
  
  .. seealso::
  
    * `matplotlib example
      <http://matplotlib.org/examples/api/patch_collection.html>`_.
    '''
  
    from matplotlib.collections import PatchCollection
    from matplotlib.patches     import Polygon
  
    # check dependent options
    if ( 'coor' not in kwargs or 'conn' not in kwargs ):
      raise IOError('Specify both "coor" and "conn"')
  
    # extract local options
    axis      = kwargs.pop( 'axis'      , plt.gca() )
    cindex    = kwargs.pop( 'cindex'    , None      )
    coor      = kwargs.pop( 'coor'      , None      )
    conn      = kwargs.pop( 'conn'      , None      )
    autoscale = kwargs.pop( 'autoscale' , True      )
  
    # set defaults
    kwargs.setdefault('edgecolor','k')
  
    # no color-index -> set transparent
    if cindex is None:
      kwargs.setdefault('facecolor',(0.,0.,0.,0.))
  
    # convert mesh -> list of Polygons
    if coor is not None and conn is not None:
      poly = []
      for iconn in conn:
        poly.append(Polygon(coor[iconn,:]))
      args = tuple(poly, *args)
  
    # convert patches -> matplotlib-objects
    p = PatchCollection(args,**kwargs)
    # add colors to patches
    if cindex is not None:
      p.set_array(cindex)
    # add patches to axis
    axis.add_collection(p)
  
    # rescale the axes manually
    if autoscale:
      # - get limits
      xlim = [ np.min(coor[:,0]) , np.max(coor[:,0]) ]
      ylim = [ np.min(coor[:,1]) , np.max(coor[:,1]) ]
      # - set limits +/- 10% extra margin
      axis.set_xlim([xlim[0]-.1*(xlim[1]-xlim[0]),xlim[1]+.1*(xlim[1]-xlim[0])])
      axis.set_ylim([ylim[0]-.1*(ylim[1]-ylim[0]),ylim[1]+.1*(ylim[1]-ylim[0])])
  
    return p