Band Structure Calculation via Tight-Binding Diagonalization

Hello! In our last lesson, we analytically derived the band structure of graphene and discovered the fascinating emergence of massless Dirac fermions. That derivation was specific to the honeycomb lattice. Today, we'll learn a far more general and powerful approach: how to write a program to calculate the band structure for any lattice described by a tight-binding model.

This is a fundamental skill in computational condensed matter physics. It allows us to move beyond simple, analytically solvable models and tackle the electronic structure of complex, real-world materials. Our goal is to implement the numerical diagonalization of a tight-binding Hamiltonian and use it to plot band structures.

1. The Algorithm: From Real Space to Band Structure

Last time, we constructed a 2x2 Bloch Hamiltonian $h(\mathbf{k})$ for graphene. The general numerical procedure to obtain a band structure follows these steps:

1. Define the Crystal Structure:

   • Specify the real-space lattice vectors, ${\mathbf{a}}_i$.
   • Specify the positions of all atoms within the unit cell (the basis), ${\mathbf{\tau }}_{\alpha }$.

2. Define the Hamiltonian:

   • Set the on-site energy for each orbital in the basis, $E_{\alpha }$.
   • Define the hopping parameters $t$ between orbitals. This is a list of connections: from orbital $\alpha$ in the home unit cell to orbital $\beta$ in a cell displaced by a lattice vector $\mathbf{R}$.

3. Construct the Bloch Hamiltonian Matrix $H(\mathbf{k})$:
   For a given momentum vector $\mathbf{k}$, the matrix elements of the Bloch Hamiltonian are given by a Fourier sum over all real-space hoppings:

   $$H_{\alpha \beta }(\mathbf{k})=\sum _{\mathbf{R}}{t}_{\alpha \beta }(\mathbf{R})e^{i\mathbf{k}\cdot (\mathbf{R}+{\mathbf{\tau }}_{\beta }-{\mathbf{\tau }}_{\alpha })}$$

   The on-site energies form the diagonal elements where $\mathbf{R}=0$ and $\alpha =\beta$.

4. Diagonalize and Plot:

   • Define a path of high-symmetry points in the Brillouin Zone (e.g., $\Gamma \to M\to K\to \Gamma$).
   • For each $\mathbf{k}$ along the path, construct and diagonalize the matrix $H(\mathbf{k})$.
   • The eigenvalues of $H(\mathbf{k})$ are the energy bands $E_n(\mathbf{k})$.
   • Plot the eigenvalues $E_n$ as a function of the distance along the k-path.

Manually constructing and diagonalizing these matrices can be tedious and error-prone. Fortunately, excellent software packages exist to automate this process. We will focus on one such package for Python called PythTB.

2. Introduction to PythTB

PythTB (Python Tight-Binding) is a package designed to make setting up and solving tight-binding models intuitive. The video below is a tutorial by one of the package's authors, Sinisa Coh. It provides a hands-on guide that covers all the essential steps of our algorithm.

To summarize the key ideas from the video:

• You create a tb_model object, specifying the real-space dimension, k-space dimension, lattice vectors, and orbital positions.
• Orbital positions are given in fractional coordinates relative to the lattice vectors.
• You use set_onsite() to define the diagonal elements of the Hamiltonian.
• You use set_hop(t, i, j, R) to define a hopping of amplitude t from orbital i in the home cell (cell [0,0,...]) to orbital j in the cell displaced by the lattice vector R.
• The code automatically handles the hermitian conjugate hopping (e.g., from j in cell -R to i in the home cell).

3. Practical Implementation: Graphene

Now, let's apply this to a system you're familiar with: graphene. The next segment of the video includes an interactive quiz where the presenter challenges the audience to construct the tight-binding models for various lattices, culminating in graphene.

The key insight for implementing graphene is to recognize its structure as a triangular Bravais lattice with a two-atom basis.

To implement this in PythTB, you would:

1. Define the primitive lattice vectors for the triangular lattice, e.g., ${\mathbf{a}}_1=(a,0)$ and ${\mathbf{a}}_2=(a/2,a\sqrt{3}/2)$.
2. Define two orbitals in the basis. If we place atom A at the origin [0.0, 0.0], atom B is located at a position like [x, y] which you need to express in fractional coordinates of ${\mathbf{a}}_1$ and ${\mathbf{a}}_2$.
3. Set on-site energies for both orbitals to 0.
4. Define the three nearest-neighbor hoppings. For an A atom at the origin, one B neighbor is in the same unit cell (R=[0,0]), while the other two are in adjacent unit cells (e.g., R=[-1,0] and R=[0,-1], depending on your choice of vectors and basis).

Once the model is defined, solving it is straightforward.

4. Code Examples and Your Turn

Reading about an API is one thing, but seeing it in a script is another. The following resource provides a complete, runnable Python script for generating a band structure.

Now, it's time to put this into practice.

5. Alternative and Advanced Implementations

While PythTB is excellent for its simplicity, other powerful libraries exist. The Stack Exchange post (LINK) also shows an example using sisl, a more verbose but highly flexible package that can even import Hamiltonians from DFT calculations.

Furthermore, given your experience with Julia, it's worth knowing that similar ecosystems exist there. The reference below is a PhD thesis that uses Julia for tight-binding calculations, including for complex systems like twisted bilayer graphene.

This Julia example highlights the use of libraries like KrylovKit.jl for efficient diagonalization of the large, sparse matrices that arise in complex systems (like the supercells needed for twisted graphene). This is the same underlying principle of numerical linear algebra used in all professional-grade simulation software.

Conclusion

In this lesson, we bridged the gap between analytical theory and computational practice. You have learned the complete workflow for numerically calculating and plotting the electronic band structure of any material that can be described by a tight-binding model.

Key Takeaways:

• The numerical calculation of a band structure involves defining the lattice and Hamiltonian in real space, then constructing and diagonalizing the Bloch Hamiltonian matrix $H(\mathbf{k})$ for a series of $\mathbf{k}$ vectors.
• Python packages like PythTB and sisl provide high-level, intuitive interfaces to perform these calculations, abstracting away the low-level matrix construction.
• The core steps in a typical script involve: defining the model (tb_model), setting parameters (set_onsite, set_hop), defining a k-path (k_path), solving (solve_all), and plotting.
• You now have the practical tools to reproduce the band structures we derived analytically (like for the 1D chain or graphene) and to explore entirely new ones.

Preview of the Next Lesson:
Now that we can compute the full energy spectrum $E_n(\mathbf{k})$, we can calculate other important electronic properties. In the next lesson, we will learn how to compute the electronic density of states (DOS) from the band structure, a quantity that is directly related to many experimental measurements.