def _real_self_energies_at_bands(self, i, fpoint, freqs, interaction,
weight):
if fpoint < self._cutoff_frequency:
return 0
sum_d = 0
for (j, k) in list(np.ndindex(interaction.shape[1:])):
if fpoint < self._cutoff_frequency:
continue
if (freqs[1, j] > self._cutoff_frequency
and freqs[2, k] > self._cutoff_frequency):
d = 0.0
n2 = bose_einstein(freqs[1, j], self._temperature)
n3 = bose_einstein(freqs[2, k], self._temperature)
f1 = fpoint + freqs[1, j] + freqs[2, k]
f2 = fpoint - freqs[1, j] - freqs[2, k]
f3 = fpoint - freqs[1, j] + freqs[2, k]
f4 = fpoint + freqs[1, j] - freqs[2, k]
# if abs(f1) > self._epsilon:
# d -= (n2 + n3 + 1) / f1
# if abs(f2) > self._epsilon:
# d += (n2 + n3 + 1) / f2
# if abs(f3) > self._epsilon:
# d -= (n2 - n3) / f3
# if abs(f4) > self._epsilon:
# d += (n2 - n3) / f4
d -= (n2 + n3 + 1) * f1 / (f1**2 + self._epsilon**2)
d += (n2 + n3 + 1) * f2 / (f2**2 + self._epsilon**2)
d -= (n2 - n3) * f3 / (f3**2 + self._epsilon**2)
d += (n2 - n3) * f4 / (f4**2 + self._epsilon**2)
sum_d += d * interaction[i, j, k] * weight
return sum_d
def _ise_thm_with_frequency_points(self):
for i, (tp, w, interaction) in enumerate(zip(self._triplets_at_q,
self._weights_at_q,
self._pp_strength)):
for j, k in list(np.ndindex(interaction.shape[1:])):
f1 = self._frequencies[tp[1]][j]
f2 = self._frequencies[tp[2]][k]
if (f1 > self._cutoff_frequency and
f2 > self._cutoff_frequency):
n2 = bose_einstein(f1, self._temperature)
n3 = bose_einstein(f2, self._temperature)
g1 = self._g[0, i, :, j, k]
g2_g3 = self._g[1, i, :, j, k] # g2 - g3
for l in range(len(interaction)):
self._imag_self_energy[:, l] += (
(n2 + n3 + 1) * g1 +
(n2 - n3) * (g2_g3)) * interaction[l, j, k] * w
self._imag_self_energy *= self._unit_conversion
def _run_c_with_g(self):
self.run_phonon_solver(self._triplets_at_q.ravel())
max_phonon_freq = np.max(self._frequencies)
self._frequency_points = get_frequency_points(
max_phonon_freq=max_phonon_freq,
sigmas=[
self._sigma,
],
frequency_points=None,
frequency_step=self._frequency_step,
num_frequency_points=self._num_frequency_points)
num_freq_points = len(self._frequency_points)
num_mesh = np.prod(self._mesh)
if self._temperatures is None:
jdos = np.zeros((num_freq_points, 2), dtype='double')
else:
num_temps = len(self._temperatures)
jdos = np.zeros((num_temps, num_freq_points, 2), dtype='double')
occ_phonons = []
for t in self._temperatures:
freqs = self._frequencies[self._triplets_at_q[:, 1:]]
occ_phonons.append(
np.where(freqs > self._cutoff_frequency,
bose_einstein(freqs, t), 0))
for i, freq_point in enumerate(self._frequency_points):
g, _ = get_triplets_integration_weights(
self,
np.array([freq_point], dtype='double'),
self._sigma,
is_collision_matrix=True,
neighboring_phonons=(i == 0))
if self._temperatures is None:
jdos[i, 1] = np.sum(
np.tensordot(g[0, :, 0], self._weights_at_q, axes=(0, 0)))
gx = g[2] - g[0]
jdos[i, 0] = np.sum(
np.tensordot(gx[:, 0], self._weights_at_q, axes=(0, 0)))
else:
for j, n in enumerate(occ_phonons):
for k, l in list(np.ndindex(g.shape[3:])):
jdos[j, i, 1] += np.dot(
(n[:, 0, k] + n[:, 1, l] + 1) * g[0, :, 0, k, l],
self._weights_at_q)
jdos[j, i, 0] += np.dot(
(n[:, 0, k] - n[:, 1, l]) * g[1, :, 0, k, l],
self._weights_at_q)
self._joint_dos = jdos / num_mesh
def _ise_thm_with_band_indices(self):
freqs = self._frequencies[self._triplets_at_q[:, [1, 2]]]
freqs = np.where(freqs > self._cutoff_frequency, freqs, 1)
n = bose_einstein(freqs, self._temperature)
for i, (tp, w, interaction) in enumerate(zip(self._triplets_at_q,
self._weights_at_q,
self._pp_strength)):
for j, k in list(np.ndindex(interaction.shape[1:])):
f1 = self._frequencies[tp[1]][j]
f2 = self._frequencies[tp[2]][k]
if (f1 > self._cutoff_frequency and
f2 > self._cutoff_frequency):
n2 = n[i, 0, j]
n3 = n[i, 1, k]
g1 = self._g[0, i, :, j, k]
g2_g3 = self._g[1, i, :, j, k] # g2 - g3
self._imag_self_energy[:] += (
(n2 + n3 + 1) * g1 +
(n2 - n3) * (g2_g3)) * interaction[:, j, k] * w
self._imag_self_energy *= self._unit_conversion
def _run_occupation(self):
t = self._temperature
freqs = self._frequencies[self._triplets_at_q[:, 1:]]
self._occupations = np.where(freqs > self._cutoff_frequency,
bose_einstein(freqs, t), -1)