def __init__( self, mesh, primitive, mass_variances=None, # length of list is num_atom. band_indices=None, sigma=None, bz_grid=None, frequency_factor_to_THz=VaspToTHz, use_grg=False, store_dense_gp_map=True, symprec=1e-5, cutoff_frequency=None, lapack_zheev_uplo="L", ): """Init method.""" self._mesh = mesh if mass_variances is None: self._mass_variances = get_mass_variances(primitive) else: self._mass_variances = np.array(mass_variances, dtype="double") self._primitive = primitive self._sigma = sigma self._bz_grid = bz_grid self._symprec = symprec if cutoff_frequency is None: self._cutoff_frequency = 0 else: self._cutoff_frequency = cutoff_frequency self._frequency_factor_to_THz = frequency_factor_to_THz self._lapack_zheev_uplo = lapack_zheev_uplo self._nac_q_direction = None self._grid_points = None self._frequencies = None self._eigenvectors = None self._phonon_done = None self._dm = None self._gamma = None self._tetrahedron_method = None num_band = len(self._primitive) * 3 if band_indices is None: self._band_indices = np.arange(num_band, dtype="int_") else: self._band_indices = np.array(band_indices, dtype="int_") if self._bz_grid is None: primitive_symmetry = Symmetry(self._primitive, self._symprec) self._bz_grid = BZGrid( self._mesh, lattice=self._primitive.cell, symmetry_dataset=primitive_symmetry.dataset, use_grg=use_grg, store_dense_gp_map=store_dense_gp_map, )
def mesh_numbers(self, mesh_numbers): self._bz_grid = BZGrid( mesh_numbers, lattice=self._primitive.cell, symmetry_dataset=self._primitive_symmetry.dataset, is_time_reversal=self._is_symmetry, use_grg=self._use_grg, force_SNF=False, SNF_coordinates=self._SNF_coordinates, store_dense_gp_map=self._store_dense_gp_map, )
def test_BZGrid_bzg2grg(si_pbesol_111): """Test of mapping of BZGrid to GRGrid. This mapping table is stored in BZGrid, but also determined by get_grid_point_from_address. This test checks the consistency. """ lat = si_pbesol_111.primitive.cell mesh = [4, 4, 4] bzgrid1 = BZGrid(mesh, lattice=lat, store_dense_gp_map=False) grg = [] for i in range(len(bzgrid1.addresses)): grg.append(get_grid_point_from_address(bzgrid1.addresses[i], mesh)) np.testing.assert_equal(grg, bzgrid1.bzg2grg) bzgrid2 = BZGrid(mesh, lattice=lat, store_dense_gp_map=True) grg = [] for i in range(len(bzgrid2.addresses)): grg.append(get_grid_point_from_address(bzgrid2.addresses[i], mesh)) np.testing.assert_equal(grg, bzgrid2.bzg2grg)
def test_get_triplets_at_q_type1(si_pbesol_111): """Test triplets under type1 grid.""" pcell = si_pbesol_111.primitive psym = si_pbesol_111.primitive_symmetry grid_point = 1 mesh = [4, 4, 4] bz_grid = BZGrid( mesh, lattice=pcell.cell, symmetry_dataset=psym.dataset, store_dense_gp_map=False, ) triplets, weights = get_triplets_at_q(grid_point, bz_grid)[:2] triplets_ref = [ 1, 0, 3, 1, 1, 2, 1, 4, 15, 1, 5, 14, 1, 6, 13, 1, 7, 12, 1, 65, 11, 1, 9, 10, 1, 24, 59, 1, 26, 88, ] weights_ref = [2, 2, 6, 6, 6, 6, 6, 6, 12, 12] # print("".join(["%d, " % i for i in triplets.ravel()])) # print("".join(["%d, " % i for i in weights])) _show_triplets_info(mesh, bz_grid, triplets, np.linalg.inv(pcell.cell)) np.testing.assert_equal(triplets.ravel(), triplets_ref) np.testing.assert_equal(weights, weights_ref)
def test_BZGrid_SNF(si_pbesol_111): """Test of SNF in BZGrid.""" lat = si_pbesol_111.primitive.cell mesh = 10 bzgrid1 = BZGrid( mesh, lattice=lat, symmetry_dataset=si_pbesol_111.primitive_symmetry.dataset, use_grg=True, store_dense_gp_map=False, ) _test_BZGrid_SNF(bzgrid1) bzgrid2 = BZGrid( mesh, lattice=lat, symmetry_dataset=si_pbesol_111.primitive_symmetry.dataset, use_grg=True, store_dense_gp_map=True, ) _test_BZGrid_SNF(bzgrid2)
def test_BZGrid_SNF_hexagonal(aln_lda): """Test of SNF in BZGrid.""" lat = aln_lda.primitive.cell mesh = 20 bzgrid = BZGrid( mesh, lattice=lat, symmetry_dataset=aln_lda.primitive_symmetry.dataset, ) np.testing.assert_equal(bzgrid.D_diag, [7, 7, 4]) bzgrid = BZGrid( mesh, lattice=lat, symmetry_dataset=aln_lda.primitive_symmetry.dataset, use_grg=True, ) np.testing.assert_equal(bzgrid.D_diag, [7, 7, 4]) bzgrid = BZGrid( mesh, lattice=lat, symmetry_dataset=aln_lda.primitive_symmetry.dataset, use_grg=True, force_SNF=True, ) np.testing.assert_equal(bzgrid.D_diag, [1, 7, 28]) bzgrid = BZGrid( mesh, lattice=lat, symmetry_dataset=aln_lda.primitive_symmetry.dataset, use_grg=True, force_SNF=True, SNF_coordinates="direct", ) np.testing.assert_equal(bzgrid.D_diag, [1, 6, 30])
def _get_jdos(ph3: Phono3py, mesh, nac_params=None, store_dense_gp_map=False): bz_grid = BZGrid( mesh, lattice=ph3.primitive.cell, symmetry_dataset=ph3.primitive_symmetry.dataset, store_dense_gp_map=store_dense_gp_map, ) jdos = JointDos( ph3.primitive, ph3.supercell, bz_grid, ph3.fc2, nac_params=nac_params, store_dense_gp_map=store_dense_gp_map, cutoff_frequency=1e-4, ) return jdos
def test_BZGrid_SNF_nonprimitive(si_pbesol_111): """Test of SNF in BZGrid.""" lat = si_pbesol_111.supercell.cell mesh = 20 with pytest.warns( RuntimeWarning, match="Non primitive cell input. Unable to use GR-grid."): bzgrid = BZGrid( mesh, lattice=lat, symmetry_dataset=si_pbesol_111.symmetry.dataset, use_grg=True, ) np.testing.assert_equal(bzgrid.D_diag, [4, 4, 4]) identity = np.eye(3, dtype=int) np.testing.assert_equal(bzgrid.P, identity) np.testing.assert_equal(bzgrid.Q, identity)
def test_SNF_tetrahedra_relative_grid(aln_lda): """Test relative grid addresses under GR-grid. Under GR-grid, grid point addressing becomes different from ordinal uniform grid. But P and Q matrices can be used to map betweewn these grid systems. In this test, the agreement is checked by representing them in Cartesian coordinates. """ lat = aln_lda.primitive.cell mesh = 25 for snf_coordinates, d_diag in zip(("direct", "reciprocal"), ([2, 8, 24], [1, 9, 45])): bzgrid = BZGrid( mesh, lattice=lat, symmetry_dataset=aln_lda.primitive_symmetry.dataset, use_grg=True, force_SNF=True, SNF_coordinates=snf_coordinates, ) np.testing.assert_equal(bzgrid.D_diag, d_diag) plat = np.linalg.inv(aln_lda.primitive.cell) mlat = bzgrid.microzone_lattice thm = TetrahedronMethod(mlat) snf_tetrahedra = np.dot(thm.get_tetrahedra(), bzgrid.P.T) for mtet, ptet in zip(thm.get_tetrahedra(), snf_tetrahedra): np.testing.assert_allclose( np.dot(mtet, mlat.T), np.dot(np.dot(ptet, bzgrid.QDinv.T), plat.T), atol=1e-8, )
def test_get_grid_points_by_bz_rotations(si_pbesol_111): """Rotate grid point by rotations with and without considering BZ surface. The following three methods are tested between type-1 and type-2. _get_grid_points_by_rotations _get_grid_points_by_bz_rotations_c _get_grid_points_by_bz_rotations_py """ ref10_type1 = [ 10, 26, 10, 26, 26, 10, 26, 10, 88, 80, 200, 208, 200, 208, 88, 80, 208, 88, 80, 200, 208, 88, 80, 200, 26, 10, 26, 10, 10, 26, 10, 26, 200, 208, 88, 80, 88, 80, 200, 208, 80, 200, 208, 88, 80, 200, 208, 88, ] ref12_type2 = [ 12, 39, 12, 39, 39, 12, 39, 12, 122, 109, 265, 278, 265, 278, 122, 109, 278, 122, 109, 265, 278, 122, 109, 265, 39, 12, 39, 12, 12, 39, 12, 39, 265, 278, 122, 109, 122, 109, 265, 278, 109, 265, 278, 122, 109, 265, 278, 122, ] ref10_bz_type1 = [ 10, 26, 260, 270, 269, 258, 271, 259, 88, 285, 200, 328, 322, 208, 291, 286, 327, 292, 287, 321, 326, 290, 80, 323, 269, 258, 271, 259, 10, 26, 260, 270, 200, 328, 88, 285, 291, 286, 322, 208, 80, 323, 326, 290, 287, 321, 327, 292, ] ref12_bz_type2 = [ 12, 39, 15, 41, 40, 13, 42, 14, 122, 110, 265, 281, 267, 278, 124, 111, 280, 125, 112, 266, 279, 123, 109, 268, 40, 13, 42, 14, 12, 39, 15, 41, 265, 281, 122, 110, 124, 111, 267, 278, 109, 268, 279, 123, 112, 266, 280, 125, ] lat = si_pbesol_111.primitive.cell mesh = 20 bz_grid_type1 = BZGrid( mesh, lattice=lat, symmetry_dataset=si_pbesol_111.primitive_symmetry.dataset, use_grg=True, store_dense_gp_map=False, ) bz_grid_type2 = BZGrid( mesh, lattice=lat, symmetry_dataset=si_pbesol_111.primitive_symmetry.dataset, use_grg=True, store_dense_gp_map=True, ) # Check data consistency by reducing to GR-grid. # Grid point 10 in type-1 and 12 in type-2 are the same points in GR-grid. assert bz_grid_type1.bzg2grg[10] == bz_grid_type2.bzg2grg[12] np.testing.assert_equal(bz_grid_type1.bzg2grg[ref10_type1], bz_grid_type2.bzg2grg[ref12_type2]) np.testing.assert_equal(bz_grid_type1.bzg2grg[ref10_type1], bz_grid_type1.bzg2grg[ref10_bz_type1]) np.testing.assert_equal(bz_grid_type1.bzg2grg[ref10_type1], bz_grid_type2.bzg2grg[ref12_bz_type2]) bzgps = _get_grid_points_by_rotations(10, bz_grid_type1, bz_grid_type1.rotations) np.testing.assert_equal(bzgps, ref10_type1) bzgps = _get_grid_points_by_rotations(12, bz_grid_type2, bz_grid_type2.rotations) np.testing.assert_equal(bzgps, ref12_type2) bzgps = _get_grid_points_by_bz_rotations_c(10, bz_grid_type1, bz_grid_type1.rotations) np.testing.assert_equal(bzgps, ref10_bz_type1) bzgps = _get_grid_points_by_bz_rotations_c(12, bz_grid_type2, bz_grid_type2.rotations) np.testing.assert_equal(bzgps, ref12_bz_type2) bzgps = _get_grid_points_by_bz_rotations_py(10, bz_grid_type1, bz_grid_type1.rotations) np.testing.assert_equal(bzgps, ref10_bz_type1) bzgps = _get_grid_points_by_bz_rotations_py(12, bz_grid_type2, bz_grid_type2.rotations) np.testing.assert_equal(bzgps, ref12_bz_type2) # Exhaustive consistency check among methods for grgp in range(np.prod(bz_grid_type1.D_diag)): bzgp_type1 = bz_grid_type1.grg2bzg[grgp] bzgp_type2 = bz_grid_type2.grg2bzg[grgp] rot_grgps = bz_grid_type1.bzg2grg[_get_grid_points_by_rotations( bzgp_type1, bz_grid_type1, bz_grid_type1.rotations)] np.testing.assert_equal( rot_grgps, bz_grid_type2.bzg2grg[_get_grid_points_by_rotations( bzgp_type2, bz_grid_type2, bz_grid_type2.rotations)], ) np.testing.assert_equal( _get_grid_points_by_bz_rotations_c(bzgp_type1, bz_grid_type1, bz_grid_type1.rotations), _get_grid_points_by_bz_rotations_py(bzgp_type1, bz_grid_type1, bz_grid_type1.rotations), ) np.testing.assert_equal( _get_grid_points_by_bz_rotations_c(bzgp_type2, bz_grid_type2, bz_grid_type2.rotations), _get_grid_points_by_bz_rotations_py(bzgp_type2, bz_grid_type2, bz_grid_type2.rotations), ) np.testing.assert_equal( rot_grgps, bz_grid_type1.bzg2grg[_get_grid_points_by_bz_rotations_c( bzgp_type1, bz_grid_type1, bz_grid_type1.rotations)], ) np.testing.assert_equal( rot_grgps, bz_grid_type2.bzg2grg[_get_grid_points_by_bz_rotations_c( bzgp_type2, bz_grid_type2, bz_grid_type2.rotations)], )
def test_BZGrid(si_pbesol_111): """Tests of BZGrid type1 and type2.""" lat = si_pbesol_111.primitive.cell reclat = np.linalg.inv(lat) mesh = [4, 4, 4] gp_map2 = [ 0, 1, 2, 4, 5, 6, 7, 8, 9, 11, 12, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 34, 35, 36, 40, 41, 43, 44, 46, 47, 48, 49, 50, 54, 56, 57, 59, 60, 61, 65, 66, 67, 68, 69, 70, 71, 72, 73, 77, 78, 79, 83, 84, 85, 86, 87, 88, 89, ] bzgrid1 = BZGrid(mesh, lattice=lat, store_dense_gp_map=False) bzgrid2 = BZGrid(mesh, lattice=lat, store_dense_gp_map=True) adrs1 = bzgrid1.addresses[:np.prod(mesh)] adrs2 = bzgrid2.addresses[bzgrid2.gp_map[:-1]] assert ((adrs1 - adrs2) % mesh == 0).all() np.testing.assert_equal(bzgrid1.addresses.shape, bzgrid2.addresses.shape) # print("".join(["%d, " % i for i in bzgrid2.gp_map.ravel()])) np.testing.assert_equal(bzgrid2.gp_map.ravel(), gp_map2) dist1 = np.sqrt((np.dot(adrs1, reclat.T)**2).sum(axis=1)) dist2 = np.sqrt((np.dot(adrs2, reclat.T)**2).sum(axis=1)) np.testing.assert_allclose(dist1, dist2, atol=1e-8)