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