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