# Band unfolding tutorial

## Requirements

### Software components

nanotools

RESCU+

### Pseudopotentials

I will need the following pseudopotentials.

Au_AtomicData.mat

Cu_AtomicData.mat

Let’s copy them from the pseudo database to the current working directory and `export RESCUPLUS_PSEUDO=$PWD`

.

### References

Chen, M., & Weinert, M. (2018). Layer k-projection and unfolding electronic bands at interfaces. Physical Review B, 98(24), 245421.

Ku, W., Berlijn, T., & Lee, C.-C. (2010). Unfolding First-Principles Band Structures. Physical Review Letters, 104(21), 216401.

## Briefing

In this tutorial, I show how to unfold the band structure of a copper supercell with a gold defect onto a copper primitive cell.

## Setup

Create the Python script `etot.py`

with the following content (see the tutorial on TotalEnergy)

```
from nanotools import Atoms, Cell, System, TotalEnergy
import numpy as np
a = 3.74
cell = Cell(avec=a*np.eye(3), resolution=0.12)
fxyz = [[0.0, 0.0, 0.0],[0.0, 0.5, 0.5],[0.5, 0.0, 0.5],[0.5, 0.5, 0.0]]
atoms = Atoms(fractional_positions=fxyz, formula="AuCu(3)")
sys = System(cell=cell, atoms=atoms)
sys.kpoint.set_grid([6,6,6])
calc = TotalEnergy(sys)
calc.solve()
```

and `bsu.py`

```
from nanotools.bandunfolding import BandUnfolding as BU
import numpy as np
calc = BU.from_totalenergy("nano_scf_out.json")
calc.set_primitive_cell(avec=3.74/2.*(np.ones((3,3)) - np.eye(3)))
calc.set_kpoint_path(special_points=["L", "G", "X"])
calc.solve()
```

## Explanations

Band structures are a useful analysis tool. Because of lattice mismatch, impurity concentration, disorder and other structural constraints, DFT calculations are routinely performed on supercells. This leads to so-called band folding which tends to obfuscate the band structure and make it difficult to analyse and compare to experimental results like ARPES data. Band unfolding is a way to recover a primitive-cell like band structure which is more readable.

The technique basically works as follows. The supercell band structure is calculated for a given path across the primitive cell band structure. The eigenstates of the supercells can be partitioned in k-space into several primitive cell states with different crystal momenta. In a perfect crystal, these states are normalized with respect to a reciprocal space cell such that their integral is 1. In general, integration over the reciprocal space cell yields a factor between 0 and 1, yielding a spectral function $A(\mathbf{k}, \epsilon)$. In other words, instead of having pure Bloch states with definite energies, we obtain a band structure where each Block states has a weight.

Here is a high level view of the calculation workflow:

Initialize the BandUnfolding calculator from a ground state calculation (

`TotalEnergy`

).Perform a band unfolding calculation (non-self-consistently).

Use

`the BandUnfolding calculator`

’s method to plot the band spectral function.

### Initialize the BandUnfolding calculator

Upon completing the total energy calculation, the results are saved in `nano_scf_out.json`

.
I will initialize a `BandUnfolding`

calculator using the class method `from_totalenergy`

.

```
calc = BU.from_totalenergy("nano_scf_out.json")
calc.set_primitive_cell(avec=3.74/2.*(np.ones((3,3)) - np.eye(3)))
```

The method `from_totalenergy`

will copy the system information and initialize the `BU`

calculator.
I need to specify which cell I would like to unfold to.
This is typically a primitive cell commensurate with the supercell, but it could also be a smaller supercell.
Here, I’m using a face-centered cubic cell with lattice parameter 3.74 ang.
Note that this is not the equilibrium lattice constant of copper, but that of AuCu$_3$ such that the primitive cell is commensurate with the supercell.
The k-point path is automatically generated from the cell shape.
It can be changed using the `system.set_kpoint_path`

method, for example

```
calc.system.set_kpoint_path(special_points=["L","G","X"])
```

### Band unfolding calculation

RESCU+’s solvers are invoked calling the `solve`

method

```
calc.solve()
```

The method writes all parameters to a JSON file, then calls the relevant (Fortran) program, then loads the data back into the calculator.
The output of `rescuplusu`

goes to `nano_bsu_out.h5`

and `nano_bsu_out.json`

.

### Plot the spectral function

I use the `plot_spectral_function`

method to plot the spectral function.

```
from nanotools.bandunfolding import BandUnfolding as BU
calc = BU.read("nano_bsu_out.json")
calc.plot_spectral_function(filename="AuCu3_bsu.png", show=False)
```

`plot_spectral_function`

is a function that returns a Pyplot figure handle.
You can use the handle to modify the figure or save it to a file.
You should see something similar to