-
Notifications
You must be signed in to change notification settings - Fork 0
/
02-02-code.tex
108 lines (84 loc) · 5.59 KB
/
02-02-code.tex
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
\chapter{Code discussion}
TB calculations, which results are presented in this work, are performed using package I wrote in Python programming language. Input should be also written in Python, but as far as Python is designed to be highly readable, even person who never programmed in Python before, can easily do this. And on the other hand this allows to simplify input data creation and further easy output rearrangement.
In this chapter I discuss the basic input example and what's going on when one runs it for calculating graphene band structure (Results of this input are presented in chapter \ref{subsec:graphene_result})
\begin{python}
from atom.model import Atom
from system.model import System
from plotter.plotter import Plotter
from numpy import array, sqrt, pi
d = 1.0
system = System([d / 2. * array([3., sqrt(3), 0.]),
- d / 2. * array([3, -sqrt(3), 0.])],
mode='with_overlap', name='grapene_sp')
system.spin_multiplier = 2
\end{python}
At the beginning of the input file I do all the imports. First three are classes from the TightBinding package and the last is necessary functions from NumPy library. NumPy is a high-level package for efficient manipulating multi-dimensional arrays in Python.
The next line defines a constant, which here represents length of $C-C$ bond in graphene.
At the beginning of logical part I define \verb!System! object. The first argument initializing the system object is list of lattice vectors. Length of this list may be from $0$ to $3$, depending on the periodicity of the system. Next argument is mode of calculation, it can be either \verb!"standard"!, \verb!"with_overlap"! when overlap matrix is not identity matrix or \verb!"with_vectors"! when one also wants eigenstates to be calculated. Name of the system is used to create directory with outputs.
Parameter \verb!spin_mutiplier! is set to $1$ by default. But if one wants to include SOC part to the Hamiltonian, one should assign value $2$ to this parameter.
\begin{python}
system.atoms = [Atom('C', array([d, 0., 0.])),
Atom('C', array([2 * d, 0., 0.])), ]
\end{python}
Next I define list of atoms in the unit cell. Each atom has a name and a position.
\begin{python}
for i in xrange(len(system.atoms)):
system.atoms[i].orbitals = ['s', 'px', 'py', 'pz', ]
\end{python}
Here I assign set of orbitals to each atom in a system. I do this in a loop, but one can also assign different sets of orbitals for every atom one by one.
\begin{python}
system.k_points = [array([0., 0., 0.]),
array([2 * pi / 3 / d, 2 * pi / 3 / sqrt(3) / d, 0]),
array([2 * pi / 3 / d, 0, 0]),
array([0., 0., 0.])]
system.make_k_mesh(100)
\end{python}
Thereafter one should define mesh of wave vector points. One can do this manually setting parameter \verb!system.k_mesh! or as above defining \verb!system.k_points! and calling method \verb!make_k_mesh!. In the snippet above I define a path of $\Gamma$, K, M and again $\Gamma$ points and call the function \verb!make_k_mesh! to create a mesh with approximately $100$ points following the path defined in the previous line.
\begin{python}
system.parameters = {
'C': {
'es': -8.7,
'ep': 0.0,
},
'CC': {
'Vsss': - 6.7,
'Vsps': 5.5,
'Vpps': 5.1,
'Vppp': -3.1,
}
}
system.s_parameters = {
'C': {
'es': 1.,
'ep': 1.,
},
'CC': {
'Vsss': 0.2,
'Vsps': - 0.1,
'Vpps': - 0.15,
'Vppp': 0.12,
}
}
\end{python}
Subsequently I define an intuitive set of parameters for my system. If parameter \verb!system.spin_multiplier! is $2$, parameter \verb!'lambda'! should be defined for each atom.
\begin{python}
system.just_do_main_magic()
plotter = Plotter(system.name)
plotter.plot_energy_bands_from_file()
\end{python}
Finally, I call the function \verb!just_do_main_magic! which does the main logic of the TB calculations. First this method calls helper function, which searches for nearest neighbors of each atom. Then for every wave vector in $system.k_mesh$ Hamiltonian (and overlap if needed) matrix is calculated. After eigenvalue problem is solved. I used functions from SciPy package for diagonalization of Hermitian matrices.
After I plot the electronic structure (this step is highly optional, as far as the results are stored in the files).
Also, after the main band structure calculation one may calculate density of states (DOS) or local density of states (LDOS) for any atom in the system or type of orbital.
\begin{python}
doser = DOSCalculator(system.dim, system.name, n)
doser.f()
\end{python}
Here first line is creation of helper object for DOS calculation, first argument is periodicity of the system, and \verb!n! is name of the system and the last is number of points in energy domain, for which one wants to calculate density of states. The next line is call of the function, which calculates DOS, writes results to the file and plots it.
To calculate LDOS:
\begin{python}
lst = system.find_indeces_for_ldos(orbital='d')
doser = LDOSCalculator(system.dim, system.name, n, localization_name, indeces_list=lst)
doser.f()
\end{python}
To be able co calculate LDOS one should first do the main TB calculations for the system in \verb!mode='with_vectors'!. First one should run helper function \verb!find_indeces_for_ldos! with keyword-argument \verb!orbital! or \verb!atom!. This function searches for all orbitals of certain type or on defined atom in the system.
DOS and LDOS are calculated as described in \ref{ch:theory}. Interpolation of energy bands functions and integration are done with built-in SciPy methods.