def MakeSystem(ps, show=False):
H = kwant.Builder()
def shape_2DEG(pos):
x, y = pos
return ((abs(x) < ps.L) and (abs(y) < ps.W)) or ((abs(x) < ps.W) and
(abs(y) < ps.L))
H[lat.shape(shape_2DEG, (0, 0))] = HedgeHog
H[lat.neighbors()] = -s_0
# ITS LEADS
sym_x = kwant.TranslationalSymmetry((-1, 0))
H_lead_x = kwant.Builder(sym_x)
shape_x = lambda pos: abs(pos[1]) < ps.W and pos[0] == 0
H_lead_x[lat.shape(shape_x, (0, 0))] = Lead_Pot
H_lead_x[lat.neighbors()] = -s_0
sym_y = kwant.TranslationalSymmetry((0, -1))
H_lead_y = kwant.Builder(sym_y)
shape_y = lambda pos: abs(pos[0]) < ps.W and pos[1] == 0
H_lead_y[lat.shape(shape_y, (0, 0))] = Lead_Pot
H_lead_y[lat.neighbors()] = -s_0
H.attach_lead(H_lead_x)
H.attach_lead(H_lead_y)
H.attach_lead(H_lead_y.reversed())
H.attach_lead(H_lead_x.reversed())
if show:
kwant.plot(H)
return H
def make_system2():
sys = kwant.Builder()
sys[graphene.shape(disk, (0, 0))] = onsite
sys[graphene.neighbors()] = s0 # comment it, when has rashba
sys[[kwant.builder.HoppingKind(*hopping)
for hopping in nnn_hoppings]] = nnn # 1j *m2 * sz #
# sys[kwant.HoppingKind((0, 0), a,b)] = hop_ras_e1
# sys[kwant.HoppingKind((0, 1), a,b)] = hop_ras_e2
# sys[kwant.HoppingKind((-1, 1), a,b)] = hop_ras_e3
sym = kwant.TranslationalSymmetry((-1, 0))
sym.add_site_family(graphene.sublattices[0], other_vectors=[(-1, 2)])
sym.add_site_family(graphene.sublattices[1], other_vectors=[(-1, 2)])
lead = kwant.Builder(sym, conservation_law=-sz) #,conservation_law=-sz
lead[graphene.shape(lead_shape, (0, width - 1))] = onsite # s0 #
lead[graphene.neighbors()] = s0
# lead[[kwant.builder.HoppingKind(*hopping) for hopping in nnn_hoppings]]=1j *m2 * sz
sys.attach_lead(lead)
# sys.attach_lead(lead.reversed())
sym1 = kwant.TranslationalSymmetry((1, 0))
sym1.add_site_family(graphene.sublattices[0], other_vectors=[(-1, 2)])
sym1.add_site_family(graphene.sublattices[1], other_vectors=[(-1, 2)])
lead1 = kwant.Builder(sym1, conservation_law=-sz) #,conservation_law=-sz
lead1[graphene.shape(lead_shape1, (0, width - 1))] = onsite # s0 #
lead1[graphene.neighbors()] = s0
# lead1[[kwant.builder.HoppingKind(*hopping) for hopping in nnn_hoppings]]=1j *m2 * sz
sys.attach_lead(lead1)
return sys.finalized()
def make_system_all(length,width,dis,salt,width_left,width_right):
def cuboid_shape(pos):
x, y= pos
return abs(x)<length and abs(y)<width
def lead_shape_left(pos):
x, y= pos
return abs(y)<width_left
def lead_shape_right(pos):
x, y= pos
return abs(y)<width_right
def onsite(site):
x,y=site.pos
return dis*(uniform(repr(site),salt)-.5)+4#-0.001j
sys = kwant.Builder()
sys[lat.shape(cuboid_shape, (0, 0))] = onsite
sys[lat.neighbors()] = -1
sym_lead = kwant.TranslationalSymmetry((-1, 0))
lead = kwant.Builder(sym_lead)
lead[lat.shape(lead_shape_left, (0, 0))] = 4
lead[lat.neighbors()] = -1
sys.attach_lead(lead)
sym_lead_r = kwant.TranslationalSymmetry((1, 0))
lead_r = kwant.Builder(sym_lead_r)
lead_r[lat.shape(lead_shape_right, (0, 0))] = 4
lead_r[lat.neighbors()] = -1
sys.attach_lead(lead_r)
return sys
def make_system(a=1,
W=10,
L=10,
barrier=1.5,
barrierpos=(3, 4),
mu=0.4,
Delta=0.1,
Deltapos=4,
t=1.0):
# Start with an empty tight-binding system and two square lattices,
# corresponding to electron and hole degree of freedom
lat_e = kwant.lattice.square(a, name='e')
lat_h = kwant.lattice.square(a, name='h')
sys = kwant.Builder()
#### Define the scattering region. ####
sys[(lat_e(x, y) for x in range(L) for y in range(W))] = 4 * t - mu
sys[(lat_h(x, y) for x in range(L) for y in range(W))] = mu - 4 * t
# the tunnel barrier
sys[(lat_e(x, y) for x in range(barrierpos[0], barrierpos[1])
for y in range(W))] = 4 * t + barrier - mu
sys[(lat_h(x, y) for x in range(barrierpos[0], barrierpos[1])
for y in range(W))] = mu - 4 * t - barrier
# hoppings for both electrons and holes
sys[lat_e.neighbors()] = -t
sys[lat_h.neighbors()] = t
# Superconducting order parameter enters as hopping between
# electrons and holes
sys[((lat_e(x, y), lat_h(x, y)) for x in range(Deltapos, L)
for y in range(W))] = Delta
# Symmetry for the left leads.
sym_left = kwant.TranslationalSymmetry((-a, 0))
# left electron lead
lead0 = kwant.Builder(sym_left)
lead0[(lat_e(0, j) for j in range(W))] = 4 * t - mu
lead0[lat_e.neighbors()] = -t
# left hole lead
lead1 = kwant.Builder(sym_left)
lead1[(lat_h(0, j) for j in range(W))] = mu - 4 * t
lead1[lat_h.neighbors()] = t
sym_right = kwant.TranslationalSymmetry((a, 0))
lead2 = kwant.Builder(sym_right)
lead2 += lead0
lead2 += lead1
lead2[((lat_e(0, j), lat_h(0, j)) for j in range(W))] = Delta
sys.attach_lead(lead0)
sys.attach_lead(lead1)
sys.attach_lead(lead2)
return sys
def make_system():
sys = kwant.Builder()
sys[lat_u.shape(disk,(0,0))] = onsite
sys[lat_d.shape(disk,(0,0))] = onsite
sys[lat_u.neighbors()] = 1
sys[lat_d.neighbors()] = 1
sys[[kwant.builder.HoppingKind(*hopping) for hopping in nnn_hoppings]] = nnn
sys[[kwant.builder.HoppingKind(*hopping) for hopping in nnn_hoppingsd]] = nnn
sys[kwant.HoppingKind((0, 0), a,bd)] = hop_ras_e1
sys[kwant.HoppingKind((0, 1), a,bd)] = hop_ras_e2
sys[kwant.HoppingKind((-1, 1), a,bd)] = hop_ras_e3
sys[kwant.HoppingKind((0, 0), ad,b)] = hop_ras_e1
sys[kwant.HoppingKind((0, 1), ad,b)] = hop_ras_e2
sys[kwant.HoppingKind((-1, 1), ad,b)] = hop_ras_e3
# sym_left = kwant.TranslationalSymmetry((-1, 0))
# lead0 = kwant.Builder(sym_left)
# lead0[lat_u.shape((lambda pos: abs(pos[1]) < width), (0, 0))]=onsite#1
# lead0[lat_u.neighbors()] = 1
# lead0[[kwant.builder.HoppingKind(*hopping) for hopping in nnn_hoppings]] = nnn
## # left hole lead
# lead1 = kwant.Builder(sym_left)
# lead1[lat_d.shape((lambda pos: abs(pos[1]) < width), (0, 0))]=onsite#1
# lead1[lat_d.neighbors()] = 1
# lead1[[kwant.builder.HoppingKind(*hopping) for hopping in nnn_hoppingsd]] = nnn
#
# sys.attach_lead(lead0) #spin up
# sys.attach_lead(lead1) #spin down
# sys.attach_lead(lead0.reversed()) #lead3 spin up
# sys.attach_lead(lead1.reversed()) #lead4 spin down
sym0u = kwant.TranslationalSymmetry((-1,0))
sym0u.add_site_family(lat_u.sublattices[0], other_vectors=[(-1, 2)])
sym0u.add_site_family(lat_u.sublattices[1], other_vectors=[(-1, 2)])
lead0_u = kwant.Builder(sym0u)
lead0_u[lat_u.shape(lead0_shape,(0,1))]= onsite # 1#
lead0_u[lat_u.neighbors()] = 1
lead0_u[[kwant.builder.HoppingKind(*hopping) for hopping in nnn_hoppings]] = nnn
sys.attach_lead(lead0_u)
#================================left_down0=====================================
sym0d = kwant.TranslationalSymmetry((-1,0))
sym0d.add_site_family(lat_d.sublattices[0], other_vectors=[(-1, 2)])
sym0d.add_site_family(lat_d.sublattices[1], other_vectors=[(-1, 2)])
lead0_d = kwant.Builder(sym0d)
lead0_d[lat_d.shape(lead0_shape,(0,1))]= onsite # 1#
lead0_d[lat_d.neighbors()] = 1
lead0_d[[kwant.builder.HoppingKind(*hopping) for hopping in nnn_hoppingsd]] = nnn
sys.attach_lead(lead0_d)
sys.attach_lead(lead0_u.reversed())
sys.attach_lead(lead0_d.reversed())
return sys
def test_plot_2d_bands():
chain = kwant.lattice.chain()
square = kwant.lattice.square()
cube = kwant.lattice.general([(1, 0, 0), (0, 1, 0), (0, 0, 1)])
hc = kwant.lattice.honeycomb()
syst_1d = kwant.Builder(kwant.TranslationalSymmetry(*chain._prim_vecs))
syst_1d[chain(0)] = 2
syst_1d[chain.neighbors()] = -1
syst_2d = _simple_syst(square, t=-1)
syst_graphene = _simple_syst(hc, t=-1)
syst_3d = kwant.Builder(kwant.TranslationalSymmetry(*cube._prim_vecs))
syst_3d[cube(0, 0, 0)] = 6
syst_3d[cube.neighbors()] = -1
with tempfile.TemporaryFile('w+b') as out:
# test 2D
plot_2d_bands(wraparound(syst_2d).finalized(),
k_x=11,
k_y=11,
file=out)
plot_2d_bands(wraparound(syst_graphene).finalized(),
k_x=11,
k_y=11,
file=out)
# test non-wrapped around system
with pytest.raises(TypeError):
plot_2d_bands(syst_1d.finalized())
# test incompletely wrapped around system
with pytest.raises(TypeError):
plot_2d_bands(wraparound(syst_2d, keep=0).finalized())
# test incorrect lattice dimention (1, 3)
with pytest.raises(ValueError):
plot_2d_bands(wraparound(syst_1d).finalized())
with pytest.raises(ValueError):
plot_2d_bands(wraparound(syst_3d).finalized())
# test k_x and k_y differ
with tempfile.TemporaryFile('w+b') as out:
syst = wraparound(syst_2d).finalized()
plot_2d_bands(syst, k_x=11, k_y=15, file=out)
plot_2d_bands(syst, k_x=np.linspace(-np.pi, np.pi, 11), file=out)
plot_2d_bands(syst, k_y=np.linspace(-np.pi, np.pi, 11), file=out)
syst = wraparound(syst_graphene).finalized()
# test extend_bbox2d
plot_2d_bands(syst, extend_bbox=1.2, k_x=11, k_y=11, file=out)
# test mask Brillouin zone
plot_2d_bands(syst, mask_brillouin_zone=True, k_x=11, k_y=11, file=out)
def test_very_singular_leads(smatrix):
syst = kwant.Builder()
chain = kwant.lattice.chain(norbs=2)
left_lead = kwant.Builder(kwant.TranslationalSymmetry((-1,)))
right_lead = kwant.Builder(kwant.TranslationalSymmetry((1,)))
syst[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)
syst.attach_lead(left_lead)
syst.attach_lead(right_lead)
fsyst = syst.finalized()
leads = smatrix(fsyst).lead_info
assert [len(i.momenta) for i in leads] == [0, 4]
def make_system(r=10, w=2.0, pot=0.1):
#### Define the scattering region. ####
# circular scattering region
def circle(pos):
x, y = pos
return x**2 + y**2 < r**2
sys = kwant.Builder()
# w: width and pot: potential maximum of the p-n junction
def potential(site):
(x, y) = site.pos
d = y * cos_30 + x * sin_30
return pot * tanh(d / w)
sys[graphene.shape(circle, (0, 0))] = potential
# specify the hoppings of the graphene lattice in the
# format expected by builder.HoppingKind
hoppings = (((0, 0), a, b), ((0, 1), a, b), ((-1, 1), a, b))
sys[[kwant.builder.HoppingKind(*hopping) for hopping in hoppings]] = -1
# Modify the scattering region
del sys[a(0, 0)]
sys[a(-2, 1), b(2, 2)] = -1
#### Define the leads. ####
# left lead
sym0 = kwant.TranslationalSymmetry(graphene.vec((-1, 0)))
def lead0_shape(pos):
x, y = pos
return (-0.4 * r < y < 0.4 * r)
lead0 = kwant.Builder(sym0)
lead0[graphene.shape(lead0_shape, (0, 0))] = -pot
lead0[[kwant.builder.HoppingKind(*hopping) for hopping in hoppings]] = -1
# The second lead, going to the top right
sym1 = kwant.TranslationalSymmetry(graphene.vec((0, 1)))
def lead1_shape(pos):
v = pos[1] * sin_30 - pos[0] * cos_30
return (-0.4 * r < v < 0.4 * r)
lead1 = kwant.Builder(sym1)
lead1[graphene.shape(lead1_shape, (0, 0))] = pot
lead1[[kwant.builder.HoppingKind(*hopping) for hopping in hoppings]] = -1
return sys, [lead0, lead1]
def make_lead():
def lead_shape(pos):
x, y = pos
return abs(y) < width
sym = kwant.TranslationalSymmetry((1, 0))
lead = kwant.Builder(sym)
sym_lead = kwant.TranslationalSymmetry((-1, 0))
lead = kwant.Builder(sym_lead)
lead[lat.shape(lead_shape, (0, 0))] = 4
lead[lat.neighbors()] = -1
return lead.finalized()
def make_lead():
syst = kwant.Builder(kwant.TranslationalSymmetry((-1, 0)))
lat = kwant.lattice.square()
syst[[lat(0, 0), lat(0, 1)]] = 3
syst[lat(0, 1), lat(0, 0)] = -1
syst[((lat(1, y), lat(0, y)) for y in range(2))] = -1
return syst
def crear_barra_hall(syst, L, W):
#Contactos laterales
tdir = -graphene.vec((1, 0))
r0 = 2 * tdir
sym = kwant.TranslationalSymmetry(tdir)
lead = create_system(L=L, W=W, sym=sym, r0=r0)
syst.attach_lead(lead)
syst.attach_lead(lead.reversed())
#Contactos verticales
tdir = -graphene.vec((0, 1))
r0 = L * graphene.vec((1, 0))
sym = kwant.TranslationalSymmetry(tdir)
lead = create_system(L=L * 2 / 3, W=W, sym=sym, r0=r0)
syst.attach_lead(lead)
syst.attach_lead(lead.reversed())
return syst
def make_system_DC(a = 1, t = 1.0,L=50,W = 2, x0 = 20, y0 = -0.4,iP = 5,lx = 4, ly = 0.2,
U = 5, V0 = 0,
Vp = 0.005, tau = 100):
lat = kwant.lattice.square(a=1, norbs = 1)
syst = kwant.Builder()
x0 = L/2
def onsite(site):
(x,y) = site.pos
return np.exp(-((x-x0)/lx)**2)*V0 + 4*t
syst[(lat(x,y) for x in range(0,L) for y in range(0,W))] = onsite
syst[lat.neighbors()] = -t
lead = kwant.Builder(kwant.TranslationalSymmetry((-a,0)))
lead[(lat(0,y) for y in range(0,W))] = 4*t
lead[lat.neighbors()] = -t
syst.attach_lead(lead)
syst.attach_lead(lead.reversed())
colormap = plt.cm.plasma
def region_colors(site):
(x,y) = site.pos
maxpot = 0.8
rap = (onsite(site)-4*t)/maxpot
return colormap(rap)
#kwant.plot(syst, site_color= region_colors, fig_size = (20,15), colorbar = 0)
# plt.savefig('syst_V0{:d}_W{:d}.pdf'.format(int(V0),W), format = 'pdf', dpi =60)
# plt.savefig('syst.pdf', format = 'pdf', dpi =100)
lead_fin = lead.finalized()
return syst
def make_system(R):
def in_ring(pos):
x, y = pos
return R**2 / 4 < x**2 + y**2 < R**2
def in_lead(pos):
x, y = pos
return -R / 4 < y < R / 4
def pot(site, B):
x, y = site.pos
return (0.1 * tanh(x / R) + tanh(2 * y / R)) * sigma_z
def hop(site1, site2, B):
x1, y1 = site1.pos
x2, y2 = site2.pos
return -exp(.5j * B * (x1 - x2) * (y1 + y2)) * sigma_0
lat = kwant.lattice.honeycomb()
syst = kwant.Builder()
syst[lat.shape(in_ring, (3 * R / 4, 0))] = pot
syst[lat.neighbors()] = hop
lead = kwant.Builder(kwant.TranslationalSymmetry(lat.vec((-1, 0))))
lead[lat.shape(in_lead, (0, 0))] = sigma_0
lead[lat.neighbors()] = sigma_x
syst.attach_lead(lead)
syst.attach_lead(lead.reversed())
return syst.finalized()
def test_selfenergy_reflection(greens_function, smatrix):
rng = ensure_rng(4)
system = kwant.Builder()
left_lead = kwant.Builder(kwant.TranslationalSymmetry((-1, )))
for b, site in [(system, chain(0)), (system, chain(1)),
(left_lead, chain(0))]:
h = rng.random_sample((n, n)) + 1j * rng.random_sample((n, n))
h += h.conjugate().transpose()
b[site] = h
for b, hopp in [(system, (chain(0), chain(1))),
(left_lead, (chain(0), chain(1)))]:
b[hopp] = (10 * rng.random_sample((n, n)) + 1j * rng.random_sample(
(n, n)))
system.attach_lead(left_lead)
fsyst = system.finalized()
t = smatrix(fsyst, 0, (), [0], [0])
fsyst.leads[0] = LeadWithOnlySelfEnergy(fsyst.leads[0])
sol = greens_function(fsyst, 0, (), [0], [0])
assert_almost_equal(sol.transmission(0, 0), t.transmission(0, 0))
fsyst = system.finalized()
for syst in (fsyst.precalculate(what='selfenergy'),
fsyst.precalculate(what='all')):
sol = greens_function(syst, 0, (), [0], [0])
assert_almost_equal(sol.transmission(0, 0), t.transmission(0, 0))
raises(ValueError, greens_function, fsyst.precalculate(what='modes'), 0,
(), [0], [0])
def test_singular_graph_system(smatrix):
rng = ensure_rng(11)
system = kwant.Builder()
lead = kwant.Builder(kwant.TranslationalSymmetry((-1, 0)))
h = rng.random_sample((n, n)) + 1j * rng.random_sample((n, n))
h += h.conjugate().transpose()
h *= 0.8
t = 4 * rng.random_sample((n, n)) + 4j * rng.random_sample((n, n))
t1 = 4 * rng.random_sample((n, n)) + 4j * rng.random_sample((n, n))
lead[sq(0, 0)] = system[[sq(0, 0), sq(1, 0)]] = h
lead[sq(0, 1)] = system[[sq(0, 1), sq(1, 1)]] = 4 * h
for builder in [system, lead]:
builder[sq(0, 0), sq(1, 0)] = t
builder[sq(0, 1), sq(1, 0)] = t1
system.attach_lead(lead)
system.attach_lead(lead.reversed())
fsyst = system.finalized()
result = smatrix(fsyst)
s, leads = result.data, result.lead_info
assert_almost_equal(np.dot(s.conjugate().transpose(), s),
np.identity(s.shape[0]))
n_modes = len(leads[0].momenta) // 2
assert len(leads[1].momenta) // 2 == n_modes
assert_almost_equal(s[:n_modes, :n_modes], 0)
t_elements = np.sort(abs(np.asarray(s[n_modes:, :n_modes])), axis=None)
t_el_should_be = n_modes * (n_modes - 1) * [0] + n_modes * [1]
assert_almost_equal(t_elements, t_el_should_be)
def make_system(width, length):
def disk_d(pos):
x,y=pos
return -width<y<0 and abs(x)<length #25.1
def lead_shape(pos):
x,y=pos
return -width<y<0
def nnn_d(site1, site2):
x,y=site1.pos
if x**2+(y+12)**2<16:
return -1j * m2
else:
return 1j *m2
sys = kwant.Builder()
sys[lat_d.shape(disk_d,(0,0))] = onsite_d
sys[lat_d.neighbors()] = 1
sys[[kwant.builder.HoppingKind(*hopping) for hopping in nnn_hoppingsd]] = nnn_d
sym = kwant.TranslationalSymmetry((-1,0))
sym.add_site_family(lat_d.sublattices[0], other_vectors=[(-1, 2)])
sym.add_site_family(lat_d.sublattices[1], other_vectors=[(-1, 2)])
lead = kwant.Builder(sym)
lead[lat_d.shape(lead_shape, (0, 0))] = onsite_d
lead[lat_d.neighbors()]=1
lead[[kwant.builder.HoppingKind(*hopping) for hopping in nnn_hoppingsd]]=1j *m2
sys.attach_lead(lead)
sys.attach_lead(lead.reversed())
return sys.finalized()
def make_system(t=1.0, W=10, L=10):
# Now we must specify the number of orbitals per site.
lat = kwant.lattice.square(norbs=2)
syst = kwant.Builder()
syst[(lat(x, y) for x in range(L) for y in range(W))] = \
lambda s, alpha, E_z: 4 * t * s0 + E_z * sz
syst[kwant.builder.HoppingKind((1, 0), lat, lat)] = \
lambda s1, s2, alpha, E_z: -t * s0 - 1j * alpha * sy
syst[kwant.builder.HoppingKind((0, 1), lat, lat)] = \
lambda s1, s2, alpha, E_z: -t * s0 + 1j * alpha * sx
# The new bit: specifying the conservation law.
lead = kwant.Builder(kwant.TranslationalSymmetry((-1, 0)),
conservation_law=-sz,
time_reversal=s0)
lead[(lat(0, j) for j in range(W))] = 4 * t * s0
lead[lat.neighbors()] = -t * s0 # Note: no spin-orbit in the lead.
syst.attach_lead(lead)
syst.attach_lead(lead.reversed())
syst = syst.finalized()
return syst
def agregar_contactos(syst, L, W):
tdir = -graphene.vec((1, 0))
sym = kwant.TranslationalSymmetry(tdir)
lead = create_system(L=L, W=W, sym=sym, r0=2 * tdir)
syst.attach_lead(lead)
syst.attach_lead(lead.reversed())
return syst
def make_system_crys_air_crys(length, width, width_lead, dis, salt):
def cuboid_shape(pos):
x, y = pos
return abs(x) < length and abs(y) < width
def lead_shape(pos):
x, y = pos
return abs(y) < width_lead
def onsite(site):
x, y = site.pos
if abs(y) < width_lead:
return 0
elif y >= width_lead:
return ((x % 2 == 0) & (y % 2 == 0)) * 2
else:
return ((x % 2 == 0) & (y % 2 == 0)) * 2
sys = kwant.Builder()
sys[lat.shape(cuboid_shape, (0, 0))] = onsite
sys[lat.neighbors()] = -1
sym_lead = kwant.TranslationalSymmetry((-1, 0))
lead = kwant.Builder(sym_lead)
lead[lat.shape(lead_shape, (0, 0))] = 0
lead[lat.neighbors()] = -1
sys.attach_lead(lead)
sys.attach_lead(lead.reversed())
return sys.finalized()
def make_cuboid(a, seed):
def cuboid_shape(pos):
x, y, z = pos
return 0 <= x < a and 0 <= y < a and 0 <= z < a
def onsite(site):
x, y, z = site.pos
return (uniform(repr(site), seed) - 0.5) * dis
# return (random.random()-0.5)*dis
sys = kwant.Builder()
sys[lat.shape(cuboid_shape, (0, 0, 0))] = onsite
sys[lat.neighbors()] = hop
sym_lead = kwant.TranslationalSymmetry((-1, 0, 0))
lead = kwant.Builder(sym_lead)
def lead_shape(pos):
x, y, z = pos
return x == 0 and 0 <= y < a and 0 <= z < a
lead[lat.shape(lead_shape, (0, 0, 0))] = 0
lead[lat.neighbors()] = hop
sys.attach_lead(lead)
sys.attach_lead(lead.reversed())
return sys.finalized()
def test_unequal_orbital_number():
model = tbmodels.Model(pos=[[0., 0.], [0.5, 0.5], [0.5, 0.5]],
on_site=[1, 0.7, -1.2])
t1 = 0.1
t2 = 0.15
t3 = 0.4
for phase, R in zip([1, -1j, 1j, -1], itertools.product([0, -1], [0, -1])):
model.add_hop(t1 * phase, 0, 1, R)
model.add_hop(t3 * phase, 1, 2, R)
for R in ((r[0], r[1]) for r in itertools.permutations([0, 1])):
model.add_hop(t2, 0, 0, R)
model.add_hop(-t2, 1, 1, R)
model.add_hop(-t2, 2, 2, R)
latt = model.to_kwant_lattice()
sym = kwant.TranslationalSymmetry(latt.vec((1, 0)), latt.vec((0, 1)))
sys = kwant.Builder(sym)
sys[latt.shape(lambda p: True, (0, 0))] = 0
model.add_hoppings_kwant(sys)
sys = wraparound.wraparound(sys).finalized()
for k in KPT:
k = k[:2]
k_kwant = tuple(np.array(k) * 2 * np.pi)
np.testing.assert_allclose(model.eigenval(k),
la.eigvalsh(
sys.hamiltonian_submatrix(k_kwant)),
atol=1e-8)
def test_fill_sticky():
"""Test that adjacent regions are properly interconnected when filled
separately.
"""
# Generate model template.
lat = kwant.lattice.kagome()
template = kwant.Builder(
kwant.TranslationalSymmetry(lat.vec((1, 0)), lat.vec((0, 1))))
for i, sl in enumerate(lat.sublattices):
template[sl(0, 0)] = i
for i in range(1, 3):
for j, hop in enumerate(template.expand(lat.neighbors(i))):
template[hop] = j * 1j
def disk(site):
pos = site.pos
return ta.dot(pos, pos) < 13
def halfplane(site):
return ta.dot(site.pos - (-1, 1), (-0.9, 0.63)) > 0
# Fill in one go.
syst0 = kwant.Builder()
syst0.fill(template, disk, (0, 0))
# Fill in two stages.
syst1 = kwant.Builder()
syst1.fill(template, lambda s: disk(s) and halfplane(s), (-2, 1))
syst1.fill(template, lambda s: disk(s) and not halfplane(s), (0, 0))
# Verify that both results are identical.
assert set(syst0.site_value_pairs()) == set(syst1.site_value_pairs())
assert (set(syst0.hopping_value_pairs()) == set(
syst1.hopping_value_pairs()))
def test_raise_nonhermitian():
syst = kwant.Builder(kwant.TranslationalSymmetry((-1, )))
lat = kwant.lattice.chain()
syst[lat(0)] = 1j
syst[lat(0), lat(1)] = complex(cos(0.2), sin(0.2))
syst = syst.finalized()
raises(ValueError, kwant.physics.Bands, syst)
def test_attach_lead_incomplete_unit_cell():
lat = kwant.lattice.chain()
syst = kwant.Builder()
lead = kwant.Builder(kwant.TranslationalSymmetry((2, )))
syst[lat(1)] = lead[lat(0)] = lead[lat(1)] = 0
lead[lat.neighbors()] = 0
assert (len(syst.attach_lead(lead)) == 0)
def test_tricky_singular_hopping(smatrix):
system = kwant.Builder()
lead = kwant.Builder(kwant.TranslationalSymmetry((4, 0)))
interface = []
for i in range(n):
site = sq(-1, i)
interface.append(site)
system[site] = 0
for j in range(4):
lead[sq(j, i)] = 0
for i in range(n - 1):
system[sq(-1, i), sq(-1, i + 1)] = -1
for j in range(4):
lead[sq(j, i), sq(j, i + 1)] = -1
for i in range(n):
for j in range(4):
lead[sq(j, i), sq(j + 1, i)] = -1
del lead[sq(1, 0), sq(2, 0)]
system.leads.append(kwant.builder.BuilderLead(lead, interface))
fsyst = system.finalized()
s = smatrix(fsyst, -1.3).data
assert_almost_equal(np.dot(s.conjugate().transpose(), s),
np.identity(s.shape[0]))
def test_closest():
rng = ensure_rng(10)
for sym_dim in range(1, 4):
for space_dim in range(sym_dim, 4):
lat = kwant.lattice.general(ta.identity(space_dim))
# Choose random periods.
while True:
periods = rng.randint(-10, 11, (sym_dim, space_dim))
if np.linalg.det(np.dot(periods, periods.T)) > 0.1:
# Periods are reasonably linearly independent.
break
syst = builder.Builder(kwant.TranslationalSymmetry(*periods))
for tag in rng.randint(-30, 31, (4, space_dim)):
# Add site and connect it to the others.
old_sites = list(syst.sites())
new_site = lat(*tag)
syst[new_site] = None
syst[((new_site, os) for os in old_sites)] = None
# Test consistency with fill().
for point in 200 * rng.random_sample((10, space_dim)) - 100:
closest = syst.closest(point)
dist = closest.pos - point
dist = ta.dot(dist, dist)
syst2 = builder.Builder()
syst2.fill(syst, inside_disc(point, 2 * dist), closest)
assert syst2.closest(point) == closest
for site in syst2.sites():
dd = site.pos - point
dd = ta.dot(dd, dd)
assert dd >= 0.999999 * dist
def test_arg_passing(wave_function, ldos, smatrix):
def onsite(site, a, b):
return site.pos[0] + site.pos[1] + a + b
def hopping(site1, site2, a, b):
return b - a
W = 3
L = 4
syst = kwant.Builder()
syst[(square(i, j) for i in range(L) for j in range(W))] = onsite
syst[square.neighbors()] = hopping
lead = kwant.Builder(kwant.TranslationalSymmetry((-1, 0)))
lead[(square(0, j) for j in range(W))] = onsite
lead[square.neighbors()] = hopping
syst.attach_lead(lead)
syst.attach_lead(lead.reversed())
fsyst = syst.finalized()
# compare results to those when we pass `args` only
args = (1, 3)
params = dict(a=1, b=3)
np.testing.assert_array_equal(
wave_function(fsyst, args=args)(0),
wave_function(fsyst, params=params)(0))
np.testing.assert_array_equal(ldos(fsyst, args=args),
ldos(fsyst, params=params))
np.testing.assert_array_equal(
smatrix(fsyst, args=args).data,
smatrix(fsyst, params=params).data)
def qsh_system(a=5, Lx=5000, Ly=500):
hamiltonian = """
(C-D*(k_x**2+k_y**2))*identity(4)
+ (M-B*(k_x**2+k_y**2))*kron(sigma_0, sigma_z)
+ A*k_x*kron(sigma_z, sigma_x)
+ A*k_y*kron(sigma_z, sigma_y)
+ V(x,y)*identity(4)
"""
template = kwant.continuum.discretize(hamiltonian, grid=a)
def shape(site):
(x, y) = site.pos
return (0 <= y < Ly and 0 <= x < Lx)
def lead_shape(site):
(x, y) = site.pos
return (0 <= y < Ly)
syst = kwant.Builder()
syst.fill(template, shape, (0, 0))
lead = kwant.Builder(kwant.TranslationalSymmetry([-a, 0]))
lead.fill(template, lead_shape, (0, 0))
syst.attach_lead(lead)
syst.attach_lead(lead.reversed())
syst = syst.finalized()
return syst
def test_opservables_spin():
def onsite(site, B):
return 2 * np.eye(2) + B * sigmaz
L = 20
lat = kwant.lattice.chain(norbs=2)
syst = kwant.Builder()
syst[(lat(i) for i in range(L))] = onsite
syst[lat.neighbors()] = -1 * np.eye(2)
lead = kwant.Builder(kwant.TranslationalSymmetry((-1, )))
lead[lat(0)] = onsite
lead[lat.neighbors()] = -1 * np.eye(2)
syst.attach_lead(lead)
syst.attach_lead(lead.reversed())
fsyst = syst.finalized()
args = (0.1, )
down, up = kwant.wave_function(fsyst, energy=1., args=args)(0)
x_hoppings = kwant.builder.HoppingKind((1, ), lat)
spin_current_z = ops.Current(fsyst, sigmaz, where=x_hoppings(syst))
_test(spin_current_z, up, args=args, per_el_val=1)
_test(spin_current_z, down, args=args, per_el_val=-1)
# calculate spin_x torque
spin_torque_x = ops.Source(fsyst, sigmax, where=[lat(L // 2)])
i = fsyst.id_by_site[lat(L // 2)]
psi = up[2 * i:2 * (i + 1)] + down[2 * i:2 * (i + 1)]
H_ii = onsite(None, *args)
K = np.dot(H_ii, sigmax) - np.dot(sigmax, H_ii)
expect = 1j * ft.reduce(np.dot, (psi.conj(), K, psi))
_test(spin_torque_x, up + down, args=args, reduced_val=expect)
def make_system(a=1, t=1.0, W=10, L=30):
# Start with an empty tight-binding system and a single square lattice.
# `a` is the lattice constant (by default set to 1 for simplicity.
lat = kwant.lattice.square(a)
syst = kwant.Builder()
syst[(lat(x, y) for x in range(L) for y in range(W))] = \
4 * t * sigma_0 + e_z * sigma_z
# hoppings in x-direction
syst[kwant.builder.HoppingKind((1, 0), lat, lat)] = \
-t * sigma_0 - 1j * alpha * sigma_y
# hoppings in y-directions
syst[kwant.builder.HoppingKind((0, 1), lat, lat)] = \
-t * sigma_0 + 1j * alpha * sigma_x
lead = kwant.Builder(kwant.TranslationalSymmetry((-a, 0)))
lead[(lat(0, j) for j in range(W))] = 4 * t * sigma_0 + e_z * sigma_z
# hoppings in x-direction
lead[kwant.builder.HoppingKind((1, 0), lat, lat)] = \
-t * sigma_0 - 1j * alpha * sigma_y
# hoppings in y-directions
lead[kwant.builder.HoppingKind((0, 1), lat, lat)] = \
-t * sigma_0 + 1j * alpha * sigma_x
syst.attach_lead(lead)
syst.attach_lead(lead.reversed())
return syst
