def _get_gv_by_gv(self, i_irgp, i_data):
rotation_map = get_grid_points_by_rotations(
self._grid_address[self._grid_points[i_irgp]],
self._point_operations, self._mesh)
gv = self._gv[i_data]
gv_by_gv = np.zeros((len(gv), 3, 3), dtype='double')
for r in self._rotations_cartesian:
gvs_rot = np.dot(gv, r.T)
gv_by_gv += [np.outer(r_gv, r_gv) for r_gv in gvs_rot]
gv_by_gv /= len(rotation_map) // len(np.unique(rotation_map))
order_kstar = len(np.unique(rotation_map))
if self._grid_weights is not None:
if order_kstar != self._grid_weights[i_irgp]:
if self._log_level:
text = ("Number of elements in k* is unequal "
"to number of equivalent grid-points. "
"This means that the mesh sampling grids break "
"symmetry. Please check carefully "
"the convergence over grid point densities.")
msg = textwrap.fill(text,
initial_indent=" ",
subsequent_indent=" ",
width=70)
print("*" * 30 + "Warning" + "*" * 30)
print(msg)
print("*" * 67)
return gv_by_gv, order_kstar
def _show_log_values_on_kstar(self, frequencies, gv, ave_pp, gp, q):
rotation_map = get_grid_points_by_rotations(
self._grid_address[gp],
self._point_operations,
self._mesh)
for i, j in enumerate(np.unique(rotation_map)):
for k, (rot, rot_c) in enumerate(zip(
self._point_operations, self._rotations_cartesian)):
if rotation_map[k] != j:
continue
print(" k*%-2d (%5.2f %5.2f %5.2f)" %
((i + 1,) + tuple(np.dot(rot, q))))
if (self._is_full_pp or
self._use_ave_pp or
self._use_const_ave_pp):
for f, v, pp in zip(frequencies,
np.dot(rot_c, gv.T).T,
ave_pp):
print("%8.3f (%8.3f %8.3f %8.3f) %8.3f %11.3e" %
(f, v[0], v[1], v[2], np.linalg.norm(v), pp))
else:
for f, v in zip(frequencies, np.dot(rot_c, gv.T).T):
print("%8.3f (%8.3f %8.3f %8.3f) %8.3f" %
(f, v[0], v[1], v[2], np.linalg.norm(v)))
print('')
def _expand_collisions(self):
num_mesh_points = np.prod(self._mesh)
num_rot = len(self._point_operations)
num_band = self._primitive.get_number_of_atoms() * 3
rot_grid_points = np.zeros(
(num_rot, num_mesh_points), dtype='intc')
collision_matrix = np.zeros(
(len(self._sigmas),
len(self._temperatures),
num_mesh_points, num_band, num_mesh_points, num_band),
dtype='double')
gamma = np.zeros((len(self._sigmas),
len(self._temperatures),
num_mesh_points,
num_band), dtype='double')
gv = np.zeros((num_mesh_points,
num_band,
3), dtype='double')
if self._gamma_iso is not None:
gamma_iso = np.zeros((len(self._sigmas),
num_mesh_points,
num_band), dtype='double')
for i in range(num_mesh_points):
rot_grid_points[:, i] = get_grid_points_by_rotations(
self._grid_address[i],
self._point_operations,
self._mesh)
for i, ir_gp in enumerate(self._ir_grid_points):
multi = (rot_grid_points[:, ir_gp] == ir_gp).sum()
g_elem = self._gamma[:, :, i, :] / multi
if self._gamma_iso is not None:
giso_elem = self._gamma_iso[:, i, :] / multi
for j, r in enumerate(self._rotations_cartesian):
gp_r = rot_grid_points[j, ir_gp]
gamma[:, :, gp_r, :] += g_elem
if self._gamma_iso is not None:
gamma_iso[:, gp_r, :] += giso_elem
for k in range(num_mesh_points):
colmat_elem = self._collision_matrix[:, :, i, :, k, :]
colmat_elem = colmat_elem.copy() / multi
gp_c = rot_grid_points[j, k]
collision_matrix[:, :, gp_r, :, gp_c, :] += colmat_elem
gv[gp_r] += np.dot(self._gv[i], r.T) / multi
self._gamma = gamma
self._collision_matrix = collision_matrix
if self._gamma_iso is not None:
self._gamma_iso = gamma_iso
self._gv = gv
def _show_log(self, q, i):
gp = self._grid_points[i]
frequencies = self._frequencies[gp][self._pp.get_band_indices()]
gv = self._gv[i]
if self._is_full_pp or self._use_ave_pp:
ave_pp = self._averaged_pp_interaction[i]
if self._is_full_pp or self._use_ave_pp:
text = "Frequency group velocity (x, y, z) |gv| Pqj"
else:
text = "Frequency group velocity (x, y, z) |gv|"
if self._gv_delta_q is None:
pass
else:
text += " (dq=%3.1e)" % self._gv_delta_q
print(text)
if self._log_level > 1:
rotation_map = get_grid_points_by_rotations(
self._grid_address[gp], self._point_operations, self._mesh)
for i, j in enumerate(np.unique(rotation_map)):
for k, (rot, rot_c) in enumerate(
zip(self._point_operations,
self._rotations_cartesian)):
if rotation_map[k] != j:
continue
print(" k*%-2d (%5.2f %5.2f %5.2f)" %
((i + 1, ) + tuple(np.dot(rot, q))))
if self._is_full_pp or self._use_ave_pp:
for f, v, pp in zip(frequencies,
np.dot(rot_c, gv.T).T, ave_pp):
print("%8.3f (%8.3f %8.3f %8.3f) %8.3f %11.3e" %
(f, v[0], v[1], v[2], np.linalg.norm(v), pp))
else:
for f, v in zip(frequencies, np.dot(rot_c, gv.T).T):
print("%8.3f (%8.3f %8.3f %8.3f) %8.3f" %
(f, v[0], v[1], v[2], np.linalg.norm(v)))
print('')
else:
if self._is_full_pp or self._use_ave_pp:
for f, v, pp in zip(frequencies, gv, ave_pp):
print("%8.3f (%8.3f %8.3f %8.3f) %8.3f %11.3e" %
(f, v[0], v[1], v[2], np.linalg.norm(v), pp))
else:
for f, v in zip(frequencies, gv):
print("%8.3f (%8.3f %8.3f %8.3f) %8.3f" %
(f, v[0], v[1], v[2], np.linalg.norm(v)))
def _get_gv_by_gv(self, i):
rotation_map = get_grid_points_by_rotations(
self._grid_address[self._grid_points[i]], self._point_operations,
self._mesh)
gv_by_gv = np.zeros((len(self._gv[i]), 3, 3), dtype='double')
for r in self._rotations_cartesian:
gvs_rot = np.dot(self._gv[i], r.T)
gv_by_gv += [np.outer(r_gv, r_gv) for r_gv in gvs_rot]
gv_by_gv /= len(rotation_map) // len(np.unique(rotation_map))
order_kstar = len(np.unique(rotation_map))
if order_kstar != self._grid_weights[i]:
if self._log_level:
print("*" * 33 + "Warning" + "*" * 33)
print(" Number of elements in k* is unequal "
"to number of equivalent grid-points.")
print("*" * 73)
return gv_by_gv, order_kstar
def _allocate_values(self):
num_band = self._primitive.get_number_of_atoms() * 3
num_grid_points = len(self._grid_points)
num_ir_grid_points = len(self._ir_grid_points)
self._kappa = np.zeros((len(self._sigmas),
len(self._temperatures),
6), dtype='double')
self._gv = np.zeros((num_grid_points,
num_band,
3), dtype='double')
if self._is_full_pp:
self._averaged_pp_interaction = np.zeros(
(num_grid_points, num_band), dtype='double')
self._gamma = np.zeros((len(self._sigmas),
len(self._temperatures),
num_grid_points,
num_band), dtype='double')
if self._isotope is not None:
self._gamma_iso = np.zeros((len(self._sigmas),
num_grid_points,
num_band), dtype='double')
if self._is_reducible_collision_matrix:
num_mesh_points = np.prod(self._mesh)
self._mode_kappa = np.zeros((len(self._sigmas),
len(self._temperatures),
num_mesh_points,
num_band,
6), dtype='double')
self._collision = CollisionMatrix(
self._pp,
is_reducible_collision_matrix=True)
self._collision_matrix = np.zeros(
(len(self._sigmas),
len(self._temperatures),
num_grid_points, num_band, num_mesh_points, num_band),
dtype='double')
else:
self._mode_kappa = np.zeros((len(self._sigmas),
len(self._temperatures),
num_grid_points,
num_band,
6), dtype='double')
self._rot_grid_points = np.zeros(
(len(self._ir_grid_points), len(self._point_operations)),
dtype='intc')
self._rot_BZ_grid_points = np.zeros(
(len(self._ir_grid_points), len(self._point_operations)),
dtype='intc')
for i, ir_gp in enumerate(self._ir_grid_points):
self._rot_grid_points[i] = get_grid_points_by_rotations(
self._grid_address[ir_gp],
self._point_operations,
self._mesh)
self._rot_BZ_grid_points[i] = get_BZ_grid_points_by_rotations(
self._grid_address[ir_gp],
self._point_operations,
self._mesh,
self._pp.get_bz_map())
self._collision = CollisionMatrix(
self._pp,
point_operations=self._point_operations,
ir_grid_points=self._ir_grid_points,
rotated_grid_points=self._rot_BZ_grid_points)
self._collision_matrix = np.zeros(
(len(self._sigmas),
len(self._temperatures),
num_grid_points, num_band, 3,
num_ir_grid_points, num_band, 3),
dtype='double')
self._collision_eigenvalues = np.zeros(
(len(self._sigmas),
len(self._temperatures),
num_ir_grid_points * num_band * 3),
dtype='double')
def expand(data):
gv = data['group_velocity']
qpoint = data['qpoint']
frequency = data['frequency']
cv = data['heat_capacity']
if 'gamma_N' in data:
g_N = data['gamma_N']
g_U = data['gamma_U']
if 'gamma_isotope' in data:
g_I = data['gamma_isotope']
symmetry = data['symmetry']
primitive = data['cell']
mesh = data['mesh']
ir_grid_points = data['ir_grid_points']
grid_address = data['grid_address']
point_operations = symmetry.get_reciprocal_operations()
rec_lat = np.linalg.inv(primitive.get_cell())
rotations_cartesian = np.array(
[similarity_transformation(rec_lat, r) for r in point_operations],
dtype='double')
gv_bz = np.zeros((len(grid_address), ) + gv.shape[1:],
dtype='double',
order='C')
qpt_bz = np.zeros((len(grid_address), 3), dtype='double', order='C')
freq_bz = np.zeros((len(grid_address), frequency.shape[1]),
dtype='double',
order='C')
cv_bz = np.zeros((cv.shape[0], len(grid_address), cv.shape[2]),
dtype='double',
order='C')
if 'gamma_N' in data:
g_N_bz = np.zeros_like(cv_bz)
g_U_bz = np.zeros_like(cv_bz)
else:
g_N_bz = None
g_U_bz = None
if 'gamma_isotope' in data:
g_I_bz = np.zeros((len(grid_address), frequency.shape[1]),
dtype='double',
order='C')
else:
g_I_bz = None
num_band = gv.shape[1]
for i, gp in enumerate(ir_grid_points):
rotation_map = get_grid_points_by_rotations(grid_address[gp],
point_operations, mesh)
multi = len(rotation_map) // len(np.unique(rotation_map))
assert len(np.unique(rotation_map)) * multi == len(rotation_map)
for rgp, r_c, r in zip(rotation_map, rotations_cartesian,
point_operations):
gv_bz[rgp] += np.dot(gv[i], r_c.T) / multi
qpt_bz[rgp] = np.dot(r, qpoint[i])
freq_bz[rgp] = frequency[i]
cv_bz[:, rgp, :] = cv[:, i, :]
if 'gamma_N' in data:
g_N_bz[:, rgp, :] = g_N[:, i, :]
g_U_bz[:, rgp, :] = g_U[:, i, :]
if 'gamma_isotope' in data:
g_I_bz[rgp] = g_I[i]
return gv_bz, qpt_bz, freq_bz, cv_bz, g_N_bz, g_U_bz, g_I_bz
