def FinalizedSystem(SitesCount_X):
# lattices
lat = kwant.lattice.general(((1, ), ))
# builder
sys = kwant.Builder()
# first, define all sites and their onsite energies
for nx in range(SitesCount_X):
sys[lat(nx, )] = onsite
# hoppings
for nx in range(SitesCount_X - 1):
sys[lat(nx + 1, ), lat(nx, )] = hop
# finalize the system
return sys.finalized()
def syst_rect(lat, salt, W=3, L=50):
syst = kwant.Builder()
ll = L // 2
ww = W // 2
def onsite(site):
return 4 + 0.1 * kwant.digest.gauss(repr(site.tag), salt=salt)
syst[(lat(i, j) for i in range(-ll, ll + 1)
for j in range(-ww, ww + 1))] = onsite
syst[lat.neighbors()] = -1
sym = kwant.TranslationalSymmetry(lat.vec((-1, 0)))
lead = kwant.Builder(sym)
lead[(lat(0, j) for j in range(-ww, ww + 1))] = 4
lead[lat.neighbors()] = -1
syst.attach_lead(lead)
syst.attach_lead(lead.reversed())
return syst
def syst_3d(W=3, r1=2, r2=4, a=1, t=1.0):
lat = kwant.lattice.general(((a, 0, 0), (0, a, 0), (0, 0, a)))
syst = kwant.Builder()
def ring(pos):
(x, y, z) = pos
rsq = x**2 + y**2
return (r1**2 < rsq < r2**2) and abs(z) < 2
syst[lat.shape(ring, (0, -r2 + 1, 0))] = 4 * t
syst[lat.neighbors()] = -t
sym_lead0 = kwant.TranslationalSymmetry(lat.vec((-1, 0, 0)))
lead0 = kwant.Builder(sym_lead0)
lead_shape = lambda pos: (-W / 2 < pos[1] < W / 2) and abs(pos[2]) < 2
lead0[lat.shape(lead_shape, (0, 0, 0))] = 4 * t
lead0[lat.neighbors()] = -t
lead1 = lead0.reversed()
syst.attach_lead(lead0)
syst.attach_lead(lead1)
return syst
def test_opposite_hoppings():
lat = kwant.lattice.square(norbs=1)
for val in [1j, lambda a, b: 1j]:
syst = kwant.Builder(kwant.TranslationalSymmetry((1, 1)))
syst[(lat(x, 0) for x in [-1, 0])] = 0
syst[lat(0, 0), lat(-1, 0)] = val
syst[lat(-1, 0), lat(-1, -1)] = val
fsyst = wraparound(syst).finalized()
params = dict(k_x=0)
np.testing.assert_almost_equal(
fsyst.hamiltonian_submatrix(params=params), 0)
def test_plot_raises_on_bad_site_spec(engine):
syst = kwant.Builder()
lat = kwant.lattice.square(norbs=1)
syst[(lat(i, j) for i in range(5) for j in range(5))] = None
# Cannot provide site_size as an array when syst is a Builder
plotter.set_engine(engine)
with pytest.raises(TypeError):
plotter.plot(syst, site_size=[1] * 25)
# Cannot provide site_size as an array when syst is a Builder
with pytest.raises(TypeError):
plotter.plot(syst, site_symbol=['o'] * 25)
def make_2d_test_system(X=2, Y=2, a=1):
ham = "(hbar^2 * (k_x^2 + k_y^2) / (2 * m) * c - mu) * sigma_z + Delta * sigma_x"
template_lead = discretize(ham, grid_spacing=a)
template = discretize(ham, locals={'Delta': 0}, grid_spacing=a)
syst = kwant.Builder()
syst.fill(template, lambda s: 0 <= s.pos[0] < X and 0 <= s.pos[1] < Y,
(0, 0))
lat = template.lattice
# Add 0 self energy lead
cuts = get_cuts(syst, lat)
syst = add_vlead(syst, lat, *cuts)
# Leads
lead = kwant.Builder(kwant.TranslationalSymmetry((a, 0)))
lead.fill(template_lead, lambda s: 0 <= s.pos[1] < Y, (0, 0))
syst.attach_lead(lead)
syst.attach_lead(lead.reversed())
syst = syst.finalized()
hopping = hopping_between_cuts(syst, *cuts)
return syst, hopping
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_discrete_symmetries():
lat = builder.SimpleSiteFamily(name='ccc', norbs=2)
lat2 = builder.SimpleSiteFamily(name='bla', norbs=1)
lat3 = builder.SimpleSiteFamily(name='dd', norbs=4)
cons_law = {lat: np.diag([1, 2]), lat2: 0}
syst = builder.Builder(conservation_law=cons_law,
time_reversal=(lambda site, p: np.exp(1j*p) *
np.identity(site.family.norbs)))
syst[lat(1)] = np.identity(2)
syst[lat2(1)] = 1
sym = syst.finalized().discrete_symmetry(args=[0])
for proj, should_be in zip(sym.projectors, np.identity(3)):
assert np.allclose(proj.toarray(), should_be.reshape((3, 1)))
assert np.allclose(sym.time_reversal.toarray(), np.identity(3))
syst.conservation_law = lambda site, p: cons_law[site.family]
sym = syst.finalized().discrete_symmetry(args=[0])
for proj, should_be in zip(sym.projectors, np.identity(3)):
assert np.allclose(proj.toarray(), should_be.reshape((-1, 1)))
syst = builder.Builder(conservation_law=np.diag([-1, 1]))
syst[lat(1)] = np.identity(2)
sym = syst.finalized().discrete_symmetry()
for proj, should_be in zip(sym.projectors, np.identity(2)):
assert np.allclose(proj.toarray(), should_be.reshape((-1, 1)))
syst = builder.Builder(conservation_law=1)
syst[lat2(1)] = 0
sym = syst.finalized().discrete_symmetry()
[proj] = sym.projectors
assert np.allclose(proj.toarray(), [[1]])
syst = kwant.Builder(conservation_law=np.diag([-1, 1, -1, 1]))
syst[lat3(0)] = np.eye(4)
sym = syst.finalized().discrete_symmetry()
p1 = np.zeros((4, 2))
p1[0, 0] = p1[2, 1] = 1
assert np.allclose(sym.projectors[0].toarray(), p1)
p2 = np.zeros((4, 2))
p2[1, 0] = p2[3, 1] = 1
assert np.allclose(sym.projectors[1].toarray(), p2)
# test parameter passing to conservation_law
syst = builder.Builder(conservation_law=lambda site, b: b)
syst[lat2(1)] = 0
sym = syst.finalized().discrete_symmetry(params=dict(a=None, b=1))
[proj] = sym.projectors
assert np.allclose(proj.toarray(), [[1]])
def test_smatrix_shape(smatrix):
system = kwant.Builder()
lead0 = kwant.Builder(kwant.TranslationalSymmetry((-1, )))
lead1 = kwant.Builder(kwant.TranslationalSymmetry((1, )))
for b, site in [(system, chain(0)), (system, chain(1)),
(system, chain(2))]:
b[site] = 2
lead0[chain(0)] = lambda site: lead0_val
lead1[chain(0)] = lambda site: lead1_val
for b, hopp in [(system, (chain(0), chain(1))),
(system, (chain(1), chain(2))),
(lead0, (chain(0), chain(1))),
(lead1, (chain(0), chain(1)))]:
b[hopp] = -1
system.attach_lead(lead0)
system.attach_lead(lead1)
fsyst = system.finalized()
lead0_val = 4
lead1_val = 4
s = smatrix(fsyst, 1.0, (), [1], [0]).data
assert s.shape == (0, 0)
lead0_val = 2
lead1_val = 2
s = smatrix(fsyst, 1.0, (), [1], [0]).data
assert s.shape == (1, 1)
lead0_val = 4
lead1_val = 2
s = smatrix(fsyst, 1.0, (), [1], [0]).data
assert s.shape == (1, 0)
lead0_val = 2
lead1_val = 4
s = smatrix(fsyst, 1.0, (), [1], [0]).data
assert s.shape == (0, 1)
def make_system():
a = 1
lat = kwant.lattice.square(a)
syst = kwant.Builder()
t = 1.0
W = 5
L = 50
syst[(lat(x, y) for x in range(L) for y in range(W))] = 0
syst[lat.neighbors()] = -t
# 几何形状如下所示：
# lead2 lead3
# lead1(L) lead4(R)
# lead6 lead5
move = 0 # the step of leads 2,3,6,5 moving to center
lead1 = kwant.Builder(kwant.TranslationalSymmetry((-a, 0)))
lead1[(lat(0, j) for j in range(W))] = 0
lead1[lat.neighbors()] = -t
syst.attach_lead(lead1)
lead2 = kwant.Builder(kwant.TranslationalSymmetry((0, -a)))
lead2[(lat(move + j, 0) for j in range(W))] = 0
lead2[lat.neighbors()] = -t
syst.attach_lead(lead2)
lead3 = kwant.Builder(kwant.TranslationalSymmetry((0, -a)))
lead3[(lat(j + (L - W - move), 0) for j in range(W))] = 0
lead3[lat.neighbors()] = -t
syst.attach_lead(lead3)
syst.attach_lead(lead1.reversed()) # lead4
syst.attach_lead(lead3.reversed()) # lead5
syst.attach_lead(lead2.reversed()) # lead6
kwant.plot(syst)
syst = syst.finalized()
return syst
def make_system():
sys = kwant.Builder(kwant.TranslationalSymmetry(graphene.vec((-Y / 2, Y))))
sys[graphene.shape(disk, (0, 0))] = onsite
sys[graphene.neighbors(1)] = hopping1
sys[[kwant.builder.HoppingKind(*hopping)
for hopping in nnn_hoppings]] = nnn_hopping
sys = wraparound.wraparound(sys)
#kwant.plot(sys, fig_size=(10, 5))
lead = kwant.Builder(
kwant.TranslationalSymmetry((1, 0), graphene.vec((-Y / 2, Y))))
lead[graphene.shape(disk, (0, 0))] = onsite_clean
lead[graphene.neighbors(1)] = hopping1
lead[[kwant.builder.HoppingKind(*hopping)
for hopping in nnn_hoppings]] = nnn_hopping
lead = wraparound.wraparound(lead, keep=0)
sys.attach_lead(lead)
sys.attach_lead(lead.reversed())
#kwant.plot(lead, fig_size=(10, 5))
#kwant.plot(sys, fig_size=(10, 5))
return sys.finalized()
def test_signatures():
lat = kwant.lattice.square()
syst = kwant.Builder(kwant.TranslationalSymmetry((-3, 0), (0, 1)))
# onsites and hoppings that will be bound as sites
syst[lat(-2, 0)] = 4
syst[(lat(-2, 0), lat(-2, 1))] = -1
#
syst[lat(-1, 0)] = lambda a, E1: E1
syst[(lat(-1, 0), lat(-1, 1))] = lambda a, b, t1: t1
#
syst[lat(0, 0)] = lambda a, E2, **kwargs: E2
syst[(lat(0, 0), lat(0, 1))] = lambda a, b, t2, **kwargs: t2
# hoppings that will be bound as hoppings
syst[(lat(-2, 0), lat(-1, 0))] = -1
syst[(lat(-2, 0), lat(2, 0))] = -1
#
syst[(lat(-2, 0), lat(0, 0))] = -1
syst[(lat(-2, 0), lat(3, 0))] = lambda a, b, t3: t3
syst[(lat(-1, 0), lat(0, 0))] = lambda a, b, t4, **kwargs: t4
syst[(lat(-1, 0), lat(3, 0))] = lambda a, b, t5: t5
wrapped_syst = wraparound(syst)
## testing
momenta = ['k_x', 'k_y']
onsites = [
(lat(-2, 0), momenta, False),
(lat(-1, 0), ['E1', 't1'] + momenta, False),
(lat(0, 0), ['E2', 't2'] + momenta, True),
]
for site, params_should_be, should_take_kwargs in onsites:
params, _, takes_kwargs = get_parameters(wrapped_syst[site])
assert params[1:] == params_should_be
assert takes_kwargs == should_take_kwargs
hoppings = [
((lat(-2, 0), lat(-1, 0)), momenta, False),
((lat(-2, 0), lat(0, 0)), ['t3'] + momenta, False),
((lat(-1, 0), lat(0, 0)), ['t4', 't5'] + momenta, True),
]
for hopping, params_should_be, should_take_kwargs in hoppings:
params, _, takes_kwargs = get_parameters(wrapped_syst[hopping])
assert params[2:] == params_should_be
assert takes_kwargs == should_take_kwargs
def make_system(p,ppar):
"""
Building the different parts by adding onsite/hoppings to sys:
Since adding lead only to scattering region, I iterate over par.middle first; then I can use just one sys object to attach the leads in the first iteration, and keep the same sys object when continuing on adding the right and left parts.
Parameters
----------
ppar.make_1DNLeft_1DN_2DS_2DSMiddle_No_NRight : Boolean.
If True or 1, a 1D semiconducting wire is constructed with a 2D superconductor connected to it along the whole wire (along the y-direction), with a pincher layer of SC (???given by a 2D hamiltonian but only with one site in width for now ???ok???) at the boundary between the semiconductor and the superconducting lead.
Notes
-----
If 1D pincher is to be added at the edges of the 1D system, this is taken care of in make_1D_system, given that p.pincher==True and a t-value p.t_pincher needs to have been defined.
"""
print("%s: in make_system()" %str(misc.round_time(datetime.datetime.now(),round_to=60)))
if ppar.one_D == True:
if ppar.make_1D_Heff_LR_leads:
sys = make_1D_system(p,ppar) # make 1D N-S-N system, where middle S is the effective Hamiltonian of the proximitized semiconductor, and there is no middle S lead, meaning that conductances above the gap obrained in this model are not accurate, as modes should in the real physical system have been able to escape through the middle S lead above the gap (where the middle S has available quasiparticle excitations).
elif ppar.make_1DNLeft_1DN_2DSMiddle_No_NRight:
sys = make_1DNLeft_1DN_2DSMiddle_No_NRight_system(p,ppar)
elif ppar.make_1DNLeft_1DN_2DS_2DSMiddle_No_NRight:
sys = make_1DNLeft_1DN_2DS_2DSMiddle_No_NRight_system(p,ppar) # make 1D N-N(S)-N system, where middle N is 1D and middle S is 2D.
elif ppar.make_1D_NLeft_1D_S_Heff_No_NRight:
sys = make_1D_NLeft_1D_S_Heff_No_NRight(p,ppar) # make 1D N-S junction for calibration, where S has the effective Hamiltonian of the proximitized semiconductor
elif ppar.make_1D_NLeft_1D_N_2D_S_2D_SMiddle_No_NRight: # make 1D N-N(S) function to calibrate, where S is a 2D SC Hamiltonian that should induce the gap in the middle N
sys = make_1D_Nleft_1D_N_2D_S_2D_SMiddle_No_NRight(p,ppar)
else:
"""Function building superconductor for parameters in SimpleNamespace object p."""
sys = kwant.Builder()
par.asymmetric = check_asymm_device(par) # True/False, to be used when printing last blocks of Hamiltonian
for i,part_ in zip(('M','L','R'),(p.middle, p.left, p.right)):
"""Printing which part is being built at the current loop iteration:"""
print_current_part(part_,i)
"""Adding parts to the system:"""
sys[(lat(x,y) for x in part_ for y in range(p.Ny))] = onsite # Not input phase/gamma explicitly such that may specify variables such as Ez at later point in code after finalizing. I think that Kwant has this particular syntax in sys[lat..]=<function_name> without having to input arguments in the function.
sys[kwant.builder.HoppingKind((1,0),lat)] = hoppingx
sys[kwant.builder.HoppingKind((0,1),lat)] = hoppingy
"""Attaching leads to the middle region, i.e. the scattering region:"""
if i == 'M':
lead = make_lead_onesite_wide(p) #make_lead(p)
sys.attach_lead(lead)
sys.attach_lead(lead.reversed())
return sys
def make_lead():
def lead_shape(pos):
x,y=pos
return abs(y)<width
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)
lead[graphene.shape(lead_shape, (0, width-1))] = 0
lead[graphene.neighbors()]=1
lead[[kwant.builder.HoppingKind(*hopping) for hopping in nnn_hoppings]]=1j *m2
return lead.finalized()
def make_system(width, length, salt):
def disk(pos):
x,y=pos
return -width<y<width and abs(x)<length #25.1
def onsite(site):
x,y=site.pos
return (uniform(repr(site),salt)-0.5)*dis
sys=kwant.Builder()
sys[graphene.shape(disk,(0,0))]= onsite #0 #
sys[graphene.neighbors()]=1 # comment it, when has rashba
sys[[kwant.builder.HoppingKind(*hopping) for hopping in nnn_hoppings]] = 1j*m2
return sys
def test_plot_more_site_families_than_colors(engine):
# test against regression reported in
# https://gitlab.kwant-project.org/kwant/kwant/issues/257
ncolors = len(pyplot.rcParams['axes.prop_cycle'])
syst = kwant.Builder()
lattices = [kwant.lattice.square(name=i, norbs=1)
for i in range(ncolors + 1)]
for i, lat in enumerate(lattices):
syst[lat(i, 0)] = None
plotter.set_engine(engine)
with tempfile.NamedTemporaryFile('w+b', suffix=plotter_file_suffix(engine)) as out:
out_filename = out.name
plotter.plot(syst, file=out_filename, show=False)
def scatter():
sys[lat.shape(disk, (1, 1))] = onsite
sys[lat.neighbors()] = -1 / n**2
lead = kwant.Builder(kwant.TranslationalSymmetry((-1, 0)))
lead[lat.shape(edge, (0, 1))] = 4 / n1**2
lead[lat.neighbors()] = -1 / n1**2
sys.attach_lead(lead)
sys.attach_lead(lead.reversed())
#lead=kwant.Builder(kwant.TranslationalSymmetry((1,0)))
#lead[lat.shape(edge,(0,1))]=4/n2**2
#lead[lat.neighbors()]=-1/n2**2
#sys.attach_lead(lead)
return sys
def make_system0(width, length):
def disk(pos):
x, y = pos
return width - di < y < width and abs(x) < length #25.1
sys = kwant.Builder()
sys[graphene.shape(disk, (0, width - 1))] = 0 #0 #
sys[graphene.neighbors()] = 1 # comment it, when has rashba
def lead_shape(pos):
x, y = pos
return width - di < y < width
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
lead[graphene.shape(lead_shape, (0, width - 1))] = 0 #1
lead[graphene.neighbors()] = 1
sys.attach_lead(lead)
sys.attach_lead(lead.reversed())
return sys
def make_system_with_less_code():
a = 1 # 晶格常数
lat = kwant.lattice.square(a) # 创建晶格，方格子
syst = kwant.Builder() # 建立中心体系
t = 1.0 # hopping值
W = 5 # 中心体系宽度
L = 40 # 中心体系长度
# 中心区
syst[(lat(x, y) for x in range(L) for y in range(W))] = 0
syst[lat.neighbors()] = -t # 用neighbors()方法
# 电极
lead = kwant.Builder(kwant.TranslationalSymmetry((-a, 0)))
lead[(lat(0, j) for j in range(W))] = 0
lead[lat.neighbors()] = -t # 用neighbors()方法
syst.attach_lead(lead) # 左电极
syst.attach_lead(lead.reversed()) # 用reversed()方法得到右电极
kwant.plot(syst) # 把电极-中心区-电极图画出来，通过图像可以看出有没有写错
syst = syst.finalized() # 结束体系的制作。这个语句不可以省。这个语句是把Builder对象转换成可计算的对象。
return syst
def make_system_step1(q):
L1=tinyarray.array((3/sqrt(3),0));SC1=L1;
L2=tinyarray.array((0,q)); SC2=L2;
syst = kwant.Builder()
##primitive graphene,dispersion without B:
# for i in range(1):
# #for i in range(q):
# for j in range(1):
# # On-site Hamiltonian
# syst[a(i, j)] =0
# syst[b(i, j)] =0
# syst[a(0,0),b(0,0)]=-1-np.exp(1j*k1)-np.exp(1j*k2)
#
def rectangle(pos):
xR, yR = pos
#print(pos)
#sys.exit()
# xR,yR=list(x*v1+y*v2)
#return (xR <=Lx2)&(yR<=Ly2)&(xR >= Lx1)&(yR>=Ly1)
return (-cos_30/3-0.00001<=xR<3/sqrt(3)*Nx-1/sqrt(3))&(0-0.0001<=yR<=Ny*q-0.0001)
syst[graphene.shape(rectangle, (0, 0))] = 0
syst0=syst.finalized()
N_ToT=syst0.graph.num_nodes;
print(N_ToT);
def neighbors():
nns=[[] for i in range(N_ToT)];
for ni in range(N_ToT):
#print(ni)
ri=syst0.sites[ni].pos;
for nj in range(N_ToT):
rj=syst0.sites[nj].pos;
for n1 in range(-1,2):
for n2 in range(-1,2):
rjn=rj+(n1*SC1+n2*SC2);
ss=ri-rjn;
dis=sqrt(np.dot(ss,ss))
if (abs(dis-1/sqrt(3))<10**-5):
if not((n1==0)&(n2==0)&(nj==ni)):
nns[ni].append((nj,n1,n2))
return nns
nns=neighbors();
return nns,syst,syst0
def make_system(length, salt):
def onsite(site):
return (uniform(repr(site), salt) - 0.5) * 2.5
sys = kwant.Builder(
kwant.TranslationalSymmetry(
*graphene.prim_vecs *
length)) #kwant.TranslationalSymmetry(*graphene.prim_vecs*20)
sys[graphene.shape((lambda pos: True), (0, 0))] = onsite
sys[graphene.neighbors(1)] = -1
sys[[kwant.builder.HoppingKind(*hopping)
for hopping in nnn_hoppings]] = .1j
sys = wraparound(sys).finalized()
return sys
def make_syst_staggered(r=30, t=-1, a=1, m=0.1):
syst = kwant.Builder()
lat = kwant.lattice.honeycomb(a, norbs=1)
def circle(pos):
x, y = pos
return x**2 + y**2 < r**2
syst[lat.a.shape(circle, (0, 0))] = m
syst[lat.b.shape(circle, (0, 0))] = -m
syst[lat.neighbors()] = t
syst.eradicate_dangling()
return syst
def lead_metalica(hamiltonian, W=W_STD, a=A_STD):
template = kwant.continuum.discretize(hamiltonian, grid=a)
def lead_shape(site):
(x, y) = site.pos
return (-W / 2 < y < W / 2)
sigma_z = np.array([[1, 0], [0, -1]])
tau_z = np.kron(sigma_z, np.eye(3))
try:
lead = kwant.Builder(kwant.TranslationalSymmetry([-a, 0]),
conservation_law=-tau_z)
except:
print(
"Except in line 674 of 'gasb_hamiltonian.py' located in ./hamiltonians "
)
lead = kwant.Builder(kwant.TranslationalSymmetry([-a, 0]))
lead.fill(template, lead_shape, (-a, 0))
return lead
def test_one_lead(smatrix):
rng = ensure_rng(3)
system = kwant.Builder()
lead = kwant.Builder(kwant.TranslationalSymmetry((-1, )))
for b, site in [(system, chain(0)), (system, chain(1)), (system, chain(2)),
(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))),
(system, (chain(1), chain(2))),
(lead, (chain(0), chain(1)))]:
b[hopp] = (10 * rng.random_sample((n, n)) + 1j * rng.random_sample(
(n, n)))
system.attach_lead(lead)
fsyst = system.finalized()
for syst in (fsyst, fsyst.precalculate(), fsyst.precalculate(what='all')):
s = smatrix(syst).data
assert_almost_equal(np.dot(s.conjugate().transpose(), s),
np.identity(s.shape[0]))
raises(ValueError, smatrix, fsyst.precalculate(what='selfenergy'))
def test_args_params_equivalence():
for lat in [
kwant.lattice.square(),
kwant.lattice.honeycomb(),
kwant.lattice.kagome()
]:
syst = kwant.Builder(kwant.TranslationalSymmetry(*lat.prim_vecs))
syst[lat.shape((lambda pos: True), (0, 0))] = 1
syst[lat.neighbors(1)] = 0.1
syst[lat.neighbors(2)] = lambda a, b, param: 0.01
syst = wraparound(syst).finalized()
shs = syst.hamiltonian_submatrix
assert_equal(shs(args=["bla", 1, 2]),
shs(params=dict(param="bla", k_x=1, k_y=2)))
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
square = kwant.lattice.square(norbs=1)
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 test_band_velocities():
syst = kwant.Builder(kwant.TranslationalSymmetry((-1, 0)))
lat = kwant.lattice.square()
syst[lat(0, 0)] = 1
syst[lat(0, 1)] = 3
syst[lat(1, 0), lat(0, 0)] = -1
syst[lat(1, 1), lat(0, 1)] = 2
bands = kwant.physics.Bands(syst.finalized())
eps = 1E-4
for k in linspace(-pi, pi, 200):
vel = bands(k, derivative_order=1)[1]
# higher order formula for first derivative to get required accuracy
num_vel = (-bands(k + 2 * eps) + bands(k - 2 * eps) + 8 *
(bands(k + eps) - bands(k - eps))) / (12 * eps)
assert_array_almost_equal(vel, num_vel)
def make_system(width, length, salt):
def disk(pos):
x, y = pos
return abs(y) < width and abs(x) < length #25.1
def lead_shape(pos):
x, y = pos
return abs(y) < width #width-di<y<width #
def nnn(site1, site2):
x, y = site1.pos
if abs(x) < length and y > width - di:
return 1j * m2 * np.sign(uniform(repr(site1.tag), salt) - alpha)
else:
return 1j * m2
sys = kwant.Builder()
sys[graphene.shape(disk, (0, 0))] = 0
sys[graphene.neighbors()] = 1 # comment it, when has rashba
sys[[kwant.builder.HoppingKind(*hopping)
for hopping in nnn_hoppings]] = nnn #1j *m2 * sz #
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
lead[graphene.shape(lead_shape, (0, width - 1))] = 0 #1
lead[graphene.neighbors()] = 1
# lead[[kwant.builder.HoppingKind(*hopping) for hopping in nnn_hoppings]]=1j *m2
sys.attach_lead(lead)
sys.attach_lead(lead.reversed())
return sys.finalized()
def make_system_all(length, width, dis, salt, command='null'):
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
def onsite(site):
x, y = site.pos
if command == 'crystal':
if (x % 2 == 0) & (y % 2 == 0):
return 2
else:
return 0
else:
if abs(x) < length: # add clean region
return dis * (uniform(repr(site), salt) - .5) + 4
else:
return 4
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))] = 4
lead[lat.neighbors()] = -1
sys.attach_lead(lead)
sys.attach_lead(lead.reversed())
return sys.finalized()
def FinalizedSystem_1D(SitesCount_X, p):
# lattices
lat = kwant.lattice.general(((p.LatticeSpacing, ), ))
# builder
sys = kwant.Builder()
# first, define all sites and their onsite energies
for nx in range(SitesCount_X):
sys[lat(nx, )] = onsite_1D
# hoppings
for nx in range(SitesCount_X - 1):
sys[lat(nx + 1, ), lat(nx, )] = hopNN_1D
for nx in range(SitesCount_X - 2):
sys[lat(nx + 2, ), lat(nx, )] = hopNNN_1D
# finalize the system
return sys.finalized()
