Creating fixed set of nodes using networkx in python

Question

I have a problem concerning graph diagrams. I have 30 nodes(points). I want to construct an adjacency matrix in such a way that each ten set of nodes are like at a vertices of a triangle. So lets say a group of 10 nodes is at the vertex A, B and C of a triangle ABC.

Two of the vertex sets should have only 10 edges(basically each node within a cluster is connected to other one). Lets say groups at A and B have 10 edges within the group. While the third vertex set should have 11 edges(10 for each nodes and one node connecting with two nodes, so 11 edges in that group). Lets say the one at C has 11 edges in it.

All these three clusters would be having one edge between them to form a triangle.That is connect group at A with group at B with one edge and B with C with one edge and C with A with one edge.

Later on I would add one more edge between B and C. Represented as dotted line in the attached figure. The point at a vertex can be in a circle or any other formation as long as they represent a group.

How do I create an adjacency matrix for such a thing. I actually know how to create the adjacency matrix for such a matrix as it is just binary symmetric matrix(undirected graph) but the problem is when I try to plot that adjacency matrix it would bring the one node from other group closer to the group to which that node is connected. So lets say I connected one node at Vertex A with one node at Vertex B by connecting an edge between the two. This edge would depict the side AB of the triangle. But when I depict it using networkx then those two nodes which are connected from these two different groups would eventually come closer and look like part of one group. How do I keep it as separate group. ?

Pls note I am making use of networkx lib of python which helps plot the adjacency matrix.

EDIT:

A code I am trying to use after below inspiration:

G=nx.Graph()
# Creating three separate groups of nodes (10 nodes each)
node_clusters = [range(1,11), range(11,21) , range(21,31)]

# Adding edges between each set of nodes in each group. 
for x in node_clusters:
    for y in x: 
        if(y!=x[-1]):
            G.add_edge(y,y+1,len=2)
        else: 
            G.add_edge(y,x[0],len=2)
# Adding three inter group edges separately:
for x in range(len(node_clusters)):
    if(x<2):
        G.add_edge(node_clusters[x][-1],node_clusters[x+1][0],len=8)
    else:
        G.add_edge(node_clusters[x][-1],node_clusters[0][0],len=8)

nx.draw_graphviz(G, prog='neato')

Gives the following error:

--> 260                           '(not available for Python3)')
    261     if root is not None:
    262         args+="-Groot=%s"%root

ImportError: ('requires pygraphviz ', 'http://networkx.lanl.gov/pygraphviz ', '(not available for Python3)')

My python version is not 3, its 2. And am using anaconda distribution

EDIT2:

I used Marius's code but instead used the following to plot:

graph_pos=nx.spring_layout(G,k=0.20,iterations=50)
nx.draw_networkx(G,graph_pos)

It has destroyed completely the whole graph. and shows this:

Answer 1

I was able to get something going fairly quickly just by hacking away at this, all you need to do is put together tuples representing each edge, you can also set some arbitrary lengths on the edges to get a decent approximation of your desired layout:

import networkx
import string

all_nodes = string.ascii_letters[:30]
a_nodes = all_nodes[:10]
b_nodes = all_nodes[10:20]
c_nodes = all_nodes[20:]

all_edges = []
for node_set in [a_nodes, b_nodes, c_nodes]:
    # Link each node to the next
    for i, node in enumerate(node_set[:-1]):
        all_edges.append((node, node_set[i + 1], 2))
    # Finish off the circle
    all_edges.append((node_set[0], node_set[-1], 2))

joins = [(a_nodes[0], b_nodes[0], 8), (b_nodes[-1], c_nodes[0], 8), (c_nodes[-1], a_nodes[-1], 8)]

all_edges += joins
# One extra edge for C:
all_edges.append((c_nodes[0], c_nodes[5], 5))

G = networkx.Graph()
for edge in all_edges:
    G.add_edge(edge[0], edge[1], len=edge[2])

networkx.draw_graphviz(G, prog='neato')

Try something like networkx.to_numpy_matrix(G) if you then want to export as an adjacency matrix.