normalized Chimera, Pegasus and Zephyr layouts to unit square

Author: boothby

dwave_networkx/drawing/chimera_layout.py

@@ -141,10 +141,11 @@ def chimera_node_placer_2d(m, n, t, scale=1., center=None, dim=2):
     """
     import numpy as np
 
+    center_pad = 1
     tile_center = t // 2
-    tile_length = t + 3  # 1 for middle of cross, 2 for spacing between tiles
+    tile_length = t + 2 + center_pad  # 2 for spacing between tiles
     # want the enter plot to fill in [0, 1] when scale=1
-    scale /= max(m, n) * tile_length - 3
+    scale /= max(m, n) * tile_length - 2 - center_pad
 
     grid_offsets = {}
 
@@ -153,10 +154,11 @@ def chimera_node_placer_2d(m, n, t, scale=1., center=None, dim=2):
     else:
         center = np.asarray(center)
 
-    paddims = dim - 2
-    if paddims < 0:
+    if dim < 2:
         raise ValueError("layout must have at least two dimensions")
 
+    paddims = np.zeros(dim - 2, dtype='float')
+
     if len(center) != dim:
         raise ValueError("length of center coordinates must match dimension of layout")
 
@@ -167,24 +169,24 @@ def _xy_coords(i, j, u, k):
         if k < tile_center:
             p = k
         else:
-            p = k + 1
+            p = k + center_pad
 
         if u:
-            xy = np.array([tile_center, -1 * p])
+            xy = np.array([tile_center, -1 * p], dtype='float')
         else:
-            xy = np.array([p, -1 * tile_center])
+            xy = np.array([p, -1 * tile_center], dtype='float')
 
         # next offset the corrdinates based on the which tile
         if i > 0 or j > 0:
             if (i, j) in grid_offsets:
                 xy += grid_offsets[(i, j)]
             else:
-                off = np.array([j * tile_length, -1 * i * tile_length])
+                off = np.array([j * tile_length, -1 * i * tile_length], dtype='float')
                 xy += off
                 grid_offsets[(i, j)] = off
 
         # convention for Chimera-lattice pictures is to invert the y-axis
-        return np.hstack((xy * scale, np.zeros(paddims))) + center
+        return np.hstack((xy * scale, paddims)) + center
 
     return _xy_coords
 

dwave_networkx/drawing/pegasus_layout.py

@@ -129,48 +129,48 @@ def pegasus_node_placer_2d(G, scale=1., center=None, dim=2, crosses=False):
     """
     import numpy as np
 
-    m = G.graph.get('rows')
-    h_offsets = G.graph.get("horizontal_offsets")
-    v_offsets = G.graph.get("vertical_offsets")
-    tile_width = G.graph.get("tile")
+    m = G.graph['rows']
+    h_offsets = G.graph["horizontal_offsets"]
+    v_offsets = G.graph["vertical_offsets"]
+    tile_width = G.graph["tile"]
+    odd_k_wobble = .05
     tile_center = tile_width / 2 - .5
+    cross_shift = 2 if crosses else 0
 
     # want the enter plot to fill in [0, 1] when scale=1
-    scale /= m * tile_width
+    scale /= m*tile_width - 2*odd_k_wobble - 1
 
     if center is None:
         center = np.zeros(dim)
     else:
         center = np.asarray(center)
 
-    paddims = dim - 2
-    if paddims < 0:
+    center[0] -= (cross_shift + odd_k_wobble)*scale
+    center[1] -= (cross_shift - odd_k_wobble)*scale
+
+    if dim < 0:
         raise ValueError("layout must have at least two dimensions")
 
+    paddims = np.zeros(dim - 2)
+
     if len(center) != dim:
         raise ValueError("length of center coordinates must match dimension of layout")
 
-    if crosses:
-        # adjustment for crosses
-        cross_shift = 2.
-    else:
-        cross_shift = 0.
-
     def _xy_coords(u, w, k, z):
         # orientation, major perpendicular offset, minor perpendicular offset, parallel offset
 
         if k % 2:
-            p = -.1
+            p = -odd_k_wobble
         else:
-            p = .1
+            p = odd_k_wobble
 
         if u:
-            xy = np.array([z*tile_width+h_offsets[k] + tile_center, -tile_width*w-k-p+cross_shift])
+            xy = np.array([z*tile_width+h_offsets[k] + tile_center, -tile_width*w-k-p+cross_shift], dtype='float')
         else:
-            xy = np.array([tile_width*w+k+p+cross_shift, -z*tile_width-v_offsets[k]-tile_center])
+            xy = np.array([tile_width*w+k+p+cross_shift, -z*tile_width-v_offsets[k]-tile_center], dtype='float')
 
         # convention for Pegasus-lattice pictures is to invert the y-axis
-        return np.hstack((xy * scale, np.zeros(paddims))) + center
+        return np.hstack((xy * scale, paddims)) + center
 
     return _xy_coords
 

dwave_networkx/drawing/zephyr_layout.py

@@ -113,40 +113,37 @@ def zephyr_node_placer_2d(G, scale=1., center=None, dim=2):
     """
     import numpy as np
 
-    m = G.graph.get('rows')
-    tile_width = G.graph.get("tile")
+    m = G.graph['rows']
+    tile_width = 2*G.graph["tile"]
 
-    # want the enter plot to fill in [0, 1] when scale=1
-    scale /= m * tile_width
+    if dim < 2:
+        raise ValueError("layout must have at least two dimensions")
+
+    paddims = np.zeros(dim - 2)
 
     if center is None:
         center = np.zeros(dim)
     else:
         center = np.asarray(center)
 
-    paddims = dim - 2
-    if paddims < 0:
-        raise ValueError("layout must have at least two dimensions")
-
     if len(center) != dim:
         raise ValueError("length of center coordinates must match dimension of layout")
 
     def _xy_coords(u, w, k, j, z):
         # orientation, major perpendicular offset, secondary perpendicular offset, minor perpendicular offset, parallel offset
-        W = 2*tile_width*w + 2*k + .625*j + .125
-        Z = (2*z+j+1)*2*tile_width - .5
-
+        W = tile_width*w + 2*k + .625*j
+        Z = (2*z+j+1)*tile_width - .6875
         if u:
-            xy = np.array([Z, -W])
+            xy = np.array([Z, -W], dtype='float')
         else:
-            xy = np.array([W, -Z])
-
+            xy = np.array([W, -Z], dtype='float')
 
-        return np.hstack((xy * scale, np.zeros(paddims))) + center
+        return np.hstack((xy * scale, paddims)) + center
 
+    # want the enter plot to fill in [0, 1] when scale=1
+    scale /= max(map(abs, _xy_coords(0, 2*m, G.graph["tile"]-1, 1, m-1)))
     return _xy_coords
 
-
 def draw_zephyr(G, **kwargs):
     """Draws graph G in a Zephyr topology.
 

tests/test_chimera_layout.py

@@ -116,3 +116,15 @@ def test_draw_overlapped_chimera_embedding(self):
         emb = {0: [1, 5], 1: [5, 9, 13], 2: [25, 29], 3: [17, 21]}
         dnx.draw_chimera_embedding(C, emb, overlapped_embedding=True)
         dnx.draw_chimera_embedding(C, emb, overlapped_embedding=True, show_labels=True)
+
+    def test_layout_bounds(self):
+        for C in [dnx.chimera_graph(1, 1, 4), dnx.chimera_graph(2, 2, 2), dnx.chimera_graph(4, 4, 4), dnx.chimera_graph(2, 2, 8)]:
+            pos = dnx.chimera_layout(C)
+            minx = min(x for x, y in pos.values())
+            miny = min(y for x, y in pos.values())
+            maxx = max(x for x, y in pos.values())
+            maxy = max(y for x, y in pos.values())
+            self.assertAlmostEqual(minx, 0)
+            self.assertAlmostEqual(maxx, 1)
+            self.assertAlmostEqual(miny, -1)
+            self.assertAlmostEqual(maxy, 0)

tests/test_pegasus_layout.py

@@ -102,3 +102,15 @@ def test_draw_overlapped_chimera_embedding(self):
         emb = {0: [12, 35], 1: [12, 31], 2: [32], 3: [14]}
         dnx.draw_pegasus_embedding(C, emb, overlapped_embedding=True)
         dnx.draw_pegasus_embedding(C, emb, overlapped_embedding=True, show_labels=True)
+
+    def test_layout_bounds(self):
+        for P in [dnx.pegasus_graph(2, fabric_only=False), dnx.pegasus_graph(3, fabric_only=False), dnx.pegasus_graph(4, fabric_only=False)]:
+            pos = dnx.pegasus_layout(P)
+            minx = min(x for x, y in pos.values())
+            miny = min(y for x, y in pos.values())
+            maxx = max(x for x, y in pos.values())
+            maxy = max(y for x, y in pos.values())
+            self.assertAlmostEqual(minx, 0)
+            self.assertAlmostEqual(maxx, 1)
+            self.assertAlmostEqual(miny, -1)
+            self.assertAlmostEqual(maxy, 0)

tests/test_zephyr_layout.py

@@ -109,3 +109,15 @@ def test_draw_overlapped_zephyr_embedding(self):
         emb = {0: [1, 3], 1: [3, 128, 15], 2: [25, 140], 3: [17, 122]}
         dnx.draw_zephyr_embedding(C, emb, overlapped_embedding=True)
         dnx.draw_zephyr_embedding(C, emb, overlapped_embedding=True, show_labels=True)
+
+    def test_layout_bounds(self):
+        for Z in [dnx.zephyr_graph(2), dnx.zephyr_graph(3), dnx.zephyr_graph(4), dnx.zephyr_graph(2, 8)]:
+            pos = dnx.zephyr_layout(Z)
+            minx = min(x for x, y in pos.values())
+            miny = min(y for x, y in pos.values())
+            maxx = max(x for x, y in pos.values())
+            maxy = max(y for x, y in pos.values())
+            self.assertAlmostEqual(minx, 0)
+            self.assertAlmostEqual(maxx, 1)
+            self.assertAlmostEqual(miny, -1)
+            self.assertAlmostEqual(maxy, 0)