def graphene_initial(onsite=(0, 0)):
theta = np.pi / 3
a1 = np.array([1 + np.cos(theta), np.sin(theta)])
a2 = np.array([0, 2 * np.sin(theta)])
lat = pb.Lattice(a1=a1, a2=a2)
lat.add_sublattices(
# name, position, and onsite potential
('A', [0, 0], onsite[0]),
('B', [1, 0], onsite[1]))
lat.add_hoppings(
# inside the main cell, between which atoms, and the value
([0, 0], 'A', 'B', -1),
# between neighboring cells, between which atoms, and the value
([-1, 0], 'A', 'B', -1 / EnergyScale),
([-1, 1], 'A', 'B', -1 / EnergyScale))
node0 = [[+0, +0], 'A']
node1 = [[+0, +0], 'B']
node2 = [[-1, +0], 'B']
node3 = [[-1, +1], 'B']
struc_disorder_one = kite.StructuralDisorder(lat, position=[[32, 32]])
struc_disorder_one.add_structural_disorder(
(*node0, *node1, timp), (*node0, *node2, timp), (*node0, *node3, timp),
(*node0, limp))
return lat, [struc_disorder_one]
# inside the main cell, between which atoms, and the value
([+0, +0], 'A', 'B', -1),
# between neighboring cells, between which atoms, and the value
([-1, +0], 'A', 'B', -1),
([-1, +1], 'A', 'B', -1))
return lat
lattice = honeycomb_lattice((-0.0, 0.0))
# Add vacancy disorder as an object of a class StructuralDisorder. In this manner we can distribute vacancy disorder
# on a specific sublattice with a specific concentration.
# unless you would like the same pattern of disorder at both sublatices,
# each realisation should be specified as a separate object
struc_disorder_A = kite.StructuralDisorder(lattice, concentration=0.1)
struc_disorder_A.add_vacancy('A')
struc_disorder_B = kite.StructuralDisorder(lattice, concentration=0.1)
struc_disorder_B.add_vacancy('B')
disorder_structural = [struc_disorder_A, struc_disorder_B]
# load a honeycomb lattice and structural disorder
nx = ny = 1
lx = 512
ly = 512
# make config object which caries info about
# - the number of decomposition parts [nx, ny],
# - lengths of structure [lx, ly]
# - boundary conditions, setting True as periodic boundary conditions, and False elsewise,
# - info if the exported hopping and onsite data should be complex,
# - info of the precision of the exported hopping and onsite data, 0 - float, 1 - double, and 2 - long double.
d1 = np.dot(kp, delta1)
d2 = np.dot(kp, delta2)
d3 = np.dot(kp, delta3)
f = np.exp(1.j * d1) + np.exp(1.j * d2) + np.exp(1.j * d3)
ham = np.array([[0, t * f], [t * np.conj(f), 0]])
w, v = LA.eigh(ham)
return [[w[0], v[:, 0]], [w[1], v[:, 1]]]
if __name__ == '__main__':
use_disorder = True # with or without the disorder
lattice = honeycomb_lattice_with_SO() # define the lattice
conc = lambda_R / disorder_strength
struc_disorder_one = kite.StructuralDisorder(lattice, concentration=conc)
struc_disorder_two = kite.StructuralDisorder(lattice, concentration=conc)
struc_disorder_one.add_structural_disorder(
# in this way we can add onsite disorder in the form [unit cell], 'sublattice', value
([+0, +0], 'Aup', +disorder_strength),
([+0, +0], 'Adown', -disorder_strength),
)
# It is possible to add multiple different disorder type which should be forwarded to the export_lattice function
# as a list.
struc_disorder_two.add_structural_disorder(
# in this way we can add onsite disorder in the form [unit cell], 'sublattice', value
([+0, +0], 'Bup', +disorder_strength),
([+0, +0], 'Bdown', -disorder_strength),
)
disorder = kite.Disorder(lattice) # Disorder definition
def graphene_initial(onsite=(0, 0)):
"""Return the basic lattice specification for monolayer graphene with nearest neighbor"""
theta = np.pi / 3
a1 = np.array([1 + np.cos(theta), np.sin(theta)])
a2 = np.array([0, 2 * np.sin(theta)])
# create a lattice with 2 primitive vectors
lat = pb.Lattice(a1=a1, a2=a2)
# Add sublattices
lat.add_sublattices(
# name, position, and onsite potential
('A', [0, 0], onsite[0]),
('B', [1, 0], onsite[1]))
# Add hoppings
lat.add_hoppings(
# inside the main cell, between which atoms, and the value
([0, 0], 'A', 'B', -1 / EnergyScale),
# between neighboring cells, between which atoms, and the value
([-1, 0], 'A', 'B', -1 / EnergyScale),
([-1, 1], 'A', 'B', -1 / EnergyScale))
# Add disorder
# Each sublattice can have different disorder. If there are multiple orbitals at one sublattice, one needs to add
# disorder vector of the same size as the number of orbitals. Type of disorder available are Gaussian,
# Deterministic and Uniform. Each of the needs the have mean value, and standard deviation, where standard deviation
# of deterministic disorder should be 0.
disorder = kite.Disorder(lat)
disorder.add_disorder('A', 'Deterministic', 0.0, 0)
disorder.add_disorder('B', 'Deterministic', 0.0, 0)
# Same procedure as adding the hopping + concentration
node0 = [[+0, +0], 'A']
node1 = [[+0, +0], 'B']
node2 = [[+1, +0], 'A']
node3 = [[+0, +1], 'B']
node4 = [[+0, +1], 'A']
node5 = [[-1, +1], 'B']
struc_disorder_one = kite.StructuralDisorder(lat, concentration=0.035)
struc_disorder_one.add_structural_disorder(
(*node0, *node1, timp / EnergyScale),
(*node1, *node2, timp / EnergyScale),
(*node2, *node3, timp / EnergyScale),
(*node3, *node4, timp / EnergyScale),
(*node4, *node5, timp / EnergyScale),
(*node5, *node0, timp / EnergyScale),
#
(*node0, *node2, nu / EnergyScale),
(*node2, *node4, nu / EnergyScale),
(*node4, *node0, nu / EnergyScale),
(*node1, *node3, nu / EnergyScale),
(*node3, *node5, nu / EnergyScale),
(*node5, *node1, nu / EnergyScale),
#
(*node0, *node3, rho / EnergyScale),
(*node1, *node4, rho / EnergyScale),
(*node2, *node5, rho / EnergyScale),
# in this way we can add onsite disorder again
(*node0, 0.))
# if there is disorder it should be returned separately from the lattice
return lat, disorder, [struc_disorder_one]
d1 = d2 = 32
# List of points where to calculate the local density of states
pos_matrix=[]
sub_matrix=[]
for i in range(-lim,lim):
for j in range(-lim,lim):
pos_matrix.append([d1+i,d2+j])
pos_matrix.append([d1+i,d2+j])
pos_matrix.append([d1+i,d2+j])
sub_matrix.append('M1')
sub_matrix.append('M2')
sub_matrix.append('M3')
# Insert a vacancy in position 32,32
struc_disorder_1 = kite.StructuralDisorder(lattice, position=[[d1,d2]])
struc_disorder_2 = kite.StructuralDisorder(lattice, position=[[d1,d2]])
struc_disorder_3 = kite.StructuralDisorder(lattice, position=[[d1,d2]])
struc_disorder_1.add_vacancy('M1')
struc_disorder_2.add_vacancy('M2')
struc_disorder_3.add_vacancy('M3')
disorder_structural = [struc_disorder_1, struc_disorder_2, struc_disorder_3]
nx = ny = 4
lx = ly = int(sys.argv[1])
configuration = kite.Configuration(divisions=[nx, ny], length=[lx, ly], boundaries=[True, True], is_complex=True, precision=1, spectrum_range = [-10,10])
calculation = kite.Calculation(configuration)
calculation.ldos(energy=np.linspace(-0.1, 0.1, 3), num_moments=N, num_disorder=1, position=pos_matrix, sublattice=sub_matrix)
calculation.dos(num_points=512, num_moments=512, num_random=1, num_disorder=1)
kite.config_system(lattice, configuration, calculation, filename='config.h5', disorder_structural=disorder_structural)
import kite
import matplotlib.pyplot as plt
import numpy as np
import pybinding as pb
from pybinding.repository import graphene
# load a monolayer graphene lattice
lattice = graphene.monolayer()
# add Disorder
disorder = kite.Disorder(lattice)
disorder.add_disorder('B', 'Deterministic', -0.7)
disorder.add_disorder('A', 'Uniform', +0.0, 0.5)
# add vacancy StructuralDisorder
disorder_struc = kite.StructuralDisorder(lattice, concentration=0.05)
disorder_struc.add_vacancy('A')
# number of decomposition parts in each direction of matrix. This divides the lattice into various sections,
# each of which is calculated in parallel
nx = ny = 1
# number of unit cells in each direction.
lx = ly = 512
# make config object which caries info about
# - the number of decomposition parts [nx, ny],
# - lengths of structure [lx, ly]
# - boundary conditions, setting True as periodic boundary conditions, and False elsewise,
# - info if the exported hopping and onsite data should be complex,
# - info of the precision of the exported hopping and onsite data, 0 - float, 1 - double, and 2 - long double.
# - scaling, if None it's automatic, if present select spectrum_bound=[e_min, e_max]
configuration = kite.Configuration(divisions=[nx, ny],
length=[lx, ly],
([+0, +0], 'A', 'B', - 1),
# between neighboring cells, between which atoms, and the value
([-1, +0], 'A', 'B', - 1),
([-1, +1], 'A', 'B', - 1)
)
return lat
lattice = honeycomb_lattice((-0.0, 0.0))
# Add vacancy disorder as an object of a class StructuralDisorder. In this manner we can distribute vacancy disorder
# on a specific sublattice with a specific concentration.
# unless you would like the same pattern of disorder at both sublatices,
# each realisation should be specified as a separate object
struc_disorder_A = kite.StructuralDisorder(lattice, position=[[64,64], [64,32], [32, 32]])
struc_disorder_A.add_vacancy('A')
struc_disorder_B = kite.StructuralDisorder(lattice, concentration=0.1)
struc_disorder_B.add_vacancy('B')
disorder_structural = [struc_disorder_A, struc_disorder_B]
# load a honeycomb lattice and structural disorder
nx = ny = 1
lx = 512
ly = 512
# make config object which caries info about
# - the number of decomposition parts [nx, ny],
# - lengths of structure [lx, ly]
# - boundary conditions, setting True as periodic boundary conditions, and False elsewise,
# - info if the exported hopping and onsite data should be complex,
# - info of the precision of the exported hopping and onsite data, 0 - float, 1 - double, and 2 - long double.