Tutorial 09: On the Hamiltonian command

The Hamiltonian command allows to compute transport by means of the NEGF formalism along a generic device defined by the user, just by simply specifying the semi-empirical tight-binding Hamiltonian in the format discussed below.
In particular, the command allows to compute the transmission coefficient as a function of the energy in the range specified by the user, and the charge density in correspondence of each atoms/grid point.
To this purpose, the hamiltonian has to be passed as a numpy bidimensional array.

The Hamiltonian to be defined is the Hamiltonian of the central part of the generic system shown below. In particular, semi-infinite leads are attached at the right and left ends of the central part, in order to compute transport within the open-boundary conditions. This is done through the definition of proper self-energies within the Hamiltonian modules (transparent for the User). If the system is composed by N atoms, we can label each atom an integer (starting from 1). The first row of the Matrix specify the number of considered orbitals.

The rows 2-N+1 specify the on-site energies, while the following rows specify the hopping parameters between two adjacent atoms.

Let’s make an example in the case of one considered orbital.

The matrix will have the following form:

1 0 0
1 1 E_11
2 2 E_22
3 3 E_33
….
….
N N E_NN
1 2 t_12
2 3 t_23
….
….
….
i j t_ij
….
….

where E_ii represent the on-site energy for the i-th atom, while t_ij the hopping parameter between the i-th and the j-th atom.

Note that atoms ordering starts from 1 and not from 0.

The first row indicates that the model is a one-orbital model, the other rows contains information about the on-site energies of the atoms and on the hoppings between different atoms. The elements that are zero do not have to be included.
Because the hamiltonian is an hermitian matrix, only the elements on the upper part needs to be passed (i<j).

To make an example, let’s define the Hamiltonian in the above-mentioned format of the system shown in the picture below. As outlined before, the structure shown here refers to the central part of the device, while semi-infinite leads are attached at the right and left ends through the definition of the self-energies. Within the single pz tight-binding basis set in the real space, the Hamiltonian can be expressed as follows.
In particular, we consider null on-site energies, a hopping parameter between C-C atoms equal to t=-2.7 eV, and t=-3.024 eV for the outer dimmer lines, in order to take into account edge relaxation.

The matrix to be passed reads:

1 0 0
1 1 0
2 2 0
3 3 0
4 4 0
5 5 0
6 6 0
7 7 0
8 8 0
9 9 0
10 10 0
11 11 0
12 12 0
13 13 0
14 14 0
15 15 0
16 16 0
1 3 -3.024
2 4 -2.7
3 5 -2.7
4 5 -2.7
4 6 -2.7
5 7 -2.7
6 8 -3.024
7 9 -2.7
7 10 -2.7
8 10 -2.7
9 11 -3.024
10 12 -2.7
11 13 -2.7
12 13 -2.7
12 14 -2.7
13 15 -2.7
14 16 -3.024

Please note that the matrix to be passed has to be complex, since, in generalthe hamiltonian is a complex hermitian matrix.

The definition of the matrix can be done automatically through a script, as the one you can download here. Please (rename the file with the .py extension, once downloaded).

The implemented function is called GNR, whose arguments are the number of dimmer lines N, and the number of slices M. In the example above, a python script would have read

from GNR import *
GNR(2,8)

Let’s go a step further and consider a generic hamiltonian with two orbitals instead of one.
Every atom and every hopping between the atoms will be now described by a 2×2 matrix, and the numpy array will now look like:

2 0 0 0 0 0
1 1 H(11)_11 H(11)_12 H(11)_21 H(11)_22
1 2 H(12)_11 H(12)_12 H(12)_21 H(12)_22
….
….
….
i j H(ij)_11 H(ij)_12 H(ij)_21 H(ij)_22
….
….
The generic element H(ij)_mn in the format represents the hamiltonian element mn between atoms i and j.

Once the hamiltonian has been specified in the format explained above, then the command Hamiltonian can be used  to calculate the the transmission coefficient within the NEGF formalism.

Let’s make another example.
We start importing the modules
from NanoTCAD_ViDES import *

If we want to simulate a GNR with 8 slices and 5 atom per slice, we generate the hamiltonian and assign it to a variable

h = GNR(5,8)

We call the hamiltonian command with same input parameters

H = Hamiltonian(5,8)

and we assign h to the attribute of H

H.H = h

At this point we define all the parameters of the Hamiltonian in order to run the calculation.
As an example suppose we want to calculate the transmission coefficent between -3eV and +3eV, with energy spacing 0.05 eV.
H.Elower = -3
H.Eupper = 3
H.dE = 0.05

we can set the small imaginary parameter parameter eta used in NEGF

H.eta = 1e-5

Then we can run the calculation:
H.charge_T()

collect the data in a file

file = [H.E,H.T]
savetxt(“transmission.dat”, transpose(file))

Hamiltonian contains other attributes that can be used, for example the position of the atoms, the potential of the atoms, the chemical potential of the leads, the temperature. The complete list of attributes is specified in the command Hamiltonian .