def check_symmetry(input_cell,
primitive_axis=np.eye(3, dtype=float),
symprec=1e-5,
phonopy_version=None):
cell = Primitive(input_cell, primitive_axis, symprec)
symmetry = Symmetry(cell, symprec)
print get_symmetry_yaml(cell, symmetry, phonopy_version),
if input_cell.get_magnetic_moments() == None:
primitive = find_primitive(cell, symprec)
if not primitive == None:
print "# Primitive cell was found. It is written into PPOSCAR."
write_vasp('PPOSCAR', primitive)
# Overwrite symmetry and cell
symmetry = Symmetry(primitive, symprec)
cell = primitive
bravais_lattice, bravais_pos, bravais_numbers = \
spg.refine_cell(cell, symprec)
bravais = Atoms(numbers=bravais_numbers,
scaled_positions=bravais_pos,
cell=bravais_lattice,
pbc=True)
print "# Bravais lattice is written into BPOSCAR."
write_vasp('BPOSCAR', bravais)
def test_magmom(self):
symprec = 1e-5
cell = read_cell_yaml(os.path.join(data_dir, "Cr.yaml"))
symmetry_nonspin = Symmetry(cell, symprec=symprec)
atom_map_nonspin = symmetry_nonspin.get_map_atoms()
len_sym_nonspin = len(
symmetry_nonspin.get_symmetry_operations()['rotations'])
spin = [1, -1]
cell_withspin = cell.copy()
cell_withspin.set_magnetic_moments(spin)
symmetry_withspin = Symmetry(cell_withspin, symprec=symprec)
atom_map_withspin = symmetry_withspin.get_map_atoms()
len_sym_withspin = len(
symmetry_withspin.get_symmetry_operations()['rotations'])
broken_spin = [1, -2]
cell_brokenspin = cell.copy()
cell_brokenspin = cell.copy()
cell_brokenspin.set_magnetic_moments(broken_spin)
symmetry_brokenspin = Symmetry(cell_brokenspin, symprec=symprec)
atom_map_brokenspin = symmetry_brokenspin.get_map_atoms()
len_sym_brokenspin = len(
symmetry_brokenspin.get_symmetry_operations()['rotations'])
self.assertTrue((atom_map_nonspin == atom_map_withspin).all())
self.assertFalse((atom_map_nonspin == atom_map_brokenspin).all())
self.assertTrue(len_sym_nonspin == len_sym_withspin)
self.assertFalse(len_sym_nonspin == len_sym_brokenspin)
def check_symmetry(input_cell,
primitive_axis=None,
symprec=1e-5,
distance_to_A=1.0,
phonopy_version=None):
if primitive_axis is None:
cell = get_primitive(input_cell, np.eye(3), symprec=symprec)
else:
cell = get_primitive(input_cell, primitive_axis, symprec=symprec)
lattice = cell.get_cell() * distance_to_A
cell.set_cell(lattice)
symmetry = Symmetry(cell, symprec)
print(_get_symmetry_yaml(cell, symmetry, phonopy_version))
if input_cell.get_magnetic_moments() is None:
primitive = find_primitive(cell, symprec)
if primitive is not None:
print("# Primitive cell was found. It is written into PPOSCAR.")
write_vasp('PPOSCAR', primitive)
# Overwrite symmetry and cell
symmetry = Symmetry(primitive, symprec)
cell = primitive
(bravais_lattice, bravais_pos,
bravais_numbers) = spg.refine_cell(cell, symprec)
bravais = Atoms(numbers=bravais_numbers,
scaled_positions=bravais_pos,
cell=bravais_lattice,
pbc=True)
print("# Bravais lattice is written into BPOSCAR.")
write_vasp('BPOSCAR', bravais)
def read_crystal(filename):
f_crystal = open(filename)
crystal_in = CrystalIn(f_crystal.readlines())
f_crystal.close()
tags = crystal_in.get_tags()
cell = Atoms(cell=tags['lattice_vectors'],
symbols=tags['atomic_species'],
scaled_positions=tags['coordinates'])
magmoms = tags['magnetic_moments']
if magmoms is not None:
# Print out symmetry information for magnetic cases
# Original code from structure/symmetry.py
symmetry = Symmetry(cell, symprec=1e-5)
print(
"CRYSTAL-interface: Magnetic structure, number of operations without spin: %d"
% len(symmetry.get_symmetry_operations()['rotations']))
print("CRYSTAL-interface: Spacegroup without spin: %s" %
symmetry.get_international_table())
cell.set_magnetic_moments(magmoms)
symmetry = Symmetry(cell, symprec=1e-5)
print(
"CRYSTAL-interface: Magnetic structure, number of operations with spin: %d"
% len(symmetry.get_symmetry_operations()['rotations']))
print("")
return cell, tags['conv_numbers']
def read_castep(filename):
f_castep = open(filename)
castep_in = CastepIn(f_castep.readlines())
f_castep.close()
tags = castep_in.get_tags()
# 1st stage is to create Atoms object ignoring Spin polarization. General case.
cell = Atoms(cell=tags['lattice_vectors'],
symbols=tags['atomic_species'],
scaled_positions=tags['coordinates'])
# Analyse spin states and add data to Atoms instance "cell" if ones exist
magmoms = tags['magnetic_moments']
if magmoms is not None:
# Print out symmetry information for magnetic cases
# Original code from structure/symmetry.py
symmetry = Symmetry(cell, symprec=1e-5)
print(
"CASTEP-interface: Magnetic structure, number of operations without spin: %d"
% len(symmetry.get_symmetry_operations()['rotations']))
print("CASTEP-interface: Spacegroup without spin: %s" %
symmetry.get_international_table())
cell.set_magnetic_moments(magmoms)
symmetry = Symmetry(cell, symprec=1e-5)
print(
"CASTEP-interface: Magnetic structure, number of operations with spin: %d"
% len(symmetry.get_symmetry_operations()['rotations']))
print("")
return cell
def test_magmom(convcell_cr):
symprec = 1e-5
cell = convcell_cr
symmetry_nonspin = Symmetry(cell, symprec=symprec)
atom_map_nonspin = symmetry_nonspin.get_map_atoms()
len_sym_nonspin = len(
symmetry_nonspin.get_symmetry_operations()['rotations'])
spin = [1, -1]
cell_withspin = cell.copy()
cell_withspin.set_magnetic_moments(spin)
symmetry_withspin = Symmetry(cell_withspin, symprec=symprec)
atom_map_withspin = symmetry_withspin.get_map_atoms()
len_sym_withspin = len(
symmetry_withspin.get_symmetry_operations()['rotations'])
broken_spin = [1, -2]
cell_brokenspin = cell.copy()
cell_brokenspin = cell.copy()
cell_brokenspin.set_magnetic_moments(broken_spin)
symmetry_brokenspin = Symmetry(cell_brokenspin, symprec=symprec)
atom_map_brokenspin = symmetry_brokenspin.get_map_atoms()
len_sym_brokenspin = len(
symmetry_brokenspin.get_symmetry_operations()['rotations'])
assert (atom_map_nonspin == atom_map_withspin).all()
assert (atom_map_nonspin != atom_map_brokenspin).any()
assert len_sym_nonspin == len_sym_withspin
assert len_sym_nonspin != len_sym_brokenspin
def test_magmom(convcell_cr: PhonopyAtoms):
"""Test symmetry search with hmagnetic moments."""
symprec = 1e-5
symmetry_nonspin = Symmetry(convcell_cr, symprec=symprec)
atom_map_nonspin = symmetry_nonspin.get_map_atoms()
len_sym_nonspin = len(symmetry_nonspin.symmetry_operations["rotations"])
spin = [1, -1]
cell_withspin = convcell_cr.copy()
cell_withspin.magnetic_moments = spin
symmetry_withspin = Symmetry(cell_withspin, symprec=symprec)
atom_map_withspin = symmetry_withspin.get_map_atoms()
len_sym_withspin = len(symmetry_withspin.symmetry_operations["rotations"])
broken_spin = [1, -2]
cell_brokenspin = convcell_cr.copy()
cell_brokenspin = convcell_cr.copy()
cell_brokenspin.magnetic_moments = broken_spin
symmetry_brokenspin = Symmetry(cell_brokenspin, symprec=symprec)
atom_map_brokenspin = symmetry_brokenspin.get_map_atoms()
len_sym_brokenspin = len(
symmetry_brokenspin.symmetry_operations["rotations"])
assert (atom_map_nonspin == atom_map_withspin).all()
assert (atom_map_nonspin != atom_map_brokenspin).any()
assert len_sym_nonspin == len_sym_withspin
assert len_sym_nonspin != len_sym_brokenspin
def __init__(
self,
supercell: Supercell,
primitive: Primitive,
fc2,
mesh=None,
nac_params=None,
nac_q_direction=None,
sigmas=None,
cutoff_frequency=1e-4,
frequency_step=None,
num_frequency_points=None,
num_points_in_batch=None,
temperatures=None,
frequency_factor_to_THz=VaspToTHz,
frequency_scale_factor=None,
use_grg=False,
SNF_coordinates="reciprocal",
is_mesh_symmetry=True,
is_symmetry=True,
store_dense_gp_map=False,
symprec=1e-5,
output_filename=None,
log_level=0,
):
"""Init method."""
self._primitive = primitive
self._supercell = supercell
self._fc2 = fc2
self._temperatures = temperatures
self._nac_params = nac_params
self._nac_q_direction = nac_q_direction
if sigmas is None:
self._sigmas = [None]
else:
self._sigmas = sigmas
self._cutoff_frequency = cutoff_frequency
self._frequency_factor_to_THz = frequency_factor_to_THz
self._frequency_scale_factor = frequency_scale_factor
self._is_mesh_symmetry = is_mesh_symmetry
self._is_symmetry = is_symmetry
self._store_dense_gp_map = store_dense_gp_map
self._use_grg = use_grg
self._SNF_coordinates = SNF_coordinates
self._symprec = symprec
self._filename = output_filename
self._log_level = log_level
self._bz_grid = None
self._joint_dos = None
self._num_frequency_points_in_batch = num_points_in_batch
self._frequency_step = frequency_step
self._num_frequency_points = num_frequency_points
self._primitive_symmetry = Symmetry(self._primitive, self._symprec,
self._is_symmetry)
if mesh is not None:
self.mesh_numbers = mesh
self.initialize(mesh)
def parse_BORN_from_strings(strings,
primitive,
symprec=1e-5,
is_symmetry=True):
f = StringIO.StringIO(strings)
symmetry = Symmetry(primitive, symprec=symprec, is_symmetry=is_symmetry)
return get_born_parameters(f, primitive, symmetry)
def _search_primitive_symmetry(self):
self._primitive_symmetry = Symmetry(self._primitive, self._symprec,
self._is_symmetry)
if (len(self._symmetry.get_pointgroup_operations()) != len(
self._primitive_symmetry.get_pointgroup_operations())):
print("Warning: point group symmetries of supercell and primitive"
"cell are different.")
def write_supercells_with_displacements(supercell,
cells_with_displacements,
ids,
npts,
r0s,
rmts,
num_unitcells_in_supercell,
pre_filename="wien2k",
width=3):
npts_super = []
r0s_super = []
rmts_super = []
for i, j, k in zip(npts, r0s, rmts):
for l in range(num_unitcells_in_supercell):
npts_super.append(i)
r0s_super.append(j)
rmts_super.append(k)
_pre_filename = pre_filename.split('/')[-1] + "S"
write_wein2k(_pre_filename, supercell, npts_super, r0s_super, rmts_super)
for i, cell in zip(ids, cells_with_displacements):
symmetry = Symmetry(cell)
filename = "{pre_filename}-{0:0{width}}.in".format(
i, pre_filename=_pre_filename, width=width)
print("Number of non-equivalent atoms in %s: %d" %
(filename, len(symmetry.get_independent_atoms())))
write_wein2k(filename, cell, npts_super, r0s_super, rmts_super)
def get_data(args, interface_mode=None):
args = parse_args()
cell, _ = read_crystal_structure(args.filenames[0],
interface_mode=interface_mode)
f = h5py.File(args.filenames[1])
primitive_matrix = np.reshape(
[fracval(x) for x in args.primitive_matrix.split()], (3, 3))
primitive = get_primitive(cell, primitive_matrix)
symmetry = Symmetry(primitive)
data = {}
data['cell'] = primitive
data['symmetry'] = symmetry
data['mesh'] = np.array(f['mesh'][:], dtype='intc') # (3)
data['weight'] = f['weight'][:] # (gp)
data['group_velocity'] = f['group_velocity'][:] # (gp, band, 3)
data['qpoint'] = f['qpoint'][:] # (gp, 3)
data['frequency'] = f['frequency'][:] # (gp, band)
if 'gamma_N' in f:
data['gamma_N'] = f['gamma_N'][:] # (temps, gp, band)
data['gamma_U'] = f['gamma_U'][:] # (temps, gp, band)
if 'gamma_isotope' in f:
data['gamma_isotope'] = f['gamma_isotope'][:] # (gp, band)
data['heat_capacity'] = f['heat_capacity'][:] # (temps, gp, band)
data['temperature'] = np.array(f['temperature'][:],
dtype='double') # (temps)
ir_grid_points, grid_address, _ = get_grid_symmetry(data)
data['ir_grid_points'] = ir_grid_points
data['grid_address'] = grid_address
return data
def _search_phonon_supercell_symmetry(self):
if self._phonon_supercell_matrix is None:
self._phonon_supercell_symmetry = self._symmetry
else:
self._phonon_supercell_symmetry = Symmetry(self._phonon_supercell,
self._symprec,
self._is_symmetry)
def _extract_independent_borns(borns,
ucell,
primitive_matrix=None,
supercell_matrix=None,
is_symmetry=True,
symprec=1e-5):
if primitive_matrix is None:
pmat = np.eye(3)
else:
pmat = primitive_matrix
if supercell_matrix is None:
smat = np.eye(3, dtype='intc')
else:
smat = supercell_matrix
inv_smat = np.linalg.inv(smat)
scell = get_supercell(ucell, smat, symprec=symprec)
pcell = get_primitive(scell, np.dot(inv_smat, pmat), symprec=symprec)
p2s = np.array(pcell.get_primitive_to_supercell_map(), dtype='intc')
p_sym = Symmetry(pcell, is_symmetry=is_symmetry, symprec=symprec)
s_indep_atoms = p2s[p_sym.get_independent_atoms()]
u2u = scell.get_unitcell_to_unitcell_map()
u_indep_atoms = [u2u[x] for x in s_indep_atoms]
reduced_borns = borns[u_indep_atoms].copy()
return reduced_borns, s_indep_atoms
def gencastep(fn, modenum, basis, natom, typatsym, symprec, atpos):
from phonopy import Phonopy
import phonopy.structure.spglib as spg
from phonopy.structure.atoms import PhonopyAtoms as Atoms
from phonopy.structure.symmetry import Symmetry, find_primitive, get_pointgroup
fh = open(fn, 'w')
unitcell = Atoms(symbols=typatsym, cell=basis, positions=atpos)
pbasis = np.eye(3)
for i in range(len(basis)):
pbasis[i] = basis[i] / np.linalg.norm(basis[i])
symmetry = Symmetry(unitcell, symprec)
rotations = symmetry.get_symmetry_operations()['rotations']
translations = symmetry.get_symmetry_operations()['translations']
print('Space group International symbol: %s' %
symmetry.get_international_table())
fh.write('%BLOCK LATTICE_CART\n')
for bl in basis:
fh.write('%s\n' % ''.join(' %12.8f' % b for b in bl))
fh.write('%ENDBLOCK LATTICE_CART\n\n')
fh.write('%BLOCK POSITIONS_ABS\n')
for i in range(len(typatsym)):
fh.write(" %3s " % typatsym[i])
fh.write('%s\n' % ''.join(' %12.8f' % p for p in atpos[i].tolist()))
fh.write('%ENDBLOCK POSITIONS_ABS\n\n')
fh.write('SYMMETRY_TOL : %f ang\n' % symprec)
fh.write('SYMMETRY_GENERATE \n')
fh.write('#KPOINT_MP_GRID : 4 4 4\n#KPOINT_MP_OFFSET : 0.5 0.5 0.5\n')
def write_supercells_with_displacements(supercell,
cells_with_displacements,
npts,
r0s,
rmts,
num_unitcells_in_supercell,
filename="wien2k-"):
npts_super = []
r0s_super = []
rmts_super = []
for i, j, k in zip(npts, r0s, rmts):
for l in range(num_unitcells_in_supercell):
npts_super.append(i)
r0s_super.append(j)
rmts_super.append(k)
w = open(filename.split('/')[-1] + "S", 'w')
w.write(_get_wien2k_struct(supercell, npts_super, r0s_super, rmts_super))
w.close()
for i, cell in enumerate(cells_with_displacements):
symmetry = Symmetry(cell)
supercell_filename = filename.split('/')[-1] + "S-%03d" % (i + 1)
print("Number of non-equivalent atoms in %s: %d" %
(supercell_filename, len(symmetry.get_independent_atoms())))
w = open(supercell_filename, 'w')
w.write(_get_wien2k_struct(cell, npts_super, r0s_super, rmts_super))
w.close()
def get_equivalent_q_points_by_symmetry(q_point, structure):
from phonopy.structure.symmetry import Symmetry
bulk = PhonopyAtoms(symbols=structure.get_atomic_elements(),
scaled_positions=structure.get_scaled_positions(),
cell=structure.get_cell().T)
tot_points = []
for operation_matrix in Symmetry(bulk).get_reciprocal_operations():
operation_matrix_q = np.dot(
np.linalg.inv(structure.get_primitive_matrix()),
operation_matrix.T)
operation_matrix_q = np.dot(operation_matrix_q,
structure.get_primitive_matrix())
q_point_test = np.dot(q_point, operation_matrix_q)
if (q_point_test >= 0).all():
tot_points.append(q_point_test)
# print tot_points
# print(np.vstack({tuple(row) for row in tot_points}))
return np.vstack({tuple(row) for row in tot_points})
def write_born_file(initial_structure, phonopy_inputs, dielectric_tensor,
born_effective_charge_tensor, file_path):
"""
Creates the born file that phonopy needs for the non-analytical correction to be applied.
"""
phonon = get_initialized_phononopy_instance(initial_structure,
phonopy_inputs)
symm = Symmetry(cell=phonon.get_primitive(),
symprec=phonopy_inputs['symprec'])
independent_atom_indices_list = symm.get_independent_atoms()
born_file = File()
born_file += "14.400"
flat_dielectric_list = misc.flatten_multi_dimensional_list(
dielectric_tensor)
born_file += " ".join(str(component) for component in flat_dielectric_list)
print "Independent atom indices:", independent_atom_indices_list
for atomic_bec_index in independent_atom_indices_list:
atomic_bec = born_effective_charge_tensor[atomic_bec_index]
flat_atomic_bec = misc.flatten_multi_dimensional_list(atomic_bec)
born_file += " ".join(str(component) for component in flat_atomic_bec)
born_file.write_to_path(file_path)
def write_supercells_with_displacements(supercell,
cells_with_displacements,
npts,
r0s,
rmts,
supercell_matrix,
filename="wien2k-"):
v = supercell_matrix
det = v[0,0] * v[1,1] * v[2,2] \
+ v[0,1] * v[1,2] * v[2,0] \
+ v[0,2] * v[1,0] * v[2,1] \
- v[0,0] * v[1,2] * v[2,1] \
- v[0,1] * v[1,0] * v[2,2] \
- v[0,2] * v[1,1] * v[2,0]
npts_super = []
r0s_super = []
rmts_super = []
for i, j, k in zip(npts, r0s, rmts):
for l in range(abs(det)):
npts_super.append(i)
r0s_super.append(j)
rmts_super.append(k)
w = open(filename.split('/')[-1] + "S", 'w')
w.write(get_wien2k_struct(supercell, npts_super, r0s_super, rmts_super))
w.close()
for i, cell in enumerate(cells_with_displacements):
symmetry = Symmetry(cell)
print "Number of non-equivalent atoms in %sS-%03d: %d" % (
filename, i + 1, len(symmetry.get_independent_atoms()))
w = open(filename.split('/')[-1] + "S-%03d" % (i + 1), 'w')
w.write(get_wien2k_struct(cell, npts_super, r0s_super, rmts_super))
w.close()
def __init__(self,
fc4,
supercell,
primitive,
mesh,
temperatures=None,
band_indices=None,
frequency_factor_to_THz=VaspToTHz,
is_nosym=False,
symprec=1e-3,
cutoff_frequency=1e-4,
log_level=False,
lapack_zheev_uplo='L'):
self._fc4 = fc4
self._supercell = supercell
self._primitive = primitive
self._masses = np.double(self._primitive.get_masses())
self._mesh = np.intc(mesh)
if temperatures is None:
self._temperatures = np.double([0])
else:
self._temperatures = np.double(temperatures)
num_band = primitive.get_number_of_atoms() * 3
if band_indices is None:
self._band_indices = np.arange(num_band, dtype='intc')
else:
self._band_indices = np.intc(band_indices)
self._frequency_factor_to_THz = frequency_factor_to_THz
self._is_nosym = is_nosym
self._symprec = symprec
self._cutoff_frequency = cutoff_frequency
self._log_level = log_level
self._lapack_zheev_uplo = lapack_zheev_uplo
symmetry = Symmetry(primitive, symprec=symprec)
self._point_group_operations = symmetry.get_pointgroup_operations()
self._grid_address = None
self._bz_map = None
self._set_grid_address()
self._grid_point = None
self._quartets_at_q = None
self._weights_at_q = None
self._phonon_done = None
self._frequencies = None
self._eigenvectors = None
self._dm = None
self._nac_q_direction = None
self._frequency_shifts = None
# Unit to THz of Delta
self._unit_conversion = (EV / Angstrom**4 / AMU**2 /
(2 * np.pi * THz)**2 * Hbar * EV /
(2 * np.pi * THz) / 8 / np.prod(self._mesh))
self._allocate_phonon()
def set_grid(self):
self._point_operations= get_pointgroup_operations(
Symmetry(self._cell).get_pointgroup_operations())
self._kpoint_operations = get_kpoint_group(self._mesh, self._point_operations)
(mapping, rot_mappings) =get_mappings(self._mesh,
Symmetry(self._cell).get_pointgroup_operations(),
qpoints=np.array([0,0,0],dtype="double"))
self._rot_mappings = self._kpoint_operations[rot_mappings]
self._mapping, self._grid=spg.get_ir_reciprocal_mesh(self._mesh, self._cell)
assert (self._mapping==mapping).all()
self._map_to_ir_index=np.zeros_like(mapping)
reverse_mapping=[]
for i,u in enumerate(np.unique(mapping)):
reverse_mapping.append(np.where(mapping==u)[0])
self._map_to_ir_index[np.where(mapping==u)] = i
self._reverse_mapping=reverse_mapping
def __init__(self,
mesh,
primitive,
supercell,
fc2,
nac_params=None,
nac_q_direction=None,
sigma=None,
cutoff_frequency=None,
frequency_step=None,
num_frequency_points=None,
temperatures=None,
frequency_factor_to_THz=VaspToTHz,
frequency_scale_factor=1.0,
is_mesh_symmetry=True,
symprec=1e-5,
filename=None,
log_level=False,
lapack_zheev_uplo='L'):
self._grid_point = None
self._mesh = np.array(mesh, dtype='intc')
self._primitive = primitive
self._supercell = supercell
self._fc2 = fc2
self._nac_params = nac_params
self._nac_q_direction = None
self.set_nac_q_direction(nac_q_direction)
self._sigma = None
self.set_sigma(sigma)
if cutoff_frequency is None:
self._cutoff_frequency = 0
else:
self._cutoff_frequency = cutoff_frequency
self._frequency_step = frequency_step
self._num_frequency_points = num_frequency_points
self._temperatures = temperatures
self._frequency_factor_to_THz = frequency_factor_to_THz
self._frequency_scale_factor = frequency_scale_factor
self._is_mesh_symmetry = is_mesh_symmetry
self._symprec = symprec
self._filename = filename
self._log_level = log_level
self._lapack_zheev_uplo = lapack_zheev_uplo
self._num_band = self._primitive.get_number_of_atoms() * 3
self._reciprocal_lattice = np.linalg.inv(self._primitive.get_cell())
self._init_dynamical_matrix()
self._symmetry = Symmetry(primitive, symprec)
self._tetrahedron_method = None
self._phonon_done = None
self._frequencies = None
self._eigenvectors = None
self._joint_dos = None
self._frequency_points = None
def get_born_OUTCAR(poscar_filename="POSCAR",
outcar_filename="OUTCAR",
primitive_matrix=None,
supercell_matrix=None,
is_symmetry=True,
symmetrize_tensors=False,
symprec=1e-5):
if primitive_matrix is None:
pmat = np.eye(3)
else:
pmat = primitive_matrix
if supercell_matrix is None:
smat = np.eye(3, dtype='intc')
else:
smat = supercell_matrix
ucell = read_vasp(poscar_filename)
outcar = open(outcar_filename)
borns, epsilon = _read_born_and_epsilon(outcar)
num_atom = len(borns)
assert num_atom == ucell.get_number_of_atoms()
if symmetrize_tensors:
lattice = ucell.get_cell().T
positions = ucell.get_scaled_positions()
u_sym = Symmetry(ucell, is_symmetry=is_symmetry, symprec=symprec)
point_sym = [
similarity_transformation(lattice, r)
for r in u_sym.get_pointgroup_operations()
]
epsilon = _symmetrize_tensor(epsilon, point_sym)
borns = _symmetrize_borns(borns, u_sym, lattice, positions, symprec)
inv_smat = np.linalg.inv(smat)
scell = get_supercell(ucell, smat, symprec=symprec)
pcell = get_primitive(scell, np.dot(inv_smat, pmat), symprec=symprec)
p2s = np.array(pcell.get_primitive_to_supercell_map(), dtype='intc')
p_sym = Symmetry(pcell, is_symmetry=is_symmetry, symprec=symprec)
s_indep_atoms = p2s[p_sym.get_independent_atoms()]
u2u = scell.get_unitcell_to_unitcell_map()
u_indep_atoms = [u2u[x] for x in s_indep_atoms]
reduced_borns = borns[u_indep_atoms].copy()
return reduced_borns, epsilon, s_indep_atoms
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 get_number_of_triplets(primitive, mesh, grid_point, symprec=1e-5):
mesh = np.array(mesh, dtype='intc')
symmetry = Symmetry(primitive, symprec)
point_group = symmetry.get_pointgroup_operations()
primitive_lattice = np.linalg.inv(primitive.get_cell())
triplets_at_q, _, _, _, _, _ = get_triplets_at_q(grid_point, mesh,
point_group,
primitive_lattice)
return len(triplets_at_q)
def _search_primitive_symmetry_ideal(self):
self._primitive_symmetry = Symmetry(self._primitive_ideal,
self._symprec,
self._is_symmetry)
n0 = len(self._symmetry.get_pointgroup_operations())
n1 = len(self._primitive_symmetry.get_pointgroup_operations())
if n0 != n1:
raise Warning("Point group symmetries of supercell and primitive"
"cell are different.")
def average_masses(self):
masses = self._unitcell.get_masses()
masses_average = calculate_average_masses(
masses, Symmetry(self._unitcell_ideal))
self._unitcell.set_masses(masses_average)
self._build_supercell()
self._build_primitive_cell()
self._search_symmetry()
self._search_primitive_symmetry()
def get_coarse_ir_grid_points(primitive,
mesh,
mesh_divisors,
coarse_mesh_shifts,
is_kappa_star=True,
symprec=1e-5):
mesh = np.array(mesh, dtype='intc')
symmetry = Symmetry(primitive, symprec)
point_group = symmetry.get_pointgroup_operations()
if mesh_divisors is None:
(ir_grid_points,
ir_grid_weights,
grid_address,
grid_mapping_table) = get_ir_grid_points(mesh, point_group)
else:
mesh_divs = np.array(mesh_divisors, dtype='intc')
coarse_mesh = mesh // mesh_divs
if coarse_mesh_shifts is None:
coarse_mesh_shifts = [False, False, False]
if not is_kappa_star:
coarse_grid_address = get_grid_address(coarse_mesh)
coarse_grid_points = np.arange(np.prod(coarse_mesh), dtype='uintp')
else:
(coarse_ir_grid_points,
coarse_ir_grid_weights,
coarse_grid_address,
coarse_grid_mapping_table) = get_ir_grid_points(
coarse_mesh,
point_group,
mesh_shifts=coarse_mesh_shifts)
ir_grid_points = from_coarse_to_dense_grid_points(
mesh,
mesh_divs,
coarse_grid_points,
coarse_grid_address,
coarse_mesh_shifts=coarse_mesh_shifts)
grid_address = get_grid_address(mesh)
ir_grid_weights = ir_grid_weights
reciprocal_lattice = np.linalg.inv(primitive.get_cell())
bz_grid_address, bz_map = spg.relocate_BZ_grid_address(grid_address,
mesh,
reciprocal_lattice,
is_dense=True)
return (ir_grid_points,
ir_grid_weights,
bz_grid_address,
grid_mapping_table)
def test_parse_wien2k_struct(self):
cell, npts, r0s, rmts = parse_wien2k_struct("BaGa2.struct")
lattice = cell.get_cell().T
displacements, supercell = parse_disp_yaml("disp_BaGa2.yaml",
return_cell=True)
symmetry = Symmetry(cell)
print(PhonopyAtoms(atoms=cell))
sym_op = symmetry.get_symmetry_operations()
print(symmetry.get_international_table())
for i, (r, t) in enumerate(
zip(sym_op['rotations'], sym_op['translations'])):
print("--- %d ---" % (i + 1))
print(r)
print(t)
def __init__(self,
dynamical_matrix,
cell,
mesh,
shift=None,
is_time_reversal=False,
is_mesh_symmetry=True,
is_eigenvectors=False,
is_band_connection=False,
is_gamma_center=False,
group_velocity=None,
factor=VaspToTHz,
symprec=1e-5):
self._mesh = np.array(mesh)
self._is_band_connection=is_band_connection
self._band_order = None
self._is_eigenvectors = is_eigenvectors
self._factor = factor
self._cell = cell
self._dynamical_matrix = dynamical_matrix
# self._qpoints, self._weights = get_qpoints(self._mesh,
# self._cell,
# shift,
# is_gamma_center,
# is_time_reversal,
# symprec,
# is_symmetry)
rotations = Symmetry(self._cell).get_pointgroup_operations()
self._gp = GridPoints(self._mesh,
np.linalg.inv(self._cell.get_cell()),
q_mesh_shift=shift,
is_gamma_center=is_gamma_center,
is_time_reversal=is_time_reversal,
rotations=rotations,
is_mesh_symmetry=is_mesh_symmetry)
self._qpoints = self._gp.get_ir_qpoints()
self._weights = self._gp.get_ir_grid_weights()
self._eigenvalues = None
self._eigenvectors = None
self._set_eigenvalues()
if self._is_band_connection:
self._set_band_connection()
self._group_velocities = None
if group_velocity is not None:
self._set_group_velocities(group_velocity)
