builder: implement __iadd__

kwant/builder.py

@@ -241,6 +241,12 @@ class Symmetry(object):
 class NoSymmetry(Symmetry):
     """A symmetry with a trivial symmetry group."""
 
+    def __eq__(self, other):
+        return isinstance(other, NoSymmetry)
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
     def __repr__(self):
         return 'NoSymmetry()'
 
@@ -875,7 +881,14 @@ class Builder(object):
         `other_sys`.  The leads of `other_sys` are appended to the leads of the
         system being extended.
         """
-        raise NotImplementedError()
+        if self.symmetry != other_sys.symmetry:
+            raise ValueError('System to be added has a different symmetry.')
+        for site, value in other_sys.site_value_pairs():
+            self[site] = value
+        for hop, value in other_sys.hopping_value_pairs():
+            self[hop] = value
+        self.leads.extend(other_sys.leads)
+        return self
 
     def possible_hoppings(self, delta, group_b, group_a):
         """Return all matching possible hoppings between existing sites.

kwant/tests/test_builder.py

@@ -465,3 +465,37 @@ def test_neighbors_not_in_single_domain():
     lead[(((0, y), (0, y + 1)) for y in range(2))] = 1
     sr.leads.append(builder.BuilderLead(lead, [lat(i, i) for i in range(3)]))
     assert_raises(ValueError, sr.finalized)
+
+def test_iadd():
+    lat = builder.SimpleSiteGroup()
+
+    sys = builder.Builder()
+    sys[[lat(0,), lat(1,)]] = 1
+    sys[lat(0,), lat(1,)] = 1
+
+    other_sys = builder.Builder()
+    other_sys[[lat(1,), lat(2,)]] = 2
+    other_sys[lat(1,), lat(2,)] = 1
+
+    lead0 = builder.Builder(VerySimpleSymmetry(-1))
+    lead0[lat(0,)] = 1
+    lead0[(lat(0,), lat(1,))] = 1
+    lead0 = builder.BuilderLead(lead0, [lat(0,)])
+    sys.leads.append(lead0)
+
+    lead1 = builder.Builder(VerySimpleSymmetry(1))
+    lead1[lat(2,)] = 1
+    lead1[(lat(2,), lat(1,))] = 1
+    lead1 = builder.BuilderLead(lead1, [lat(2,)])
+    other_sys.leads.append(lead1)
+
+    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())), 
+                 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())), 
+                 expected)
+