Skip to content

6. Disorder

KITE's disorder implementation — general-purpose and user-friendly — is one of its main features. The inclusion of disorder in a given system follows a simple recipe: the user specifies one or more disorder patterns in the Python interface together with the desired disorder statistics. This information is passed on to KITEx and used to automatically perform the required modifications of on-site energies and hopping terms across the whole lattice on-the-fly.

Info

Disorder patterns are local modifications of the Hamiltonian that can be constricted to one unit cell or can connect neighboring unit cells.

KITE handles both standard uncorrelated disorder (e.g., random on-site energies) and realistic short-range disorder (e.g., vacancies or impurity scattering centers distributed randomly over the lattice sites with a specified concentration). KITE can handle multiple disorder patterns simultaneously.

Disorder implementation: After defining a regular lattice, disorder can be added to the system. KITE allows the user to select between on-site and structural disorder by choosing between predefined classes in the python interface. The interface provides two different classes of disorder:

  • kite.Disorder - onsite disorder with two possible statistical distributions
  • kite.StructuralDisorder - multi-orbital impurities and defects (including bond disorder) with a given concentration

Onsite disorder

kite.Disorder adds randomly generated on-site terms at the sites of a desired sublattice drawn from one of the two statistical distributions:

  • Gaussian
  • Uniform

One can select a sublattice type in which the disorder will appear, the mean value and the standard deviation of the selected distribution. To include on-site disorder, one builds the pb.lattice and use the following procedure:

# define an object based on the lattice
disorder = kite.Disorder(lattice)
# add Gaussian distributed disorder at all sites of a selected sublattice
disorder.add_disorder('A', 'Gaussian', mean, std)

In a single object it is possible to select multiple sublattices, each with its own disorder distribution following the rule kite.Disorder.add_disorder('sublattice', 'type', mean, std). For example,

disorder.add_disorder('A', 'Gaussian', 0.1, 0.1)
disorder.add_disorder('B', 'Uniform', 0.2, 0.1)

The final step consists of adding the disorder as an additional parameter into the kite.config_system function:

kite.config_system(..., disorder=disorder)

A complete example that calculates the average density of states of graphene with different on-site disorder distributions on each sublattice is given below:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
""" Onsite disorder
    Lattice : Monolayer graphene (from Pybinding repository);
    Disorder : Uncorrelated on-site disorder (uniform PDF) on single sublattice;
    Configuration : size of the system 1024×1024, with domain decomposition (nx=ny=2),
                    periodic boundary conditions,
                    double precision, automatic scaling;
    Calculation : DOS;
    Modification : magnetic field is off;
"""

import kite
import numpy as np
from pybinding.repository import graphene

# load graphene lattice from Pybinding repository 
lattice = graphene.monolayer(nearest_neighbors=1,onsite=(0,0),t=-2.7)

# add Disorder
disorder = kite.Disorder(lattice)
mean = 1.5 # mean
std  = 1.0 # standard deviation
disorder.add_disorder('A', 'Uniform', mean, std)

# Manual rescaling: lower/upper bounds on smallest/largest energy eigenvalue
t = -2.7
Emax = 3*np.abs(t) + mean + np.sqrt(3)*std
Emin = -3*np.abs(t) + mean - np.sqrt(3)*std

# Calculation settings
nx = ny = 2    #number of decomposition parts
lx = ly = 1024 #number of unit cells in each direction
# Boundary Mode
mode = "periodic"
configuration = kite.Configuration(
    divisions=[nx, ny],
    length=[lx, ly],
    boundaries=[mode, mode],
    is_complex=False,
    precision=1,
    spectrum_range=[Emin,Emax])

# require the calculation of DOS
calculation = kite.Calculation(configuration)
calculation.dos(num_points=5000, num_moments=512, num_random=1, num_disorder=1)
# configure the *.h5 file
kite.config_system(lattice, configuration, calculation, filename='on_site_disorder.h5', disorder=disorder)
DOS for the on-site disorder example.

Structural disorder

kite.StructuralDisorder class adds the possibility of selecting between two different short-range disorder types, i.e. vacancy defects, randomly distributed with a certain concentration over lattice sites on a selected sublattice, and a more generic multi-orbital disorder which may combine of on-site and hopping terms (also distributed with a certain concentration).

Example 1: Vacancy defects

To add vacancy defects with a given concentration on a single sublattice one uses the simple instruction:

struc_disorder = kite.StructuralDisorder(lattice, concentration=0.2)
struc_disorder.add_vacancy('B') # add a vacancy to a selected sublattice

Note

To distribute the vacancies on both sublattices (compensated or otherwise), one needs to treat each sublattice as a separate object of the class kite.StructuralDisorder

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]

Example 2: mixed on-site/bond disorder

The following example illustrates KITE's most general type of short-range disorder, which includes both atomic defects (vacancies) and bond modifications. This type of disorder can be added as an object of the class kite.StructuralDisorder. The procedure is analogous to adding a hopping term to the Pybinding lattice object.

For the sake of clarity, let us first define sublattices that will compose the disorder. In this case we are not restricted to a single unit cell:

#  define a node in a unit cell [i, j] selecting a single sublattice
node0 = [[+0, +0], 'A']
node1 = [[+0, +0], 'B']
node2 = [[+1, +0], 'A']
node3 = [[+0, +1], 'B']
node4 = [[+0, +1], 'A']
node5 = [[-1, +1], 'B']

After the definition of a parent kite.StructuralDisorder object, we can define the desired pattern:

 # define an object based on the lattice with a certain concentration
struc_disorder = kite.StructuralDisorder(lattice, concentration=0.2)

struc_disorder.add_structural_disorder(
    # add bond disorder in the form
    #  [from unit cell], 'sublattice_from', [to_unit_cell], 'sublattice_to', value:
    (*node0, *node1, 0.5),
    (*node1, *node2, 0.1),
    (*node2, *node3, 0.5),
    (*node3, *node4, 0.3),
    (*node4, *node5, 0.4),
    (*node5, *node0, 0.8),
    # in this way we can add onsite disorder in the form [unit cell], 'sublattice', value
    ([+0, +0], 'B', 0.1)
)

# It is possible to add multiple different disorder types which
#  should be forwarded to the config_system function as a list.
another_struc_disorder = kite.StructuralDisorder(lattice, concentration=0.6)
another_struc_disorder.add_structural_disorder(
    (*node0, *node1, 0.05),
    (*node4, *node5, 0.4),
    (*node5, *node0, 0.02),
    ([+0, +0], 'A', 0.3)
)

Before exporting the settings to the HDF5-file, it is possible to define multiple disorder realizations which will be superimposed to the clean system.

The following script has a minimal example of how to configure the structural disorder

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
""" Mixed short-range disorder
    Lattice : Monolayer graphene (from Pybinding repository);
    Disorder : StructuralDisorder class - bond and vacancy disorder;
    Configuration : size of the system 1024x1024, with domain decomposition (nx=ny=2),
                    periodic boundary conditions,
                    double precision, manual scaling;
    Calculation : DOS;
    Modification : magnetic field is off;
"""

import kite
import numpy as np
from pybinding.repository import graphene

#load graphene lattice from Pybinding repository
lattice = graphene.monolayer(nearest_neighbors=1,onsite=(0,0),t=-2.7)

# Add short-range mixed disorder as an object of a class StructuralDisorder.
# In this manner we can add onsite and bond defects with a specific 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(lattice, concentration=0.05)
struc_disorder_one.add_structural_disorder(

# add bond disorder in the form
# [from unit cell], 'sublattice_from', [to_unit_cell], 'sublattice_to', value:
(*node0, *node1, 1),
(*node1, *node2, 1),
(*node2, *node3, 1),
(*node3, *node4, 1),
(*node4, *node5, 1),
(*node5, *node0, 1),
# in this way we can add onsite disorder in the form [unit cell], 'sublattice', value
([+0, +0], 'B', 0.3))

# It is possible to add multiple different disorder type which
# should be forwarded to the export_lattice function as a list.

struc_disorder_two = kite.StructuralDisorder(lattice, concentration=0.2)
struc_disorder_two.add_structural_disorder(
    (*node0, *node1, 0.4),
    (*node4, *node5, 0.4),
    (*node5, *node0, 0.4),
    ([+0, +0], 'B', 0.4))

struc_disorder_two.add_vacancy('B')

struc_disorder_three = kite.StructuralDisorder(lattice, concentration=0.01)
struc_disorder_three.add_vacancy('A')

# if there is disorder it should be returned separately from the lattice
disorder_structural = [struc_disorder_one, struc_disorder_two, struc_disorder_three]

# Manual rescaling: lower/upper bounds on smallest/largest energy eigenvalue

t = -2.7
Emax = 3*np.abs(t)*1.2 
Emin = -3*np.abs(t)*1.2

#Calculation settings

nx = ny = 2     #number of decomposition parts
lx = ly = 1024  #number of decomposition parts 

#Boundary mode
mode = "periodic"
configuration = kite.Configuration(
    divisions=[nx, ny],
    length=[lx, ly],
    boundaries=[mode, mode],
    is_complex=False,
    precision=1,
    spectrum_range=[Emin,Emax])

# require the calculation of DOS
calculation = kite.Calculation(configuration)
calculation.dos(num_points=5000, num_moments=512, num_random=1, num_disorder=1)

# configure the *.h5 file
kite.config_system(lattice, configuration, calculation, filename='mixed_disorder.h5',
                   disorder_structural=disorder_structural)

with the resulting density of states:

DOS for the structural disorder example.