code: def to_directed(self):
          
          from .dyndigraph import DynDiGraph
          G = DynDiGraph()
          G.name = self.name
          G.add_nodes_from(self)
          for it in self.interactions_iter():
              for t in it[2]['t']:
                  G.add_interaction(it[0], it[1], t=t[0], e=t[1])
  
          G.graph = deepcopy(self.graph)
          G._node = deepcopy(self._node)
          return G
docs: Return a directed representation of the graph.
  
          Returns
          -------
          G : DynDiGraph
              A dynamic directed graph with the same name, same nodes, and with
              each edge (u,v,data) replaced by two directed edges
              (u,v,data) and (v,u,data).
  
          Notes
          -----
          This returns a "deepcopy" of the edge, node, and
          graph attributes which attempts to completely copy
          all of the data and references.
  
          This is in contrast to the similar D=DynDiGraph(G) which returns a
          shallow copy of the data.
  
          See the Python copy module for more information on shallow
          and deep copies, http://docs.python.org/library/copy.html.
  
          Warning: If you have subclassed Graph to use dict-like objects in the
          data structure, those changes do not transfer to the DynDiGraph
          created by this method.
  
          Examples
          --------
          >>> G = dn.DynGraph()   # or MultiGraph, etc
          >>> G.add_path([0,1])
          >>> H = G.to_directed()
          >>> H.edges()
          [(0, 1), (1, 0)]
  
          If already directed, return a (deep) copy
  
          >>> G = dn.DynDiGraph()   # or MultiDiGraph, etc
          >>> G.add_path([0,1])
          >>> H = G.to_directed()
          >>> H.edges()
          [(0, 1)]