def test_honeycomb():
lat = kwant.lattice.honeycomb(norbs=1)
# Test simple honeycomb model with constant terms
# Add discrete symmetries to the kwant builder as well, to check that they are
# returned as well.
syst = kwant.Builder(symmetry=TranslationalSymmetry(*lat.prim_vecs))
syst[lat.a(0, 0)] = 1
syst[lat.b(0, 0)] = 1
syst[lat.neighbors(1)] = -1
H = builder_to_model(syst)
sg, cs = symmetries(H, hexagonal(sympy_R=False), prettify=True)
assert len(sg) == 24
assert len(cs) == 0
# Test simple honeycomb model with value functions
syst = kwant.Builder(symmetry=TranslationalSymmetry(*lat.prim_vecs))
syst[lat.a(0, 0)] = lambda site, ma: ma
syst[lat.b(0, 0)] = lambda site, mb: mb
syst[lat.neighbors(1)] = lambda site1, site2, t: t
H = builder_to_model(syst)
sg, cs = symmetries(H, hexagonal(sympy_R=False), prettify=True)
assert len(sg) == 12
assert len(cs) == 0
def test_higher_dim():
# Test 0D finite system
lat = kwant.lattice.cubic(norbs=1)
syst = kwant.Builder()
syst[lat(0, 0, 0)] = 1
syst[lat(1, 1, 0)] = 1
syst[lat(0, 1, 1)] = 1
syst[lat(1, 0, -1)] = 1
syst[lat(0, 0, 0), lat(1, 1, 0)] = -1
syst[lat(0, 0, 0), lat(0, 1, 1)] = -1
syst[lat(0, 0, 0), lat(1, 0, -1)] = -1
H = builder_to_model(syst)
sg, cs = symmetries(H, prettify=True)
assert len(sg) == 2
assert len(cs) == 5
# Test triangular lattice system embedded in 3D
sym = TranslationalSymmetry([1, 1, 0], [0, 1, 1])
lat = kwant.lattice.cubic(norbs=1)
syst = kwant.Builder(symmetry=sym)
syst[lat(0, 0, 0)] = 1
syst[lat(0, 0, 0), lat(1, 1, 0)] = -1
syst[lat(0, 0, 0), lat(0, 1, 1)] = -1
syst[lat(0, 0, 0), lat(1, 0, -1)] = -1
H = builder_to_model(syst)
sg, cs = symmetries(H, hexagonal(sympy_R=False), prettify=True)
assert len(sg) == 24
assert len(cs) == 0
def test_find_builder_discrete_symmetries():
symm_class = ['AI', 'D', 'AIII', 'BDI']
class_dict = {
'AI': ['time_reversal'],
'D': ['particle_hole'],
'AIII': ['chiral'],
'BDI': ['time_reversal', 'particle_hole', 'chiral']
}
sym_dict = {
'time_reversal': qsymm.PointGroupElement(np.eye(2), True, False, None),
'particle_hole': qsymm.PointGroupElement(np.eye(2), True, True, None),
'chiral': qsymm.PointGroupElement(np.eye(2), False, True, None)
}
n = 4
rng = 11
for sym in symm_class:
# Random Hamiltonian in the symmetry class
h_ons = kwant.rmt.gaussian(n, sym, rng=rng)
h_hop = 10 * kwant.rmt.gaussian(2 * n, sym, rng=rng)[:n, n:]
# Make a Kwant builder in the symmetry class and find its symmetries
lat = kwant.lattice.square(norbs=n)
bulk = kwant.Builder(TranslationalSymmetry([1, 0], [0, 1]))
bulk[lat(0, 0)] = h_ons
bulk[kwant.builder.HoppingKind((1, 0), lat)] = h_hop
bulk[kwant.builder.HoppingKind((0, 1), lat)] = h_hop
# We need to specify 'prettify=True' here to ensure that we do not end up with
# an overcomplete set of symmetries. In some badly conditioned cases sparse=True
# or sparse=False may affect how many symmetries are found.
builder_symmetries_default = find_builder_symmetries(
bulk, spatial_symmetries=True, prettify=True)
builder_symmetries_sparse = find_builder_symmetries(
bulk, spatial_symmetries=True, prettify=True, sparse=True)
builder_symmetries_dense = find_builder_symmetries(
bulk, spatial_symmetries=True, prettify=True, sparse=False)
assert len(builder_symmetries_default) == len(
builder_symmetries_sparse)
assert len(builder_symmetries_default) == len(builder_symmetries_dense)
# Equality of symmetries ignores unitary part
fourfold_rotation = qsymm.PointGroupElement(np.array([[0, 1], [1, 0]]),
False, False, None)
assert fourfold_rotation in builder_symmetries_default
assert fourfold_rotation in builder_symmetries_sparse
assert fourfold_rotation in builder_symmetries_dense
class_symmetries = class_dict[sym]
for class_symmetry in class_symmetries:
assert sym_dict[class_symmetry] in builder_symmetries_default
assert sym_dict[class_symmetry] in builder_symmetries_sparse
assert sym_dict[class_symmetry] in builder_symmetries_dense
def test_basis_ordering():
symm_class = ['AI', 'D', 'AIII', 'BDI']
n = 2
rng = 12
for sym in symm_class:
# Make a small finite system in the symmetry class, finalize it and check
# that the basis is consistent.
h_ons = kwant.rmt.gaussian(n, sym, rng=rng)
h_hop = 10 * kwant.rmt.gaussian(2 * n, sym, rng=rng)[:n, n:]
lat = kwant.lattice.square(norbs=n)
bulk = kwant.Builder(TranslationalSymmetry([1, 0], [0, 1]))
bulk[lat(0, 0)] = h_ons
bulk[kwant.builder.HoppingKind((1, 0), lat)] = h_hop
bulk[kwant.builder.HoppingKind((0, 1), lat)] = h_hop
def rect(site):
x, y = site.pos
return (0 <= x < 2) and (0 <= y < 3)
square = kwant.Builder()
square.fill(bulk,
lambda site: rect(site), (0, 0),
max_sites=float('inf'))
# Find the symmetries of the square
builder_symmetries = find_builder_symmetries(square,
spatial_symmetries=False,
prettify=True)
# Finalize the square, extract Hamiltonian
fsquare = square.finalized()
ham = fsquare.hamiltonian_submatrix()
# Check manually that the found symmetries are in the same basis as the
# finalized system
for symmetry in builder_symmetries:
U = symmetry.U
if isinstance(symmetry, qsymm.ContinuousGroupGenerator):
assert symmetry.R is None
assert allclose(U.dot(ham), ham.dot(U))
else:
if symmetry.conjugate:
left = U.dot(ham.conj())
else:
left = U.dot(ham)
if symmetry.antisymmetry:
assert allclose(left, -ham.dot(U))
else:
assert allclose(left, ham.dot(U))
def test_find_builder_discrete_symmetries():
symm_class = ['AI', 'D', 'AIII', 'BDI']
class_dict = {
'AI': ['time_reversal'],
'D': ['particle_hole'],
'AIII': ['chiral'],
'BDI': ['time_reversal', 'particle_hole', 'chiral']
}
sym_dict = {
'time_reversal': qsymm.PointGroupElement(np.eye(2), True, False, None),
'particle_hole': qsymm.PointGroupElement(np.eye(2), True, True, None),
'chiral': qsymm.PointGroupElement(np.eye(2), False, True, None)
}
n = 4
rng = 11
for sym in symm_class:
# Random Hamiltonian in the symmetry class
h_ons = kwant.rmt.gaussian(n, sym, rng=rng)
h_hop = 10 * kwant.rmt.gaussian(2 * n, sym, rng=rng)[:n, n:]
# Make a Kwant builder in the symmetry class and find its symmetries
lat = kwant.lattice.square(norbs=n)
bulk = kwant.Builder(TranslationalSymmetry([1, 0], [0, 1]))
bulk[lat(0, 0)] = h_ons
bulk[kwant.builder.HoppingKind((1, 0), lat)] = h_hop
bulk[kwant.builder.HoppingKind((0, 1), lat)] = h_hop
builder_symmetries = find_builder_symmetries(bulk,
spatial_symmetries=True,
prettify=True)
# Equality of symmetries ignores unitary part
fourfold_rotation = qsymm.PointGroupElement(np.array([[0, 1], [1, 0]]),
False, False, None)
assert fourfold_rotation in builder_symmetries
class_symmetries = class_dict[sym]
for class_symmetry in class_symmetries:
assert sym_dict[class_symmetry] in builder_symmetries