fix possible_hoppings, add test

kwant/builder.py

@@ -889,12 +889,15 @@ class Builder(object):
         self.leads.extend(other_sys.leads)
         return self
 
-    def possible_hoppings(self, delta, group_b, group_a):
+    def possible_hoppings(self, delta, group_a, group_b):
         """Return all matching possible hoppings between existing sites.
 
         A hopping ``(a, b)`` matches precisely when the site group of ``a`` is
-        `group_a` and that of ``b`` is `group_b` and ``(a.tag - b.tag)``
-        (interpreted as vectors) equals to `delta`.
+        `group_a` and that of ``b`` is `group_b` and ``(a.tag - b.tag)`` is
+        equal to `delta`.
+
+        In other words, the matching hoppings have the form:
+        ``(group_a(x + delta), group_b(x))``
 
         Parameters
         ----------
@@ -910,13 +913,13 @@ class Builder(object):
         """
         H = self.H
         symtofd = self.symmetry.to_fd
-        d = -ta.array(delta, int)
-        for site0 in self.H:
-            if site0.group is not group_a:
+        delta = ta.array(delta, int)
+        for a in self.H:
+            if a.group is not group_a:
                 continue
-            site1 = Site(group_b, site0.tag + d, True)
-            if symtofd(site1) in H: # if site1 in self
-                yield site0, site1
+            b = Site(group_b, a.tag - delta, True)
+            if symtofd(b) in H:
+                yield a, b
 
     def attach_lead(self, lead_builder, origin=None):
         """Attach a lead to the builder, possibly adding missing sites.

kwant/tests/test_builder.py

@@ -492,10 +492,47 @@ def test_iadd():
     sys += other_sys
     assert_equal(sys.leads, [lead0, lead1])
     expected = sorted([[(0,), 1], [(1,), 2], [(2,), 2]])
-    assert_equal(sorted(((s.tag, v) for s, v in sys.site_value_pairs())), 
+    assert_equal(sorted(((s.tag, v) for s, v in sys.site_value_pairs())),
                  expected)
     expected = sorted([[(0,), (1,), 1], [(1,), (2,), 1]])
     assert_equal(sorted(((a.tag, b.tag, v)
-                         for (a, b), v in sys.hopping_value_pairs())), 
+                         for (a, b), v in sys.hopping_value_pairs())),
                  expected)
 
+# y=0:    y=1:
+#
+# hhhh    hhhh
+# gggh    gggh
+# hhgh    hhgh
+# ghgh    hhgh
+#
+def test_possible_hoppings():
+    g = kwant.make_lattice(ta.identity(3))
+    h = kwant.make_lattice(ta.identity(3))
+    sym = kwant.TranslationalSymmetry((0, 2, 0))
+    sys = builder.Builder(sym)
+    sys[((h if max(x, y, z) % 2 else g)(x, y, z)
+         for x in range(4) for y in range(2) for z in range(4))] = None
+    for delta, group_a, group_b, n in [((1, 0, 0), g, h, 4),
+                                       ((1, 0, 0), h, g, 7),
+                                       ((0, 1, 0), g, h, 1),
+                                       ((0, 4, 0), h, h, 21),
+                                       ((0, 0, 1), g, h, 4)
+                                       ]:
+        ph = list(sys.possible_hoppings(delta, group_a, group_b))
+        assert_equal(len(ph), n)
+        ph = set(ph)
+        assert_equal(len(ph), n)
+
+        ph2 = list((
+                sym.to_fd(b, a) for a, b in
+                sys.possible_hoppings(ta.negative(delta), group_b, group_a)))
+        assert_equal(len(ph2), n)
+        ph2 = set(ph2)
+        assert_equal(ph2, ph)
+
+        for a, b in ph:
+            assert a.group is group_a
+            assert b.group is group_b
+            assert sym.to_fd(a) == a
+            assert_equal(a.tag - b.tag, delta)