def draw_diagram_edges(graph, pos=None, edgelist=None, width=1.0,
                       edge_color='k', style='dashed', alpha=1.0,
                       edge_cmap=None, edge_vmin=None, edge_vmax=None, ax=None,
                       label=None, nodelist=None, node_size=.7):
    """
    Draw edges of graph.

    This draws only the edges of a graph.

    Parameters
    ----------
    graph : `networkx.Graph`
        A NetworkX graph.
    pos : mapping, optional
        A mapping with nodes as keys and positions as values. Positions should
        be sequences of length 2. If not specified (default), a diagram layout
        positioning will be computed. See `networkx.layout` and
        `pyrrole.drawing` for functions that compute node positions.
    edgelist : collection of edge `tuple`
        Draw only specified edges (default is ``graph.edges()``).
    width : `float`, or array of `float`
        Line width of edges (default is ``1.0``).
    edge_color : color `str`, or array of `float`
        Edge color. Can be a single color format `str` (default is ``'r'``),
        or a sequence of colors with the same length as edgelist. If numeric
        values are specified they will be mapped to colors using the
        `edge_cmap` and `edge_vmin`, `edge_vmax` parameters.
    style : `str` (``'solid'``, ``'dashed'``, ``'dotted'``, ``'dashdot'``)
        Edge line style (default is ``'dashed'``). See `matplotlib.hlines` for
        more details.
    alpha : `float`, optional
        The edge transparency (default is ``1.0``).
    edge_cmap : Matplotlib colormap, optional
        Colormap for mapping intensities of edges.
    edge_vmin : `float`, optional
        Minimum for edge colormap scaling.
    edge_vmax : `float`, optional
        Maximum for edge colormap scaling.
    ax : `matplotlib.axes.Axes`, optional
        Draw the graph in the specified Matplotlib axes.
    label : `str`,  optional
        Label for legend.
    nodelist : `list`, optional
        Draw only specified nodes (default is ``graph.nodes()``).
    node_size : scalar or array
        Size of nodes (default is ``.7``). If an array is specified it must be
        the same length as nodelist.

    Returns
    -------
    `matplotlib.collections.LineCollection`
        `LineCollection` of the edges.

    Raises
    ------
    networkx.NetworkXError
        Raised if a node has no position or one with bad value.
    ValueError
        Raised if `edge_color` contains something other than color names (one
        or a list of one per edge) or numbers.

    Examples
    --------
    >>> import pandas as pd
    >>> from pyrrole import ChemicalSystem
    >>> from pyrrole.drawing import draw_diagram_edges
    >>> data = pd.DataFrame(
    ...     [{"name": "Separated_Reactants", "freeenergy": 0.},
    ...      {"name": "mlC1", "freeenergy": -5.4},
    ...      {"name": "mlC2", "freeenergy": -15.6},
    ...      {"name": "mTS1", "freeenergy": 28.5, "color": "g"},
    ...      {"name": "mCARB1", "freeenergy": -9.7},
    ...      {"name": "mCARB2", "freeenergy": -19.8},
    ...      {"name": "mCARBX", "freeenergy": 20}]).set_index("name")
    >>> system = ChemicalSystem(
    ...     ["Separated_Reactants -> mlC1 -> mTS1",
    ...      "Separated_Reactants -> mlC2 -> mTS1",
    ...      "mCARB2 <- mTS1 -> mCARB1",
    ...      "Separated_Reactants -> mCARBX"], data)
    >>> digraph = system.to_digraph()
    >>> edges = draw_diagram_edges(digraph)

    """
    if ax is None:
        ax = _plt.gca()

    if edgelist is None:
        edgelist = list(graph.edges())

    if not edgelist or len(edgelist) == 0:  # no edges!
        return None

    if nodelist is None:
        nodelist = list(graph.nodes())

    if pos is None:
        pos = diagram_layout(graph)

    try:
        # set edge positions
        edge_pos = _np.asarray([(pos[e[0]] + node_size/2.,
                                 pos[e[1]] - node_size/2.) for e in edgelist])
    except KeyError as e:
        raise _nx.NetworkXError('Node {} has no position.'.format(e))
    except ValueError:
        raise _nx.NetworkXError('Bad value in node positions.')

    if not _cb.iterable(width):
        lw = (width,)
    else:
        lw = width

    if not isinstance(edge_color, str) \
            and _cb.iterable(edge_color) \
            and len(edge_color) == len(edge_pos):
        if _np.alltrue([isinstance(c, str) for c in edge_color]):
            # (should check ALL elements)
            # list of color letters such as ['k','r','k',...]
            edge_colors = tuple([_colorConverter.to_rgba(c, alpha)
                                 for c in edge_color])
        elif _np.alltrue([not isinstance(c, str) for c in edge_color]):
            # If color specs are given as (rgb) or (rgba) tuples, we're OK
            if _np.alltrue([_cb.iterable(c) and len(c) in (3, 4)
                            for c in edge_color]):
                edge_colors = tuple(edge_color)
            else:
                # numbers (which are going to be mapped with a colormap)
                edge_colors = None
        else:
            raise ValueError('edge_color must contain color names or numbers')
    else:
        if isinstance(edge_color, str) or len(edge_color) == 1:
            edge_colors = (_colorConverter.to_rgba(edge_color, alpha), )
        else:
            raise ValueError('edge_color must be a color or list of one color '
                             ' per edge')

    edge_collection = _LineCollection(edge_pos,
                                      colors=edge_colors,
                                      linewidths=lw,
                                      antialiaseds=(1,),
                                      linestyle=style,
                                      transOffset=ax.transData)

    edge_collection.set_zorder(1)  # edges go behind nodes
    edge_collection.set_label(label)
    ax.add_collection(edge_collection)

    if _cb.is_numlike(alpha):
        edge_collection.set_alpha(alpha)

    if edge_colors is None:
        if edge_cmap is not None:
            assert(isinstance(edge_cmap, _Colormap))
        edge_collection.set_array(_np.asarray(edge_color))
        edge_collection.set_cmap(edge_cmap)
        if edge_vmin is not None or edge_vmax is not None:
            edge_collection.set_clim(edge_vmin, edge_vmax)
        else:
            edge_collection.autoscale()

    ax.autoscale_view()
    return edge_collection
Draw edges of graph.

    This draws only the edges of a graph.

    Parameters
    ----------
    graph : `networkx.Graph`
        A NetworkX graph.
    pos : mapping, optional
        A mapping with nodes as keys and positions as values. Positions should
        be sequences of length 2. If not specified (default), a diagram layout
        positioning will be computed. See `networkx.layout` and
        `pyrrole.drawing` for functions that compute node positions.
    edgelist : collection of edge `tuple`
        Draw only specified edges (default is ``graph.edges()``).
    width : `float`, or array of `float`
        Line width of edges (default is ``1.0``).
    edge_color : color `str`, or array of `float`
        Edge color. Can be a single color format `str` (default is ``'r'``),
        or a sequence of colors with the same length as edgelist. If numeric
        values are specified they will be mapped to colors using the
        `edge_cmap` and `edge_vmin`, `edge_vmax` parameters.
    style : `str` (``'solid'``, ``'dashed'``, ``'dotted'``, ``'dashdot'``)
        Edge line style (default is ``'dashed'``). See `matplotlib.hlines` for
        more details.
    alpha : `float`, optional
        The edge transparency (default is ``1.0``).
    edge_cmap : Matplotlib colormap, optional
        Colormap for mapping intensities of edges.
    edge_vmin : `float`, optional
        Minimum for edge colormap scaling.
    edge_vmax : `float`, optional
        Maximum for edge colormap scaling.
    ax : `matplotlib.axes.Axes`, optional
        Draw the graph in the specified Matplotlib axes.
    label : `str`,  optional
        Label for legend.
    nodelist : `list`, optional
        Draw only specified nodes (default is ``graph.nodes()``).
    node_size : scalar or array
        Size of nodes (default is ``.7``). If an array is specified it must be
        the same length as nodelist.

    Returns
    -------
    `matplotlib.collections.LineCollection`
        `LineCollection` of the edges.

    Raises
    ------
    networkx.NetworkXError
        Raised if a node has no position or one with bad value.
    ValueError
        Raised if `edge_color` contains something other than color names (one
        or a list of one per edge) or numbers.

    Examples
    --------
    >>> import pandas as pd
    >>> from pyrrole import ChemicalSystem
    >>> from pyrrole.drawing import draw_diagram_edges
    >>> data = pd.DataFrame(
    ...     [{"name": "Separated_Reactants", "freeenergy": 0.},
    ...      {"name": "mlC1", "freeenergy": -5.4},
    ...      {"name": "mlC2", "freeenergy": -15.6},
    ...      {"name": "mTS1", "freeenergy": 28.5, "color": "g"},
    ...      {"name": "mCARB1", "freeenergy": -9.7},
    ...      {"name": "mCARB2", "freeenergy": -19.8},
    ...      {"name": "mCARBX", "freeenergy": 20}]).set_index("name")
    >>> system = ChemicalSystem(
    ...     ["Separated_Reactants -> mlC1 -> mTS1",
    ...      "Separated_Reactants -> mlC2 -> mTS1",
    ...      "mCARB2 <- mTS1 -> mCARB1",
    ...      "Separated_Reactants -> mCARBX"], data)
    >>> digraph = system.to_digraph()
    >>> edges = draw_diagram_edges(digraph)