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 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 check_symmetry(input_cell,
primitive_axis=None,
symprec=1e-5,
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)
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 _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 test_get_primitive_convcell_nacl(convcell_nacl,
primcell_nacl,
helper_methods):
pcell = get_primitive(convcell_nacl, [[0, 0.5, 0.5],
[0.5, 0, 0.5],
[0.5, 0.5, 0]])
helper_methods.compare_cells_with_order(pcell, primcell_nacl)
def _arrange_supercell_fc(self, cell, q2r_fc, is_full_fc=False):
dim = self.dimension
q2r_spos = self._get_q2r_positions(cell)
scell = get_supercell(cell, np.diag(dim))
pcell = get_primitive(scell, np.diag(1.0 / dim))
diff = cell.get_scaled_positions() - pcell.get_scaled_positions()
diff -= np.rint(diff)
assert (np.abs(diff) < 1e-8).all()
assert scell.get_number_of_atoms() == len(q2r_spos)
site_map = self._get_site_mapping(scell.get_scaled_positions(),
q2r_spos,
scell.get_cell())
natom = pcell.get_number_of_atoms()
ndim = np.prod(dim)
natom_s = natom * ndim
if is_full_fc:
fc = np.zeros((natom_s, natom_s, 3, 3), dtype='double', order='C')
p2s = pcell.get_primitive_to_supercell_map()
fc[p2s, :] = q2r_fc[:, site_map]
distribute_force_constants_by_translations(fc,
pcell,
scell)
else:
fc = np.zeros((natom, natom_s, 3, 3), dtype='double', order='C')
fc[:, :] = q2r_fc[:, site_map]
return fc, pcell, scell
def test(self):
natoms = self._atoms.get_number_of_atoms()
primitive = get_primitive(self._atoms, self._primitive_matrix)
symprec = 1e-6
smallest_vectors0, multiplicity0 = _get_smallest_vectors(
self._atoms, primitive, symprec)
smallest_vectors1, multiplicity1 = get_smallest_vectors_upho(
self._atoms, primitive, symprec)
dt_old = 0.0
dt_new = 0.0
for i in range(natoms):
for j in range(primitive.get_number_of_atoms()):
t0 = time.time()
tmp0 = smallest_vectors0[i, j, :multiplicity0[i][j]]
t1 = time.time()
dt_old += t1 - t0
t0 = time.time()
tmp1 = smallest_vectors1[i, j, :multiplicity1[i][j]]
t1 = time.time()
dt_new += t1 - t0
print(tmp0)
print(tmp1)
self.assertTrue(np.array_equal(tmp0, tmp1))
print(dt_old)
print(dt_new)
def get_born_OUTCAR(
poscar_filename="POSCAR",
outcar_filename="OUTCAR",
primitive_axis=np.eye(3),
supercell_matrix=np.eye(3, dtype="intc"),
is_symmetry=True,
symmetrize_tensors=False,
symprec=1e-5,
):
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(supercell_matrix)
scell = get_supercell(ucell, supercell_matrix, symprec=symprec)
pcell = get_primitive(scell, np.dot(inv_smat, primitive_axis), 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
def __init__(self,
paths,
dynamical_matrix,
unitcell_ideal,
primitive_matrix_ideal,
is_eigenvectors=False,
is_band_connection=False,
group_velocity=None,
factor=VaspToTHz,
star="none",
mode="eigenvector",
verbose=False):
"""
Args:
dynamical_matrix:
Dynamical matrix for the (disordered) supercell.
primitive_ideal_wrt_unitcell:
Primitive cell w.r.t. the unitcell (not the supercell).
"""
# ._dynamical_matrix must be assigned for calculating DOS
# using the tetrahedron method.
self._dynamical_matrix = dynamical_matrix
# self._cell is used for write_yaml and _shift_point.
# This must correspond to the "ideal" primitive cell.
primitive_ideal_wrt_unitcell = (
get_primitive(unitcell_ideal, primitive_matrix_ideal))
self._cell = primitive_ideal_wrt_unitcell
self._factor = factor
self._is_eigenvectors = is_eigenvectors
self._is_band_connection = is_band_connection
if is_band_connection:
self._is_eigenvectors = True
self._group_velocity = group_velocity
self._paths = [np.array(path) for path in paths]
self._distances = []
self._distance = 0.
self._special_point = [0.]
self._eigenvalues = None
self._eigenvectors = None
self._frequencies = None
self._star = star
self._mode = mode
self._eigenstates = Eigenstates(
dynamical_matrix,
unitcell_ideal,
primitive_matrix_ideal,
mode=mode,
star=star,
verbose=verbose)
with h5py.File('band.hdf5', 'w') as f:
self._hdf5_file = f
self._write_hdf5_header()
self._set_band(verbose=verbose)
def ph2fc(ph_orig, supercell_matrix):
"""Transform force constants in Phonopy instance to other shape
For example, ph_orig.supercell_matrix is np.diag([2, 2, 2]) and
supercell_matrix is np.diag([4, 4, 4]), force constants having the
later shape are returned. This is considered useful when ph_orig
has non-analytical correction (NAC). The effect of this correction
is included in the returned force constants. Phonons before and after
this operation at commensurate points of the later supercell_matrix
should agree.
"""
smat = shape_supercell_matrix(supercell_matrix)
scell = get_supercell(ph_orig.unitcell, smat)
pcell = get_primitive(
scell,
np.dot(np.linalg.inv(smat), ph_orig.primitive_matrix),
positions_to_reorder=ph_orig.primitive.scaled_positions)
d2f = DynmatToForceConstants(pcell, scell)
ph_orig.run_qpoints(d2f.commensurate_points, with_dynamical_matrices=True)
ph_dict = ph_orig.get_qpoints_dict()
d2f.dynamical_matrices = ph_dict['dynamical_matrices']
d2f.run()
return d2f.force_constants
def check_symmetry(phonon, optional_structure_info):
# Assumed that primitive cell is the cell that user is interested in.
print(_get_symmetry_yaml(phonon.primitive,
phonon.primitive_symmetry,
phonon.version))
if phonon.unitcell.magnetic_moments is None:
base_fname = get_default_cell_filename(phonon.calculator)
symprec = phonon.primitive_symmetry.get_symmetry_tolerance()
(bravais_lattice,
bravais_pos,
bravais_numbers) = spglib.refine_cell(phonon.primitive, symprec)
bravais = PhonopyAtoms(numbers=bravais_numbers,
scaled_positions=bravais_pos,
cell=bravais_lattice)
filename = 'B' + base_fname
print("# Symmetrized conventional unit cell is written into %s."
% filename)
trans_mat = guess_primitive_matrix(bravais, symprec=symprec)
primitive = get_primitive(bravais, trans_mat, symprec=symprec)
write_crystal_structure(
filename,
bravais,
interface_mode=phonon.calculator,
optional_structure_info=optional_structure_info)
filename = 'P' + base_fname
print("# Symmetrized primitive is written into %s." % filename)
write_crystal_structure(
filename,
primitive,
interface_mode=phonon.calculator,
optional_structure_info=optional_structure_info)
def __init__(self,
dynamical_matrix,
unitcell_ideal,
primitive_matrix_ideal,
star="none",
mode="eigenvector",
factor=VaspToTHz,
verbose=False):
self._verbose = verbose
self._mode = mode
self._factor = factor
self._cell = dynamical_matrix.get_primitive() # Disordered
self._dynamical_matrix = dynamical_matrix
self._star = star
self._unitcell_ideal = unitcell_ideal
# In this module, primitive is w.r.t. the unit cell (may be disordered).
self._primitive = get_primitive(self._unitcell_ideal,
primitive_matrix_ideal)
self._build_star_creator()
self._generate_translational_projector()
self._generate_vectors_adjuster()
self._create_rotational_projector()
self._build_element_weights_calculator()
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 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 _arrange_supercell_fc(self, cell, q2r_fc, is_full_fc=False):
dim = self.dimension
q2r_spos = self._get_q2r_positions(cell)
scell = get_supercell(cell, np.diag(dim))
pcell = get_primitive(scell, np.diag(1.0 / dim))
diff = cell.get_scaled_positions() - pcell.get_scaled_positions()
diff -= np.rint(diff)
assert (np.abs(diff) < 1e-8).all()
assert scell.get_number_of_atoms() == len(q2r_spos)
site_map = self._get_site_mapping(scell.get_scaled_positions(),
q2r_spos,
scell.get_cell())
natom = pcell.get_number_of_atoms()
ndim = np.prod(dim)
natom_s = natom * ndim
if is_full_fc:
fc = np.zeros((natom_s, natom_s, 3, 3), dtype='double', order='C')
p2s = pcell.get_primitive_to_supercell_map()
fc[p2s, :] = q2r_fc[:, site_map]
distribute_force_constants_by_translations(fc,
pcell,
scell)
else:
fc = np.zeros((natom, natom_s, 3, 3), dtype='double', order='C')
fc[:, :] = q2r_fc[:, site_map]
return fc, pcell, scell
def __init__(self,
paths,
dynamical_matrix,
unitcell_ideal,
primitive_matrix_ideal,
is_eigenvectors=False,
is_band_connection=False,
group_velocity=None,
factor=VaspToTHz,
star="none",
mode="eigenvector",
verbose=False):
"""
Args:
dynamical_matrix:
Dynamical matrix for the (disordered) supercell.
primitive_ideal_wrt_unitcell:
Primitive cell w.r.t. the unitcell (not the supercell).
"""
# ._dynamical_matrix must be assigned for calculating DOS
# using the tetrahedron method.
self._dynamical_matrix = dynamical_matrix
# self._cell is used for write_yaml and _shift_point.
# This must correspond to the "ideal" primitive cell.
primitive_ideal_wrt_unitcell = (get_primitive(unitcell_ideal,
primitive_matrix_ideal))
self._cell = primitive_ideal_wrt_unitcell
self._factor = factor
self._is_eigenvectors = is_eigenvectors
self._is_band_connection = is_band_connection
if is_band_connection:
self._is_eigenvectors = True
self._group_velocity = group_velocity
self._paths = [np.array(path) for path in paths]
self._distances = []
self._distance = 0.
self._special_point = [0.]
self._eigenvalues = None
self._eigenvectors = None
self._frequencies = None
self._star = star
self._mode = mode
self._eigenstates = Eigenstates(dynamical_matrix,
unitcell_ideal,
primitive_matrix_ideal,
mode=mode,
star=star,
verbose=verbose)
with h5py.File('band.hdf5', 'w') as f:
self._hdf5_file = f
self._write_hdf5_header()
self._set_band(verbose=verbose)
def _get_primitive_cell(self, supercell, supercell_matrix, primitive_matrix):
inv_supercell_matrix = np.linalg.inv(supercell_matrix)
if primitive_matrix is None:
t_mat = inv_supercell_matrix
else:
t_mat = np.dot(inv_supercell_matrix, primitive_matrix)
return get_primitive(supercell, t_mat, self._symprec)
def _get_primitive_cell(self, supercell, supercell_matrix, primitive_matrix):
inv_supercell_matrix = np.linalg.inv(supercell_matrix)
if primitive_matrix is None:
t_mat = inv_supercell_matrix
else:
t_mat = np.dot(inv_supercell_matrix, primitive_matrix)
return get_primitive(supercell, t_mat, self._symprec)
def test_B3(self):
unitcell = read_vasp("poscars/POSCAR_B3_conv")
primitive_matrix = [
[0.0, 0.5, 0.5],
[0.5, 0.0, 0.5],
[0.5, 0.5, 0.0],
]
primitive = get_primitive(unitcell, primitive_matrix)
self.check(unitcell, primitive)
def test_get_commensurate_points(self):
smat = np.diag([2, 2, 2])
pmat = np.dot(np.linalg.inv(smat),
[[0, 0.5, 0.5], [0.5, 0, 0.5], [0.5, 0.5, 0]])
supercell = get_supercell(self._cell, smat)
primitive = get_primitive(supercell, pmat)
comm_points = get_commensurate_points(primitive, supercell)
for i, p in enumerate(comm_points):
print("%d %s" % (i + 1, p))
def test_get_primitive_convcell_Cr(convcell_cr: PhonopyAtoms, helper_methods):
"""Test get_primitive by NaCl."""
convcell_cr.magnetic_moments = [1, -1]
smat = [[2, 0, 0], [0, 2, 0], [0, 0, 2]]
scell = get_supercell(convcell_cr, smat, is_old_style=True)
pmat = np.linalg.inv(smat)
pcell = get_primitive(scell, pmat)
helper_methods.compare_cells(convcell_cr, pcell)
convcell_cr.magnetic_moments = None
def test_get_commensurate_points(self):
smat = np.diag([2, 2, 2])
pmat = np.dot(np.linalg.inv(smat),
[[0, 0.5, 0.5], [0.5, 0, 0.5], [0.5, 0.5, 0]])
supercell = get_supercell(self._cell, smat)
primitive = get_primitive(supercell, pmat)
comm_points = get_commensurate_points(primitive, supercell)
for i, p in enumerate(comm_points):
print("%d %s" % (i + 1, p))
def test_B3(self):
unitcell = read_vasp(os.path.join(POSCAR_DIR, "POSCAR_B3_conv"))
primitive_matrix = [
[0.0, 0.5, 0.5],
[0.5, 0.0, 0.5],
[0.5, 0.5, 0.0],
]
primitive = get_primitive(unitcell, primitive_matrix)
self.check(unitcell, primitive)
def test_B3(self):
unitcell = read_vasp("poscars/POSCAR_B3_conv")
primitive_matrix = [
[0.0, 0.5, 0.5],
[0.5, 0.0, 0.5],
[0.5, 0.5, 0.0],
]
primitive = get_primitive(unitcell, primitive_matrix)
self.check(unitcell, primitive)
def create_primitive(self, filename="POSCAR", conf_file=None):
from phonopy.structure.cells import get_primitive
from phonopy.interface.vasp import read_vasp
if conf_file is None:
self._check_conf_files()
else:
self.set_conf_file(conf_file)
primitive_matrix = self._read_primitive_matrix()
atoms = read_vasp(filename)
return get_primitive(atoms, primitive_matrix)
def create_primitive(self, filename="POSCAR", conf_file=None):
from phonopy.structure.cells import get_primitive
from phonopy.interface.vasp import read_vasp
if conf_file is None:
self._check_conf_files()
else:
self.set_conf_file(conf_file)
primitive_matrix = self._read_primitive_matrix()
atoms = read_vasp(filename)
return get_primitive(atoms, primitive_matrix)
def test_get_commensurate_points(self):
smat = np.diag([2, 2, 2])
pmat = np.dot(np.linalg.inv(smat),
[[0, 0.5, 0.5], [0.5, 0, 0.5], [0.5, 0.5, 0]])
supercell = get_supercell(self._cell, smat)
primitive = get_primitive(supercell, pmat)
supercell_matrix = np.linalg.inv(primitive.get_primitive_matrix())
supercell_matrix = np.rint(supercell_matrix).astype('intc')
comm_points = get_commensurate_points(supercell_matrix)
# self._write(comm_points)
self._compare(comm_points)
def test_get_commensurate_points(self):
smat = np.diag([2, 2, 2])
pmat = np.dot(np.linalg.inv(smat),
[[0, 0.5, 0.5], [0.5, 0, 0.5], [0.5, 0.5, 0]])
supercell = get_supercell(self._cell, smat)
primitive = get_primitive(supercell, pmat)
supercell_matrix = np.linalg.inv(primitive.get_primitive_matrix())
supercell_matrix = np.rint(supercell_matrix).astype('intc')
comm_points = get_commensurate_points(supercell_matrix)
# self._write(comm_points)
self._compare(comm_points)
def test_project_vectors(self):
unitcell, unitcell_ideal, primitive_matrix = self.prepare_L1_2()
primitive = get_primitive(unitcell_ideal, primitive_matrix)
natoms_u = unitcell.get_number_of_atoms()
natoms_p = primitive.get_number_of_atoms()
num_elements = 2
ndims = 3
nbands = 4
vectors = np.arange(ndims * natoms_u * nbands).reshape(-1, nbands)
elemental_projector = ElementWeightsCalculator(unitcell, primitive)
projected_vectors = elemental_projector.project_vectors(vectors)
print(projected_vectors)
projected_vectors_expected = [
[
[0, 1, 2, 3],
[4, 5, 6, 7],
[8, 9, 10, 11],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
],
[
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23],
[24, 25, 26, 27],
[28, 29, 30, 31],
[32, 33, 34, 35],
[36, 37, 38, 39],
[40, 41, 42, 43],
[44, 45, 46, 47],
],
]
self.assertTrue(
np.all(projected_vectors == projected_vectors_expected))
def test_project_vectors(self):
unitcell, unitcell_ideal, primitive_matrix = self.prepare_L1_2()
primitive = get_primitive(unitcell_ideal, primitive_matrix)
natoms_u = unitcell.get_number_of_atoms()
natoms_p = primitive.get_number_of_atoms()
num_elements = 2
ndims = 3
nbands = 4
vectors = np.arange(ndims * natoms_u * nbands).reshape(-1, nbands)
elemental_projector = ElementWeightsCalculator(unitcell, primitive)
projected_vectors = elemental_projector.project_vectors(vectors)
print(projected_vectors)
projected_vectors_expected = [
[
[0, 1, 2, 3],
[4, 5, 6, 7],
[8, 9, 10, 11],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
],
[
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23],
[24, 25, 26, 27],
[28, 29, 30, 31],
[32, 33, 34, 35],
[36, 37, 38, 39],
[40, 41, 42, 43],
[44, 45, 46, 47],
],
]
self.assertTrue(
np.all(projected_vectors == projected_vectors_expected))
def test_get_primitive_convcell_nacl_svecs(convcell_nacl: PhonopyAtoms,
store_dense_svecs):
"""Test shortest vectors by NaCl."""
pcell = get_primitive(convcell_nacl,
primitive_matrix_nacl,
store_dense_svecs=store_dense_svecs)
svecs, multi = pcell.get_smallest_vectors()
if store_dense_svecs:
assert svecs.shape == (54, 3)
assert multi.shape == (8, 2, 2)
assert np.sum(multi[:, :, 0]) == 54
assert np.sum(multi[-1:, -1, :]) == 54
else:
assert svecs.shape == (8, 2, 27, 3)
assert multi.shape == (8, 2)
def get_BORN_txt(structure, parameters, nac_data, symprec=1.e-5):
from phonopy.structure.cells import get_primitive, get_supercell
from phonopy.structure.symmetry import Symmetry
from phonopy.interface import get_default_physical_units
from phonopy.structure.atoms import Atoms as PhonopyAtoms
born_charges = nac_data.get_array('born_charges')
epsilon = nac_data.get_array('epsilon')
print ('inside born parameters')
pmat = parameters['primitive']
smat = parameters['supercell']
ucell = PhonopyAtoms(symbols=[site.kind_name for site in structure.sites],
positions=[site.position for site in structure.sites],
cell=structure.cell)
num_atom = len(born_charges)
assert num_atom == ucell.get_number_of_atoms(), \
"num_atom %d != len(borns) %d" % (ucell.get_number_of_atoms(),
len(born_charges))
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=True, 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 = born_charges[u_indep_atoms].copy()
factor = get_default_physical_units('vasp')['nac_factor'] # born charges in VASP units
born_txt = ('{}\n'.format(factor))
for num in epsilon.flatten():
born_txt += ('{0:4.8f}'.format(num))
born_txt += ('\n')
for atom in reduced_borns:
for num in atom:
born_txt += ('{0:4.8f}'.format(num))
born_txt += ('\n')
born_txt += ('{}\n'.format(factor))
return born_txt
def _get_supercell_and_primitive(ucell,
primitive_matrix=None,
supercell_matrix=None,
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)
return scell, pcell
def _get_supercell_and_primitive(ucell,
primitive_matrix=None,
supercell_matrix=None,
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)
return scell, pcell
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 test_reduce_vectors_to_primitive_for_multidimensional_vectors(self):
vectors_adjuster = self._vectors_adjuster
atoms = read_vasp(os.path.join(POSCAR_DIR, "POSCAR_fcc"))
primitive_matrix = [
[0.0, 0.5, 0.5],
[0.5, 0.0, 0.5],
[0.5, 0.5, 0.0],
]
primitive = get_primitive(atoms, primitive_matrix)
vectors = self.get_eigvec_0()[None, :, None]
reduced_vectors = vectors_adjuster.reduce_vectors_to_primitive(
vectors, primitive)
nexpansion = 4
exp = np.array([
0.5,
0.0,
0.0,
])[None, :, None]
exp *= np.sqrt(nexpansion)
self.assertTrue(np.all(np.abs(reduced_vectors - exp) < 1e-6))
def test_reduce_vectors_to_primitive_for_multidimensional_vectors(self):
vectors_adjuster = self._vectors_adjuster
atoms = read_vasp("poscars/POSCAR_fcc")
primitive_matrix = [
[0.0, 0.5, 0.5],
[0.5, 0.0, 0.5],
[0.5, 0.5, 0.0],
]
primitive = get_primitive(atoms, primitive_matrix)
vectors = self.get_eigvec_0()[None, :, None]
reduced_vectors = vectors_adjuster.reduce_vectors_to_primitive(
vectors, primitive)
nexpansion = 4
exp = np.array([
0.5,
0.0,
0.0,
])[None, :, None]
exp *= np.sqrt(nexpansion)
self.assertTrue(np.all(np.abs(reduced_vectors - exp) < 1e-6))
def test_reduce_vectors_to_primitive(self):
vectors_adjuster = self._vectors_adjuster
atoms = read_vasp("poscars/POSCAR_fcc")
primitive_matrix = [
[0.0, 0.5, 0.5],
[0.5, 0.0, 0.5],
[0.5, 0.5, 0.0],
]
primitive = get_primitive(atoms, primitive_matrix)
vectors = self.get_eigvec_0()[:, None]
reduced_vectors = vectors_adjuster.reduce_vectors_to_primitive(
vectors, primitive)
nexpansion = 4
exp = np.array([
[0.5],
[0.0],
[0.0],
])
exp *= np.sqrt(nexpansion)
self.assertTrue(np.all(np.abs(reduced_vectors - exp) < 1e-6))
def get_born_parameters(phonon, born_charges, epsilon, symprec=1e-5):
from phonopy.structure.cells import get_primitive, get_supercell
from phonopy.structure.symmetry import Symmetry
from phonopy.interface import get_default_physical_units
print('inside born parameters')
pmat = phonon.get_primitive_matrix()
smat = phonon.get_supercell_matrix()
ucell = phonon.get_unitcell()
print pmat
print smat
print ucell
num_atom = len(born_charges)
assert num_atom == ucell.get_number_of_atoms(), \
"num_atom %d != len(borns) %d" % (ucell.get_number_of_atoms(),
len(born_charges))
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=True, 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 = born_charges[u_indep_atoms].copy()
factor = get_default_physical_units('vasp')[
'nac_factor'] # born charges in VASP units
born_dict = {
'born': reduced_borns,
'dielectric': epsilon,
'factor': factor
}
print('final born dict', born_dict)
return born_dict
def _build_primitive_cell_ideal(self):
"""
primitive_matrix:
Relative axes of primitive cell to the input unit cell.
Relative axes to the supercell is calculated by:
supercell_matrix^-1 * primitive_matrix
Therefore primitive cell lattice is finally calculated by:
(supercell_lattice * (supercell_matrix)^-1 * primitive_matrix)^T
"""
inv_supercell_matrix = np.linalg.inv(self._supercell_matrix)
if self._primitive_matrix_ideal is None:
trans_mat = inv_supercell_matrix
else:
trans_mat = np.dot(inv_supercell_matrix, self._primitive_matrix_ideal)
self._primitive_ideal = get_primitive(
self._supercell_ideal, trans_mat, self._symprec)
num_satom = self._supercell_ideal.get_number_of_atoms()
num_patom = self._primitive_ideal.get_number_of_atoms()
if abs(num_satom * np.linalg.det(trans_mat) - num_patom) < 0.1:
return True
else:
return False
def _build_primitive_cell(self):
"""
primitive_matrix:
Relative axes of primitive cell to the input unit cell.
Relative axes to the supercell is calculated by:
supercell_matrix^-1 * primitive_matrix
Therefore primitive cell lattice is finally calculated by:
(supercell_lattice * (supercell_matrix)^-1 * primitive_matrix)^T
"""
inv_supercell_matrix = np.linalg.inv(self._supercell_matrix)
if self._primitive_matrix is None:
trans_mat = inv_supercell_matrix
else:
trans_mat = np.dot(inv_supercell_matrix, self._primitive_matrix)
try:
self._primitive = get_primitive(self._supercell, trans_mat,
self._symprec)
except ValueError as err:
print("Creating primitive cell is failed.")
print("PRIMITIVE_AXIS may be incorrectly specified.")
raise
def _build_primitive_cell_ideal(self):
"""
primitive_matrix:
Relative axes of primitive cell to the input unit cell.
Relative axes to the supercell is calculated by:
supercell_matrix^-1 * primitive_matrix
Therefore primitive cell lattice is finally calculated by:
(supercell_lattice * (supercell_matrix)^-1 * primitive_matrix)^T
"""
inv_supercell_matrix = np.linalg.inv(self._supercell_matrix)
if self._primitive_matrix_ideal is None:
trans_mat = inv_supercell_matrix
else:
trans_mat = np.dot(inv_supercell_matrix, self._primitive_matrix_ideal)
self._primitive_ideal = get_primitive(
self._supercell_ideal, trans_mat, self._symprec)
num_satom = self._supercell_ideal.get_number_of_atoms()
num_patom = self._primitive_ideal.get_number_of_atoms()
if abs(num_satom * np.linalg.det(trans_mat) - num_patom) < 0.1:
return True
else:
return False
def test_L1_2(self):
unitcell, unitcell_ideal, primitive_matrix = self.prepare_L1_2()
primitive = get_primitive(unitcell_ideal, primitive_matrix)
self.check(unitcell, primitive)
def setUp(self):
cell = read_cell_yaml(os.path.join(data_dir, "..", "NaCl.yaml"))
self._pcell = get_primitive(cell, [[0, 0.5, 0.5],
[0.5, 0, 0.5],
[0.5, 0.5, 0]])
def get_born_OUTCAR(poscar_filename="POSCAR",
outcar_filename="OUTCAR",
primitive_axis=np.eye(3),
supercell_matrix=np.eye(3, dtype='intc'),
is_symmetry=True,
symmetrize_tensors=False):
ucell = read_vasp(poscar_filename)
scell = get_supercell(ucell, supercell_matrix)
inv_smat = np.linalg.inv(supercell_matrix)
pcell = get_primitive(scell, np.dot(inv_smat, primitive_axis))
u_sym = Symmetry(ucell, is_symmetry=is_symmetry)
p_sym = Symmetry(pcell, is_symmetry=is_symmetry)
lattice = ucell.get_cell().T
outcar = open(outcar_filename)
borns = []
while True:
line = outcar.readline()
if not line:
break
if "NIONS" in line:
num_atom = int(line.split()[11])
if "MACROSCOPIC STATIC DIELECTRIC TENSOR" in line:
epsilon = []
outcar.readline()
epsilon.append([float(x) for x in outcar.readline().split()])
epsilon.append([float(x) for x in outcar.readline().split()])
epsilon.append([float(x) for x in outcar.readline().split()])
if "BORN" in line:
outcar.readline()
line = outcar.readline()
if "ion" in line:
for i in range(num_atom):
born = []
born.append([float(x)
for x in outcar.readline().split()][1:])
born.append([float(x)
for x in outcar.readline().split()][1:])
born.append([float(x)
for x in outcar.readline().split()][1:])
outcar.readline()
borns.append(born)
borns = np.array(borns, dtype='double')
epsilon = np.array(epsilon, dtype='double')
if symmetrize_tensors:
borns_orig = borns.copy()
point_sym = [similarity_transformation(lattice, r)
for r in u_sym.get_pointgroup_operations()]
epsilon = symmetrize_tensor(epsilon, point_sym)
for i in range(num_atom):
z = borns[i]
site_sym = [similarity_transformation(lattice, r)
for r in u_sym.get_site_symmetry(i)]
borns[i] = symmetrize_tensor(z, site_sym)
rotations = u_sym.get_symmetry_operations()['rotations']
map_atoms = u_sym.get_map_atoms()
borns_copy = np.zeros_like(borns)
for i, m_i in enumerate(map_atoms):
count = 0
for j, r_j in enumerate(u_sym.get_map_operations()):
if map_atoms[j] == m_i:
count += 1
r_cart = similarity_transformation(lattice, rotations[r_j])
borns_copy[i] += similarity_transformation(r_cart, borns[j])
borns_copy[i] /= count
borns = borns_copy
sum_born = borns.sum(axis=0) / len(borns)
borns -= sum_born
if (np.abs(borns_orig - borns) > 0.1).any():
sys.stderr.write(
"Born effective charge symmetrization might go wrong.\n")
p2s = np.array(pcell.get_primitive_to_supercell_map(), dtype='intc')
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
def __init__(self,
dynamical_matrix,
unitcell_ideal,
primitive_matrix_ideal,
mesh,
shift=None,
is_time_reversal=True,
is_mesh_symmetry=True,
is_eigenvectors=False,
is_gamma_center=False,
star="none",
group_velocity=None,
rotations=None, # Point group operations in real space
factor=VaspToTHz,
use_lapack_solver=False,
mode="eigenvector"):
self._mesh = np.array(mesh, dtype='intc')
self._is_eigenvectors = is_eigenvectors
self._factor = factor
primitive_ideal_wrt_unitcell = (
get_primitive(unitcell_ideal, primitive_matrix_ideal))
self._cell = primitive_ideal_wrt_unitcell
# ._dynamical_matrix must be assigned for calculating DOS
# using the tetrahedron method.
# In the "DOS", this is used to get "primitive".
# In the "TetrahedronMesh", this is used just as the "Atoms".
# Currently, we must not use the tetrahedron method,
# because now we do not give the primitive but the unitcell for the
# self._dynamical_matrix.
self._dynamical_matrix = dynamical_matrix
self._use_lapack_solver = use_lapack_solver
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._star = star
self._eigenstates_unfolding = Eigenstates(
dynamical_matrix,
unitcell_ideal,
primitive_matrix_ideal,
mode=mode,
star=star,
verbose=False)
self._frequencies = None
self._eigenvalues = None
self._eigenvectors = None
self._set_phonon()
self._group_velocities = None
if group_velocity is not None:
self._set_group_velocities(group_velocity)
def get_primitive_structure(structure, primitive_matrix=np.eye(3)):
from phonopy.structure.cells import get_primitive
return get_primitive(structure, primitive_matrix)
def test_L1_2(self):
unitcell, unitcell_ideal, primitive_matrix = self.prepare_L1_2()
primitive = get_primitive(unitcell_ideal, primitive_matrix)
self.check(unitcell, primitive)
