Skip to content

Instantly share code, notes, and snippets.

@ExpHP
Last active December 11, 2019 18:21
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save ExpHP/0d0f4314a648debbd06b5706aa19ecc1 to your computer and use it in GitHub Desktop.
Save ExpHP/0d0f4314a648debbd06b5706aa19ecc1 to your computer and use it in GitHub Desktop.
unfolding notes

Unfolding requirements

Unfolding the eigenvectors at a given K

  • We must define a superlattice and sublattice.  Following physics naming convention, the superlattice corresponds to a supercell, making it a subgroup of the sublattice.

  • We need the 3N eigenstates computed at a point K in the supercell FBZ.

  • The rest of the details will depend significantly on the data format used to represent eigenstates. (For phonons, these are 3N-dimensional eigenvectors defining a 3-vector at each atom.)

  • We need a way to mathematically define a bloch function over all space for each eigenstate.  (For phonons, I repeat the eigenvectors in real space and multiply them by bloch phases for K.)

  • We need a data format for the bloch functions. I imagine that the eigenvector data format usually suffices (though I'm not 100% sure that it would be enough for symmetry-reduced formats). (For phonons, I use a 3N-dimensional vector containing data for atoms in a single image of the unit cell.)

  • We need a way to apply an inner product on this representation between two bloch functions with the same K vector.  The bloch functions for our eigenstates should be orthogonal under this operation, and ideally they are also normalized.  (For phonons we can just conjugate-dot the vectors. In twisted bilayer graphene I must project the eigenvectors onto one layer, which reduces their norm.)

  • We need a way to apply translation operators T(R) on that representation, where R is a member of the sublattice/superlattice quotient group.  (For phonons, a translation largely just permutes the atoms. Some phase corrections are also needed to handle atoms that are translated between different images of the unit cell.)

  • Then, for each eigenvector, we simply need to compute expectation values for all of the translation operators T(R), followed by the projection operators P(K -> K + G) as defined by Allen (2013).  (If you merely want to unfold onto a specific point, you still need all of the translations, but only need to compute one projection operator.)

Those projection operators provide the probability of each eigenvalue at a given point k = K + G in the primitive FBZ.

Producing a band plot

Bringing together data from multiple K points

If you want to produce a band plot, then the way you best ought to do this depends on the problem size. In general, however, nice-looking bands will almost certainly require repeating the above process at more than one K.

For small structures where computing eigenstates at a given K is cheap, you may find it worthwhile to simply perform the process separately at every point on the plot x axis. (computing supercell eigenstates at the reduced K, then computing the expectation value of the one projection operator that corresponds to the plotted point in the primitive reciprocal FBZ)

Given the large structures in tBLG, it was only feasible for me to compute eigenvectors at a few points in the supercell FBZ.  For each of those K points I compute all of the projections, creating a large set of points in the primitive FBZ where the unfolded eigenvalues and probabilities are known. Then for the band plot, each point on the x-axis simply shows data from the nearest one of these points. The implementation of this was pretty gnarly, so hopefully we can reuse my code for this if it is needed.

Coalescing degenerate kets

Making a nice looking band plot also requires combining multiple data points of similar y value into one by adding their probabilities. This is to ensure that the total alpha at that point adds correctly to the sum of probabilities.

If you have large structures, then coalescing degenerate kets makes the aforementioned gnarly code even gnarlier.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment