From 074aacbade0cd36f2993b44ed4ca1b01e7c50432 Mon Sep 17 00:00:00 2001
From: Christoph Groth <christoph.groth@cea.fr>
Date: Mon, 20 Jan 2014 17:19:12 +0100
Subject: [PATCH] replace legacy "sg" and "gr" variable names
---
kwant/builder.py | 2 +-
kwant/solvers/tests/_test_sparse.py | 16 +--
kwant/tests/test_builder.py | 190 ++++++++++++++--------------
kwant/tests/test_system.py | 28 ++--
4 files changed, 118 insertions(+), 118 deletions(-)
diff --git a/kwant/builder.py b/kwant/builder.py
index 636b6d0..1215e19 100644
--- a/kwant/builder.py
+++ b/kwant/builder.py
@@ -142,7 +142,7 @@ class SiteFamily(object):
"""
A convenience function.
- This function allows to write sg(1, 2) instead of Site(sg, (1, 2)).
+ This function allows to write fam(1, 2) instead of Site(fam, (1, 2)).
"""
# Catch a likely and difficult to find mistake.
if tag and isinstance(tag[0], tuple):
diff --git a/kwant/solvers/tests/_test_sparse.py b/kwant/solvers/tests/_test_sparse.py
index 2970456..e3d2e1e 100644
--- a/kwant/solvers/tests/_test_sparse.py
+++ b/kwant/solvers/tests/_test_sparse.py
@@ -364,12 +364,12 @@ def test_selfenergy_reflection(greens_function, smatrix):
def test_very_singular_leads(smatrix):
sys = kwant.Builder()
- gr = kwant.lattice.chain()
+ chain = kwant.lattice.chain()
left_lead = kwant.Builder(kwant.TranslationalSymmetry((-1,)))
right_lead = kwant.Builder(kwant.TranslationalSymmetry((1,)))
- sys[gr(0)] = left_lead[gr(0)] = right_lead[gr(0)] = np.identity(2)
- left_lead[gr(0), gr(1)] = np.zeros((2, 2))
- right_lead[gr(0), gr(1)] = np.identity(2)
+ sys[chain(0)] = left_lead[chain(0)] = right_lead[chain(0)] = np.identity(2)
+ left_lead[chain(0), chain(1)] = np.zeros((2, 2))
+ right_lead[chain(0), chain(1)] = np.identity(2)
sys.attach_lead(left_lead)
sys.attach_lead(right_lead)
fsys = sys.finalized()
@@ -379,10 +379,10 @@ def test_very_singular_leads(smatrix):
def test_ldos(ldos):
sys = kwant.Builder()
- gr = kwant.lattice.chain()
- lead = kwant.Builder(kwant.TranslationalSymmetry(gr.vec((1,))))
- sys[gr(0)] = sys[gr(1)] = lead[gr(0)] = 0
- sys[gr(0), gr(1)] = lead[gr(0), gr(1)] = 1
+ chain = kwant.lattice.chain()
+ lead = kwant.Builder(kwant.TranslationalSymmetry(chain.vec((1,))))
+ sys[chain(0)] = sys[chain(1)] = lead[chain(0)] = 0
+ sys[chain(0), chain(1)] = lead[chain(0), chain(1)] = 1
sys.attach_lead(lead)
sys.attach_lead(lead.reversed())
fsys = sys.finalized()
diff --git a/kwant/tests/test_builder.py b/kwant/tests/test_builder.py
index 6aa6ea7..f7cfa69 100644
--- a/kwant/tests/test_builder.py
+++ b/kwant/tests/test_builder.py
@@ -18,20 +18,20 @@ from kwant import builder
def test_site_families():
sys = builder.Builder()
- sg = builder.SimpleSiteFamily()
- osg = builder.SimpleSiteFamily()
- yasg = builder.SimpleSiteFamily('another_name')
+ fam = builder.SimpleSiteFamily()
+ ofam = builder.SimpleSiteFamily()
+ yafam = builder.SimpleSiteFamily('another_name')
assert_raises(KeyError, sys.__setitem__, (0, ), 7)
- sys[sg(0)] = 7
- assert_equal(sys[sg(0)], 7)
+ sys[fam(0)] = 7
+ assert_equal(sys[fam(0)], 7)
assert_raises(KeyError, sys.__getitem__, (0, ))
- assert len(set([sg, osg, sg('a'), osg('a'), yasg])) == 3
- sys[sg(1)] = 123
- assert_equal(sys[sg(1)], 123)
- assert_equal(sys[osg(1)], 123)
- assert_raises(KeyError, sys.__getitem__, yasg(1))
+ assert len(set([fam, ofam, fam('a'), ofam('a'), yafam])) == 3
+ sys[fam(1)] = 123
+ assert_equal(sys[fam(1)], 123)
+ assert_equal(sys[ofam(1)], 123)
+ assert_raises(KeyError, sys.__getitem__, yafam(1))
class VerySimpleSymmetry(builder.Symmetry):
@@ -58,7 +58,7 @@ class VerySimpleSymmetry(builder.Symmetry):
# made.
def check_construction_and_indexing(sites, sites_fd, hoppings, hoppings_fd,
failing_hoppings, sym=None):
- gr = builder.SimpleSiteFamily()
+ fam = builder.SimpleSiteFamily()
sys = builder.Builder(sym)
t, V = 1.0j, 0.0
sys[sites] = V
@@ -71,9 +71,9 @@ def check_construction_and_indexing(sites, sites_fd, hoppings, hoppings_fd,
for hopping in failing_hoppings:
assert_raises(KeyError, sys.__setitem__, hopping, t)
- assert (gr(5), gr(123)) not in sys
- assert (sites[0], gr(5, 123)) not in sys
- assert (gr(7, 8), sites[0]) not in sys
+ assert (fam(5), fam(123)) not in sys
+ assert (sites[0], fam(5, 123)) not in sys
+ assert (fam(7, 8), sites[0]) not in sys
for site in sites:
assert site in sys
assert_equal(sys[site], V)
@@ -110,31 +110,31 @@ def check_construction_and_indexing(sites, sites_fd, hoppings, hoppings_fd,
def test_construction_and_indexing():
# Without symmetry
- gr = builder.SimpleSiteFamily()
- sites = [gr(0, 0), gr(0, 1), gr(1, 0)]
- hoppings = [(gr(0, 0), gr(0, 1)),
- (gr(0, 1), gr(1, 0)),
- (gr(1, 0), gr(0, 0))]
- failing_hoppings = [(gr(0, 1), gr(0, 1)),
- (gr(0, 1), gr(7, 8)),
- (gr(12, 14), gr(0, 1))]
+ fam = builder.SimpleSiteFamily()
+ sites = [fam(0, 0), fam(0, 1), fam(1, 0)]
+ hoppings = [(fam(0, 0), fam(0, 1)),
+ (fam(0, 1), fam(1, 0)),
+ (fam(1, 0), fam(0, 0))]
+ failing_hoppings = [(fam(0, 1), fam(0, 1)),
+ (fam(0, 1), fam(7, 8)),
+ (fam(12, 14), fam(0, 1))]
check_construction_and_indexing(sites, sites, hoppings, hoppings,
failing_hoppings)
# With symmetry
- sites = [gr(0, 0), gr(1, 1), gr(2, 1), gr(4, 2)]
- sites_fd = [gr(0, 0), gr(1, 1), gr(0, 1), gr(0, 2)]
- hoppings = [(gr(0, 0), gr(1, 1)),
- (gr(1, 1), gr(2, 1)),
- (gr(2, 1), gr(4, 2)),
- (gr(4, 2), gr(0, 0))]
- hoppings_fd = [(gr(0, 0), gr(1, 1)),
- (gr(1, 1), gr(2, 1)),
- (gr(0, 1), gr(2, 2)),
- (gr(0, 2), gr(-4, 0))]
- failing_hoppings = [(gr(0, 0), gr(0, 3)), (gr(0, 4), gr(0, 0)),
- (gr(0, 0), gr(2, 3)), (gr(2, 4), gr(0, 0)),
- (gr(4, 2), gr(6, 3)), (gr(6, 4), gr(4, 2))]
+ sites = [fam(0, 0), fam(1, 1), fam(2, 1), fam(4, 2)]
+ sites_fd = [fam(0, 0), fam(1, 1), fam(0, 1), fam(0, 2)]
+ hoppings = [(fam(0, 0), fam(1, 1)),
+ (fam(1, 1), fam(2, 1)),
+ (fam(2, 1), fam(4, 2)),
+ (fam(4, 2), fam(0, 0))]
+ hoppings_fd = [(fam(0, 0), fam(1, 1)),
+ (fam(1, 1), fam(2, 1)),
+ (fam(0, 1), fam(2, 2)),
+ (fam(0, 2), fam(-4, 0))]
+ failing_hoppings = [(fam(0, 0), fam(0, 3)), (fam(0, 4), fam(0, 0)),
+ (fam(0, 0), fam(2, 3)), (fam(2, 4), fam(0, 0)),
+ (fam(4, 2), fam(6, 3)), (fam(6, 4), fam(4, 2))]
sym = VerySimpleSymmetry(2)
check_construction_and_indexing(sites, sites_fd, hoppings, hoppings_fd,
failing_hoppings, sym)
@@ -149,35 +149,35 @@ def test_hermitian_conjugation():
raise ValueError
sys = builder.Builder()
- sg = builder.SimpleSiteFamily()
- sys[sg(0)] = sys[sg(1)] = ta.identity(2)
+ fam = builder.SimpleSiteFamily()
+ sys[fam(0)] = sys[fam(1)] = ta.identity(2)
- sys[sg(0), sg(1)] = f
- assert sys[sg(0), sg(1)] is f
- assert isinstance(sys[sg(1), sg(0)], builder.HermConjOfFunc)
- assert_equal(sys[sg(1), sg(0)](sg(1), sg(0)),
- sys[sg(0), sg(1)](sg(0), sg(1)).conjugate().transpose())
- sys[sg(0), sg(1)] = sys[sg(1), sg(0)]
- assert isinstance(sys[sg(0), sg(1)], builder.HermConjOfFunc)
- assert sys[sg(1), sg(0)] is f
+ sys[fam(0), fam(1)] = f
+ assert sys[fam(0), fam(1)] is f
+ assert isinstance(sys[fam(1), fam(0)], builder.HermConjOfFunc)
+ assert_equal(sys[fam(1), fam(0)](fam(1), fam(0)),
+ sys[fam(0), fam(1)](fam(0), fam(1)).conjugate().transpose())
+ sys[fam(0), fam(1)] = sys[fam(1), fam(0)]
+ assert isinstance(sys[fam(0), fam(1)], builder.HermConjOfFunc)
+ assert sys[fam(1), fam(0)] is f
def test_value_equality_and_identity():
m = ta.array([[1, 2], [3j, 4j]])
sys = builder.Builder()
- sg = builder.SimpleSiteFamily()
+ fam = builder.SimpleSiteFamily()
- sys[sg(0)] = m
- sys[sg(1)] = m
- assert sys[sg(1)] is m
+ sys[fam(0)] = m
+ sys[fam(1)] = m
+ assert sys[fam(1)] is m
- sys[sg(0), sg(1)] = m
- assert_equal(sys[sg(1), sg(0)], m.transpose().conjugate())
- assert sys[sg(0), sg(1)] is m
+ sys[fam(0), fam(1)] = m
+ assert_equal(sys[fam(1), fam(0)], m.transpose().conjugate())
+ assert sys[fam(0), fam(1)] is m
- sys[sg(1), sg(0)] = m
- assert_equal(sys[sg(0), sg(1)], m.transpose().conjugate())
- assert sys[sg(1), sg(0)] is m
+ sys[fam(1), fam(0)] = m
+ assert_equal(sys[fam(0), fam(1)], m.transpose().conjugate())
+ assert sys[fam(1), fam(0)] is m
def random_onsite_hamiltonian(rng):
@@ -273,11 +273,11 @@ def test_finalization():
# Build scattering region from blueprint and test it.
sys = builder.Builder()
- sg = kwant.lattice.general(ta.identity(2))
+ fam = kwant.lattice.general(ta.identity(2))
for site, value in sr_sites.iteritems():
- sys[sg(*site)] = value
+ sys[fam(*site)] = value
for hop, value in sr_hops.iteritems():
- sys[sg(*hop[0]), sg(*hop[1])] = value
+ sys[fam(*hop[0]), fam(*hop[1])] = value
fsys = sys.finalized()
check_onsite(fsys, sr_sites)
check_hoppings(fsys, sr_hops)
@@ -287,7 +287,7 @@ def test_finalization():
for site, value in lead_sites.iteritems():
shift = rng.randrange(-5, 6) * size
site = site[0] + shift, site[1]
- lead[sg(*site)] = value
+ lead[fam(*site)] = value
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
lead.finalized() # Trigger the warning.
@@ -298,7 +298,7 @@ def test_finalization():
shift = rng.randrange(-5, 6) * size
a = a[0] + shift, a[1]
b = b[0] + shift, b[1]
- lead[sg(*a), sg(*b)] = value
+ lead[fam(*a), fam(*b)] = value
flead = lead.finalized()
all_sites = list(lead_sites)
all_sites.extend((x - size, y) for (x, y) in neighbors)
@@ -312,12 +312,12 @@ def test_finalization():
# Attach lead with improper interface.
sys.leads[-1] = builder.BuilderLead(
- lead, 2 * tuple(builder.Site(sg, n) for n in neighbors))
+ lead, 2 * tuple(builder.Site(fam, n) for n in neighbors))
assert_raises(ValueError, sys.finalized)
# Attach lead properly.
sys.leads[-1] = builder.BuilderLead(
- lead, (builder.Site(sg, n) for n in neighbors))
+ lead, (builder.Site(fam, n) for n in neighbors))
fsys = sys.finalized()
assert_equal(len(fsys.lead_interfaces), 1)
assert_equal([fsys.site(i).tag for i in fsys.lead_interfaces[0]],
@@ -328,7 +328,7 @@ def test_finalization():
a = rng.choice(lead_sites_list)
b = rng.choice(possible_neighbors)
b = b[0] + 2 * size, b[1]
- lead[sg(*a), sg(*b)] = random_hopping_integral(rng)
+ lead[fam(*a), fam(*b)] = random_hopping_integral(rng)
assert_raises(ValueError, lead.finalized)
@@ -344,10 +344,10 @@ def test_hamiltonian_evaluation():
edges = [(0, 1), (0, 2), (0, 3), (1, 2)]
sys = builder.Builder()
- sg = builder.SimpleSiteFamily()
- sites = [sg(*tag) for tag in tags]
- sys[(sg(*tag) for tag in tags)] = f_onsite
- sys[((sg(*tags[i]), sg(*tags[j])) for (i, j) in edges)] = f_hopping
+ fam = builder.SimpleSiteFamily()
+ sites = [fam(*tag) for tag in tags]
+ sys[(fam(*tag) for tag in tags)] = f_onsite
+ sys[((fam(*tags[i]), fam(*tags[j])) for (i, j) in edges)] = f_hopping
fsys = sys.finalized()
assert_equal(fsys.graph.num_nodes, len(tags))
@@ -372,11 +372,11 @@ def test_dangling():
# / \
# 3-0---2-4-5 6-7 8
sys = builder.Builder()
- sg = builder.SimpleSiteFamily()
- sys[(sg(i) for i in range(9))] = None
- sys[[(sg(0), sg(1)), (sg(1), sg(2)), (sg(2), sg(0))]] = None
- sys[[(sg(0), sg(3)), (sg(2), sg(4)), (sg(4), sg(5))]] = None
- sys[sg(6), sg(7)] = None
+ fam = builder.SimpleSiteFamily()
+ sys[(fam(i) for i in range(9))] = None
+ sys[[(fam(0), fam(1)), (fam(1), fam(2)), (fam(2), fam(0))]] = None
+ sys[[(fam(0), fam(3)), (fam(2), fam(4)), (fam(4), fam(5))]] = None
+ sys[fam(6), fam(7)] = None
return sys
sys0 = make_system()
@@ -445,52 +445,52 @@ def test_builder_with_symmetry():
def test_attach_lead():
- gr = builder.SimpleSiteFamily()
- gr_noncommensurate = builder.SimpleSiteFamily(name='other')
+ fam = builder.SimpleSiteFamily()
+ fam_noncommensurate = builder.SimpleSiteFamily(name='other')
sys = builder.Builder()
- sys[gr(1)] = 0
+ sys[fam(1)] = 0
lead = builder.Builder(VerySimpleSymmetry(-2))
assert_raises(ValueError, sys.attach_lead, lead)
- lead[gr(0)] = 1
+ lead[fam(0)] = 1
assert_raises(ValueError, sys.attach_lead, lead)
- lead[gr(1)] = 1
+ lead[fam(1)] = 1
sys.attach_lead(lead)
- assert_raises(ValueError, sys.attach_lead, lead, gr(5))
+ assert_raises(ValueError, sys.attach_lead, lead, fam(5))
sys = builder.Builder()
# The tag of the site that is added in the following line is an empty tuple.
# This simulates a site family that is not commensurate with the symmetry of
# the lead. Such sites may be present in the system, as long as there are
# other sites that will interrupt the lead.
- sys[gr_noncommensurate()] = 2
- sys[gr(1)] = 0
- sys[gr(0)] = 1
- lead[gr(0), gr(1)] = lead[gr(0), gr(2)] = 1
+ sys[fam_noncommensurate()] = 2
+ sys[fam(1)] = 0
+ sys[fam(0)] = 1
+ lead[fam(0), fam(1)] = lead[fam(0), fam(2)] = 1
sys.attach_lead(lead)
assert_equal(len(list(sys.sites())), 4)
- assert_equal(set(sys.leads[0].interface), set([gr(-1), gr(0)]))
- sys[gr(-10)] = sys[gr(-11)] = 0
+ assert_equal(set(sys.leads[0].interface), set([fam(-1), fam(0)]))
+ sys[fam(-10)] = sys[fam(-11)] = 0
sys.attach_lead(lead)
- assert_equal(set(sys.leads[1].interface), set([gr(-10), gr(-11)]))
+ assert_equal(set(sys.leads[1].interface), set([fam(-10), fam(-11)]))
assert_equal(len(list(sys.sites())), 6)
- sys.attach_lead(lead, gr(-5))
- assert_equal(set(sys.leads[0].interface), set([gr(-1), gr(0)]))
+ sys.attach_lead(lead, fam(-5))
+ assert_equal(set(sys.leads[0].interface), set([fam(-1), fam(0)]))
sys.finalized()
def test_neighbors_not_in_single_domain():
sr = builder.Builder()
lead = builder.Builder(VerySimpleSymmetry(-1))
- gr = builder.SimpleSiteFamily()
- sr[(gr(x, y) for x in range(3) for y in range(3) if x >= y)] = 0
- sr[builder.HoppingKind((1, 0), gr)] = 1
- sr[builder.HoppingKind((0, 1), gr)] = 1
- lead[(gr(0, y) for y in range(3))] = 0
- lead[((gr(0, y), gr(1, y)) for y in range(3))] = 1
- lead[((gr(0, y), gr(0, y + 1)) for y in range(2))] = 1
- sr.leads.append(builder.BuilderLead(lead, [gr(i, i) for i in range(3)]))
+ fam = builder.SimpleSiteFamily()
+ sr[(fam(x, y) for x in range(3) for y in range(3) if x >= y)] = 0
+ sr[builder.HoppingKind((1, 0), fam)] = 1
+ sr[builder.HoppingKind((0, 1), fam)] = 1
+ lead[(fam(0, y) for y in range(3))] = 0
+ lead[((fam(0, y), fam(1, y)) for y in range(3))] = 1
+ lead[((fam(0, y), fam(0, y + 1)) for y in range(2))] = 1
+ sr.leads.append(builder.BuilderLead(lead, [fam(i, i) for i in range(3)]))
assert_raises(ValueError, sr.finalized)
diff --git a/kwant/tests/test_system.py b/kwant/tests/test_system.py
index 346a2dd..be78058 100644
--- a/kwant/tests/test_system.py
+++ b/kwant/tests/test_system.py
@@ -13,11 +13,11 @@ import kwant
def test_hamiltonian_submatrix():
sys = kwant.Builder()
- gr = kwant.lattice.chain()
+ chain = kwant.lattice.chain()
for i in xrange(3):
- sys[gr(i)] = 0.5 * i
+ sys[chain(i)] = 0.5 * i
for i in xrange(2):
- sys[gr(i), gr(i + 1)] = 1j * (i + 1)
+ sys[chain(i), chain(i + 1)] = 1j * (i + 1)
sys2 = sys.finalized()
mat = sys2.hamiltonian_submatrix()
@@ -46,11 +46,11 @@ def test_hamiltonian_submatrix():
# Test for correct treatment of matrix input.
sys = kwant.Builder()
- sys[gr(0)] = np.array([[0, 1j], [-1j, 0]])
- sys[gr(1)] = np.array([[1]])
- sys[gr(2)] = np.array([[2]])
- sys[gr(1), gr(0)] = np.array([[1, 2j]])
- sys[gr(2), gr(1)] = np.array([[3j]])
+ sys[chain(0)] = np.array([[0, 1j], [-1j, 0]])
+ sys[chain(1)] = np.array([[1]])
+ sys[chain(2)] = np.array([[2]])
+ sys[chain(1), chain(0)] = np.array([[1, 2j]])
+ sys[chain(2), chain(1)] = np.array([[3j]])
sys2 = sys.finalized()
mat_dense = sys2.hamiltonian_submatrix()
mat_sp = sys2.hamiltonian_submatrix(sparse=True).todense()
@@ -59,8 +59,8 @@ def test_hamiltonian_submatrix():
# Test precalculation of modes.
np.random.seed(5)
lead = kwant.Builder(kwant.TranslationalSymmetry((-1,)))
- lead[gr(0)] = np.zeros((2, 2))
- lead[gr(0), gr(1)] = np.random.randn(2, 2)
+ lead[chain(0)] = np.zeros((2, 2))
+ lead[chain(0), chain(1)] = np.random.randn(2, 2)
sys.attach_lead(lead)
sys2 = sys.finalized()
smatrix = kwant.smatrix(sys2, .1).data
@@ -70,11 +70,11 @@ def test_hamiltonian_submatrix():
assert_raises(ValueError, kwant.solvers.default.greens_function, sys3, 0.2)
# Test for shape errors.
- sys[gr(0), gr(2)] = np.array([[1, 2]])
+ sys[chain(0), chain(2)] = np.array([[1, 2]])
sys2 = sys.finalized()
assert_raises(ValueError, sys2.hamiltonian_submatrix)
assert_raises(ValueError, sys2.hamiltonian_submatrix, sparse=True)
- sys[gr(0), gr(2)] = 1
+ sys[chain(0), chain(2)] = 1
sys2 = sys.finalized()
assert_raises(ValueError, sys2.hamiltonian_submatrix)
assert_raises(ValueError, sys2.hamiltonian_submatrix, sparse=True)
@@ -87,8 +87,8 @@ def test_hamiltonian_submatrix():
return p1 - p2
sys = kwant.Builder()
- sys[(gr(i) for i in xrange(3))] = onsite
- sys[((gr(i), gr(i + 1)) for i in xrange(2))] = hopping
+ sys[(chain(i) for i in xrange(3))] = onsite
+ sys[((chain(i), chain(i + 1)) for i in xrange(2))] = hopping
sys2 = sys.finalized()
mat = sys2.hamiltonian_submatrix((2, 1))
mat_should_be = [[5, 1, 0], [1, 4, 1.], [0, 1, 3]]
--
GitLab