PAOFLOW.elphon.fermi_surface_coupling#

State-resolved electron-phonon coupling on the Fermi surface.

Input of the anisotropic Migdal-Eliashberg equations (PAOFLOW.elphon.anisotropic_eliashberg), accumulated during the dense-q loop of eliashberg_dense_q().

The Fermi-surface states are the bands n at the dense k-points with |e_nk - E_F| < fsthick (EPW fsthick). Only irreducible states are kept: Delta_nk and Z_nk are invariant under the crystal point group (with time reversal), so k runs over one representative per star of the dense k-grid. With Lambda_{nk,mk'}(omega) the coupling of the pair at phonon frequency omega, the folded pair coupling of two irreducible states a = (n, i) and b = (m, i') is the average over the star of a, weighted by the Fermi-surface delta, of the coupling to every member of the star of b:

\[\Lambda_{ab}(\omega) = \frac{1}{D_a}\sum_{q\in\mathrm{IBZ}} w_q \sum_{k\in\star(i),\,k+q\in\star(i')} \delta(\epsilon_{nk})\,\Lambda_{nk, m\,k+q}(\omega), \qquad D_a = \sum_{k\in\star(i)}\delta(\epsilon_{nk}),\]

with w_q the star multiplicity of q. Summing irreducible q with their multiplicities instead of all q uses Lambda_{Sk, Sk+Sq} = Lambda_{k, k+q} and lets the existing loop over irreducible q and all k fill the folded coupling directly. With exact symmetry Lambda_ab = sum_{k' in star(i')} Lambda_{n k_i, m k'}; the delta weighting keeps N_F and the isotropic lambda exact when the interpolated bands are only approximately symmetric. The pair coupling is

\[\Lambda_{nk,mk+q}(\omega) = \frac{1}{N_q}\sum_\nu \delta(\epsilon_{m k+q})\,\frac{2|g_{mn\nu}(k,q)|^2}{\omega_{q\nu}}\, \delta(\omega - \omega_{q\nu}),\]

so that lambda_nk = sum_b int Lambda_ab is EPW’s lambda_nk and sum_a W_a lambda_a / N_F the isotropic lambda, with the state weights W_a = D_a / N_k summing to N_F. The Coulomb weights

\[M_{ab} = \frac{1}{D_a}\sum_{q\in\mathrm{IBZ}} \frac{w_q}{N_q} \sum_{k\in\star(i),\,k+q\in\star(i')} \delta(\epsilon_{nk})\,\delta(\epsilon_{m\,k+q})\]

restrict the mu* term to the same pairs as the phonon kernel (EPW sums both over k+q). When the q-grid is coarser than the k-grid, k+q reaches only a sublattice of the k-grid; a Coulomb term spread uniformly over the whole Fermi surface would then couple sublattices that the phonons do not, and favour spurious gaps of opposite sign on them. The frequency dependence is stored on the uniform grid omega_j = j * d_omega: every mode is split between its two neighbouring grid points with linear weights, which conserves lambda exactly.

Classes#

FermiSurfacePairCoupling

Accumulator of the folded pair coupling Lambda_ab(omega).

Functions#

write_fs_coupling(path, coupling)

Save the Fermi-surface coupling of FermiSurfacePairCoupling.result().

read_fs_coupling(path)

Load a Fermi-surface coupling written by write_fs_coupling().

Module Contents#

class PAOFLOW.elphon.fermi_surface_coupling.FermiSurfacePairCoupling(electrons, star_index, representatives, star_sizes, fsthick_ev, omega_max_ev, n_freq=100, isig=0)[source]#

Accumulator of the folded pair coupling Lambda_ab(omega).

Parameters:
  • electrons (dict) – Dense electron cache of precompute_dense_electrons().

  • star_index (ndarray, shape (Nk^3,)) – k-star of every dense k-point (irreducible_mesh()).

  • representatives (ndarray, shape (nk_irr,)) – Flat index of the representative of each k-star.

  • star_sizes (ndarray, shape (nk_irr,)) – Multiplicity of each k-star.

  • fsthick_ev (float) – Half-width of the Fermi window (eV).

  • omega_max_ev (float) – Highest phonon frequency (eV); the frequency grid extends to 1.05 * omega_max_ev.

  • n_freq (int, optional) – Number of phonon-frequency grid points (default 100).

  • isig (int, optional) – Smearing index of electrons (default 0).

Notes

Memory is 8 N^2 n_freq bytes, with N the number of irreducible Fermi-surface states.

nk_side[source]#
delta_ry[source]#
star_index[source]#
star_sizes[source]#
fsthick_ev[source]#
sigma_ev[source]#
nstates[source]#
state_of[source]#
k_in_window[source]#
state_band[source]#
state_irreducible_k[source]#
state_k_cryst[source]#
state_energy_ev[source]#
state_multiplicity[source]#
state_delta_sum[source]#
state_weight[source]#
fermi_ev[source]#
n_freq = 100[source]#
freq_step_ev[source]#
freq_ev[source]#
coupling[source]#
coulomb[source]#
accumulate(k_indices, k_shift, g2_tilde, freqs_thz, mode_weights, q_weight)[source]#

Add the pairs (nk, m k+q) of one block of k-points.

Parameters:
  • k_indices (ndarray, shape (nb,)) – Flat dense-grid indices of the k-points.

  • k_shift (ndarray, shape (3,)) – q * Nk (integers): k + q is the grid point shifted by it.

  • g2_tilde (ndarray, shape (nb, nmode, nawf, nawf)) – |<m k+q| dV_nu |n k>|^2 with mass-weighted eigenvectors and no 1/(2 omega) factor (Ry^3), indexed [k, nu, m, n], as built in lambda_q_dense_ws_fast().

  • freqs_thz (ndarray, shape (nmode,)) – Phonon frequencies at q (THz).

  • mode_weights (ndarray, shape (nmode,)) – Weight of each mode: the q-star multiplicity divided by the number of q-points, or 0 for modes excluded from the coupling.

  • q_weight (float) – q-star multiplicity divided by the number of q-points, the weight of the Coulomb pairs (no mode exclusions).

Notes

A mode adds delta(e_{m k+q}) |g~|^2 / omega^2 = 2 delta |g|^2 / omega (the pair lambda) times mode_weights * delta(e_nk) / D_a.

reduce(comm)[source]#

Sum the coupling accumulated on every rank of comm (in place).

result(bg, at, nq_side)[source]#

The Fermi-surface coupling as a dictionary of arrays.

Parameters:
  • bg (array_like, shape (3, 3)) – Reciprocal and direct lattice vectors (rows).

  • at (array_like, shape (3, 3)) – Reciprocal and direct lattice vectors (rows).

  • nq_side (int) – Dense q-grid size.

Returns:

coupling (N, N, n_freq) (dimensionless pair lambda per frequency point), freq_ev (n_freq,), coulomb (N, N) (M_ab, 1/eV per spin, rows summing to about N_F); per state band, k_cryst (N, 3), energy_ev (e - E_F), weight (W_a, 1/eV per spin, summing to N_F), multiplicity and irreducible_k; and fermi_ev, fsthick_ev, sigma_ev, nk_dense, nq_dense, bg, at. See write_fs_coupling().

Return type:

dict

PAOFLOW.elphon.fermi_surface_coupling.write_fs_coupling(path, coupling)[source]#

Save the Fermi-surface coupling of FermiSurfacePairCoupling.result().

Parameters:
  • path (str) – Output .npz file.

  • coupling (dict) – The coupling dictionary.

PAOFLOW.elphon.fermi_surface_coupling.read_fs_coupling(path)[source]#

Load a Fermi-surface coupling written by write_fs_coupling().

Parameters:

path (str) – The .npz file.

Returns:

The arrays, with the 0-d entries converted to Python scalars.

Return type:

dict