Tight Binding

Introduction

There are many methods to calculate band structures of crystals. I implemented the Empirical Pseudopotential project, some of the code can be reused for other methods. One of the methods is simple and fast, the tight binding method, so I simply took the code from the last project, cut a part out and modified another part and here it is: Semi-Empirical Tight-Binding¹.

Here is the program in action, on YouTube:

Some theory

You should probably go to the last post for some of the theory, there are there links relevant to this project, too. I won’t write here much about the theory, but I’ll give some links, as always.

The main idea is that the method is opposed of the one from the last post, in the sense that now electrons are considered ‘tightly bound’ to the nucleus. The description is based on Linear Combination of Atomic Orbitals which you could have met on this blog already, for example related with the Hartree-Fock project. Because orbitals for different atoms overlap, there is a probability for the electrons to ‘jump’ between different atoms. Only close neighbors must be taken into account, the overlap for atoms that are far apart being negligible.

Now, some links to papers. First, the most important paper which started it: Simplified LCAO Method for the Periodic Potential Problem by Slater and Koster². Here is a review worth looking into: The Slater–Koster tight-binding method: a computationally efficient and accurate approach by Papaconstantopoulos and Mehl³. Here is another paper you might find interesting: Tight-Binding Calculations of the Valence Bands of Diamond and Zincblende Crystals by Chadi and Cohen⁴. The paper that describes the method and contains the parameters for this project is: A SEMI-EMPIRICAL TIGHT-BINDING THEORY OF THE ELECTRONIC STRUCTURE OF SEMICONDUCTORS by P. Vogl, Harold P. Hjalmarson, John D. Dow⁵. Here is some introductory text: An Introduction to the Tight Binding Approximation – Implementation by Diagonalisation by Paxton⁶. Here are two PhD thesis on the subject: Semi-Empirical Tight-Binding Ways and Means for the Atomistic Simulation of Materials by Oliver Hein⁷ and Spin-Orbit Coupling Effects From Graphene To Graphite by Sergej Konschuh⁸. Those links should get one started, of course there are plenty more docs on the internet worth looking into.

You can also find some tight binding related projects on GitHub, here is one that is worth looking into (python code): Tight Binding program to compute the band structure of simple semiconductors by Rick Muller⁹. There are at least three implementations there, one based on the Chadi and Cohen paper mentioned above, one based on a book and one of the Vogl paper I also used for the implementation. I did not look over that code before implementing my project, I looked over it briefly only after having it working. I implemented the Hamiltonian using the same order for the basis as in the article, the python project orders the orbitals differently. It even makes more sense, because if you separate the orbitals for each atom like that, you separate the Hamiltonian on blocks, having the diagonal blocks diagonal (sic) because the orbitals for one atom are orthogonal, with the off diagonal blocks being the ‘overlap’ ones. There are also some signs that are different, but probably that does not change the spectrum. I’ll let you look into that code in more detail than I did. I preferred to use the same layout as in the paper, because it’s easier to understand the program if you look over the paper.

The code

The code is based on the code of the Empirical Pseudopotential project, so it’s worth looking into that one first. I simply dropped the Pseudopotential class, having now the parameters described in the Material directly. The ‘big’ change is in the Hamiltonian implementation. As in the last project, the important classes are in a separate namespace, this time called TightBinding. The project is simpler than the last one, for example I got rid of GenerateBasisVectors from the BandStructure class. Because a lot of code is inherited from the last project, there are even features that are not really necessary for this one, such as multithreaded computation. The Hamiltonian matrix is small so computations are really fast. For all the details I’ll let you look over the project¹, there isn’t much to describe besides what I already did in the last post.

Libraries used

Of course they are the same as for the last project, but here they are again: wxWidgets¹⁰, VTK¹¹ and Eigen¹².

Conclusion

This ends the description of a project I implemented very fast by reusing code from the last project. If you find and issues or have suggestions, please let me know, either here or on GitHub¹.

CodeProject