def set_mesh(self,
mesh,
shift=None,
is_time_reversal=True,
is_mesh_symmetry=True,
is_eigenvectors=False,
is_gamma_center=False,
run_immediately=True):
if self._dynamical_matrix is None:
print("Warning: Dynamical matrix has not yet built.")
self._mesh = None
return False
self._mesh = Mesh(
self._dynamical_matrix,
mesh,
shift=shift,
is_time_reversal=is_time_reversal,
is_mesh_symmetry=is_mesh_symmetry,
is_eigenvectors=is_eigenvectors,
is_gamma_center=is_gamma_center,
group_velocity=self._group_velocity,
rotations=self._primitive_symmetry.get_pointgroup_operations(),
factor=self._factor,
use_lapack_solver=self._use_lapack_solver)
if run_immediately:
self._mesh.run()
return True
def _test_Mesh(ph_nacl):
mesh_obj = Mesh(ph_nacl.dynamical_matrix, [10, 10, 10],
with_eigenvectors=True)
mesh_obj.run()
for i, x in enumerate(mesh_obj):
pass
for j, x in enumerate(mesh_obj):
pass
assert i == j
assert id(mesh_obj.dynamical_matrix) == id(mesh_obj.get_dynamical_matrix())
def testMesh(self):
phonon = self._get_phonon()
mesh_obj = Mesh(phonon.dynamical_matrix, [10, 10, 10],
with_eigenvectors=True)
mesh_obj.run()
for i, x in enumerate(mesh_obj):
pass
for j, x in enumerate(mesh_obj):
pass
assert i == j
self.assertTrue(id(mesh_obj.dynamical_matrix)
== id(mesh_obj.get_dynamical_matrix()))
def testMesh(self):
phonon = self._get_phonon()
mesh_obj = Mesh(phonon.dynamical_matrix, [10, 10, 10],
is_eigenvectors=True)
mesh_obj.run()
for i, x in enumerate(mesh_obj):
pass
for j, x in enumerate(mesh_obj):
pass
assert i == j
self.assertTrue(
id(mesh_obj.dynamical_matrix) == id(
mesh_obj.get_dynamical_matrix()))
def set_mesh(self,
mesh,
shift=None,
is_time_reversal=True,
is_mesh_symmetry=True,
is_eigenvectors=False,
is_gamma_center=False):
if self._dynamical_matrix is None:
print("Warning: Dynamical matrix has not yet built.")
self._mesh = None
return False
self._mesh = Mesh(
self._dynamical_matrix,
mesh,
shift=shift,
is_time_reversal=is_time_reversal,
is_mesh_symmetry=is_mesh_symmetry,
is_eigenvectors=is_eigenvectors,
is_gamma_center=is_gamma_center,
group_velocity=self._group_velocity,
rotations=self._primitive_symmetry.get_pointgroup_operations(),
factor=self._factor,
use_lapack_solver=self._use_lapack_solver)
return True
def set_mesh(self,
mesh,
shift=None,
is_time_reversal=True,
is_mesh_symmetry=True,
is_eigenvectors=False,
is_gamma_center=False):
self._set_dynamical_matrix()
self._mesh = Mesh(
self._dynamical_matrix,
mesh,
shift=shift,
is_time_reversal=is_time_reversal,
is_mesh_symmetry=is_mesh_symmetry,
is_eigenvectors=is_eigenvectors,
is_gamma_center=is_gamma_center,
group_velocity=self._group_velocity,
rotations=self._primitive_symmetry.get_pointgroup_operations(),
factor=self._factor)
def set_mesh(self,
mesh,
shift=None,
is_time_reversal=True,
is_symmetry=True,
is_band_connection=False,
is_eigenvectors=False,
is_gamma_center=False):
self._mesh = Mesh(self._dynamical_matrix,
self._primitive,
mesh,
shift=shift,
is_time_reversal=is_time_reversal,
is_mesh_symmetry=is_symmetry,
is_eigenvectors=is_eigenvectors,
is_band_connection=is_band_connection,
is_gamma_center=is_gamma_center,
group_velocity=self._group_velocity,
factor=self._factor,
symprec=self._symprec)
def set_mesh( self,
mesh,
shift=None,
is_time_reversal=True,
is_symmetry=True,
is_eigenvectors=False ):
self.__mesh = Mesh( self.dynamical_matrix,
self.primitive,
mesh,
shift=shift,
is_time_reversal=is_time_reversal,
is_symmetry=is_symmetry,
is_eigenvectors=is_eigenvectors,
factor=self.factor,
symprec=self.symprec )
def set_mesh(self,
mesh,
shift=None,
is_time_reversal=True,
is_mesh_symmetry=True,
is_eigenvectors=False,
is_gamma_center=False):
self._set_dynamical_matrix()
self._mesh = Mesh(
self._dynamical_matrix,
mesh,
shift=shift,
is_time_reversal=is_time_reversal,
is_mesh_symmetry=is_mesh_symmetry,
is_eigenvectors=is_eigenvectors,
is_gamma_center=is_gamma_center,
group_velocity=self._group_velocity,
rotations=self._primitive_symmetry.get_pointgroup_operations(),
factor=self._factor)
def set_mesh(self,
mesh,
shift=None,
is_time_reversal=True,
is_symmetry=True,
is_band_connection=False,
is_eigenvectors=False,
is_gamma_center=False):
self._mesh = Mesh(self._dynamical_matrix,
self._primitive,
mesh,
shift=shift,
is_time_reversal=is_time_reversal,
is_mesh_symmetry=is_symmetry,
is_eigenvectors=is_eigenvectors,
is_band_connection=is_band_connection,
is_gamma_center=is_gamma_center,
group_velocity=self._group_velocity,
factor=self._factor,
symprec=self._symprec)
class Phonopy:
def __init__(self,
unitcell,
supercell_matrix,
distance=0.01,
factor=VaspToTHz,
is_auto_displacements=True,
symprec=1e-5,
is_symmetry=True,
log_level=0):
self._symprec = symprec
self._unitcell = unitcell
self._supercell_matrix = supercell_matrix
self._factor = factor
self._is_symmetry = is_symmetry
self._log_level = log_level
self._supercell = None
self._set_supercell()
self._symmetry = None
self._set_symmetry()
# set_displacements (used only in preprocess)
self._displacements = None
self._displacement_directions = None
self._supercells_with_displacements = None
if is_auto_displacements:
self.generate_displacements(distance)
# set_post_process
self._primitive = None
self._dynamical_matrix = None
self._is_nac = False
# set_force_constants or set_forces
self._set_of_forces_objects = None
self._force_constants = None
# set_band_structure
self._band_structure = None
# set_mesh
self._mesh = None
# set_thermal_properties
self._thermal_properties = None
# set_thermal_displacements
self._thermal_displacements = None
# set_thermal_displacement_matrices
self._thermal_displacement_matrices = None
# set_partial_DOS
self._pdos = None
# set_total_DOS
self._total_dos = None
# set_modulation
self._modulation = None
# set_character_table
self._irreps = None
# set_group_velocity
self._group_velocity = None
def get_primitive(self):
return self._primitive
primitive = property(get_primitive)
def set_primitive(self, primitive):
self._primitive = primitive
def get_unitcell(self):
return self._unitcell
unitcell = property(get_unitcell)
def get_supercell(self):
return self._supercell
supercell = property(get_supercell)
def set_supercell(self, supercell):
self._supercell = supercell
def get_symmetry(self):
return self._symmetry
symmetry = property(get_symmetry)
def get_unit_conversion_factor(self):
return self._factor
unit_conversion_factor = property(get_unit_conversion_factor)
def generate_displacements(self,
distance=0.01,
is_plusminus='auto',
is_diagonal=True,
is_trigonal=False):
"""Generate displacements automatically
displacements:
List of displacements in Cartesian coordinates.
See 'set_displacements'
displacement_directions:
List of directions with respect to axes. This gives only the
symmetrically non equivalent directions. The format is like:
[[0, 1, 0, 0],
[7, 1, 0, 1], ...]
where each list is defined by:
First value: Atom index in supercell starting with 0
Second to fourth: If the direction is displaced or not ( 1, 0, or -1 )
with respect to the axes.
"""
lattice = self._supercell.get_cell()
self._displacements = []
self._displacement_directions = \
get_least_displacements(self._symmetry,
is_plusminus=is_plusminus,
is_diagonal=is_diagonal,
is_trigonal=is_trigonal,
log_level=self._log_level)
for disp in self._displacement_directions:
atom_num = disp[0]
disp_cartesian = np.dot(disp[1:], lattice)
disp_cartesian *= distance / np.linalg.norm(disp_cartesian)
self._displacements.append([
atom_num, disp_cartesian[0], disp_cartesian[1],
disp_cartesian[2]
])
self._set_supercells_with_displacements()
def set_displacements(self, displacements):
"""Set displacements manually
displacemsts: List of disctionaries
[[0, 0.01, 0.00, 0.00], ...]
where each set of elements is defined by:
First value: Atom index in supercell starting with 0
Second to fourth: Displacement in Cartesian coordinates
"""
self._displacements = displacements
self._set_supercells_with_displacements()
def get_displacements(self):
return self._displacements
displacements = property(get_displacements)
def get_displacement_directions(self):
return self._displacement_directions
displacement_directions = property(get_displacement_directions)
def get_supercells_with_displacements(self):
return self._supercells_with_displacements
def set_post_process(self,
primitive_matrix=np.eye(3, dtype=float),
sets_of_forces=None,
set_of_forces_objects=None,
force_constants=None,
is_nac=False,
calculate_full_force_constants=False,
force_constants_decimals=None,
dynamical_matrix_decimals=None):
"""
Set forces or force constants to prepare phonon calculations.
The order of 'sets_of_forces' has to correspond to that of
'displacements' that should be already stored.
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
sets_of_forces:
[[[f_1x, f_1y, f_1z], [f_2x, f_2y, f_2z], ...], # first supercell
[[f_1x, f_1y, f_1z], [f_2x, f_2y, f_2z], ...], # second supercell
... ]
set_of_forces_objects:
[FORCES_object, FORCES_object, FORCES_object, ...]
"""
self._is_nac = is_nac
# Primitive cell
inv_supercell_matrix = np.linalg.inv(self._supercell_matrix)
self._primitive = Primitive(
self._supercell, np.dot(inv_supercell_matrix, primitive_matrix),
self._symprec)
# Set set of FORCES objects or force constants
if sets_of_forces is not None:
self.set_forces(sets_of_forces)
elif set_of_forces_objects is not None:
self.set_force_sets(set_of_forces_objects)
elif force_constants is not None:
self.set_force_constants(force_constants)
# Calculate force cosntants from forces (full or symmetry reduced)
if self._set_of_forces_objects is not None:
if calculate_full_force_constants:
self.set_force_constants_from_forces(
distributed_atom_list=None,
force_constants_decimals=force_constants_decimals)
else:
p2s_map = self._primitive.get_primitive_to_supercell_map()
self.set_force_constants_from_forces(
distributed_atom_list=p2s_map,
force_constants_decimals=force_constants_decimals)
if self._force_constants is None:
print "In set_post_process, sets_of_forces or force_constants"
print "has to be set."
return False
# Dynamical Matrix
self.set_dynamical_matrix(decimals=dynamical_matrix_decimals)
def set_nac_params(self, nac_params, method='wang'):
if self._is_nac:
self._dynamical_matrix.set_nac_params(nac_params, method)
def set_dynamical_matrix(self, decimals=None):
if self._is_nac:
self._dynamical_matrix = \
DynamicalMatrixNAC(self._supercell,
self._primitive,
self._force_constants,
decimals=decimals,
symprec=self._symprec)
else:
self._dynamical_matrix = \
DynamicalMatrix(self._supercell,
self._primitive,
self._force_constants,
decimals=decimals,
symprec=self._symprec)
def get_dynamical_matrix(self):
return self._dynamical_matrix
dynamical_matrix = property(get_dynamical_matrix)
def set_forces(self, sets_of_forces):
forces = []
for i, disp in enumerate(self._displacements):
forces.append(Forces(disp[0], disp[1:4], sets_of_forces[i]))
self._set_of_forces_objects = forces
def set_force_constants_from_forces(self,
distributed_atom_list=None,
force_constants_decimals=None):
self._force_constants = get_force_constants(
self._set_of_forces_objects,
self._symmetry,
self._supercell,
atom_list=distributed_atom_list,
decimals=force_constants_decimals)
def set_force_constants_zero_with_radius(self, cutoff_radius):
cutoff_force_constants(self._force_constants,
self._supercell,
cutoff_radius,
symprec=self._symprec)
def set_force_constants(self, force_constants):
self._force_constants = force_constants
def set_force_sets(self, sets_of_forces_objects):
self._set_of_forces_objects = sets_of_forces_objects
def symmetrize_force_constants(self, iteration=3):
symmetrize_force_constants(self._force_constants, iteration)
def get_force_constants(self):
return self._force_constants
force_constants = property(get_force_constants)
def get_rotational_condition_of_fc(self):
return rotational_invariance(self._force_constants, self._supercell,
self._primitive, self._symprec)
def get_dynamical_matrix_at_q(self, q):
self._dynamical_matrix.set_dynamical_matrix(q)
return self._dynamical_matrix.get_dynamical_matrix()
# Frequency at a q-point
def get_frequencies(self, q):
"""
Calculate phonon frequencies at q
q: q-vector in reduced coordinates of primitive cell
"""
self._dynamical_matrix.set_dynamical_matrix(q)
dm = self._dynamical_matrix.get_dynamical_matrix()
frequencies = []
for eig in np.linalg.eigvalsh(dm).real:
if eig < 0:
frequencies.append(-np.sqrt(-eig))
else:
frequencies.append(np.sqrt(eig))
return np.array(frequencies) * self._factor
# Frequency and eigenvector at a q-point
def get_frequencies_with_eigenvectors(self, q):
"""
Calculate phonon frequencies and eigenvectors at q
q: q-vector in reduced coordinates of primitive cell
"""
self._dynamical_matrix.set_dynamical_matrix(q)
dm = self._dynamical_matrix.get_dynamical_matrix()
frequencies = []
eigvals, eigenvectors = np.linalg.eigh(dm)
frequencies = []
for eig in eigvals:
if eig < 0:
frequencies.append(-np.sqrt(-eig))
else:
frequencies.append(np.sqrt(eig))
return np.array(frequencies) * self._factor, eigenvectors
## This expression may not be supported in old python versions.
# frequencies = np.array(
# [np.sqrt(x) if x > 0 else -np.sqrt(-x) for x in eigvals])
# return frequencies * self._factor, eigenvectors
# Band structure
def set_band_structure(self,
bands,
is_eigenvectors=False,
is_band_connection=False):
self._band_structure = BandStructure(
bands,
self._dynamical_matrix,
self._primitive,
is_eigenvectors=is_eigenvectors,
is_band_connection=is_band_connection,
group_velocity=self._group_velocity,
factor=self._factor)
def get_band_structure(self):
band = self._band_structure
return (band.get_qpoints(), band.get_distances(),
band.get_frequencies(), band.get_eigenvectors())
def plot_band_structure(self, symbols=None):
return self._band_structure.plot_band(symbols)
def write_yaml_band_structure(self):
self._band_structure.write_yaml()
# Mesh sampling
def set_mesh(self,
mesh,
shift=None,
is_time_reversal=True,
is_symmetry=True,
is_band_connection=False,
is_eigenvectors=False,
is_gamma_center=False):
self._mesh = Mesh(self._dynamical_matrix,
self._primitive,
mesh,
shift=shift,
is_time_reversal=is_time_reversal,
is_mesh_symmetry=is_symmetry,
is_eigenvectors=is_eigenvectors,
is_band_connection=is_band_connection,
is_gamma_center=is_gamma_center,
group_velocity=self._group_velocity,
factor=self._factor,
symprec=self._symprec)
def get_mesh(self):
return (self._mesh.get_qpoints(), self._mesh.get_weights(),
self._mesh.get_frequencies(), self._mesh.get_eigenvectors())
def write_yaml_mesh(self):
self._mesh.write_yaml()
def write_hdf5_mesh(self):
self._mesh.write_hdf5()
# Thermal property
def set_thermal_properties(self,
t_step=10,
t_max=1000,
t_min=0,
is_projection=False,
cutoff_frequency=None):
if self._mesh == None:
print "set_mesh has to be done before set_thermal_properties"
sys.exit(1)
tp = ThermalProperties(self._mesh.get_frequencies(),
weights=self._mesh.get_weights(),
eigenvectors=self._mesh.get_eigenvectors(),
is_projection=is_projection,
cutoff_frequency=cutoff_frequency)
tp.set_thermal_properties(t_step, t_max, t_min)
self._thermal_properties = tp
def get_thermal_properties(self):
temps, fe, entropy, cv = \
self._thermal_properties.get_thermal_properties()
return temps, fe, entropy, cv
def plot_thermal_properties(self):
return self._thermal_properties.plot_thermal_properties()
def write_yaml_thermal_properties(self,
filename='thermal_properties.yaml'):
self._thermal_properties.write_yaml(filename=filename)
# Partial DOS
def set_partial_DOS(self,
sigma=None,
omega_min=None,
omega_max=None,
omega_pitch=None,
tetrahedron_method=False):
if self._mesh == None:
print "set_mesh has to be done before set_thermal_properties"
sys.exit(1)
if self._mesh.get_eigenvectors() == None:
print "Eigenvectors have to be calculated."
sys.exit(1)
pdos = PartialDos(self._mesh,
sigma=sigma,
tetrahedron_method=tetrahedron_method)
pdos.set_draw_area(omega_min, omega_max, omega_pitch)
pdos.calculate()
self._pdos = pdos
def get_partial_DOS(self):
"""
Retern omegas and partial_dos.
The first element is omegas and the second is partial_dos.
omegas: [freq1, freq2, ...]
partial_dos:
[[elem1-freq1, elem1-freq2, ...],
[elem2-freq1, elem2-freq2, ...],
...]
where
elem1: atom1-x compornent
elem2: atom1-y compornent
elem3: atom1-z compornent
elem4: atom2-x compornent
...
"""
return self._pdos.get_partial_dos()
def plot_partial_DOS(self, pdos_indices=None, legend=None):
return self._pdos.plot_pdos(indices=pdos_indices, legend=legend)
def write_partial_DOS(self):
self._pdos.write()
# Total DOS
def set_total_DOS(self,
sigma=None,
omega_min=None,
omega_max=None,
omega_pitch=None,
tetrahedron_method=False):
if self._mesh == None:
print "set_mesh has to be done before set_thermal_properties"
sys.exit(1)
total_dos = TotalDos(self._mesh,
sigma=sigma,
tetrahedron_method=tetrahedron_method)
total_dos.set_draw_area(omega_min, omega_max, omega_pitch)
total_dos.calculate()
self._total_dos = total_dos
def get_total_DOS(self):
"""
Retern omegas and total dos.
The first element is omegas and the second is total dos.
omegas: [freq1, freq2, ...]
total_dos: [dos1, dos2, ...]
"""
return self._total_dos.get_dos()
def set_Debye_frequency(self, freq_max_fit=None):
self._total_dos.set_Debye_frequency(
self._primitive.get_number_of_atoms(), freq_max_fit)
def get_Debye_frequency(self):
return self._total_dos.get_Debye_frequency()
def plot_total_DOS(self):
return self._total_dos.plot_dos()
def write_total_DOS(self):
self._total_dos.write()
# Thermal displacement
def set_thermal_displacements(self,
t_step=10,
t_max=1000,
t_min=0,
direction=None,
cutoff_eigenvalue=None):
"""
cutoff_eigenvalue:
phonon modes that have frequencies below cutoff_eigenvalue
are ignored.
e.g. 0.1 (THz^2)
direction:
Projection direction in reduced coordinates
"""
if self._mesh == None:
print "set_mesh has to be done before set_thermal_properties"
sys.exit(1)
eigvecs = self._mesh.get_eigenvectors()
frequencies = self._mesh.get_frequencies()
mesh_nums = self._mesh.get_mesh_numbers()
if self._mesh.get_eigenvectors() is None:
print "Eigenvectors have to be calculated."
sys.exit(1)
if np.prod(mesh_nums) != len(eigvecs):
print "Sampling mesh must not be symmetrized."
sys.exit(1)
td = ThermalDisplacements(frequencies,
eigvecs,
self._primitive.get_masses(),
cutoff_eigenvalue=cutoff_eigenvalue)
td.set_temperature_range(t_min, t_max, t_step)
if direction is not None:
td.project_eigenvectors(direction, self._primitive.get_cell())
# td.run()
td.run_mesh()
self._thermal_displacements = td
def get_thermal_displacements(self):
if self._thermal_displacements is not None:
return self._thermal_displacements.get_thermal_displacements()
def plot_thermal_displacements(self, is_legend=False):
return self._thermal_displacements.plot(is_legend)
def write_yaml_thermal_displacements(self):
self._thermal_displacements.write_yaml()
def write_hdf5_thermal_displacements(self):
self._thermal_displacements.write_hdf5()
# Thermal displacement matrices
def set_thermal_displacement_matrices(self,
t_step=10,
t_max=1000,
t_min=0,
cutoff_eigenvalue=None):
"""
cutoff_eigenvalue:
phonon modes that have frequencies below cutoff_eigenvalue
are ignored.
e.g. 0.1 (THz^2)
direction:
Projection direction in reduced coordinates
"""
if self._mesh == None:
print "set_mesh has to be done before set_thermal_properties"
sys.exit(1)
eigvecs = self._mesh.get_eigenvectors()
frequencies = self._mesh.get_frequencies()
mesh_nums = self._mesh.get_mesh_numbers()
if self._mesh.get_eigenvectors() is None:
print "Eigenvectors have to be calculated."
sys.exit(1)
if np.prod(mesh_nums) != len(eigvecs):
print "Sampling mesh must not be symmetrized."
sys.exit(1)
tdm = ThermalDisplacementMatrices(frequencies,
eigvecs,
self._primitive.get_masses(),
cutoff_eigenvalue=cutoff_eigenvalue)
tdm.set_temperature_range(t_min, t_max, t_step)
# tdm.run()
tdm.run_mesh()
self._thermal_displacement_matrices = tdm
def get_thermal_displacement_matrices(self):
if self._thermal_displacement_matrices is not None:
return self._thermal_displacement_matrices.get_thermal_displacement_matrices(
)
def write_yaml_thermal_displacement_matrices(self):
self._thermal_displacement_matrices.write_yaml()
def write_hdf5_thermal_displacement_matrices(self):
self._thermal_displacement_matrices.write_hdf5()
# Thermal displacement
def set_thermal_distances(self,
atom_pairs,
t_step=10,
t_max=1000,
t_min=0,
cutoff_eigenvalue=None):
"""
atom_pairs: List of list
Mean square distances are calculated for the atom_pairs
e.g. [[1, 2], [1, 4]]
cutoff_eigenvalue:
phonon modes that have frequencies below cutoff_eigenvalue
are ignored.
e.g. 0.1 (THz^2)
"""
td = ThermalDistances(self._mesh.get_frequencies(),
self._mesh.get_eigenvectors(),
self._supercell,
self._primitive,
self._mesh.get_qpoints(),
symprec=self._symprec,
cutoff_eigenvalue=cutoff_eigenvalue)
td.set_temperature_range(t_min, t_max, t_step)
# td.run(atom_pairs)
td.run_mesh(atom_pairs)
self._thermal_distances = td
def write_yaml_thermal_distances(self):
self._thermal_distances.write_yaml()
def write_hdf5_thermal_distances(self):
self._thermal_distances.write_hdf5()
# Q-points mode
def write_yaml_qpoints(self,
q_points,
nac_q_direction=None,
is_eigenvectors=False,
write_dynamical_matrices=False,
factor=VaspToTHz):
write_yaml_qpoints(q_points,
self._primitive,
self._dynamical_matrix,
nac_q_direction=nac_q_direction,
is_eigenvectors=is_eigenvectors,
group_velocity=self._group_velocity,
write_dynamical_matrices=write_dynamical_matrices,
factor=self._factor)
# Animation
def write_animation(self,
q_point=None,
anime_type='v_sim',
band_index=None,
amplitude=None,
num_div=None,
shift=None,
filename=None):
if q_point == None:
animation = Animation([0, 0, 0],
self._dynamical_matrix,
self._primitive,
shift=shift)
else:
animation = Animation(q_point,
self._dynamical_matrix,
self._primitive,
shift=shift)
if anime_type == 'v_sim':
if amplitude:
amplitude_ = amplitude
else:
amplitude_ = 1.0
if filename:
animation.write_v_sim(amplitude=amplitude_,
factor=self._factor,
filename=filename)
else:
animation.write_v_sim(amplitude=amplitude_,
factor=self._factor)
if (anime_type == 'arc' or anime_type == 'xyz' or anime_type == 'jmol'
or anime_type == 'poscar'):
if band_index == None or amplitude == None or num_div == None:
print "Parameters are not correctly set for animation."
sys.exit(1)
if anime_type == 'arc' or anime_type == None:
if filename:
animation.write_arc(band_index,
amplitude,
num_div,
filename=filename)
else:
animation.write_arc(band_index, amplitude, num_div)
if anime_type == 'xyz':
if filename:
animation.write_xyz(band_index,
amplitude,
num_div,
self._factor,
filename=filename)
else:
animation.write_xyz(band_index, amplitude, num_div,
self._factor)
if anime_type == 'jmol':
if filename:
animation.write_xyz_jmol(amplitude=amplitude,
factor=self._factor,
filename=filename)
else:
animation.write_xyz_jmol(amplitude=amplitude,
factor=self._factor)
if anime_type == 'poscar':
if filename:
animation.write_POSCAR(band_index,
amplitude,
num_div,
filename=filename)
else:
animation.write_POSCAR(band_index, amplitude, num_div)
# Modulation
def set_modulations(self,
dimension,
phonon_modes,
delta_q=None,
derivative_order=None,
nac_q_direction=None):
self._modulation = Modulation(self._dynamical_matrix,
self._primitive,
dimension=dimension,
phonon_modes=phonon_modes,
delta_q=delta_q,
derivative_order=derivative_order,
nac_q_direction=nac_q_direction,
factor=self._factor)
self._modulation.run()
def get_modulations(self):
"""Returns cells with modulations as Atoms objects"""
return self._modulation.get_modulations()
def get_delta_modulations(self):
"""Return modulations relative to equilibrium supercell
(modulations, supercell)
modulations: Atomic modulations of supercell in Cartesian coordinates
supercell: Supercell as an Atoms object.
"""
return self._modulation.get_delta_modulations()
def write_modulations(self):
"""Create MPOSCAR's"""
self._modulation.write()
def write_yaml_modulations(self):
self._modulation.write_yaml()
# Characters of irreducible representations
def set_irreps(self, q, degeneracy_tolerance=1e-4):
self._irreps = IrReps(self._dynamical_matrix,
q,
factor=self._factor,
symprec=self._symprec,
degeneracy_tolerance=degeneracy_tolerance,
log_level=self._log_level)
return self._irreps.run()
def get_irreps(self):
return self._irreps
def show_irreps(self, show_irreps=False):
self._irreps.show(show_irreps=show_irreps)
def write_yaml_irreps(self, show_irreps=False):
self._irreps.write_yaml(show_irreps=show_irreps)
# Group velocity
def set_group_velocity(self, q_points=None, q_length=1e-4):
self._group_velocity = GroupVelocity(
self._dynamical_matrix,
q_points=q_points,
symmetry=self._symmetry,
q_length=q_length,
frequency_factor_to_THz=self._factor)
def get_group_velocity(self, q_point):
self._group_velocity.set_q_points([q_point])
return self._group_velocity.get_group_velocity()[0]
def _set_supercell(self):
self._supercell = get_supercell(self._unitcell, self._supercell_matrix,
self._symprec)
def _set_symmetry(self):
self._symmetry = Symmetry(self._supercell, self._symprec,
self._is_symmetry)
def _set_supercells_with_displacements(self):
supercells = []
for disp in self._displacements:
positions = self._supercell.get_positions()
positions[disp[0]] += disp[1:4]
supercells.append(
Atoms(numbers=self._supercell.get_atomic_numbers(),
masses=self._supercell.get_masses(),
magmoms=self._supercell.get_magnetic_moments(),
positions=positions,
cell=self._supercell.get_cell(),
pbc=True))
self._supercells_with_displacements = supercells
class Phonopy:
def __init__(self,
unitcell,
supercell_matrix,
primitive_matrix=None,
nac_params=None,
distance=0.01,
factor=VaspToTHz,
is_auto_displacements=True,
dynamical_matrix_decimals=None,
force_constants_decimals=None,
symprec=1e-5,
is_symmetry=True,
log_level=0):
self._symprec = symprec
self._factor = factor
self._is_symmetry = is_symmetry
self._log_level = log_level
# Create supercell and primitive cell
self._unitcell = unitcell
self._supercell_matrix = supercell_matrix
self._primitive_matrix = primitive_matrix
self._supercell = None
self._primitive = None
self._build_supercell()
self._build_primitive_cell()
# Set supercell and primitive symmetry
self._symmetry = None
self._primitive_symmetry = None
self._search_symmetry()
self._search_primitive_symmetry()
# set_displacements (used only in preprocess)
self._displacement_dataset = None
self._displacements = None
self._displacement_directions = None
self._supercells_with_displacements = None
if is_auto_displacements:
self.generate_displacements(distance=distance)
# set_force_constants or set_forces
self._force_constants = None
self._force_constants_decimals = force_constants_decimals
# set_dynamical_matrix
self._dynamical_matrix = None
self._nac_params = nac_params
self._dynamical_matrix_decimals = dynamical_matrix_decimals
# set_band_structure
self._band_structure = None
# set_mesh
self._mesh = None
# set_tetrahedron_method
self._tetrahedron_method = None
# set_thermal_properties
self._thermal_properties = None
# set_thermal_displacements
self._thermal_displacements = None
# set_thermal_displacement_matrices
self._thermal_displacement_matrices = None
# set_partial_DOS
self._pdos = None
# set_total_DOS
self._total_dos = None
# set_modulation
self._modulation = None
# set_character_table
self._irreps = None
# set_group_velocity
self._group_velocity = None
def set_post_process(self,
primitive_matrix=None,
sets_of_forces=None,
displacement_dataset=None,
force_constants=None,
is_nac=None):
print
print ("********************************** Warning"
"**********************************")
print "set_post_process will be obsolete."
print (" produce_force_constants is used instead of set_post_process"
" for producing")
print (" force constants from forces.")
if primitive_matrix is not None:
print (" primitive_matrix has to be given at Phonopy::__init__"
" object creation.")
print ("******************************************"
"**********************************")
print
if primitive_matrix is not None:
self._primitive_matrix = primitive_matrix
self._build_primitive_cell()
self._search_primitive_symmetry()
if sets_of_forces is not None:
self.set_forces(sets_of_forces)
elif displacement_dataset is not None:
self._displacement_dataset = displacement_dataset
elif force_constants is not None:
self.set_force_constants(force_constants)
if self._displacement_dataset is not None:
self.produce_force_constants()
def set_masses(self, masses):
p_masses = np.array(masses)
self._primitive.set_masses(p_masses)
p2p_map = self._primitive.get_primitive_to_primitive_map()
s_masses = p_masses[[p2p_map[x] for x in
self._primitive.get_supercell_to_primitive_map()]]
self._supercell.set_masses(s_masses)
u2s_map = self._supercell.get_unitcell_to_supercell_map()
u_masses = s_masses[u2s_map]
self._unitcell.set_masses(u_masses)
def get_primitive(self):
return self._primitive
primitive = property(get_primitive)
def get_unitcell(self):
return self._unitcell
unitcell = property(get_unitcell)
def get_supercell(self):
return self._supercell
supercell = property(get_supercell)
def set_supercell(self, supercell):
self._supercell = supercell
def get_symmetry(self):
"""return symmetry of supercell"""
return self._symmetry
symmetry = property(get_symmetry)
def get_primitive_symmetry(self):
"""return symmetry of primitive cell"""
return self._primitive_symmetry
def get_unit_conversion_factor(self):
return self._factor
unit_conversion_factor = property(get_unit_conversion_factor)
def produce_force_constants(self,
forces=None,
calculate_full_force_constants=True,
computation_algorithm="svd"):
if forces is not None:
self.set_forces(forces)
if calculate_full_force_constants:
self._run_force_constants_from_forces(
decimals=self._force_constants_decimals,
computation_algorithm=computation_algorithm)
else:
p2s_map = self._primitive.get_primitive_to_supercell_map()
self._run_force_constants_from_forces(
distributed_atom_list=p2s_map,
decimals=self._force_constants_decimals,
computation_algorithm=computation_algorithm)
def set_nac_params(self, nac_params=None, method=None):
if method is not None:
print "set_nac_params:"
print " Keyword argument of \"method\" is not more supported."
self._nac_params = nac_params
def generate_displacements(self,
distance=0.01,
is_plusminus='auto',
is_diagonal=True,
is_trigonal=False):
"""Generate displacements automatically
displacemsts: List of displacements in Cartesian coordinates.
[[0, 0.01, 0.00, 0.00], ...]
where each set of elements is defined by:
First value: Atom index in supercell starting with 0
Second to fourth: Displacement in Cartesian coordinates
displacement_directions:
List of directions with respect to axes. This gives only the
symmetrically non equivalent directions. The format is like:
[[0, 1, 0, 0],
[7, 1, 0, 1], ...]
where each list is defined by:
First value: Atom index in supercell starting with 0
Second to fourth: If the direction is displaced or not ( 1, 0, or -1 )
with respect to the axes.
"""
displacement_directions = get_least_displacements(
self._symmetry,
is_plusminus=is_plusminus,
is_diagonal=is_diagonal,
is_trigonal=is_trigonal,
log_level=self._log_level)
displacement_dataset = direction_to_displacement(
displacement_directions,
distance,
self._supercell)
self.set_displacement_dataset(displacement_dataset)
def set_displacements(self, displacements):
print
print ("********************************** Warning"
"**********************************")
print "set_displacements is obsolete. Do nothing."
print ("******************************************"
"**********************************")
print
def get_displacements(self):
return self._displacements
displacements = property(get_displacements)
def get_displacement_directions(self):
return self._displacement_directions
displacement_directions = property(get_displacement_directions)
def get_displacement_dataset(self):
return self._displacement_dataset
def get_supercells_with_displacements(self):
if self._displacement_dataset is None:
return None
else:
self._build_supercells_with_displacements()
return self._supercells_with_displacements
def get_dynamical_matrix(self):
return self._dynamical_matrix
dynamical_matrix = property(get_dynamical_matrix)
def set_forces(self, sets_of_forces):
"""
sets_of_forces:
[[[f_1x, f_1y, f_1z], [f_2x, f_2y, f_2z], ...], # first supercell
[[f_1x, f_1y, f_1z], [f_2x, f_2y, f_2z], ...], # second supercell
... ]
"""
for disp, forces in zip(
self._displacement_dataset['first_atoms'], sets_of_forces):
disp['forces'] = forces
def set_force_constants_zero_with_radius(self, cutoff_radius):
cutoff_force_constants(self._force_constants,
self._supercell,
cutoff_radius,
symprec=self._symprec)
def set_force_constants(self, force_constants):
self._force_constants = force_constants
def set_force_sets(self, force_sets):
print
print ("********************************** Warning"
"**********************************")
print "set_force_sets will be obsolete."
print (" The method name is changed to set_displacement_dataset.")
print ("******************************************"
"**********************************")
print
self.set_displacement_dataset(force_sets)
def set_displacement_dataset(self, displacement_dataset):
"""
displacement_dataset:
{'natom': number_of_atoms_in_supercell,
'first_atoms': [
{'number': atom index of displaced atom,
'displacement': displacement in Cartesian coordinates,
'direction': displacement direction with respect to axes
'forces': forces on atoms in supercell},
{...}, ...]}
"""
self._displacement_dataset = displacement_dataset
self._displacements = []
self._displacement_directions = []
for disp in self._displacement_dataset['first_atoms']:
x = disp['displacement']
self._displacements.append([disp['number'], x[0], x[1], x[2]])
if 'direction' in disp:
y = disp['direction']
self._displacement_directions.append(
[disp['number'], y[0], y[1], y[2]])
if not self._displacement_directions:
self._displacement_directions = None
def symmetrize_force_constants(self, iteration=3):
symmetrize_force_constants(self._force_constants, iteration)
def symmetrize_force_constants_by_space_group(self):
rotations = self._symmetry.get_symmetry_operations()['rotations']
translations = self._symmetry.get_symmetry_operations()['translations']
set_tensor_symmetry(self._force_constants,
self._supercell.get_cell().T,
self._supercell.get_scaled_positions(),
rotations,
translations,
self._symprec)
def get_force_constants(self):
return self._force_constants
force_constants = property(get_force_constants)
def get_rotational_condition_of_fc(self):
return rotational_invariance(self._force_constants,
self._supercell,
self._primitive,
self._symprec)
def set_dynamical_matrix(self):
self._set_dynamical_matrix()
def get_dynamical_matrix_at_q(self, q):
self._set_dynamical_matrix()
self._dynamical_matrix.set_dynamical_matrix(q)
return self._dynamical_matrix.get_dynamical_matrix()
def get_frequencies(self, q):
"""
Calculate phonon frequencies at q
q: q-vector in reduced coordinates of primitive cell
"""
self._set_dynamical_matrix()
self._dynamical_matrix.set_dynamical_matrix(q)
dm = self._dynamical_matrix.get_dynamical_matrix()
frequencies = []
for eig in np.linalg.eigvalsh(dm).real:
if eig < 0:
frequencies.append(-np.sqrt(-eig))
else:
frequencies.append(np.sqrt(eig))
return np.array(frequencies) * self._factor
def get_frequencies_with_eigenvectors(self, q):
"""
Calculate phonon frequencies and eigenvectors at q
q: q-vector in reduced coordinates of primitive cell
"""
self._set_dynamical_matrix()
self._dynamical_matrix.set_dynamical_matrix(q)
dm = self._dynamical_matrix.get_dynamical_matrix()
frequencies = []
eigvals, eigenvectors = np.linalg.eigh(dm)
frequencies = []
for eig in eigvals:
if eig < 0:
frequencies.append(-np.sqrt(-eig))
else:
frequencies.append(np.sqrt(eig))
return np.array(frequencies) * self._factor, eigenvectors
def set_band_structure(self,
bands,
is_eigenvectors=False,
is_band_connection=False):
self._set_dynamical_matrix()
self._band_structure = BandStructure(
bands,
self._dynamical_matrix,
is_eigenvectors=is_eigenvectors,
is_band_connection=is_band_connection,
group_velocity=self._group_velocity,
factor=self._factor)
def get_band_structure(self):
band = self._band_structure
return (band.get_qpoints(),
band.get_distances(),
band.get_frequencies(),
band.get_eigenvectors())
def plot_band_structure(self, symbols=None):
return self._band_structure.plot_band(symbols)
def write_yaml_band_structure(self):
self._band_structure.write_yaml()
def set_mesh(self,
mesh,
shift=None,
is_time_reversal=True,
is_mesh_symmetry=True,
is_eigenvectors=False,
is_gamma_center=False):
self._set_dynamical_matrix()
self._mesh = Mesh(
self._dynamical_matrix,
mesh,
shift=shift,
is_time_reversal=is_time_reversal,
is_mesh_symmetry=is_mesh_symmetry,
is_eigenvectors=is_eigenvectors,
is_gamma_center=is_gamma_center,
group_velocity=self._group_velocity,
rotations=self._primitive_symmetry.get_pointgroup_operations(),
factor=self._factor)
def get_mesh(self):
return (self._mesh.get_qpoints(),
self._mesh.get_weights(),
self._mesh.get_frequencies(),
self._mesh.get_eigenvectors())
def write_yaml_mesh(self):
self._mesh.write_yaml()
def set_thermal_properties(self,
t_step=10,
t_max=1000,
t_min=0,
is_projection=False,
band_indices=None,
cutoff_frequency=None):
if self._mesh is None:
print "set_mesh has to be done before set_thermal_properties"
return False
else:
tp = ThermalProperties(self._mesh.get_frequencies(),
weights=self._mesh.get_weights(),
eigenvectors=self._mesh.get_eigenvectors(),
is_projection=is_projection,
band_indices=band_indices,
cutoff_frequency=cutoff_frequency)
tp.set_thermal_properties(t_step=t_step,
t_max=t_max,
t_min=t_min)
self._thermal_properties = tp
def get_thermal_properties(self):
temps, fe, entropy, cv = \
self._thermal_properties.get_thermal_properties()
return temps, fe, entropy, cv
def plot_thermal_properties(self):
return self._thermal_properties.plot_thermal_properties()
def write_yaml_thermal_properties(self, filename='thermal_properties.yaml'):
self._thermal_properties.write_yaml(filename=filename)
def set_partial_DOS(self,
sigma=None,
freq_min=None,
freq_max=None,
freq_pitch=None,
tetrahedron_method=False,
direction=None):
if self._mesh is None:
print "set_mesh has to be done before set_thermal_properties"
sys.exit(1)
if self._mesh.get_eigenvectors() is None:
print "Eigenvectors have to be calculated."
sys.exit(1)
if direction is not None:
direction_cart = np.dot(direction, self._primitive.get_cell())
else:
direction_cart = None
pdos = PartialDos(self._mesh,
sigma=sigma,
tetrahedron_method=tetrahedron_method,
direction=direction_cart)
pdos.set_draw_area(freq_min, freq_max, freq_pitch)
pdos.run()
self._pdos = pdos
def get_partial_DOS(self):
"""
Retern frequencies and partial_dos.
The first element is freqs and the second is partial_dos.
frequencies: [freq1, freq2, ...]
partial_dos:
[[atom1-freq1, atom1-freq2, ...],
[atom2-freq1, atom2-freq2, ...],
...]
"""
return self._pdos.get_partial_dos()
def plot_partial_DOS(self, pdos_indices=None, legend=None):
return self._pdos.plot_pdos(indices=pdos_indices,
legend=legend)
def write_partial_DOS(self):
self._pdos.write()
def set_total_DOS(self,
sigma=None,
freq_min=None,
freq_max=None,
freq_pitch=None,
tetrahedron_method=False):
if self._mesh is None:
print "set_mesh has to be done before set_thermal_properties"
sys.exit(1)
total_dos = TotalDos(self._mesh,
sigma=sigma,
tetrahedron_method=tetrahedron_method)
total_dos.set_draw_area(freq_min, freq_max, freq_pitch)
total_dos.run()
self._total_dos = total_dos
def get_total_DOS(self):
"""
Retern frequencies and total dos.
The first element is freqs and the second is total dos.
frequencies: [freq1, freq2, ...]
total_dos: [dos1, dos2, ...]
"""
return self._total_dos.get_dos()
def set_Debye_frequency(self, freq_max_fit=None):
self._total_dos.set_Debye_frequency(
self._primitive.get_number_of_atoms(),
freq_max_fit=freq_max_fit)
def get_Debye_frequency(self):
return self._total_dos.get_Debye_frequency()
def plot_total_DOS(self):
return self._total_dos.plot_dos()
def write_total_DOS(self):
self._total_dos.write()
def set_thermal_displacements(self,
t_step=10,
t_max=1000,
t_min=0,
direction=None,
cutoff_frequency=None):
"""
cutoff_frequency:
phonon modes that have frequencies below cutoff_frequency
are ignored.
direction:
Projection direction in reduced coordinates
"""
if self._mesh is None:
print "set_mesh has to be done before set_thermal_properties"
sys.exit(1)
eigvecs = self._mesh.get_eigenvectors()
frequencies = self._mesh.get_frequencies()
mesh_nums = self._mesh.get_mesh_numbers()
if self._mesh.get_eigenvectors() is None:
print "Eigenvectors have to be calculated."
sys.exit(1)
if np.prod(mesh_nums) != len(eigvecs):
print "Sampling mesh must not be symmetrized."
sys.exit(1)
td = ThermalDisplacements(frequencies,
eigvecs,
self._primitive.get_masses(),
cutoff_frequency=cutoff_frequency)
td.set_temperature_range(t_min, t_max, t_step)
if direction is not None:
td.project_eigenvectors(direction, self._primitive.get_cell())
td.run()
self._thermal_displacements = td
def get_thermal_displacements(self):
if self._thermal_displacements is not None:
return self._thermal_displacements.get_thermal_displacements()
def plot_thermal_displacements(self, is_legend=False):
return self._thermal_displacements.plot(is_legend)
def write_yaml_thermal_displacements(self):
self._thermal_displacements.write_yaml()
def set_thermal_displacement_matrices(self,
t_step=10,
t_max=1000,
t_min=0,
cutoff_frequency=None):
"""
cutoff_frequency:
phonon modes that have frequencies below cutoff_frequency
are ignored.
direction:
Projection direction in reduced coordinates
"""
if self._mesh is None:
print "set_mesh has to be done before set_thermal_properties"
sys.exit(1)
eigvecs = self._mesh.get_eigenvectors()
frequencies = self._mesh.get_frequencies()
mesh_nums = self._mesh.get_mesh_numbers()
if self._mesh.get_eigenvectors() is None:
print "Eigenvectors have to be calculated."
sys.exit(1)
if np.prod(mesh_nums) != len(eigvecs):
print "Sampling mesh must not be symmetrized."
sys.exit(1)
tdm = ThermalDisplacementMatrices(frequencies,
eigvecs,
self._primitive.get_masses(),
cutoff_frequency=cutoff_frequency)
tdm.set_temperature_range(t_min, t_max, t_step)
tdm.run()
self._thermal_displacement_matrices = tdm
def get_thermal_displacement_matrices(self):
if self._thermal_displacement_matrices is not None:
return self._thermal_displacement_matrices.get_thermal_displacement_matrices()
def write_yaml_thermal_displacement_matrices(self):
self._thermal_displacement_matrices.write_yaml()
def set_thermal_distances(self,
atom_pairs,
t_step=10,
t_max=1000,
t_min=0,
cutoff_frequency=None):
"""
atom_pairs: List of list
Mean square distances are calculated for the atom_pairs
e.g. [[1, 2], [1, 4]]
cutoff_frequency:
phonon modes that have frequencies below cutoff_frequency
are ignored.
"""
td = ThermalDistances(self._mesh.get_frequencies(),
self._mesh.get_eigenvectors(),
self._supercell,
self._primitive,
self._mesh.get_qpoints(),
cutoff_frequency=cutoff_frequency)
td.set_temperature_range(t_min, t_max, t_step)
td.run(atom_pairs)
self._thermal_distances = td
def write_yaml_thermal_distances(self):
self._thermal_distances.write_yaml()
def set_qpoints_phonon(self,
q_points,
nac_q_direction=None,
is_eigenvectors=False,
write_dynamical_matrices=False,
factor=VaspToTHz):
self._set_dynamical_matrix()
self._qpoints_phonon = QpointsPhonon(
q_points,
self._dynamical_matrix,
nac_q_direction=nac_q_direction,
is_eigenvectors=is_eigenvectors,
group_velocity=self._group_velocity,
write_dynamical_matrices=write_dynamical_matrices,
factor=self._factor)
def get_qpoints_phonon(self):
return (self._qpoints_phonon.get_frequencies(),
self._qpoints_phonon.get_eigenvectors())
def write_yaml_qpoints_phonon(self):
self._qpoints_phonon.write_yaml()
def write_animation(self,
q_point=None,
anime_type='v_sim',
band_index=None,
amplitude=None,
num_div=None,
shift=None,
filename=None):
self._set_dynamical_matrix()
if q_point is None:
animation = Animation([0, 0, 0],
self._dynamical_matrix,
shift=shift)
else:
animation = Animation(q_point,
self._dynamical_matrix,
shift=shift)
if anime_type == 'v_sim':
if amplitude:
amplitude_ = amplitude
else:
amplitude_ = 1.0
if filename:
animation.write_v_sim(amplitude=amplitude_,
factor=self._factor,
filename=filename)
else:
animation.write_v_sim(amplitude=amplitude_,
factor=self._factor)
if (anime_type == 'arc' or
anime_type == 'xyz' or
anime_type == 'jmol' or
anime_type == 'poscar'):
if band_index is None or amplitude is None or num_div is None:
print "Parameters are not correctly set for animation."
sys.exit(1)
if anime_type == 'arc' or anime_type is None:
if filename:
animation.write_arc(band_index,
amplitude,
num_div,
filename=filename)
else:
animation.write_arc(band_index,
amplitude,
num_div)
if anime_type == 'xyz':
if filename:
animation.write_xyz(band_index,
amplitude,
num_div,
self._factor,
filename=filename)
else:
animation.write_xyz(band_index,
amplitude,
num_div,
self._factor)
if anime_type == 'jmol':
if filename:
animation.write_xyz_jmol(amplitude=amplitude,
factor=self._factor,
filename=filename)
else:
animation.write_xyz_jmol(amplitude=amplitude,
factor=self._factor)
if anime_type == 'poscar':
if filename:
animation.write_POSCAR(band_index,
amplitude,
num_div,
filename=filename)
else:
animation.write_POSCAR(band_index,
amplitude,
num_div)
def set_modulations(self,
dimension,
phonon_modes,
delta_q=None,
derivative_order=None,
nac_q_direction=None):
self._set_dynamical_matrix()
self._modulation = Modulation(self._dynamical_matrix,
dimension,
phonon_modes,
delta_q=delta_q,
derivative_order=derivative_order,
nac_q_direction=nac_q_direction,
factor=self._factor)
self._modulation.run()
def get_modulations(self):
"""Returns cells with modulations as Atoms objects"""
return self._modulation.get_modulations()
def get_delta_modulations(self):
"""Return modulations relative to equilibrium supercell
(modulations, supercell)
modulations: Atomic modulations of supercell in Cartesian coordinates
supercell: Supercell as an Atoms object.
"""
return self._modulation.get_delta_modulations()
def write_modulations(self):
"""Create MPOSCAR's"""
self._modulation.write()
def write_yaml_modulations(self):
self._modulation.write_yaml()
def set_irreps(self,
q,
is_little_cogroup=False,
nac_q_direction=None,
degeneracy_tolerance=1e-4):
self._set_dynamical_matrix()
self._irreps = IrReps(
self._dynamical_matrix,
q,
is_little_cogroup=is_little_cogroup,
nac_q_direction=nac_q_direction,
factor=self._factor,
symprec=self._symprec,
degeneracy_tolerance=degeneracy_tolerance,
log_level=self._log_level)
return self._irreps.run()
def get_irreps(self):
return self._irreps
def show_irreps(self, show_irreps=False):
self._irreps.show(show_irreps=show_irreps)
def write_yaml_irreps(self, show_irreps=False):
self._irreps.write_yaml(show_irreps=show_irreps)
def set_group_velocity(self, q_length=None):
self._set_dynamical_matrix()
self._group_velocity = GroupVelocity(
self._dynamical_matrix,
q_length=q_length,
symmetry=self._primitive_symmetry,
frequency_factor_to_THz=self._factor)
def get_group_velocity(self):
return self._group_velocity.get_group_velocity()
def get_group_velocity_at_q(self, q_point):
if self._group_velocity is None:
self.set_group_velocity()
self._group_velocity.set_q_points([q_point])
return self._group_velocity.get_group_velocity()[0]
def _run_force_constants_from_forces(self,
distributed_atom_list=None,
decimals=None,
computation_algorithm="svd"):
if self._displacement_dataset is not None:
self._force_constants = get_fc2(
self._supercell,
self._symmetry,
self._displacement_dataset,
atom_list=distributed_atom_list,
decimals=decimals,
computation_algorithm=computation_algorithm)
def _set_dynamical_matrix(self):
if self._nac_params is None:
self._dynamical_matrix = DynamicalMatrix(
self._supercell,
self._primitive,
self._force_constants,
decimals=self._dynamical_matrix_decimals,
symprec=self._symprec)
else:
self._dynamical_matrix = DynamicalMatrixNAC(
self._supercell,
self._primitive,
self._force_constants,
nac_params=self._nac_params,
decimals=self._dynamical_matrix_decimals,
symprec=self._symprec)
def _search_symmetry(self):
self._symmetry = Symmetry(self._supercell,
self._symprec,
self._is_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 _build_supercell(self):
self._supercell = get_supercell(self._unitcell,
self._supercell_matrix,
self._symprec)
def _build_supercells_with_displacements(self):
supercells = []
for disp in self._displacement_dataset['first_atoms']:
positions = self._supercell.get_positions()
positions[disp['number']] += disp['displacement']
supercells.append(Atoms(
numbers=self._supercell.get_atomic_numbers(),
masses=self._supercell.get_masses(),
magmoms=self._supercell.get_magnetic_moments(),
positions=positions,
cell=self._supercell.get_cell(),
pbc=True))
self._supercells_with_displacements = supercells
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)
self._primitive = get_primitive(
self._supercell, trans_mat, self._symprec)
num_satom = self._supercell.get_number_of_atoms()
num_patom = self._primitive.get_number_of_atoms()
if abs(num_satom * np.linalg.det(trans_mat) - num_patom) < 0.1:
return True
else:
return False
class Phonopy:
def __init__( self,
unitcell,
supercell_matrix,
is_preprocess=True,
distance=0.01,
symprec=1e-5,
factor=VaspToTHz,
is_nosym=False,
log_level=0 ):
self.symprec = symprec
self.unitcell = unitcell
self.supercell_matrix = supercell_matrix
self.distance = distance
self.factor = factor
self.is_nosym = is_nosym
self.log_level = log_level
self.supercell = None
self.__supercell()
self.symmetry = None
self.__symmetry()
if is_preprocess:
self.displacements = None
self.displacement_directions = None
self.supercells_with_displacements = None
self.set_displacements()
# set_post_process
self.primitive = None
self.dynamical_matrix = None
self.is_nac = False
# set_force_constants or set_forces
self.force_constants = None
# set_band_structure
self.__band_structure = None
# set_mesh
self.__mesh = None
# set_thermal_properties
self.__thermal_properties = None
# set_thermal_displacements
self.__thermal_displacements = None
# set_partial_DOS
self.__pdos = None
# set_total_DOS
self.__total_dos = None
def __supercell(self):
self.supercell = get_supercell( self.unitcell,
self.supercell_matrix,
self.symprec )
def get_supercell( self ):
return self.supercell
def set_supercell( self, supercell ):
self.supercell = supercell
def get_primitive( self ):
return self.primitive
def set_primitive( self, primitive ):
self.primitive = primitive
def __symmetry(self):
self.symmetry = Symmetry( self.supercell,
self.symprec,
self.is_nosym )
def get_symmetry(self):
return self.symmetry
def set_displacements( self,
is_plusminus='auto',
is_diagonal=True ):
"""
displacements:
List of displacements in Cartesian coordinates.
See 'set_special_displacements'
displacement_directions:
List of directions with respect to axes. This gives only the
symmetrically non equivalent directions. The format is like:
[[ 0, 1, 0, 0 ],
[ 7, 1, 0, 1 ], ...]
where each list is defined by:
First value: Atom index in supercell starting with 0
Second to fourth: If the direction is displaced or not ( 1, 0, or -1 )
with respect to the axes.
"""
lattice = self.supercell.get_cell()
self.displacements = []
self.displacement_directions = \
get_least_displacements( self.symmetry,
is_plusminus=is_plusminus,
is_diagonal=is_diagonal,
log_level=self.log_level )
for disp in self.displacement_directions:
atom_num = disp[0]
disp_cartesian = np.dot(disp[1:], lattice)
disp_cartesian *= self.distance / np.linalg.norm(disp_cartesian)
self.displacements.append( [ atom_num,
disp_cartesian[0],
disp_cartesian[1],
disp_cartesian[2] ] )
self.__supercells_with_displacements()
def set_special_displacements(self, displacements):
"""
This method orverwrites displacements that were automatically
determined in the post-process.
displacemsts: List of disctionaries
[[ 0, 0.01, 0.00, 0.00 ], ... ]
where each set of elements is defined by:
First value: Atom index in supercell starting with 0
Second to fourth: Displacement in Cartesian coordinates
"""
self.displacements = displacements
self.__supercells_with_displacements()
def get_displacements( self ):
return self.displacements
def get_displacement_directions( self ):
return self.displacement_directions
def print_displacements(self):
print "Least displacements:"
print " Atom Displacement"
print " ----------------------------"
for disp in self.displacements:
print " %4d " % disp[0],
print disp[1:4]
def __supercells_with_displacements(self):
supercells = []
for disp in self.displacements:
positions = self.supercell.get_positions()
positions[disp[0]] += disp[1:4]
supercells.append( Atoms(
numbers = self.supercell.get_atomic_numbers(),
masses = self.supercell.get_masses(),
positions = positions,
cell = self.supercell.get_cell(),
pbc = True ) )
self.supercells_with_displacements = supercells
def get_supercells_with_displacements(self):
return self.supercells_with_displacements
def set_post_process( self,
primitive_matrix,
set_of_forces=None,
force_constants=None,
is_nac=False ):
"""
Set forces to prepare phonon calculations. The order of
'set_of_forces' has to correspond to that of 'displacements'.
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
set_of_forces:
[ [ [ f_1x, f_1y, f_1z ], [ f_2x, f_2y, f_2z ], ... ], # first supercell
[ [ f_1x, f_1y, f_1z ], [ f_2x, f_2y, f_2z ], ... ], # second supercell
... ]
"""
self.is_nac = is_nac
if not set_of_forces == None:
self.set_forces( set_of_forces )
elif not force_constants == None:
self.set_force_constants( force_constants )
elif self.force_constants == None:
print "In set_post_process, set_of_forces or force_constants"
print "has to be set."
sys.exit(1)
# Primitive cell
inv_supercell_matrix = np.linalg.inv( self.supercell_matrix )
self.primitive = Primitive( self.supercell,
np.dot( inv_supercell_matrix, primitive_matrix ),
self.symprec )
# Dynamical Matrix
if self.is_nac:
self.dynamical_matrix = \
DynamicalMatrixNAC( self.supercell,
self.primitive,
self.force_constants,
symprec=self.symprec )
else:
self.dynamical_matrix = \
DynamicalMatrix( self.supercell,
self.primitive,
self.force_constants,
symprec=self.symprec )
def set_nac_params( self, nac_params, method='wang' ):
if self.is_nac:
self.dynamical_matrix.set_nac_params( nac_params, method )
def get_dynamical_matrix( self ):
return self.dynamical_matrix
def set_forces( self,
set_of_forces,
is_tensor_symmetry=False ):
# Forces
forces = []
for i, disp in enumerate( self.displacements ):
forces.append( Forces( disp[0],
disp[1:4],
set_of_forces[i] ) )
# Force constants
self.force_constants = get_force_constants( forces,
self.symmetry,
self.supercell,
is_tensor_symmetry )
def set_force_constants( self, force_constants ):
self.force_constants = force_constants
def symmetrize_force_constants( self, iteration=3 ):
symmetrize_force_constants( self.force_constants, iteration )
def get_force_constants( self ):
return self.force_constants
def get_rotational_condition_of_fc( self ):
return rotational_invariance( self.force_constants,
self.supercell,
self.primitive,
self.symprec )
# Frequency at a q-point
def get_frequencies(self, q):
"""
Calculate phonon frequency
q: k-vector in reduced coordinates of primitive cell
"""
self.dynamical_matrix.set_dynamical_matrix(q)
dm = self.dynamical_matrix.get_dynamical_matrix()
frequencies = []
for eig in np.linalg.eigvalsh(dm):
if eig < 0:
frequencies.append(-np.sqrt(-eig))
else:
frequencies.append(np.sqrt(eig))
return np.array(frequencies) * self.factor
# Band structure
def set_band_structure( self,
bands,
is_eigenvectors=False ):
self.__band_structure = BandStructure( bands,
self.dynamical_matrix,
self.primitive,
is_eigenvectors=is_eigenvectors,
factor=self.factor )
def get_band_structure( self ):
band = self.__band_structure
return ( band.get_distances(),
band.get_qpoints(),
band.get_eigenvalues(),
band.get_eigenvectors() )
def plot_band_structure( self, symbols=None ):
return self.__band_structure.plot_band( symbols )
def write_yaml_band_structure( self ):
self.__band_structure.write_yaml()
# Mesh sampling
def set_mesh( self,
mesh,
shift=None,
is_time_reversal=True,
is_symmetry=True,
is_eigenvectors=False ):
self.__mesh = Mesh( self.dynamical_matrix,
self.primitive,
mesh,
shift=shift,
is_time_reversal=is_time_reversal,
is_symmetry=is_symmetry,
is_eigenvectors=is_eigenvectors,
factor=self.factor,
symprec=self.symprec )
def get_mesh( self ):
return ( self.__mesh.get_weights(),
self.__mesh.get_qpoints(),
self.__mesh.get_eigenvalues(),
self.__mesh.get_eigenvectors() )
def write_yaml_mesh( self ):
self.__mesh.write_yaml()
# Thermal property
def set_thermal_properties( self, t_step=10, t_max=1000, t_min=0,
cutoff_eigenvalue=None ):
if self.__mesh==None:
print "set_mesh has to be done before set_thermal_properties"
sys.exit(1)
tp = ThermalProperties( self.__mesh.get_eigenvalues(),
weights=self.__mesh.get_weights(),
factor=self.factor,
cutoff_eigenvalue=cutoff_eigenvalue )
tp.set_thermal_properties( t_step, t_max, t_min )
self.__thermal_properties = tp
def get_thermal_properties( self ):
temps, fe, entropy, cv = \
self.__thermal_properties.get_thermal_properties()
return np.array([ temps, fe, entropy, cv ]).transpose()
def plot_thermal_properties( self ):
return self.__thermal_properties.plot_thermal_properties()
def write_yaml_thermal_properties( self ):
self.__thermal_properties.write_yaml()
# Partial DOS
def set_partial_DOS( self,
sigma=None,
omega_min=None,
omega_max=None,
omega_pitch=None ):
if self.__mesh==None:
print "set_mesh has to be done before set_thermal_properties"
sys.exit(1)
if self.__mesh.get_eigenvectors() == None:
print "Eigenvectors have to be calculated."
sys.exit(1)
pdos = PartialDos( self.__mesh.get_eigenvalues(),
self.__mesh.get_weights(),
self.__mesh.get_eigenvectors(),
factor=self.factor,
sigma=sigma )
pdos.set_draw_area( omega_min,
omega_max,
omega_pitch )
pdos.calculate()
self.__pdos = pdos
def get_partial_DOS( self ):
"""
Retern omegas and partial_dos.
The first element is omegas and the second is partial_dos.
omegas: [ freq1, freq2, ... ]
partial_dos:
[[elem1-freq1, elem1-freq2, ... ],
[elem2-freq1, elem2-freq2, ... ],
... ]
where
elem1: atom1-x compornent
elem2: atom1-y compornent
elem3: atom1-z compornent
elem4: atom2-x compornent
...
"""
return self.__pdos.get_partial_dos()
def plot_partial_DOS( self, pdos_indices ):
return self.__pdos.plot_pdos( pdos_indices )
def write_partial_DOS( self ):
self.__pdos.write()
# Total DOS
def set_total_DOS( self,
sigma=None,
omega_min=None,
omega_max=None,
omega_pitch=None ):
if self.__mesh==None:
print "set_mesh has to be done before set_thermal_properties"
sys.exit(1)
total_dos = TotalDos( self.__mesh.get_eigenvalues(),
self.__mesh.get_weights(),
factor=self.factor,
sigma=sigma )
total_dos.set_draw_area( omega_min,
omega_max,
omega_pitch )
total_dos.calculate()
self.__total_dos = total_dos
def get_total_DOS( self ):
"""
Retern omegas and total dos.
The first element is omegas and the second is total dos.
omegas: [ freq1, freq2, ... ]
total_dos: [ dos1, dos2, ... ]
"""
return self.__total_dos.get_dos()
def plot_total_DOS( self ):
return self.__total_dos.plot_dos()
def write_total_DOS( self ):
self.__total_dos.write()
# Thermal displacement
def set_thermal_displacements( self,
t_step=10,
t_max=1000,
t_min=0,
projector=None,
cutoff_eigenvalue=None ):
"""
cutoff_eigenvalue:
phonon modes that have frequencies below cutoff_eigenvalue
are ignored.
e.g. 0.1 (THz)
"""
if self.__mesh==None:
print "set_mesh has to be done before set_thermal_properties"
sys.exit(1)
if self.__mesh.get_eigenvectors() == None:
print "Eigenvectors have to be calculated."
sys.exit(1)
td = ThermalDisplacements( self.__mesh.get_eigenvalues(),
self.__mesh.get_eigenvectors(),
self.__mesh.get_weights(),
self.primitive.get_masses(),
factor=self.factor,
cutoff_eigenvalue=cutoff_eigenvalue )
td.set_temperature_range( t_min, t_max, t_step )
if not projector==None:
td.project_eigenvectors( projector, self.primitive.get_cell() )
td.set_thermal_displacements()
self.__thermal_displacements = td
def plot_thermal_displacements( self, is_legend=False ):
return self.__thermal_displacements.plot_thermal_displacements( is_legend )
def write_yaml_thermal_displacements( self ):
self.__thermal_displacements.write_yaml()
# Thermal displacement
def set_thermal_distances( self,
atom_pairs,
t_step=10,
t_max=1000,
t_min=0,
cutoff_eigenvalue=None ):
"""
atom_pairs: List of list
Mean square distances are calculated for the atom_pairs
e.g. [ [ 1, 2 ], [ 1, 4 ] ]
cutoff_eigenvalue:
phonon modes that have frequencies below cutoff_eigenvalue
are ignored.
e.g. 0.1 (THz)
"""
td = ThermalDistances( self.__mesh.get_eigenvalues(),
self.__mesh.get_eigenvectors(),
self.__mesh.get_weights(),
self.supercell,
self.primitive,
self.__mesh.get_qpoints(),
symprec=self.symprec,
factor=self.factor,
cutoff_eigenvalue=cutoff_eigenvalue )
td.set_temperature_range( t_min, t_max, t_step )
td.set_thermal_distances( atom_pairs )
self.__thermal_distances = td
def write_yaml_thermal_distances( self ):
self.__thermal_distances.write_yaml()
# Q-points mode
def write_yaml_qpoints( self,
qpoints,
is_eigenvectors=False,
factor=VaspToTHz ):
write_yaml_qpoints( qpoints,
self.primitive,
self.dynamical_matrix,
is_eigenvectors=is_eigenvectors,
factor=self.factor )
# Animation
def write_animation( self,
qpoint=None,
anime_type='v_sim',
band_index=None,
amplitude=None,
num_div=None,
shift=None ):
if qpoint==None:
animation = Animation( [0, 0, 0],
self.dynamical_matrix,
self.primitive,
shift=shift )
else:
animation = Animation( qpoint,
self.dynamical_matrix,
self.primitive,
shift=shift )
if anime_type=='v_sim':
animation.write_v_sim( self.factor )
if ( anime_type=='arc' or
anime_type=='xyz' or
anime_type=='jmol' or
anime_type=='poscar' ):
if band_index==None or amplitude==None or num_div==None:
print "Parameters are not correctly set for animation."
sys.exit(1)
if anime_type=='arc' or anime_type==None:
animation.write_arc( band_index,
amplitude,
num_div )
if anime_type=='xyz':
animation.write_xyz( band_index,
amplitude,
num_div,
self.factor )
if anime_type=='jmol':
animation.write_xyz_jmol( amplitude=amplitude,
factor=self.factor )
if anime_type=='poscar':
animation.write_POSCAR( band_index,
amplitude,
num_div )
def write_modulation( self, setting ):
write_modulations( self.dynamical_matrix,
self.primitive,
setting )
class Phonopy:
def __init__(self,
unitcell,
supercell_matrix,
distance=0.01,
factor=VaspToTHz,
is_auto_displacements=True,
symprec=1e-5,
is_symmetry=True,
log_level=0):
self._symprec = symprec
self._unitcell = unitcell
self._supercell_matrix = supercell_matrix
self._factor = factor
self._is_symmetry = is_symmetry
self._log_level = log_level
self._supercell = None
self._set_supercell()
self._symmetry = None
self._set_symmetry()
# set_displacements (used only in preprocess)
self._displacements = None
self._displacement_directions = None
self._supercells_with_displacements = None
if is_auto_displacements:
self.generate_displacements(distance)
# set_post_process
self._primitive = None
self._dynamical_matrix = None
self._is_nac = False
# set_force_constants or set_forces
self._set_of_forces_objects = None
self._force_constants = None
# set_band_structure
self._band_structure = None
# set_mesh
self._mesh = None
# set_thermal_properties
self._thermal_properties = None
# set_thermal_displacements
self._thermal_displacements = None
# set_thermal_displacement_matrices
self._thermal_displacement_matrices = None
# set_partial_DOS
self._pdos = None
# set_total_DOS
self._total_dos = None
# set_modulation
self._modulation = None
# set_character_table
self._irreps = None
# set_group_velocity
self._group_velocity = None
def get_primitive(self):
return self._primitive
primitive = property(get_primitive)
def set_primitive(self, primitive):
self._primitive = primitive
def get_unitcell(self):
return self._unitcell
unitcell = property(get_unitcell)
def get_supercell(self):
return self._supercell
supercell = property(get_supercell)
def set_supercell(self, supercell):
self._supercell = supercell
def get_symmetry(self):
return self._symmetry
symmetry = property(get_symmetry)
def get_unit_conversion_factor(self):
return self._factor
unit_conversion_factor = property(get_unit_conversion_factor)
def generate_displacements(self,
distance=0.01,
is_plusminus='auto',
is_diagonal=True,
is_trigonal=False):
"""Generate displacements automatically
displacements:
List of displacements in Cartesian coordinates.
See 'set_displacements'
displacement_directions:
List of directions with respect to axes. This gives only the
symmetrically non equivalent directions. The format is like:
[[0, 1, 0, 0],
[7, 1, 0, 1], ...]
where each list is defined by:
First value: Atom index in supercell starting with 0
Second to fourth: If the direction is displaced or not ( 1, 0, or -1 )
with respect to the axes.
"""
lattice = self._supercell.get_cell()
self._displacements = []
self._displacement_directions = \
get_least_displacements(self._symmetry,
is_plusminus=is_plusminus,
is_diagonal=is_diagonal,
is_trigonal=is_trigonal,
log_level=self._log_level)
for disp in self._displacement_directions:
atom_num = disp[0]
disp_cartesian = np.dot(disp[1:], lattice)
disp_cartesian *= distance / np.linalg.norm(disp_cartesian)
self._displacements.append([atom_num,
disp_cartesian[0],
disp_cartesian[1],
disp_cartesian[2]])
self._set_supercells_with_displacements()
def set_displacements(self, displacements):
"""Set displacements manually
displacemsts: List of disctionaries
[[0, 0.01, 0.00, 0.00], ...]
where each set of elements is defined by:
First value: Atom index in supercell starting with 0
Second to fourth: Displacement in Cartesian coordinates
"""
self._displacements = displacements
self._set_supercells_with_displacements()
def get_displacements(self):
return self._displacements
displacements = property(get_displacements)
def get_displacement_directions(self):
return self._displacement_directions
displacement_directions = property(get_displacement_directions)
def get_supercells_with_displacements(self):
return self._supercells_with_displacements
def set_post_process(self,
primitive_matrix=np.eye(3, dtype=float),
sets_of_forces=None,
set_of_forces_objects=None,
force_constants=None,
is_nac=False,
calculate_full_force_constants=False,
force_constants_decimals=None,
dynamical_matrix_decimals=None):
"""
Set forces or force constants to prepare phonon calculations.
The order of 'sets_of_forces' has to correspond to that of
'displacements' that should be already stored.
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
sets_of_forces:
[[[f_1x, f_1y, f_1z], [f_2x, f_2y, f_2z], ...], # first supercell
[[f_1x, f_1y, f_1z], [f_2x, f_2y, f_2z], ...], # second supercell
... ]
set_of_forces_objects:
[FORCES_object, FORCES_object, FORCES_object, ...]
"""
self._is_nac = is_nac
# Primitive cell
inv_supercell_matrix = np.linalg.inv(self._supercell_matrix)
self._primitive = Primitive(
self._supercell,
np.dot(inv_supercell_matrix, primitive_matrix),
self._symprec)
# Set set of FORCES objects or force constants
if sets_of_forces is not None:
self.set_forces(sets_of_forces)
elif set_of_forces_objects is not None:
self.set_force_sets(set_of_forces_objects)
elif force_constants is not None:
self.set_force_constants(force_constants)
# Calculate force cosntants from forces (full or symmetry reduced)
if self._set_of_forces_objects is not None:
if calculate_full_force_constants:
self.set_force_constants_from_forces(
distributed_atom_list=None,
force_constants_decimals=force_constants_decimals)
else:
p2s_map = self._primitive.get_primitive_to_supercell_map()
self.set_force_constants_from_forces(
distributed_atom_list=p2s_map,
force_constants_decimals=force_constants_decimals)
if self._force_constants is None:
print "In set_post_process, sets_of_forces or force_constants"
print "has to be set."
return False
# Dynamical Matrix
self.set_dynamical_matrix(decimals=dynamical_matrix_decimals)
def set_nac_params(self, nac_params, method='wang'):
if self._is_nac:
self._dynamical_matrix.set_nac_params(nac_params, method)
def set_dynamical_matrix(self, decimals=None):
if self._is_nac:
self._dynamical_matrix = \
DynamicalMatrixNAC(self._supercell,
self._primitive,
self._force_constants,
decimals=decimals,
symprec=self._symprec)
else:
self._dynamical_matrix = \
DynamicalMatrix(self._supercell,
self._primitive,
self._force_constants,
decimals=decimals,
symprec=self._symprec)
def get_dynamical_matrix(self):
return self._dynamical_matrix
dynamical_matrix = property(get_dynamical_matrix)
def set_forces(self, sets_of_forces):
forces = []
for i, disp in enumerate(self._displacements):
forces.append(Forces(disp[0],
disp[1:4],
sets_of_forces[i]))
self._set_of_forces_objects = forces
def set_force_constants_from_forces(self,
distributed_atom_list=None,
force_constants_decimals=None):
self._force_constants = get_force_constants(
self._set_of_forces_objects,
self._symmetry,
self._supercell,
atom_list=distributed_atom_list,
decimals=force_constants_decimals)
def set_force_constants_zero_with_radius(self,
cutoff_radius):
cutoff_force_constants(self._force_constants,
self._supercell,
cutoff_radius,
symprec=self._symprec)
def set_force_constants(self, force_constants):
self._force_constants = force_constants
def set_force_sets(self, sets_of_forces_objects):
self._set_of_forces_objects = sets_of_forces_objects
def symmetrize_force_constants(self, iteration=3):
symmetrize_force_constants(self._force_constants, iteration)
def get_force_constants(self):
return self._force_constants
force_constants = property(get_force_constants)
def get_rotational_condition_of_fc(self):
return rotational_invariance(self._force_constants,
self._supercell,
self._primitive,
self._symprec)
def get_dynamical_matrix_at_q(self, q):
self._dynamical_matrix.set_dynamical_matrix(q)
return self._dynamical_matrix.get_dynamical_matrix()
# Frequency at a q-point
def get_frequencies(self, q):
"""
Calculate phonon frequencies at q
q: q-vector in reduced coordinates of primitive cell
"""
self._dynamical_matrix.set_dynamical_matrix(q)
dm = self._dynamical_matrix.get_dynamical_matrix()
frequencies = []
for eig in np.linalg.eigvalsh(dm).real:
if eig < 0:
frequencies.append(-np.sqrt(-eig))
else:
frequencies.append(np.sqrt(eig))
return np.array(frequencies) * self._factor
# Frequency and eigenvector at a q-point
def get_frequencies_with_eigenvectors(self, q):
"""
Calculate phonon frequencies and eigenvectors at q
q: q-vector in reduced coordinates of primitive cell
"""
self._dynamical_matrix.set_dynamical_matrix(q)
dm = self._dynamical_matrix.get_dynamical_matrix()
frequencies = []
eigvals, eigenvectors = np.linalg.eigh(dm)
frequencies = []
for eig in eigvals:
if eig < 0:
frequencies.append(-np.sqrt(-eig))
else:
frequencies.append(np.sqrt(eig))
return np.array(frequencies) * self._factor, eigenvectors
## This expression may not be supported in old python versions.
# frequencies = np.array(
# [np.sqrt(x) if x > 0 else -np.sqrt(-x) for x in eigvals])
# return frequencies * self._factor, eigenvectors
# Band structure
def set_band_structure(self,
bands,
is_eigenvectors=False,
is_band_connection=False):
self._band_structure = BandStructure(
bands,
self._dynamical_matrix,
self._primitive,
is_eigenvectors=is_eigenvectors,
is_band_connection=is_band_connection,
group_velocity=self._group_velocity,
factor=self._factor)
def get_band_structure(self):
band = self._band_structure
return (band.get_qpoints(),
band.get_distances(),
band.get_frequencies(),
band.get_eigenvectors())
def plot_band_structure(self, symbols=None):
return self._band_structure.plot_band(symbols)
def write_yaml_band_structure(self):
self._band_structure.write_yaml()
# Mesh sampling
def set_mesh(self,
mesh,
shift=None,
is_time_reversal=True,
is_symmetry=True,
is_band_connection=False,
is_eigenvectors=False,
is_gamma_center=False):
self._mesh = Mesh(self._dynamical_matrix,
self._primitive,
mesh,
shift=shift,
is_time_reversal=is_time_reversal,
is_mesh_symmetry=is_symmetry,
is_eigenvectors=is_eigenvectors,
is_band_connection=is_band_connection,
is_gamma_center=is_gamma_center,
group_velocity=self._group_velocity,
factor=self._factor,
symprec=self._symprec)
def get_mesh(self):
return (self._mesh.get_qpoints(),
self._mesh.get_weights(),
self._mesh.get_frequencies(),
self._mesh.get_eigenvectors())
def write_yaml_mesh(self):
self._mesh.write_yaml()
def write_hdf5_mesh(self):
self._mesh.write_hdf5()
# Thermal property
def set_thermal_properties(self,
t_step=10,
t_max=1000,
t_min=0,
is_projection=False,
cutoff_frequency=None):
if self._mesh==None:
print "set_mesh has to be done before set_thermal_properties"
sys.exit(1)
tp = ThermalProperties(self._mesh.get_frequencies(),
weights=self._mesh.get_weights(),
eigenvectors=self._mesh.get_eigenvectors(),
is_projection=is_projection,
cutoff_frequency=cutoff_frequency)
tp.set_thermal_properties(t_step, t_max, t_min)
self._thermal_properties = tp
def get_thermal_properties(self):
temps, fe, entropy, cv = \
self._thermal_properties.get_thermal_properties()
return temps, fe, entropy, cv
def plot_thermal_properties(self):
return self._thermal_properties.plot_thermal_properties()
def write_yaml_thermal_properties(self, filename='thermal_properties.yaml'):
self._thermal_properties.write_yaml(filename=filename)
# Partial DOS
def set_partial_DOS(self,
sigma=None,
omega_min=None,
omega_max=None,
omega_pitch=None,
tetrahedron_method=False):
if self._mesh==None:
print "set_mesh has to be done before set_thermal_properties"
sys.exit(1)
if self._mesh.get_eigenvectors() == None:
print "Eigenvectors have to be calculated."
sys.exit(1)
pdos = PartialDos(self._mesh,
sigma=sigma,
tetrahedron_method=tetrahedron_method)
pdos.set_draw_area(omega_min,
omega_max,
omega_pitch)
pdos.calculate()
self._pdos = pdos
def get_partial_DOS(self):
"""
Retern omegas and partial_dos.
The first element is omegas and the second is partial_dos.
omegas: [freq1, freq2, ...]
partial_dos:
[[elem1-freq1, elem1-freq2, ...],
[elem2-freq1, elem2-freq2, ...],
...]
where
elem1: atom1-x compornent
elem2: atom1-y compornent
elem3: atom1-z compornent
elem4: atom2-x compornent
...
"""
return self._pdos.get_partial_dos()
def plot_partial_DOS(self, pdos_indices=None, legend=None):
return self._pdos.plot_pdos(indices=pdos_indices,
legend=legend)
def write_partial_DOS(self):
self._pdos.write()
# Total DOS
def set_total_DOS(self,
sigma=None,
omega_min=None,
omega_max=None,
omega_pitch=None,
tetrahedron_method=False):
if self._mesh==None:
print "set_mesh has to be done before set_thermal_properties"
sys.exit(1)
total_dos = TotalDos(self._mesh,
sigma=sigma,
tetrahedron_method=tetrahedron_method)
total_dos.set_draw_area(omega_min,
omega_max,
omega_pitch)
total_dos.calculate()
self._total_dos = total_dos
def get_total_DOS(self):
"""
Retern omegas and total dos.
The first element is omegas and the second is total dos.
omegas: [freq1, freq2, ...]
total_dos: [dos1, dos2, ...]
"""
return self._total_dos.get_dos()
def set_Debye_frequency(self, freq_max_fit=None):
self._total_dos.set_Debye_frequency(
self._primitive.get_number_of_atoms(), freq_max_fit)
def get_Debye_frequency(self):
return self._total_dos.get_Debye_frequency()
def plot_total_DOS(self):
return self._total_dos.plot_dos()
def write_total_DOS(self):
self._total_dos.write()
# Thermal displacement
def set_thermal_displacements(self,
t_step=10,
t_max=1000,
t_min=0,
direction=None,
cutoff_eigenvalue=None):
"""
cutoff_eigenvalue:
phonon modes that have frequencies below cutoff_eigenvalue
are ignored.
e.g. 0.1 (THz^2)
direction:
Projection direction in reduced coordinates
"""
if self._mesh==None:
print "set_mesh has to be done before set_thermal_properties"
sys.exit(1)
eigvecs = self._mesh.get_eigenvectors()
frequencies = self._mesh.get_frequencies()
mesh_nums = self._mesh.get_mesh_numbers()
if self._mesh.get_eigenvectors() is None:
print "Eigenvectors have to be calculated."
sys.exit(1)
if np.prod(mesh_nums) != len(eigvecs):
print "Sampling mesh must not be symmetrized."
sys.exit(1)
td = ThermalDisplacements(frequencies,
eigvecs,
self._primitive.get_masses(),
cutoff_eigenvalue=cutoff_eigenvalue)
td.set_temperature_range(t_min, t_max, t_step)
if direction is not None:
td.project_eigenvectors(direction, self._primitive.get_cell())
# td.run()
td.run_mesh()
self._thermal_displacements = td
def get_thermal_displacements(self):
if self._thermal_displacements is not None:
return self._thermal_displacements.get_thermal_displacements()
def plot_thermal_displacements(self, is_legend=False):
return self._thermal_displacements.plot(is_legend)
def write_yaml_thermal_displacements(self):
self._thermal_displacements.write_yaml()
def write_hdf5_thermal_displacements(self):
self._thermal_displacements.write_hdf5()
# Thermal displacement matrices
def set_thermal_displacement_matrices(self,
t_step=10,
t_max=1000,
t_min=0,
cutoff_eigenvalue=None):
"""
cutoff_eigenvalue:
phonon modes that have frequencies below cutoff_eigenvalue
are ignored.
e.g. 0.1 (THz^2)
direction:
Projection direction in reduced coordinates
"""
if self._mesh==None:
print "set_mesh has to be done before set_thermal_properties"
sys.exit(1)
eigvecs = self._mesh.get_eigenvectors()
frequencies = self._mesh.get_frequencies()
mesh_nums = self._mesh.get_mesh_numbers()
if self._mesh.get_eigenvectors() is None:
print "Eigenvectors have to be calculated."
sys.exit(1)
if np.prod(mesh_nums) != len(eigvecs):
print "Sampling mesh must not be symmetrized."
sys.exit(1)
tdm = ThermalDisplacementMatrices(frequencies,
eigvecs,
self._primitive.get_masses(),
cutoff_eigenvalue=cutoff_eigenvalue)
tdm.set_temperature_range(t_min, t_max, t_step)
# tdm.run()
tdm.run_mesh()
self._thermal_displacement_matrices = tdm
def get_thermal_displacement_matrices(self):
if self._thermal_displacement_matrices is not None:
return self._thermal_displacement_matrices.get_thermal_displacement_matrices()
def write_yaml_thermal_displacement_matrices(self):
self._thermal_displacement_matrices.write_yaml()
def write_hdf5_thermal_displacement_matrices(self):
self._thermal_displacement_matrices.write_hdf5()
# Thermal displacement
def set_thermal_distances(self,
atom_pairs,
t_step=10,
t_max=1000,
t_min=0,
cutoff_eigenvalue=None):
"""
atom_pairs: List of list
Mean square distances are calculated for the atom_pairs
e.g. [[1, 2], [1, 4]]
cutoff_eigenvalue:
phonon modes that have frequencies below cutoff_eigenvalue
are ignored.
e.g. 0.1 (THz^2)
"""
td = ThermalDistances(self._mesh.get_frequencies(),
self._mesh.get_eigenvectors(),
self._supercell,
self._primitive,
self._mesh.get_qpoints(),
symprec=self._symprec,
cutoff_eigenvalue=cutoff_eigenvalue)
td.set_temperature_range(t_min, t_max, t_step)
# td.run(atom_pairs)
td.run_mesh(atom_pairs)
self._thermal_distances = td
def write_yaml_thermal_distances(self):
self._thermal_distances.write_yaml()
def write_hdf5_thermal_distances(self):
self._thermal_distances.write_hdf5()
# Q-points mode
def write_yaml_qpoints(self,
q_points,
nac_q_direction=None,
is_eigenvectors=False,
write_dynamical_matrices=False,
factor=VaspToTHz):
write_yaml_qpoints(q_points,
self._primitive,
self._dynamical_matrix,
nac_q_direction=nac_q_direction,
is_eigenvectors=is_eigenvectors,
group_velocity=self._group_velocity,
write_dynamical_matrices=write_dynamical_matrices,
factor=self._factor)
# Animation
def write_animation(self,
q_point=None,
anime_type='v_sim',
band_index=None,
amplitude=None,
num_div=None,
shift=None,
filename=None):
if q_point==None:
animation = Animation([0, 0, 0],
self._dynamical_matrix,
self._primitive,
shift=shift)
else:
animation = Animation(q_point,
self._dynamical_matrix,
self._primitive,
shift=shift)
if anime_type=='v_sim':
if amplitude:
amplitude_ = amplitude
else:
amplitude_ = 1.0
if filename:
animation.write_v_sim(amplitude=amplitude_,
factor=self._factor,
filename=filename)
else:
animation.write_v_sim(amplitude=amplitude_,
factor=self._factor)
if (anime_type=='arc' or
anime_type=='xyz' or
anime_type=='jmol' or
anime_type=='poscar'):
if band_index==None or amplitude==None or num_div==None:
print "Parameters are not correctly set for animation."
sys.exit(1)
if anime_type=='arc' or anime_type==None:
if filename:
animation.write_arc(band_index,
amplitude,
num_div,
filename=filename)
else:
animation.write_arc(band_index,
amplitude,
num_div)
if anime_type=='xyz':
if filename:
animation.write_xyz(band_index,
amplitude,
num_div,
self._factor,
filename=filename)
else:
animation.write_xyz(band_index,
amplitude,
num_div,
self._factor)
if anime_type=='jmol':
if filename:
animation.write_xyz_jmol(amplitude=amplitude,
factor=self._factor,
filename=filename)
else:
animation.write_xyz_jmol(amplitude=amplitude,
factor=self._factor)
if anime_type=='poscar':
if filename:
animation.write_POSCAR(band_index,
amplitude,
num_div,
filename=filename)
else:
animation.write_POSCAR(band_index,
amplitude,
num_div)
# Modulation
def set_modulations(self,
dimension,
phonon_modes,
delta_q=None,
derivative_order=None,
nac_q_direction=None):
self._modulation = Modulation(self._dynamical_matrix,
self._primitive,
dimension=dimension,
phonon_modes=phonon_modes,
delta_q= delta_q,
derivative_order=derivative_order,
nac_q_direction=nac_q_direction,
factor=self._factor)
self._modulation.run()
def get_modulations(self):
"""Returns cells with modulations as Atoms objects"""
return self._modulation.get_modulations()
def get_delta_modulations(self):
"""Return modulations relative to equilibrium supercell
(modulations, supercell)
modulations: Atomic modulations of supercell in Cartesian coordinates
supercell: Supercell as an Atoms object.
"""
return self._modulation.get_delta_modulations()
def write_modulations(self):
"""Create MPOSCAR's"""
self._modulation.write()
def write_yaml_modulations(self):
self._modulation.write_yaml()
# Characters of irreducible representations
def set_irreps(self, q, degeneracy_tolerance=1e-4):
self._irreps = IrReps(
self._dynamical_matrix,
q,
factor=self._factor,
symprec=self._symprec,
degeneracy_tolerance=degeneracy_tolerance,
log_level=self._log_level)
return self._irreps.run()
def get_irreps(self):
return self._irreps
def show_irreps(self, show_irreps=False):
self._irreps.show(show_irreps=show_irreps)
def write_yaml_irreps(self, show_irreps=False):
self._irreps.write_yaml(show_irreps=show_irreps)
# Group velocity
def set_group_velocity(self,
q_points=None,
q_length=1e-4):
self._group_velocity = GroupVelocity(
self._dynamical_matrix,
q_points=q_points,
symmetry=self._symmetry,
q_length=q_length,
frequency_factor_to_THz=self._factor)
def get_group_velocity(self, q_point):
self._group_velocity.set_q_points([q_point])
return self._group_velocity.get_group_velocity()[0]
def _set_supercell(self):
self._supercell = get_supercell(self._unitcell,
self._supercell_matrix,
self._symprec)
def _set_symmetry(self):
self._symmetry = Symmetry(self._supercell,
self._symprec,
self._is_symmetry)
def _set_supercells_with_displacements(self):
supercells = []
for disp in self._displacements:
positions = self._supercell.get_positions()
positions[disp[0]] += disp[1:4]
supercells.append(Atoms(
numbers=self._supercell.get_atomic_numbers(),
masses=self._supercell.get_masses(),
magmoms=self._supercell.get_magnetic_moments(),
positions=positions,
cell=self._supercell.get_cell(),
pbc=True))
self._supercells_with_displacements = supercells
class Phonopy:
def __init__(self,
unitcell,
supercell_matrix,
primitive_matrix=None,
nac_params=None,
distance=0.01,
factor=VaspToTHz,
is_auto_displacements=True,
dynamical_matrix_decimals=None,
force_constants_decimals=None,
symprec=1e-5,
is_symmetry=True,
log_level=0):
self._symprec = symprec
self._factor = factor
self._is_symmetry = is_symmetry
self._log_level = log_level
# Create supercell and primitive cell
self._unitcell = unitcell
self._supercell_matrix = supercell_matrix
self._primitive_matrix = primitive_matrix
self._supercell = None
self._primitive = None
self._build_supercell()
self._build_primitive_cell()
# Set supercell and primitive symmetry
self._symmetry = None
self._primitive_symmetry = None
self._search_symmetry()
self._search_primitive_symmetry()
# set_displacements (used only in preprocess)
self._displacement_dataset = None
self._displacements = None
self._displacement_directions = None
self._supercells_with_displacements = None
if is_auto_displacements:
self.generate_displacements(distance=distance)
# set_force_constants or set_forces
self._force_constants = None
self._force_constants_decimals = force_constants_decimals
# set_dynamical_matrix
self._dynamical_matrix = None
self._nac_params = nac_params
self._dynamical_matrix_decimals = dynamical_matrix_decimals
# set_band_structure
self._band_structure = None
# set_mesh
self._mesh = None
# set_tetrahedron_method
self._tetrahedron_method = None
# set_thermal_properties
self._thermal_properties = None
# set_thermal_displacements
self._thermal_displacements = None
# set_thermal_displacement_matrices
self._thermal_displacement_matrices = None
# set_partial_DOS
self._pdos = None
# set_total_DOS
self._total_dos = None
# set_modulation
self._modulation = None
# set_character_table
self._irreps = None
# set_group_velocity
self._group_velocity = None
def set_post_process(self,
primitive_matrix=None,
sets_of_forces=None,
displacement_dataset=None,
force_constants=None,
is_nac=None):
print
print(
"********************************** Warning"
"**********************************")
print "set_post_process will be obsolete."
print(
" produce_force_constants is used instead of set_post_process"
" for producing")
print(" force constants from forces.")
if primitive_matrix is not None:
print(
" primitive_matrix has to be given at Phonopy::__init__"
" object creation.")
print(
"******************************************"
"**********************************")
print
if primitive_matrix is not None:
self._primitive_matrix = primitive_matrix
self._build_primitive_cell()
self._search_primitive_symmetry()
if sets_of_forces is not None:
self.set_forces(sets_of_forces)
elif displacement_dataset is not None:
self._displacement_dataset = displacement_dataset
elif force_constants is not None:
self.set_force_constants(force_constants)
if self._displacement_dataset is not None:
self.produce_force_constants()
def set_masses(self, masses):
p_masses = np.array(masses)
self._primitive.set_masses(p_masses)
p2p_map = self._primitive.get_primitive_to_primitive_map()
s_masses = p_masses[[
p2p_map[x]
for x in self._primitive.get_supercell_to_primitive_map()
]]
self._supercell.set_masses(s_masses)
u2s_map = self._supercell.get_unitcell_to_supercell_map()
u_masses = s_masses[u2s_map]
self._unitcell.set_masses(u_masses)
def get_primitive(self):
return self._primitive
primitive = property(get_primitive)
def get_unitcell(self):
return self._unitcell
unitcell = property(get_unitcell)
def get_supercell(self):
return self._supercell
supercell = property(get_supercell)
def set_supercell(self, supercell):
self._supercell = supercell
def get_symmetry(self):
"""return symmetry of supercell"""
return self._symmetry
symmetry = property(get_symmetry)
def get_primitive_symmetry(self):
"""return symmetry of primitive cell"""
return self._primitive_symmetry
def get_unit_conversion_factor(self):
return self._factor
unit_conversion_factor = property(get_unit_conversion_factor)
def produce_force_constants(self,
forces=None,
calculate_full_force_constants=True,
computation_algorithm="svd"):
if forces is not None:
self.set_forces(forces)
if calculate_full_force_constants:
self._run_force_constants_from_forces(
decimals=self._force_constants_decimals,
computation_algorithm=computation_algorithm)
else:
p2s_map = self._primitive.get_primitive_to_supercell_map()
self._run_force_constants_from_forces(
distributed_atom_list=p2s_map,
decimals=self._force_constants_decimals,
computation_algorithm=computation_algorithm)
def set_nac_params(self, nac_params=None, method=None):
if method is not None:
print "set_nac_params:"
print " Keyword argument of \"method\" is not more supported."
self._nac_params = nac_params
def generate_displacements(self,
distance=0.01,
is_plusminus='auto',
is_diagonal=True,
is_trigonal=False):
"""Generate displacements automatically
displacemsts: List of displacements in Cartesian coordinates.
[[0, 0.01, 0.00, 0.00], ...]
where each set of elements is defined by:
First value: Atom index in supercell starting with 0
Second to fourth: Displacement in Cartesian coordinates
displacement_directions:
List of directions with respect to axes. This gives only the
symmetrically non equivalent directions. The format is like:
[[0, 1, 0, 0],
[7, 1, 0, 1], ...]
where each list is defined by:
First value: Atom index in supercell starting with 0
Second to fourth: If the direction is displaced or not ( 1, 0, or -1 )
with respect to the axes.
"""
displacement_directions = get_least_displacements(
self._symmetry,
is_plusminus=is_plusminus,
is_diagonal=is_diagonal,
is_trigonal=is_trigonal,
log_level=self._log_level)
displacement_dataset = direction_to_displacement(
displacement_directions, distance, self._supercell)
self.set_displacement_dataset(displacement_dataset)
def set_displacements(self, displacements):
print
print(
"********************************** Warning"
"**********************************")
print "set_displacements is obsolete. Do nothing."
print(
"******************************************"
"**********************************")
print
def get_displacements(self):
return self._displacements
displacements = property(get_displacements)
def get_displacement_directions(self):
return self._displacement_directions
displacement_directions = property(get_displacement_directions)
def get_displacement_dataset(self):
return self._displacement_dataset
def get_supercells_with_displacements(self):
if self._displacement_dataset is None:
return None
else:
self._build_supercells_with_displacements()
return self._supercells_with_displacements
def get_dynamical_matrix(self):
return self._dynamical_matrix
dynamical_matrix = property(get_dynamical_matrix)
def set_forces(self, sets_of_forces):
"""
sets_of_forces:
[[[f_1x, f_1y, f_1z], [f_2x, f_2y, f_2z], ...], # first supercell
[[f_1x, f_1y, f_1z], [f_2x, f_2y, f_2z], ...], # second supercell
... ]
"""
for disp, forces in zip(self._displacement_dataset['first_atoms'],
sets_of_forces):
disp['forces'] = forces
def set_force_constants_zero_with_radius(self, cutoff_radius):
cutoff_force_constants(self._force_constants,
self._supercell,
cutoff_radius,
symprec=self._symprec)
def set_force_constants(self, force_constants):
self._force_constants = force_constants
def set_force_sets(self, force_sets):
print
print(
"********************************** Warning"
"**********************************")
print "set_force_sets will be obsolete."
print(" The method name is changed to set_displacement_dataset.")
print(
"******************************************"
"**********************************")
print
self.set_displacement_dataset(force_sets)
def set_displacement_dataset(self, displacement_dataset):
"""
displacement_dataset:
{'natom': number_of_atoms_in_supercell,
'first_atoms': [
{'number': atom index of displaced atom,
'displacement': displacement in Cartesian coordinates,
'direction': displacement direction with respect to axes
'forces': forces on atoms in supercell},
{...}, ...]}
"""
self._displacement_dataset = displacement_dataset
self._displacements = []
self._displacement_directions = []
for disp in self._displacement_dataset['first_atoms']:
x = disp['displacement']
self._displacements.append([disp['number'], x[0], x[1], x[2]])
if 'direction' in disp:
y = disp['direction']
self._displacement_directions.append(
[disp['number'], y[0], y[1], y[2]])
if not self._displacement_directions:
self._displacement_directions = None
def symmetrize_force_constants(self, iteration=3):
symmetrize_force_constants(self._force_constants, iteration)
def symmetrize_force_constants_by_space_group(self):
rotations = self._symmetry.get_symmetry_operations()['rotations']
translations = self._symmetry.get_symmetry_operations()['translations']
set_tensor_symmetry(self._force_constants,
self._supercell.get_cell().T,
self._supercell.get_scaled_positions(), rotations,
translations, self._symprec)
def get_force_constants(self):
return self._force_constants
force_constants = property(get_force_constants)
def get_rotational_condition_of_fc(self):
return rotational_invariance(self._force_constants, self._supercell,
self._primitive, self._symprec)
def set_dynamical_matrix(self):
self._set_dynamical_matrix()
def get_dynamical_matrix_at_q(self, q):
self._set_dynamical_matrix()
self._dynamical_matrix.set_dynamical_matrix(q)
return self._dynamical_matrix.get_dynamical_matrix()
def get_frequencies(self, q):
"""
Calculate phonon frequencies at q
q: q-vector in reduced coordinates of primitive cell
"""
self._set_dynamical_matrix()
self._dynamical_matrix.set_dynamical_matrix(q)
dm = self._dynamical_matrix.get_dynamical_matrix()
frequencies = []
for eig in np.linalg.eigvalsh(dm).real:
if eig < 0:
frequencies.append(-np.sqrt(-eig))
else:
frequencies.append(np.sqrt(eig))
return np.array(frequencies) * self._factor
def get_frequencies_with_eigenvectors(self, q):
"""
Calculate phonon frequencies and eigenvectors at q
q: q-vector in reduced coordinates of primitive cell
"""
self._set_dynamical_matrix()
self._dynamical_matrix.set_dynamical_matrix(q)
dm = self._dynamical_matrix.get_dynamical_matrix()
frequencies = []
eigvals, eigenvectors = np.linalg.eigh(dm)
frequencies = []
for eig in eigvals:
if eig < 0:
frequencies.append(-np.sqrt(-eig))
else:
frequencies.append(np.sqrt(eig))
return np.array(frequencies) * self._factor, eigenvectors
def set_band_structure(self,
bands,
is_eigenvectors=False,
is_band_connection=False):
self._set_dynamical_matrix()
self._band_structure = BandStructure(
bands,
self._dynamical_matrix,
is_eigenvectors=is_eigenvectors,
is_band_connection=is_band_connection,
group_velocity=self._group_velocity,
factor=self._factor)
def get_band_structure(self):
band = self._band_structure
return (band.get_qpoints(), band.get_distances(),
band.get_frequencies(), band.get_eigenvectors())
def plot_band_structure(self, symbols=None):
return self._band_structure.plot_band(symbols)
def write_yaml_band_structure(self):
self._band_structure.write_yaml()
def set_mesh(self,
mesh,
shift=None,
is_time_reversal=True,
is_mesh_symmetry=True,
is_eigenvectors=False,
is_gamma_center=False):
self._set_dynamical_matrix()
self._mesh = Mesh(
self._dynamical_matrix,
mesh,
shift=shift,
is_time_reversal=is_time_reversal,
is_mesh_symmetry=is_mesh_symmetry,
is_eigenvectors=is_eigenvectors,
is_gamma_center=is_gamma_center,
group_velocity=self._group_velocity,
rotations=self._primitive_symmetry.get_pointgroup_operations(),
factor=self._factor)
def get_mesh(self):
return (self._mesh.get_qpoints(), self._mesh.get_weights(),
self._mesh.get_frequencies(), self._mesh.get_eigenvectors())
def write_yaml_mesh(self):
self._mesh.write_yaml()
def set_thermal_properties(self,
t_step=10,
t_max=1000,
t_min=0,
is_projection=False,
band_indices=None,
cutoff_frequency=None):
if self._mesh is None:
print "set_mesh has to be done before set_thermal_properties"
return False
else:
tp = ThermalProperties(self._mesh.get_frequencies(),
weights=self._mesh.get_weights(),
eigenvectors=self._mesh.get_eigenvectors(),
is_projection=is_projection,
band_indices=band_indices,
cutoff_frequency=cutoff_frequency)
tp.set_thermal_properties(t_step=t_step, t_max=t_max, t_min=t_min)
self._thermal_properties = tp
def get_thermal_properties(self):
temps, fe, entropy, cv = \
self._thermal_properties.get_thermal_properties()
return temps, fe, entropy, cv
def plot_thermal_properties(self):
return self._thermal_properties.plot_thermal_properties()
def write_yaml_thermal_properties(self,
filename='thermal_properties.yaml'):
self._thermal_properties.write_yaml(filename=filename)
def set_partial_DOS(self,
sigma=None,
freq_min=None,
freq_max=None,
freq_pitch=None,
tetrahedron_method=False,
direction=None):
if self._mesh is None:
print "set_mesh has to be done before set_thermal_properties"
sys.exit(1)
if self._mesh.get_eigenvectors() is None:
print "Eigenvectors have to be calculated."
sys.exit(1)
if direction is not None:
direction_cart = np.dot(direction, self._primitive.get_cell())
else:
direction_cart = None
pdos = PartialDos(self._mesh,
sigma=sigma,
tetrahedron_method=tetrahedron_method,
direction=direction_cart)
pdos.set_draw_area(freq_min, freq_max, freq_pitch)
pdos.run()
self._pdos = pdos
def get_partial_DOS(self):
"""
Retern frequencies and partial_dos.
The first element is freqs and the second is partial_dos.
frequencies: [freq1, freq2, ...]
partial_dos:
[[atom1-freq1, atom1-freq2, ...],
[atom2-freq1, atom2-freq2, ...],
...]
"""
return self._pdos.get_partial_dos()
def plot_partial_DOS(self, pdos_indices=None, legend=None):
return self._pdos.plot_pdos(indices=pdos_indices, legend=legend)
def write_partial_DOS(self):
self._pdos.write()
def set_total_DOS(self,
sigma=None,
freq_min=None,
freq_max=None,
freq_pitch=None,
tetrahedron_method=False):
if self._mesh is None:
print "set_mesh has to be done before set_thermal_properties"
sys.exit(1)
total_dos = TotalDos(self._mesh,
sigma=sigma,
tetrahedron_method=tetrahedron_method)
total_dos.set_draw_area(freq_min, freq_max, freq_pitch)
total_dos.run()
self._total_dos = total_dos
def get_total_DOS(self):
"""
Retern frequencies and total dos.
The first element is freqs and the second is total dos.
frequencies: [freq1, freq2, ...]
total_dos: [dos1, dos2, ...]
"""
return self._total_dos.get_dos()
def set_Debye_frequency(self, freq_max_fit=None):
self._total_dos.set_Debye_frequency(
self._primitive.get_number_of_atoms(), freq_max_fit=freq_max_fit)
def get_Debye_frequency(self):
return self._total_dos.get_Debye_frequency()
def plot_total_DOS(self):
return self._total_dos.plot_dos()
def write_total_DOS(self):
self._total_dos.write()
def set_thermal_displacements(self,
t_step=10,
t_max=1000,
t_min=0,
direction=None,
cutoff_frequency=None):
"""
cutoff_frequency:
phonon modes that have frequencies below cutoff_frequency
are ignored.
direction:
Projection direction in reduced coordinates
"""
if self._mesh is None:
print "set_mesh has to be done before set_thermal_properties"
sys.exit(1)
eigvecs = self._mesh.get_eigenvectors()
frequencies = self._mesh.get_frequencies()
mesh_nums = self._mesh.get_mesh_numbers()
if self._mesh.get_eigenvectors() is None:
print "Eigenvectors have to be calculated."
sys.exit(1)
if np.prod(mesh_nums) != len(eigvecs):
print "Sampling mesh must not be symmetrized."
sys.exit(1)
td = ThermalDisplacements(frequencies,
eigvecs,
self._primitive.get_masses(),
cutoff_frequency=cutoff_frequency)
td.set_temperature_range(t_min, t_max, t_step)
if direction is not None:
td.project_eigenvectors(direction, self._primitive.get_cell())
td.run()
self._thermal_displacements = td
def get_thermal_displacements(self):
if self._thermal_displacements is not None:
return self._thermal_displacements.get_thermal_displacements()
def plot_thermal_displacements(self, is_legend=False):
return self._thermal_displacements.plot(is_legend)
def write_yaml_thermal_displacements(self):
self._thermal_displacements.write_yaml()
def set_thermal_displacement_matrices(self,
t_step=10,
t_max=1000,
t_min=0,
cutoff_frequency=None):
"""
cutoff_frequency:
phonon modes that have frequencies below cutoff_frequency
are ignored.
direction:
Projection direction in reduced coordinates
"""
if self._mesh is None:
print "set_mesh has to be done before set_thermal_properties"
sys.exit(1)
eigvecs = self._mesh.get_eigenvectors()
frequencies = self._mesh.get_frequencies()
mesh_nums = self._mesh.get_mesh_numbers()
if self._mesh.get_eigenvectors() is None:
print "Eigenvectors have to be calculated."
sys.exit(1)
if np.prod(mesh_nums) != len(eigvecs):
print "Sampling mesh must not be symmetrized."
sys.exit(1)
tdm = ThermalDisplacementMatrices(frequencies,
eigvecs,
self._primitive.get_masses(),
cutoff_frequency=cutoff_frequency)
tdm.set_temperature_range(t_min, t_max, t_step)
tdm.run()
self._thermal_displacement_matrices = tdm
def get_thermal_displacement_matrices(self):
if self._thermal_displacement_matrices is not None:
return self._thermal_displacement_matrices.get_thermal_displacement_matrices(
)
def write_yaml_thermal_displacement_matrices(self):
self._thermal_displacement_matrices.write_yaml()
def set_thermal_distances(self,
atom_pairs,
t_step=10,
t_max=1000,
t_min=0,
cutoff_frequency=None):
"""
atom_pairs: List of list
Mean square distances are calculated for the atom_pairs
e.g. [[1, 2], [1, 4]]
cutoff_frequency:
phonon modes that have frequencies below cutoff_frequency
are ignored.
"""
td = ThermalDistances(self._mesh.get_frequencies(),
self._mesh.get_eigenvectors(),
self._supercell,
self._primitive,
self._mesh.get_qpoints(),
cutoff_frequency=cutoff_frequency)
td.set_temperature_range(t_min, t_max, t_step)
td.run(atom_pairs)
self._thermal_distances = td
def write_yaml_thermal_distances(self):
self._thermal_distances.write_yaml()
def set_qpoints_phonon(self,
q_points,
nac_q_direction=None,
is_eigenvectors=False,
write_dynamical_matrices=False,
factor=VaspToTHz):
self._set_dynamical_matrix()
self._qpoints_phonon = QpointsPhonon(
q_points,
self._dynamical_matrix,
nac_q_direction=nac_q_direction,
is_eigenvectors=is_eigenvectors,
group_velocity=self._group_velocity,
write_dynamical_matrices=write_dynamical_matrices,
factor=self._factor)
def get_qpoints_phonon(self):
return (self._qpoints_phonon.get_frequencies(),
self._qpoints_phonon.get_eigenvectors())
def write_yaml_qpoints_phonon(self):
self._qpoints_phonon.write_yaml()
def write_animation(self,
q_point=None,
anime_type='v_sim',
band_index=None,
amplitude=None,
num_div=None,
shift=None,
filename=None):
self._set_dynamical_matrix()
if q_point is None:
animation = Animation([0, 0, 0],
self._dynamical_matrix,
shift=shift)
else:
animation = Animation(q_point, self._dynamical_matrix, shift=shift)
if anime_type == 'v_sim':
if amplitude:
amplitude_ = amplitude
else:
amplitude_ = 1.0
if filename:
animation.write_v_sim(amplitude=amplitude_,
factor=self._factor,
filename=filename)
else:
animation.write_v_sim(amplitude=amplitude_,
factor=self._factor)
if (anime_type == 'arc' or anime_type == 'xyz' or anime_type == 'jmol'
or anime_type == 'poscar'):
if band_index is None or amplitude is None or num_div is None:
print "Parameters are not correctly set for animation."
sys.exit(1)
if anime_type == 'arc' or anime_type is None:
if filename:
animation.write_arc(band_index,
amplitude,
num_div,
filename=filename)
else:
animation.write_arc(band_index, amplitude, num_div)
if anime_type == 'xyz':
if filename:
animation.write_xyz(band_index,
amplitude,
num_div,
self._factor,
filename=filename)
else:
animation.write_xyz(band_index, amplitude, num_div,
self._factor)
if anime_type == 'jmol':
if filename:
animation.write_xyz_jmol(amplitude=amplitude,
factor=self._factor,
filename=filename)
else:
animation.write_xyz_jmol(amplitude=amplitude,
factor=self._factor)
if anime_type == 'poscar':
if filename:
animation.write_POSCAR(band_index,
amplitude,
num_div,
filename=filename)
else:
animation.write_POSCAR(band_index, amplitude, num_div)
def set_modulations(self,
dimension,
phonon_modes,
delta_q=None,
derivative_order=None,
nac_q_direction=None):
self._set_dynamical_matrix()
self._modulation = Modulation(self._dynamical_matrix,
dimension,
phonon_modes,
delta_q=delta_q,
derivative_order=derivative_order,
nac_q_direction=nac_q_direction,
factor=self._factor)
self._modulation.run()
def get_modulations(self):
"""Returns cells with modulations as Atoms objects"""
return self._modulation.get_modulations()
def get_delta_modulations(self):
"""Return modulations relative to equilibrium supercell
(modulations, supercell)
modulations: Atomic modulations of supercell in Cartesian coordinates
supercell: Supercell as an Atoms object.
"""
return self._modulation.get_delta_modulations()
def write_modulations(self):
"""Create MPOSCAR's"""
self._modulation.write()
def write_yaml_modulations(self):
self._modulation.write_yaml()
def set_irreps(self,
q,
is_little_cogroup=False,
nac_q_direction=None,
degeneracy_tolerance=1e-4):
self._set_dynamical_matrix()
self._irreps = IrReps(self._dynamical_matrix,
q,
is_little_cogroup=is_little_cogroup,
nac_q_direction=nac_q_direction,
factor=self._factor,
symprec=self._symprec,
degeneracy_tolerance=degeneracy_tolerance,
log_level=self._log_level)
return self._irreps.run()
def get_irreps(self):
return self._irreps
def show_irreps(self, show_irreps=False):
self._irreps.show(show_irreps=show_irreps)
def write_yaml_irreps(self, show_irreps=False):
self._irreps.write_yaml(show_irreps=show_irreps)
def set_group_velocity(self, q_length=None):
self._set_dynamical_matrix()
self._group_velocity = GroupVelocity(
self._dynamical_matrix,
q_length=q_length,
symmetry=self._primitive_symmetry,
frequency_factor_to_THz=self._factor)
def get_group_velocity(self):
return self._group_velocity.get_group_velocity()
def get_group_velocity_at_q(self, q_point):
if self._group_velocity is None:
self.set_group_velocity()
self._group_velocity.set_q_points([q_point])
return self._group_velocity.get_group_velocity()[0]
def _run_force_constants_from_forces(self,
distributed_atom_list=None,
decimals=None,
computation_algorithm="svd"):
if self._displacement_dataset is not None:
self._force_constants = get_fc2(
self._supercell,
self._symmetry,
self._displacement_dataset,
atom_list=distributed_atom_list,
decimals=decimals,
computation_algorithm=computation_algorithm)
def _set_dynamical_matrix(self):
if self._nac_params is None:
self._dynamical_matrix = DynamicalMatrix(
self._supercell,
self._primitive,
self._force_constants,
decimals=self._dynamical_matrix_decimals,
symprec=self._symprec)
else:
self._dynamical_matrix = DynamicalMatrixNAC(
self._supercell,
self._primitive,
self._force_constants,
nac_params=self._nac_params,
decimals=self._dynamical_matrix_decimals,
symprec=self._symprec)
def _search_symmetry(self):
self._symmetry = Symmetry(self._supercell, self._symprec,
self._is_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 _build_supercell(self):
self._supercell = get_supercell(self._unitcell, self._supercell_matrix,
self._symprec)
def _build_supercells_with_displacements(self):
supercells = []
for disp in self._displacement_dataset['first_atoms']:
positions = self._supercell.get_positions()
positions[disp['number']] += disp['displacement']
supercells.append(
Atoms(numbers=self._supercell.get_atomic_numbers(),
masses=self._supercell.get_masses(),
magmoms=self._supercell.get_magnetic_moments(),
positions=positions,
cell=self._supercell.get_cell(),
pbc=True))
self._supercells_with_displacements = supercells
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)
self._primitive = get_primitive(self._supercell, trans_mat,
self._symprec)
num_satom = self._supercell.get_number_of_atoms()
num_patom = self._primitive.get_number_of_atoms()
if abs(num_satom * np.linalg.det(trans_mat) - num_patom) < 0.1:
return True
else:
return False
class Phonopy(object):
def __init__(self,
unitcell,
supercell_matrix,
primitive_matrix=None,
nac_params=None,
distance=None,
factor=VaspToTHz,
is_auto_displacements=None,
dynamical_matrix_decimals=None,
force_constants_decimals=None,
symprec=1e-5,
is_symmetry=True,
use_lapack_solver=False,
log_level=0):
if is_auto_displacements is not None:
print("Warning: \'is_auto_displacements\' argument is obsolete.")
if is_auto_displacements is False:
print("Sets of displacements are not created as default.")
else:
print("Use \'generate_displacements\' method explicitly to "
"create sets of displacements.")
if distance is not None:
print("Warning: \'distance\' keyword argument is obsolete at "
"Phonopy instantiation.")
print("Specify \'distance\' keyword argument when calling "
"\'generate_displacements\'")
print("method (See the Phonopy API document).")
self._symprec = symprec
self._factor = factor
self._is_symmetry = is_symmetry
self._use_lapack_solver = use_lapack_solver
self._log_level = log_level
# Create supercell and primitive cell
self._unitcell = Atoms(atoms=unitcell)
self._supercell_matrix = supercell_matrix
self._primitive_matrix = primitive_matrix
self._supercell = None
self._primitive = None
self._build_supercell()
self._build_primitive_cell()
# Set supercell and primitive symmetry
self._symmetry = None
self._primitive_symmetry = None
self._search_symmetry()
self._search_primitive_symmetry()
# set_displacements (used only in preprocess)
self._displacement_dataset = None
self._displacements = None
self._displacement_directions = None
self._supercells_with_displacements = None
# set_force_constants or set_forces
self._force_constants = None
self._force_constants_decimals = force_constants_decimals
# set_dynamical_matrix
self._dynamical_matrix = None
self._nac_params = nac_params
self._dynamical_matrix_decimals = dynamical_matrix_decimals
# set_band_structure
self._band_structure = None
# set_mesh
self._mesh = None
# set_tetrahedron_method
self._tetrahedron_method = None
# set_thermal_properties
self._thermal_properties = None
# set_thermal_displacements
self._thermal_displacements = None
# set_thermal_displacement_matrices
self._thermal_displacement_matrices = None
# set_partial_DOS
self._pdos = None
# set_total_DOS
self._total_dos = None
# set_modulation
self._modulation = None
# set_character_table
self._irreps = None
# set_group_velocity
self._group_velocity = None
def get_version(self):
return __version__
def get_primitive(self):
return self._primitive
primitive = property(get_primitive)
def get_unitcell(self):
return self._unitcell
unitcell = property(get_unitcell)
def get_supercell(self):
return self._supercell
supercell = property(get_supercell)
def get_symmetry(self):
"""return symmetry of supercell"""
return self._symmetry
symmetry = property(get_symmetry)
def get_primitive_symmetry(self):
"""return symmetry of primitive cell"""
return self._primitive_symmetry
def get_supercell_matrix(self):
return self._supercell_matrix
def get_primitive_matrix(self):
return self._primitive_matrix
def get_unit_conversion_factor(self):
return self._factor
unit_conversion_factor = property(get_unit_conversion_factor)
def get_displacement_dataset(self):
return self._displacement_dataset
def get_displacements(self):
return self._displacements
displacements = property(get_displacements)
def get_displacement_directions(self):
return self._displacement_directions
displacement_directions = property(get_displacement_directions)
def get_supercells_with_displacements(self):
if self._displacement_dataset is None:
return None
else:
self._build_supercells_with_displacements()
return self._supercells_with_displacements
def get_force_constants(self):
return self._force_constants
force_constants = property(get_force_constants)
def get_rotational_condition_of_fc(self):
return rotational_invariance(self._force_constants,
self._supercell,
self._primitive,
self._symprec)
def get_nac_params(self):
return self._nac_params
def get_dynamical_matrix(self):
return self._dynamical_matrix
dynamical_matrix = property(get_dynamical_matrix)
def set_unitcell(self, unitcell):
self._unitcell = unitcell
self._build_supercell()
self._build_primitive_cell()
self._search_symmetry()
self._search_primitive_symmetry()
self._displacement_dataset = None
def set_masses(self, masses):
p_masses = np.array(masses)
self._primitive.set_masses(p_masses)
p2p_map = self._primitive.get_primitive_to_primitive_map()
s_masses = p_masses[[p2p_map[x] for x in
self._primitive.get_supercell_to_primitive_map()]]
self._supercell.set_masses(s_masses)
u2s_map = self._supercell.get_unitcell_to_supercell_map()
u_masses = s_masses[u2s_map]
self._unitcell.set_masses(u_masses)
self._set_dynamical_matrix()
def set_nac_params(self, nac_params=None):
self._nac_params = nac_params
self._set_dynamical_matrix()
def set_displacement_dataset(self, displacement_dataset):
"""
displacement_dataset:
{'natom': number_of_atoms_in_supercell,
'first_atoms': [
{'number': atom index of displaced atom,
'displacement': displacement in Cartesian coordinates,
'direction': displacement direction with respect to axes
'forces': forces on atoms in supercell},
{...}, ...]}
"""
self._displacement_dataset = displacement_dataset
self._displacements = []
self._displacement_directions = []
for disp in self._displacement_dataset['first_atoms']:
x = disp['displacement']
self._displacements.append([disp['number'], x[0], x[1], x[2]])
if 'direction' in disp:
y = disp['direction']
self._displacement_directions.append(
[disp['number'], y[0], y[1], y[2]])
if not self._displacement_directions:
self._displacement_directions = None
def set_forces(self, sets_of_forces):
"""
sets_of_forces:
[[[f_1x, f_1y, f_1z], [f_2x, f_2y, f_2z], ...], # first supercell
[[f_1x, f_1y, f_1z], [f_2x, f_2y, f_2z], ...], # second supercell
... ]
"""
for disp, forces in zip(
self._displacement_dataset['first_atoms'], sets_of_forces):
disp['forces'] = forces
def set_force_constants(self, force_constants):
self._force_constants = force_constants
self._set_dynamical_matrix()
def set_force_constants_zero_with_radius(self, cutoff_radius):
cutoff_force_constants(self._force_constants,
self._supercell,
cutoff_radius,
symprec=self._symprec)
self._set_dynamical_matrix()
def set_dynamical_matrix(self):
self._set_dynamical_matrix()
def generate_displacements(self,
distance=0.01,
is_plusminus='auto',
is_diagonal=True,
is_trigonal=False):
"""Generate displacements automatically
displacemsts: List of displacements in Cartesian coordinates.
[[0, 0.01, 0.00, 0.00], ...]
where each set of elements is defined by:
First value: Atom index in supercell starting with 0
Second to fourth: Displacement in Cartesian coordinates
displacement_directions:
List of directions with respect to axes. This gives only the
symmetrically non equivalent directions. The format is like:
[[0, 1, 0, 0],
[7, 1, 0, 1], ...]
where each list is defined by:
First value: Atom index in supercell starting with 0
Second to fourth: If the direction is displaced or not ( 1, 0, or -1 )
with respect to the axes.
"""
displacement_directions = get_least_displacements(
self._symmetry,
is_plusminus=is_plusminus,
is_diagonal=is_diagonal,
is_trigonal=is_trigonal,
log_level=self._log_level)
displacement_dataset = direction_to_displacement(
displacement_directions,
distance,
self._supercell)
self.set_displacement_dataset(displacement_dataset)
def produce_force_constants(self,
forces=None,
calculate_full_force_constants=True,
computation_algorithm="svd"):
if forces is not None:
self.set_forces(forces)
# A primitive check if 'forces' key is in displacement_dataset.
for disp in self._displacement_dataset['first_atoms']:
if 'forces' not in disp:
return False
if calculate_full_force_constants:
self._run_force_constants_from_forces(
decimals=self._force_constants_decimals,
computation_algorithm=computation_algorithm)
else:
p2s_map = self._primitive.get_primitive_to_supercell_map()
self._run_force_constants_from_forces(
distributed_atom_list=p2s_map,
decimals=self._force_constants_decimals,
computation_algorithm=computation_algorithm)
self._set_dynamical_matrix()
return True
def symmetrize_force_constants(self, iteration=3):
symmetrize_force_constants(self._force_constants, iteration)
self._set_dynamical_matrix()
def symmetrize_force_constants_by_space_group(self):
from phonopy.harmonic.force_constants import (set_tensor_symmetry,
set_tensor_symmetry_PJ)
set_tensor_symmetry_PJ(self._force_constants,
self._supercell.get_cell().T,
self._supercell.get_scaled_positions(),
self._symmetry)
self._set_dynamical_matrix()
#####################
# Phonon properties #
#####################
# Single q-point
def get_dynamical_matrix_at_q(self, q):
self._set_dynamical_matrix()
if self._dynamical_matrix is None:
print("Warning: Dynamical matrix has not yet built.")
return None
self._dynamical_matrix.set_dynamical_matrix(q)
return self._dynamical_matrix.get_dynamical_matrix()
def get_frequencies(self, q):
"""
Calculate phonon frequencies at q
q: q-vector in reduced coordinates of primitive cell
"""
self._set_dynamical_matrix()
if self._dynamical_matrix is None:
print("Warning: Dynamical matrix has not yet built.")
return None
self._dynamical_matrix.set_dynamical_matrix(q)
dm = self._dynamical_matrix.get_dynamical_matrix()
frequencies = []
for eig in np.linalg.eigvalsh(dm).real:
if eig < 0:
frequencies.append(-np.sqrt(-eig))
else:
frequencies.append(np.sqrt(eig))
return np.array(frequencies) * self._factor
def get_frequencies_with_eigenvectors(self, q):
"""
Calculate phonon frequencies and eigenvectors at q
q: q-vector in reduced coordinates of primitive cell
"""
self._set_dynamical_matrix()
if self._dynamical_matrix is None:
print("Warning: Dynamical matrix has not yet built.")
return None
self._dynamical_matrix.set_dynamical_matrix(q)
dm = self._dynamical_matrix.get_dynamical_matrix()
frequencies = []
eigvals, eigenvectors = np.linalg.eigh(dm)
frequencies = []
for eig in eigvals:
if eig < 0:
frequencies.append(-np.sqrt(-eig))
else:
frequencies.append(np.sqrt(eig))
return np.array(frequencies) * self._factor, eigenvectors
# Band structure
def set_band_structure(self,
bands,
is_eigenvectors=False,
is_band_connection=False):
if self._dynamical_matrix is None:
print("Warning: Dynamical matrix has not yet built.")
self._band_structure = None
return False
self._band_structure = BandStructure(
bands,
self._dynamical_matrix,
is_eigenvectors=is_eigenvectors,
is_band_connection=is_band_connection,
group_velocity=self._group_velocity,
factor=self._factor)
return True
def get_band_structure(self):
band = self._band_structure
return (band.get_qpoints(),
band.get_distances(),
band.get_frequencies(),
band.get_eigenvectors())
def plot_band_structure(self, labels=None):
import matplotlib.pyplot as plt
if labels:
from matplotlib import rc
rc('text', usetex=True)
fig, ax = plt.subplots()
ax.xaxis.set_ticks_position('both')
ax.yaxis.set_ticks_position('both')
ax.xaxis.set_tick_params(which='both', direction='in')
ax.yaxis.set_tick_params(which='both', direction='in')
self._band_structure.plot(plt, labels=labels)
return plt
def write_yaml_band_structure(self,
labels=None,
comment=None,
filename="band.yaml"):
self._band_structure.write_yaml(labels=labels,
comment=comment,
filename=filename)
# Sampling mesh
def run_mesh(self):
if self._mesh is not None:
self._mesh.run()
def set_mesh(self,
mesh,
shift=None,
is_time_reversal=True,
is_mesh_symmetry=True,
is_eigenvectors=False,
is_gamma_center=False,
run_immediately=True):
if self._dynamical_matrix is None:
print("Warning: Dynamical matrix has not yet built.")
self._mesh = None
return False
self._mesh = Mesh(
self._dynamical_matrix,
mesh,
shift=shift,
is_time_reversal=is_time_reversal,
is_mesh_symmetry=is_mesh_symmetry,
is_eigenvectors=is_eigenvectors,
is_gamma_center=is_gamma_center,
group_velocity=self._group_velocity,
rotations=self._primitive_symmetry.get_pointgroup_operations(),
factor=self._factor,
use_lapack_solver=self._use_lapack_solver)
if run_immediately:
self._mesh.run()
return True
def get_mesh(self):
if self._mesh is None:
return None
else:
return (self._mesh.get_qpoints(),
self._mesh.get_weights(),
self._mesh.get_frequencies(),
self._mesh.get_eigenvectors())
def get_mesh_grid_info(self):
if self._mesh is None:
return None
else:
return (self._mesh.get_grid_address(),
self._mesh.get_ir_grid_points(),
self._mesh.get_grid_mapping_table())
def write_hdf5_mesh(self):
self._mesh.write_hdf5()
def write_yaml_mesh(self):
self._mesh.write_yaml()
# Plot band structure and DOS (PDOS) together
def plot_band_structure_and_dos(self, pdos_indices=None, labels=None):
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
if labels:
from matplotlib import rc
rc('text', usetex=True)
plt.figure(figsize=(10, 6))
gs = gridspec.GridSpec(1, 2, width_ratios=[3, 1])
ax1 = plt.subplot(gs[0, 0])
ax1.xaxis.set_ticks_position('both')
ax1.yaxis.set_ticks_position('both')
ax1.xaxis.set_tick_params(which='both', direction='in')
ax1.yaxis.set_tick_params(which='both', direction='in')
self._band_structure.plot(plt, labels=labels)
ax2 = plt.subplot(gs[0, 1], sharey=ax1)
ax2.xaxis.set_ticks_position('both')
ax2.yaxis.set_ticks_position('both')
ax2.xaxis.set_tick_params(which='both', direction='in')
ax2.yaxis.set_tick_params(which='both', direction='in')
plt.subplots_adjust(wspace=0.03)
plt.setp(ax2.get_yticklabels(), visible=False)
if pdos_indices is None:
self._total_dos.plot(plt,
ylabel="",
draw_grid=False,
flip_xy=True)
else:
self._pdos.plot(plt,
indices=pdos_indices,
ylabel="",
draw_grid=False,
flip_xy=True)
ax2.set_xlim((0, None))
return plt
# DOS
def set_total_DOS(self,
sigma=None,
freq_min=None,
freq_max=None,
freq_pitch=None,
tetrahedron_method=False):
if self._mesh is None:
print("Warning: \'set_mesh\' has to finish correctly "
"before DOS calculation.")
self._total_dos = None
return False
total_dos = TotalDos(self._mesh,
sigma=sigma,
tetrahedron_method=tetrahedron_method)
total_dos.set_draw_area(freq_min, freq_max, freq_pitch)
total_dos.run()
self._total_dos = total_dos
return True
def get_total_DOS(self):
"""
Retern frequencies and total dos.
The first element is freqs and the second is total dos.
frequencies: [freq1, freq2, ...]
total_dos: [dos1, dos2, ...]
"""
return self._total_dos.get_dos()
def set_Debye_frequency(self, freq_max_fit=None):
self._total_dos.set_Debye_frequency(
self._primitive.get_number_of_atoms(),
freq_max_fit=freq_max_fit)
def get_Debye_frequency(self):
return self._total_dos.get_Debye_frequency()
def plot_total_DOS(self):
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
ax.xaxis.set_ticks_position('both')
ax.yaxis.set_ticks_position('both')
ax.xaxis.set_tick_params(which='both', direction='in')
ax.yaxis.set_tick_params(which='both', direction='in')
self._total_dos.plot(plt, draw_grid=False)
ax.set_ylim((0, None))
return plt
def write_total_DOS(self):
self._total_dos.write()
# PDOS
def set_partial_DOS(self,
sigma=None,
freq_min=None,
freq_max=None,
freq_pitch=None,
tetrahedron_method=False,
direction=None,
xyz_projection=False):
self._pdos = None
if self._mesh is None:
print("Warning: \'set_mesh\' has to be called before "
"PDOS calculation.")
return False
if self._mesh.get_eigenvectors() is None:
print("Warning: Eigenvectors have to be calculated.")
return False
num_grid = np.prod(self._mesh.get_mesh_numbers())
if num_grid != len(self._mesh.get_ir_grid_points()):
print("Warning: \'set_mesh\' has to be called with "
"is_mesh_symmetry=False.")
return False
if direction is not None:
direction_cart = np.dot(direction, self._primitive.get_cell())
else:
direction_cart = None
self._pdos = PartialDos(self._mesh,
sigma=sigma,
tetrahedron_method=tetrahedron_method,
direction=direction_cart,
xyz_projection=xyz_projection)
self._pdos.set_draw_area(freq_min, freq_max, freq_pitch)
self._pdos.run()
return True
def get_partial_DOS(self):
"""
Retern frequencies and partial_dos.
The first element is freqs and the second is partial_dos.
frequencies: [freq1, freq2, ...]
partial_dos:
[[atom1-freq1, atom1-freq2, ...],
[atom2-freq1, atom2-freq2, ...],
...]
"""
return self._pdos.get_partial_dos()
def plot_partial_DOS(self, pdos_indices=None, legend=None):
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
ax.xaxis.set_ticks_position('both')
ax.yaxis.set_ticks_position('both')
ax.xaxis.set_tick_params(which='both', direction='in')
ax.yaxis.set_tick_params(which='both', direction='in')
self._pdos.plot(plt,
indices=pdos_indices,
legend=legend,
draw_grid=False)
ax.set_ylim((0, None))
return plt
def write_partial_DOS(self):
self._pdos.write()
# Thermal property
def set_thermal_properties(self,
t_step=10,
t_max=1000,
t_min=0,
temperatures=None,
is_projection=False,
band_indices=None,
cutoff_frequency=None,
pretend_real=False):
if self._mesh is None:
print("Warning: set_mesh has to be done before "
"set_thermal_properties")
return False
else:
tp = ThermalProperties(self._mesh.get_frequencies(),
weights=self._mesh.get_weights(),
eigenvectors=self._mesh.get_eigenvectors(),
is_projection=is_projection,
band_indices=band_indices,
cutoff_frequency=cutoff_frequency,
pretend_real=pretend_real)
if temperatures is None:
tp.set_temperature_range(t_step=t_step,
t_max=t_max,
t_min=t_min)
else:
tp.set_temperatures(temperatures)
tp.run()
self._thermal_properties = tp
def get_thermal_properties(self):
temps, fe, entropy, cv = \
self._thermal_properties.get_thermal_properties()
return temps, fe, entropy, cv
def plot_thermal_properties(self):
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
ax.xaxis.set_ticks_position('both')
ax.yaxis.set_ticks_position('both')
ax.xaxis.set_tick_params(which='both', direction='in')
ax.yaxis.set_tick_params(which='both', direction='in')
self._thermal_properties.plot(plt)
temps, _, _, _ = self._thermal_properties.get_thermal_properties()
ax.set_xlim((0, temps[-1]))
return plt
def write_yaml_thermal_properties(self, filename='thermal_properties.yaml'):
self._thermal_properties.write_yaml(filename=filename)
# Thermal displacement
def set_thermal_displacements(self,
t_step=10,
t_max=1000,
t_min=0,
temperatures=None,
direction=None,
cutoff_frequency=None):
"""
cutoff_frequency:
phonon modes that have frequencies below cutoff_frequency
are ignored.
direction:
Projection direction in reduced coordinates
"""
self._thermal_displacements = None
if self._mesh is None:
print("Warning: \'set_mesh\' has to finish correctly "
"before \'set_thermal_displacements\'.")
return False
eigvecs = self._mesh.get_eigenvectors()
frequencies = self._mesh.get_frequencies()
mesh_nums = self._mesh.get_mesh_numbers()
if self._mesh.get_eigenvectors() is None:
print("Warning: Eigenvectors have to be calculated.")
return False
if np.prod(mesh_nums) != len(eigvecs):
print("Warning: Sampling mesh must not be symmetrized.")
return False
td = ThermalDisplacements(frequencies,
eigvecs,
self._primitive.get_masses(),
cutoff_frequency=cutoff_frequency)
if temperatures is None:
td.set_temperature_range(t_min, t_max, t_step)
else:
td.set_temperatures(temperatures)
if direction is not None:
td.project_eigenvectors(direction, self._primitive.get_cell())
td.run()
self._thermal_displacements = td
return True
def get_thermal_displacements(self):
if self._thermal_displacements is not None:
return self._thermal_displacements.get_thermal_displacements()
def plot_thermal_displacements(self, is_legend=False):
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
ax.xaxis.set_ticks_position('both')
ax.yaxis.set_ticks_position('both')
ax.xaxis.set_tick_params(which='both', direction='in')
ax.yaxis.set_tick_params(which='both', direction='in')
self._thermal_displacements.plot(plt, is_legend=is_legend)
temps, _ = self._thermal_displacements.get_thermal_displacements()
ax.set_xlim((0, temps[-1]))
return plt
def write_yaml_thermal_displacements(self):
self._thermal_displacements.write_yaml()
# Thermal displacement matrix
def set_thermal_displacement_matrices(self,
t_step=10,
t_max=1000,
t_min=0,
cutoff_frequency=None,
t_cif=None):
"""
cutoff_frequency:
phonon modes that have frequencies below cutoff_frequency
are ignored.
direction:
Projection direction in reduced coordinates
"""
self._thermal_displacement_matrices = None
if self._mesh is None:
print("Warning: \'set_mesh\' has to finish correctly "
"before \'set_thermal_displacement_matrices\'.")
return False
eigvecs = self._mesh.get_eigenvectors()
frequencies = self._mesh.get_frequencies()
mesh_nums = self._mesh.get_mesh_numbers()
if self._mesh.get_eigenvectors() is None:
print("Warning: Eigenvectors have to be calculated.")
return False
if np.prod(mesh_nums) != len(eigvecs):
print("Warning: Sampling mesh must not be symmetrized.")
return False
tdm = ThermalDisplacementMatrices(frequencies,
eigvecs,
self._primitive.get_masses(),
cutoff_frequency=cutoff_frequency,
lattice=self._primitive.get_cell().T)
if t_cif is None:
tdm.set_temperature_range(t_min, t_max, t_step)
else:
tdm.set_temperatures([t_cif])
tdm.run()
self._thermal_displacement_matrices = tdm
return True
def get_thermal_displacement_matrices(self):
tdm = self._thermal_displacement_matrices
if tdm is not None:
return tdm.get_thermal_displacement_matrices()
def write_yaml_thermal_displacement_matrices(self):
self._thermal_displacement_matrices.write_yaml()
def write_thermal_displacement_matrix_to_cif(self,
temperature_index):
self._thermal_displacement_matrices.write_cif(self._primitive,
temperature_index)
# Mean square distance between a pair of atoms
def set_thermal_distances(self,
atom_pairs,
t_step=10,
t_max=1000,
t_min=0,
cutoff_frequency=None):
"""
atom_pairs: List of list
Mean square distances are calculated for the atom_pairs
e.g. [[1, 2], [1, 4]]
cutoff_frequency:
phonon modes that have frequencies below cutoff_frequency
are ignored.
"""
td = ThermalDistances(self._mesh.get_frequencies(),
self._mesh.get_eigenvectors(),
self._supercell,
self._primitive,
self._mesh.get_qpoints(),
cutoff_frequency=cutoff_frequency)
td.set_temperature_range(t_min, t_max, t_step)
td.run(atom_pairs)
self._thermal_distances = td
def write_yaml_thermal_distances(self):
self._thermal_distances.write_yaml()
# Sampling at q-points
def set_qpoints_phonon(self,
q_points,
nac_q_direction=None,
is_eigenvectors=False,
write_dynamical_matrices=False):
if self._dynamical_matrix is None:
print("Warning: Dynamical matrix has not yet built.")
self._qpoints_phonon = None
return False
self._qpoints_phonon = QpointsPhonon(
np.reshape(q_points, (-1, 3)),
self._dynamical_matrix,
nac_q_direction=nac_q_direction,
is_eigenvectors=is_eigenvectors,
group_velocity=self._group_velocity,
write_dynamical_matrices=write_dynamical_matrices,
factor=self._factor)
return True
def get_qpoints_phonon(self):
return (self._qpoints_phonon.get_frequencies(),
self._qpoints_phonon.get_eigenvectors())
def write_hdf5_qpoints_phonon(self):
self._qpoints_phonon.write_hdf5()
def write_yaml_qpoints_phonon(self):
self._qpoints_phonon.write_yaml()
# Normal mode animation
def write_animation(self,
q_point=None,
anime_type='v_sim',
band_index=None,
amplitude=None,
num_div=None,
shift=None,
filename=None):
if self._dynamical_matrix is None:
print("Warning: Dynamical matrix has not yet built.")
return False
if q_point is None:
animation = Animation([0, 0, 0],
self._dynamical_matrix,
shift=shift)
else:
animation = Animation(q_point,
self._dynamical_matrix,
shift=shift)
if anime_type == 'v_sim':
if amplitude:
amplitude_ = amplitude
else:
amplitude_ = 1.0
if filename:
animation.write_v_sim(amplitude=amplitude_,
factor=self._factor,
filename=filename)
else:
animation.write_v_sim(amplitude=amplitude_,
factor=self._factor)
if (anime_type == 'arc' or
anime_type == 'xyz' or
anime_type == 'jmol' or
anime_type == 'poscar'):
if band_index is None or amplitude is None or num_div is None:
print("Warning: Parameters are not correctly set for "
"animation.")
return False
if anime_type == 'arc' or anime_type is None:
if filename:
animation.write_arc(band_index,
amplitude,
num_div,
filename=filename)
else:
animation.write_arc(band_index,
amplitude,
num_div)
if anime_type == 'xyz':
if filename:
animation.write_xyz(band_index,
amplitude,
num_div,
self._factor,
filename=filename)
else:
animation.write_xyz(band_index,
amplitude,
num_div,
self._factor)
if anime_type == 'jmol':
if filename:
animation.write_xyz_jmol(amplitude=amplitude,
factor=self._factor,
filename=filename)
else:
animation.write_xyz_jmol(amplitude=amplitude,
factor=self._factor)
if anime_type == 'poscar':
if filename:
animation.write_POSCAR(band_index,
amplitude,
num_div,
filename=filename)
else:
animation.write_POSCAR(band_index,
amplitude,
num_div)
return True
# Atomic modulation of normal mode
def set_modulations(self,
dimension,
phonon_modes,
delta_q=None,
derivative_order=None,
nac_q_direction=None):
if self._dynamical_matrix is None:
print("Warning: Dynamical matrix has not yet built.")
self._modulation = None
return False
self._modulation = Modulation(self._dynamical_matrix,
dimension,
phonon_modes,
delta_q=delta_q,
derivative_order=derivative_order,
nac_q_direction=nac_q_direction,
factor=self._factor)
self._modulation.run()
return True
def get_modulated_supercells(self):
"""Returns cells with modulations as Atoms objects"""
return self._modulation.get_modulated_supercells()
def get_modulations_and_supercell(self):
"""Return modulations and supercell
(modulations, supercell)
modulations: Atomic modulations of supercell in Cartesian coordinates
supercell: Supercell as an Atoms object.
"""
return self._modulation.get_modulations_and_supercell()
def write_modulations(self):
"""Create MPOSCAR's"""
self._modulation.write()
def write_yaml_modulations(self):
self._modulation.write_yaml()
# Irreducible representation
def set_irreps(self,
q,
is_little_cogroup=False,
nac_q_direction=None,
degeneracy_tolerance=1e-4):
if self._dynamical_matrix is None:
print("Warning: Dynamical matrix has not yet built.")
self._irreps = None
return None
self._irreps = IrReps(
self._dynamical_matrix,
q,
is_little_cogroup=is_little_cogroup,
nac_q_direction=nac_q_direction,
factor=self._factor,
symprec=self._symprec,
degeneracy_tolerance=degeneracy_tolerance,
log_level=self._log_level)
return self._irreps.run()
def get_irreps(self):
return self._irreps
def show_irreps(self, show_irreps=False):
self._irreps.show(show_irreps=show_irreps)
def write_yaml_irreps(self, show_irreps=False):
self._irreps.write_yaml(show_irreps=show_irreps)
# Group velocity
def set_group_velocity(self, q_length=None):
if self._dynamical_matrix is None:
print("Warning: Dynamical matrix has not yet built.")
self._group_velocity = None
return False
self._group_velocity = GroupVelocity(
self._dynamical_matrix,
q_length=q_length,
symmetry=self._primitive_symmetry,
frequency_factor_to_THz=self._factor)
return True
def get_group_velocity(self):
return self._group_velocity.get_group_velocity()
def get_group_velocity_at_q(self, q_point):
if self._group_velocity is None:
self.set_group_velocity()
self._group_velocity.set_q_points([q_point])
return self._group_velocity.get_group_velocity()[0]
# Moment
def set_moment(self,
order=1,
is_projection=False,
freq_min=None,
freq_max=None):
if self._mesh is None:
print("Warning: set_mesh has to be done before set_moment")
return False
else:
if is_projection:
if self._mesh.get_eigenvectors() is None:
print("Warning: Eigenvectors have to be calculated.")
return False
moment = PhononMoment(
self._mesh.get_frequencies(),
weights=self._mesh.get_weights(),
eigenvectors=self._mesh.get_eigenvectors())
else:
moment = PhononMoment(
self._mesh.get_frequencies(),
weights=self._mesh.get_weights())
if freq_min is not None or freq_max is not None:
moment.set_frequency_range(freq_min=freq_min,
freq_max=freq_max)
moment.run(order=order)
self._moment = moment.get_moment()
return True
def get_moment(self):
return self._moment
#################
# Local methods #
#################
def _run_force_constants_from_forces(self,
distributed_atom_list=None,
decimals=None,
computation_algorithm="svd"):
if self._displacement_dataset is not None:
self._force_constants = get_fc2(
self._supercell,
self._symmetry,
self._displacement_dataset,
atom_list=distributed_atom_list,
decimals=decimals,
computation_algorithm=computation_algorithm)
def _set_dynamical_matrix(self):
self._dynamical_matrix = None
if (self._supercell is None or self._primitive is None):
print("Bug: Supercell or primitive is not created.")
return False
elif self._force_constants is None:
print("Warning: Force constants are not prepared.")
return False
elif self._primitive.get_masses() is None:
print("Warning: Atomic masses are not correctly set.")
return False
else:
if self._nac_params is None:
self._dynamical_matrix = DynamicalMatrix(
self._supercell,
self._primitive,
self._force_constants,
decimals=self._dynamical_matrix_decimals,
symprec=self._symprec)
else:
self._dynamical_matrix = DynamicalMatrixNAC(
self._supercell,
self._primitive,
self._force_constants,
nac_params=self._nac_params,
decimals=self._dynamical_matrix_decimals,
symprec=self._symprec)
return True
def _search_symmetry(self):
self._symmetry = Symmetry(self._supercell,
self._symprec,
self._is_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 _build_supercell(self):
self._supercell = get_supercell(self._unitcell,
self._supercell_matrix,
self._symprec)
def _build_supercells_with_displacements(self):
supercells = []
for disp in self._displacement_dataset['first_atoms']:
positions = self._supercell.get_positions()
positions[disp['number']] += disp['displacement']
supercells.append(Atoms(
numbers=self._supercell.get_atomic_numbers(),
masses=self._supercell.get_masses(),
magmoms=self._supercell.get_magnetic_moments(),
positions=positions,
cell=self._supercell.get_cell(),
pbc=True))
self._supercells_with_displacements = supercells
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)
self._primitive = get_primitive(
self._supercell, trans_mat, self._symprec)
num_satom = self._supercell.get_number_of_atoms()
num_patom = self._primitive.get_number_of_atoms()
if abs(num_satom * np.linalg.det(trans_mat) - num_patom) < 0.1:
return True
else:
return False
class Phonopy(object):
def __init__(self,
unitcell,
supercell_matrix,
primitive_matrix=None,
nac_params=None,
distance=None,
factor=VaspToTHz,
is_auto_displacements=None,
dynamical_matrix_decimals=None,
force_constants_decimals=None,
symprec=1e-5,
is_symmetry=True,
use_lapack_solver=False,
log_level=0):
if is_auto_displacements is not None:
print("Warning: \'is_auto_displacements\' argument is obsolete.")
if is_auto_displacements is False:
print("Sets of displacements are not created as default.")
else:
print("Use \'generate_displacements\' method explicitly to "
"create sets of displacements.")
if distance is not None:
print("Warning: \'distance\' keyword argument is obsolete at "
"Phonopy instantiation.")
print("Specify \'distance\' keyword argument when calling "
"\'generate_displacements\'")
print("method (See the Phonopy API document).")
self._symprec = symprec
self._factor = factor
self._is_symmetry = is_symmetry
self._use_lapack_solver = use_lapack_solver
self._log_level = log_level
# Create supercell and primitive cell
self._unitcell = Atoms(atoms=unitcell)
self._supercell_matrix = supercell_matrix
self._primitive_matrix = primitive_matrix
self._supercell = None
self._primitive = None
self._build_supercell()
self._build_primitive_cell()
# Set supercell and primitive symmetry
self._symmetry = None
self._primitive_symmetry = None
self._search_symmetry()
self._search_primitive_symmetry()
# set_displacements (used only in preprocess)
self._displacement_dataset = None
self._displacements = None
self._displacement_directions = None
self._supercells_with_displacements = None
# set_force_constants or set_forces
self._force_constants = None
self._force_constants_decimals = force_constants_decimals
# set_dynamical_matrix
self._dynamical_matrix = None
self._nac_params = nac_params
self._dynamical_matrix_decimals = dynamical_matrix_decimals
# set_band_structure
self._band_structure = None
# set_mesh
self._mesh = None
# set_tetrahedron_method
self._tetrahedron_method = None
# set_thermal_properties
self._thermal_properties = None
# set_thermal_displacements
self._thermal_displacements = None
# set_thermal_displacement_matrices
self._thermal_displacement_matrices = None
# set_partial_DOS
self._pdos = None
# set_total_DOS
self._total_dos = None
# set_modulation
self._modulation = None
# set_character_table
self._irreps = None
# set_group_velocity
self._group_velocity = None
def get_version(self):
return __version__
def get_primitive(self):
return self._primitive
primitive = property(get_primitive)
def get_unitcell(self):
return self._unitcell
unitcell = property(get_unitcell)
def get_supercell(self):
return self._supercell
supercell = property(get_supercell)
def get_symmetry(self):
"""return symmetry of supercell"""
return self._symmetry
symmetry = property(get_symmetry)
def get_primitive_symmetry(self):
"""return symmetry of primitive cell"""
return self._primitive_symmetry
def get_supercell_matrix(self):
return self._supercell_matrix
def get_primitive_matrix(self):
return self._primitive_matrix
def get_unit_conversion_factor(self):
return self._factor
unit_conversion_factor = property(get_unit_conversion_factor)
def get_displacement_dataset(self):
return self._displacement_dataset
def get_displacements(self):
return self._displacements
displacements = property(get_displacements)
def get_displacement_directions(self):
return self._displacement_directions
displacement_directions = property(get_displacement_directions)
def get_supercells_with_displacements(self):
if self._displacement_dataset is None:
return None
else:
self._build_supercells_with_displacements()
return self._supercells_with_displacements
def get_force_constants(self):
return self._force_constants
force_constants = property(get_force_constants)
def get_rotational_condition_of_fc(self):
return rotational_invariance(self._force_constants,
self._supercell,
self._primitive,
self._symprec)
def get_nac_params(self):
return self._nac_params
def get_dynamical_matrix(self):
return self._dynamical_matrix
dynamical_matrix = property(get_dynamical_matrix)
def set_unitcell(self, unitcell):
self._unitcell = unitcell
self._build_supercell()
self._build_primitive_cell()
self._search_symmetry()
self._search_primitive_symmetry()
self._displacement_dataset = None
def set_masses(self, masses):
p_masses = np.array(masses)
self._primitive.set_masses(p_masses)
p2p_map = self._primitive.get_primitive_to_primitive_map()
s_masses = p_masses[[p2p_map[x] for x in
self._primitive.get_supercell_to_primitive_map()]]
self._supercell.set_masses(s_masses)
u2s_map = self._supercell.get_unitcell_to_supercell_map()
u_masses = s_masses[u2s_map]
self._unitcell.set_masses(u_masses)
self._set_dynamical_matrix()
def set_nac_params(self, nac_params=None):
self._nac_params = nac_params
self._set_dynamical_matrix()
def set_displacement_dataset(self, displacement_dataset):
"""
displacement_dataset:
{'natom': number_of_atoms_in_supercell,
'first_atoms': [
{'number': atom index of displaced atom,
'displacement': displacement in Cartesian coordinates,
'direction': displacement direction with respect to axes
'forces': forces on atoms in supercell},
{...}, ...]}
"""
self._displacement_dataset = displacement_dataset
self._displacements = []
self._displacement_directions = []
for disp in self._displacement_dataset['first_atoms']:
x = disp['displacement']
self._displacements.append([disp['number'], x[0], x[1], x[2]])
if 'direction' in disp:
y = disp['direction']
self._displacement_directions.append(
[disp['number'], y[0], y[1], y[2]])
if not self._displacement_directions:
self._displacement_directions = None
def set_forces(self, sets_of_forces):
"""
sets_of_forces:
[[[f_1x, f_1y, f_1z], [f_2x, f_2y, f_2z], ...], # first supercell
[[f_1x, f_1y, f_1z], [f_2x, f_2y, f_2z], ...], # second supercell
... ]
"""
for disp, forces in zip(
self._displacement_dataset['first_atoms'], sets_of_forces):
disp['forces'] = forces
def set_force_constants(self, force_constants):
self._force_constants = force_constants
self._set_dynamical_matrix()
def set_force_constants_zero_with_radius(self, cutoff_radius):
cutoff_force_constants(self._force_constants,
self._supercell,
cutoff_radius,
symprec=self._symprec)
self._set_dynamical_matrix()
def set_dynamical_matrix(self):
self._set_dynamical_matrix()
def generate_displacements(self,
distance=0.01,
is_plusminus='auto',
is_diagonal=True,
is_trigonal=False):
"""Generate displacements automatically
displacemsts: List of displacements in Cartesian coordinates.
[[0, 0.01, 0.00, 0.00], ...]
where each set of elements is defined by:
First value: Atom index in supercell starting with 0
Second to fourth: Displacement in Cartesian coordinates
displacement_directions:
List of directions with respect to axes. This gives only the
symmetrically non equivalent directions. The format is like:
[[0, 1, 0, 0],
[7, 1, 0, 1], ...]
where each list is defined by:
First value: Atom index in supercell starting with 0
Second to fourth: If the direction is displaced or not ( 1, 0, or -1 )
with respect to the axes.
"""
displacement_directions = get_least_displacements(
self._symmetry,
is_plusminus=is_plusminus,
is_diagonal=is_diagonal,
is_trigonal=is_trigonal,
log_level=self._log_level)
displacement_dataset = direction_to_displacement(
displacement_directions,
distance,
self._supercell)
self.set_displacement_dataset(displacement_dataset)
def produce_force_constants(self,
forces=None,
calculate_full_force_constants=True,
computation_algorithm="svd"):
if forces is not None:
self.set_forces(forces)
# A primitive check if 'forces' key is in displacement_dataset.
for disp in self._displacement_dataset['first_atoms']:
if 'forces' not in disp:
return False
if calculate_full_force_constants:
self._run_force_constants_from_forces(
decimals=self._force_constants_decimals,
computation_algorithm=computation_algorithm)
else:
p2s_map = self._primitive.get_primitive_to_supercell_map()
self._run_force_constants_from_forces(
distributed_atom_list=p2s_map,
decimals=self._force_constants_decimals,
computation_algorithm=computation_algorithm)
self._set_dynamical_matrix()
return True
def symmetrize_force_constants(self, iteration=3):
symmetrize_force_constants(self._force_constants, iteration)
self._set_dynamical_matrix()
def symmetrize_force_constants_by_space_group(self):
from phonopy.harmonic.force_constants import (set_tensor_symmetry,
set_tensor_symmetry_PJ)
set_tensor_symmetry_PJ(self._force_constants,
self._supercell.get_cell().T,
self._supercell.get_scaled_positions(),
self._symmetry)
self._set_dynamical_matrix()
#####################
# Phonon properties #
#####################
# Single q-point
def get_dynamical_matrix_at_q(self, q):
self._set_dynamical_matrix()
if self._dynamical_matrix is None:
print("Warning: Dynamical matrix has not yet built.")
return None
self._dynamical_matrix.set_dynamical_matrix(q)
return self._dynamical_matrix.get_dynamical_matrix()
def get_frequencies(self, q):
"""
Calculate phonon frequencies at q
q: q-vector in reduced coordinates of primitive cell
"""
self._set_dynamical_matrix()
if self._dynamical_matrix is None:
print("Warning: Dynamical matrix has not yet built.")
return None
self._dynamical_matrix.set_dynamical_matrix(q)
dm = self._dynamical_matrix.get_dynamical_matrix()
frequencies = []
for eig in np.linalg.eigvalsh(dm).real:
if eig < 0:
frequencies.append(-np.sqrt(-eig))
else:
frequencies.append(np.sqrt(eig))
return np.array(frequencies) * self._factor
def get_frequencies_with_eigenvectors(self, q):
"""
Calculate phonon frequencies and eigenvectors at q
q: q-vector in reduced coordinates of primitive cell
"""
self._set_dynamical_matrix()
if self._dynamical_matrix is None:
print("Warning: Dynamical matrix has not yet built.")
return None
self._dynamical_matrix.set_dynamical_matrix(q)
dm = self._dynamical_matrix.get_dynamical_matrix()
frequencies = []
eigvals, eigenvectors = np.linalg.eigh(dm)
frequencies = []
for eig in eigvals:
if eig < 0:
frequencies.append(-np.sqrt(-eig))
else:
frequencies.append(np.sqrt(eig))
return np.array(frequencies) * self._factor, eigenvectors
# Band structure
def set_band_structure(self,
bands,
is_eigenvectors=False,
is_band_connection=False):
if self._dynamical_matrix is None:
print("Warning: Dynamical matrix has not yet built.")
self._band_structure = None
return False
self._band_structure = BandStructure(
bands,
self._dynamical_matrix,
is_eigenvectors=is_eigenvectors,
is_band_connection=is_band_connection,
group_velocity=self._group_velocity,
factor=self._factor)
return True
def get_band_structure(self):
band = self._band_structure
return (band.get_qpoints(),
band.get_distances(),
band.get_frequencies(),
band.get_eigenvectors())
def plot_band_structure(self, labels=None):
import matplotlib.pyplot as plt
if labels:
from matplotlib import rc
rc('text', usetex=True)
self._band_structure.plot(plt, labels=labels)
return plt
def write_yaml_band_structure(self,
labels=None,
comment=None,
filename="band.yaml"):
self._band_structure.write_yaml(labels=labels,
comment=comment,
filename=filename)
# Sampling mesh
def set_mesh(self,
mesh,
shift=None,
is_time_reversal=True,
is_mesh_symmetry=True,
is_eigenvectors=False,
is_gamma_center=False):
if self._dynamical_matrix is None:
print("Warning: Dynamical matrix has not yet built.")
self._mesh = None
return False
self._mesh = Mesh(
self._dynamical_matrix,
mesh,
shift=shift,
is_time_reversal=is_time_reversal,
is_mesh_symmetry=is_mesh_symmetry,
is_eigenvectors=is_eigenvectors,
is_gamma_center=is_gamma_center,
group_velocity=self._group_velocity,
rotations=self._primitive_symmetry.get_pointgroup_operations(),
factor=self._factor,
use_lapack_solver=self._use_lapack_solver)
return True
def get_mesh(self):
if self._mesh is None:
return None
else:
return (self._mesh.get_qpoints(),
self._mesh.get_weights(),
self._mesh.get_frequencies(),
self._mesh.get_eigenvectors())
def get_mesh_grid_info(self):
if self._mesh is None:
return None
else:
return (self._mesh.get_grid_address(),
self._mesh.get_ir_grid_points(),
self._mesh.get_grid_mapping_table())
def write_hdf5_mesh(self):
self._mesh.write_hdf5()
def write_yaml_mesh(self):
self._mesh.write_yaml()
# Plot band structure and DOS (PDOS) together
def plot_band_structure_and_dos(self, pdos_indices=None, labels=None):
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
if labels:
from matplotlib import rc
rc('text', usetex=True)
plt.figure(figsize=(10, 6))
gs = gridspec.GridSpec(1, 2, width_ratios=[3, 1])
ax1 = plt.subplot(gs[0, 0])
self._band_structure.plot(plt, labels=labels)
ax2 = plt.subplot(gs[0, 1], sharey=ax1)
plt.subplots_adjust(wspace=0.03)
plt.setp(ax2.get_yticklabels(), visible=False)
if pdos_indices is None:
self._total_dos.plot(plt,
ylabel="",
draw_grid=False,
flip_xy=True)
else:
self._pdos.plot(plt,
indices=pdos_indices,
ylabel="",
draw_grid=False,
flip_xy=True)
return plt
# DOS
def set_total_DOS(self,
sigma=None,
freq_min=None,
freq_max=None,
freq_pitch=None,
tetrahedron_method=False):
if self._mesh is None:
print("Warning: \'set_mesh\' has to finish correctly "
"before DOS calculation.")
self._total_dos = None
return False
total_dos = TotalDos(self._mesh,
sigma=sigma,
tetrahedron_method=tetrahedron_method)
total_dos.set_draw_area(freq_min, freq_max, freq_pitch)
total_dos.run()
self._total_dos = total_dos
return True
def get_total_DOS(self):
"""
Retern frequencies and total dos.
The first element is freqs and the second is total dos.
frequencies: [freq1, freq2, ...]
total_dos: [dos1, dos2, ...]
"""
return self._total_dos.get_dos()
def set_Debye_frequency(self, freq_max_fit=None):
self._total_dos.set_Debye_frequency(
self._primitive.get_number_of_atoms(),
freq_max_fit=freq_max_fit)
def get_Debye_frequency(self):
return self._total_dos.get_Debye_frequency()
def plot_total_DOS(self):
import matplotlib.pyplot as plt
self._total_dos.plot(plt)
return plt
def write_total_DOS(self):
self._total_dos.write()
# PDOS
def set_partial_DOS(self,
sigma=None,
freq_min=None,
freq_max=None,
freq_pitch=None,
tetrahedron_method=False,
direction=None,
xyz_projection=False):
self._pdos = None
if self._mesh is None:
print("Warning: \'set_mesh\' has to be called before "
"PDOS calculation.")
return False
if self._mesh.get_eigenvectors() is None:
print("Warning: Eigenvectors have to be calculated.")
return False
num_grid = np.prod(self._mesh.get_mesh_numbers())
if num_grid != len(self._mesh.get_ir_grid_points()):
print("Warning: \'set_mesh\' has to be called with "
"is_mesh_symmetry=False.")
return False
if direction is not None:
direction_cart = np.dot(direction, self._primitive.get_cell())
else:
direction_cart = None
self._pdos = PartialDos(self._mesh,
sigma=sigma,
tetrahedron_method=tetrahedron_method,
direction=direction_cart,
xyz_projection=xyz_projection)
self._pdos.set_draw_area(freq_min, freq_max, freq_pitch)
self._pdos.run()
return True
def get_partial_DOS(self):
"""
Retern frequencies and partial_dos.
The first element is freqs and the second is partial_dos.
frequencies: [freq1, freq2, ...]
partial_dos:
[[atom1-freq1, atom1-freq2, ...],
[atom2-freq1, atom2-freq2, ...],
...]
"""
return self._pdos.get_partial_dos()
def plot_partial_DOS(self, pdos_indices=None, legend=None):
import matplotlib.pyplot as plt
self._pdos.plot(plt,
indices=pdos_indices,
legend=legend)
return plt
def write_partial_DOS(self):
self._pdos.write()
# Thermal property
def set_thermal_properties(self,
t_step=10,
t_max=1000,
t_min=0,
temperatures=None,
is_projection=False,
band_indices=None,
cutoff_frequency=None):
if self._mesh is None:
print("Warning: set_mesh has to be done before "
"set_thermal_properties")
return False
else:
tp = ThermalProperties(self._mesh.get_frequencies(),
weights=self._mesh.get_weights(),
eigenvectors=self._mesh.get_eigenvectors(),
is_projection=is_projection,
band_indices=band_indices,
cutoff_frequency=cutoff_frequency)
if temperatures is None:
tp.set_temperature_range(t_step=t_step,
t_max=t_max,
t_min=t_min)
else:
tp.set_temperatures(temperatures)
tp.run()
self._thermal_properties = tp
def get_thermal_properties(self):
temps, fe, entropy, cv = \
self._thermal_properties.get_thermal_properties()
return temps, fe, entropy, cv
def plot_thermal_properties(self):
import matplotlib.pyplot as plt
self._thermal_properties.plot(plt)
return plt
def write_yaml_thermal_properties(self, filename='thermal_properties.yaml'):
self._thermal_properties.write_yaml(filename=filename)
# Thermal displacement
def set_thermal_displacements(self,
t_step=10,
t_max=1000,
t_min=0,
temperatures=None,
direction=None,
cutoff_frequency=None):
"""
cutoff_frequency:
phonon modes that have frequencies below cutoff_frequency
are ignored.
direction:
Projection direction in reduced coordinates
"""
self._thermal_displacements = None
if self._mesh is None:
print("Warning: \'set_mesh\' has to finish correctly "
"before \'set_thermal_displacements\'.")
return False
eigvecs = self._mesh.get_eigenvectors()
frequencies = self._mesh.get_frequencies()
mesh_nums = self._mesh.get_mesh_numbers()
if self._mesh.get_eigenvectors() is None:
print("Warning: Eigenvectors have to be calculated.")
return False
if np.prod(mesh_nums) != len(eigvecs):
print("Warning: Sampling mesh must not be symmetrized.")
return False
td = ThermalDisplacements(frequencies,
eigvecs,
self._primitive.get_masses(),
cutoff_frequency=cutoff_frequency)
if temperatures is None:
td.set_temperature_range(t_min, t_max, t_step)
else:
td.set_temperatures(temperatures)
if direction is not None:
td.project_eigenvectors(direction, self._primitive.get_cell())
td.run()
self._thermal_displacements = td
return True
def get_thermal_displacements(self):
if self._thermal_displacements is not None:
return self._thermal_displacements.get_thermal_displacements()
def plot_thermal_displacements(self, is_legend=False):
import matplotlib.pyplot as plt
self._thermal_displacements.plot(plt, is_legend=is_legend)
return plt
def write_yaml_thermal_displacements(self):
self._thermal_displacements.write_yaml()
# Thermal displacement matrix
def set_thermal_displacement_matrices(self,
t_step=10,
t_max=1000,
t_min=0,
cutoff_frequency=None,
t_cif=None):
"""
cutoff_frequency:
phonon modes that have frequencies below cutoff_frequency
are ignored.
direction:
Projection direction in reduced coordinates
"""
self._thermal_displacement_matrices = None
if self._mesh is None:
print("Warning: \'set_mesh\' has to finish correctly "
"before \'set_thermal_displacement_matrices\'.")
return False
eigvecs = self._mesh.get_eigenvectors()
frequencies = self._mesh.get_frequencies()
mesh_nums = self._mesh.get_mesh_numbers()
if self._mesh.get_eigenvectors() is None:
print("Warning: Eigenvectors have to be calculated.")
return False
if np.prod(mesh_nums) != len(eigvecs):
print("Warning: Sampling mesh must not be symmetrized.")
return False
tdm = ThermalDisplacementMatrices(frequencies,
eigvecs,
self._primitive.get_masses(),
cutoff_frequency=cutoff_frequency,
lattice=self._primitive.get_cell().T)
if t_cif is None:
tdm.set_temperature_range(t_min, t_max, t_step)
else:
tdm.set_temperatures([t_cif])
tdm.run()
self._thermal_displacement_matrices = tdm
return True
def get_thermal_displacement_matrices(self):
tdm = self._thermal_displacement_matrices
if tdm is not None:
return tdm.get_thermal_displacement_matrices()
def write_yaml_thermal_displacement_matrices(self):
self._thermal_displacement_matrices.write_yaml()
def write_thermal_displacement_matrix_to_cif(self,
temperature_index):
self._thermal_displacement_matrices.write_cif(self._primitive,
temperature_index)
# Mean square distance between a pair of atoms
def set_thermal_distances(self,
atom_pairs,
t_step=10,
t_max=1000,
t_min=0,
cutoff_frequency=None):
"""
atom_pairs: List of list
Mean square distances are calculated for the atom_pairs
e.g. [[1, 2], [1, 4]]
cutoff_frequency:
phonon modes that have frequencies below cutoff_frequency
are ignored.
"""
td = ThermalDistances(self._mesh.get_frequencies(),
self._mesh.get_eigenvectors(),
self._supercell,
self._primitive,
self._mesh.get_qpoints(),
cutoff_frequency=cutoff_frequency)
td.set_temperature_range(t_min, t_max, t_step)
td.run(atom_pairs)
self._thermal_distances = td
def write_yaml_thermal_distances(self):
self._thermal_distances.write_yaml()
# Sampling at q-points
def set_qpoints_phonon(self,
q_points,
nac_q_direction=None,
is_eigenvectors=False,
write_dynamical_matrices=False):
if self._dynamical_matrix is None:
print("Warning: Dynamical matrix has not yet built.")
self._qpoints_phonon = None
return False
self._qpoints_phonon = QpointsPhonon(
np.reshape(q_points, (-1, 3)),
self._dynamical_matrix,
nac_q_direction=nac_q_direction,
is_eigenvectors=is_eigenvectors,
group_velocity=self._group_velocity,
write_dynamical_matrices=write_dynamical_matrices,
factor=self._factor)
return True
def get_qpoints_phonon(self):
return (self._qpoints_phonon.get_frequencies(),
self._qpoints_phonon.get_eigenvectors())
def write_hdf5_qpoints_phonon(self):
self._qpoints_phonon.write_hdf5()
def write_yaml_qpoints_phonon(self):
self._qpoints_phonon.write_yaml()
# Normal mode animation
def write_animation(self,
q_point=None,
anime_type='v_sim',
band_index=None,
amplitude=None,
num_div=None,
shift=None,
filename=None):
if self._dynamical_matrix is None:
print("Warning: Dynamical matrix has not yet built.")
return False
if q_point is None:
animation = Animation([0, 0, 0],
self._dynamical_matrix,
shift=shift)
else:
animation = Animation(q_point,
self._dynamical_matrix,
shift=shift)
if anime_type == 'v_sim':
if amplitude:
amplitude_ = amplitude
else:
amplitude_ = 1.0
if filename:
animation.write_v_sim(amplitude=amplitude_,
factor=self._factor,
filename=filename)
else:
animation.write_v_sim(amplitude=amplitude_,
factor=self._factor)
if (anime_type == 'arc' or
anime_type == 'xyz' or
anime_type == 'jmol' or
anime_type == 'poscar'):
if band_index is None or amplitude is None or num_div is None:
print("Warning: Parameters are not correctly set for "
"animation.")
return False
if anime_type == 'arc' or anime_type is None:
if filename:
animation.write_arc(band_index,
amplitude,
num_div,
filename=filename)
else:
animation.write_arc(band_index,
amplitude,
num_div)
if anime_type == 'xyz':
if filename:
animation.write_xyz(band_index,
amplitude,
num_div,
self._factor,
filename=filename)
else:
animation.write_xyz(band_index,
amplitude,
num_div,
self._factor)
if anime_type == 'jmol':
if filename:
animation.write_xyz_jmol(amplitude=amplitude,
factor=self._factor,
filename=filename)
else:
animation.write_xyz_jmol(amplitude=amplitude,
factor=self._factor)
if anime_type == 'poscar':
if filename:
animation.write_POSCAR(band_index,
amplitude,
num_div,
filename=filename)
else:
animation.write_POSCAR(band_index,
amplitude,
num_div)
return True
# Atomic modulation of normal mode
def set_modulations(self,
dimension,
phonon_modes,
delta_q=None,
derivative_order=None,
nac_q_direction=None):
if self._dynamical_matrix is None:
print("Warning: Dynamical matrix has not yet built.")
self._modulation = None
return False
self._modulation = Modulation(self._dynamical_matrix,
dimension,
phonon_modes,
delta_q=delta_q,
derivative_order=derivative_order,
nac_q_direction=nac_q_direction,
factor=self._factor)
self._modulation.run()
return True
def get_modulated_supercells(self):
"""Returns cells with modulations as Atoms objects"""
return self._modulation.get_modulated_supercells()
def get_modulations_and_supercell(self):
"""Return modulations and supercell
(modulations, supercell)
modulations: Atomic modulations of supercell in Cartesian coordinates
supercell: Supercell as an Atoms object.
"""
return self._modulation.get_modulations_and_supercell()
def write_modulations(self):
"""Create MPOSCAR's"""
self._modulation.write()
def write_yaml_modulations(self):
self._modulation.write_yaml()
# Irreducible representation
def set_irreps(self,
q,
is_little_cogroup=False,
nac_q_direction=None,
degeneracy_tolerance=1e-4):
if self._dynamical_matrix is None:
print("Warning: Dynamical matrix has not yet built.")
self._irreps = None
return None
self._irreps = IrReps(
self._dynamical_matrix,
q,
is_little_cogroup=is_little_cogroup,
nac_q_direction=nac_q_direction,
factor=self._factor,
symprec=self._symprec,
degeneracy_tolerance=degeneracy_tolerance,
log_level=self._log_level)
return self._irreps.run()
def get_irreps(self):
return self._irreps
def show_irreps(self, show_irreps=False):
self._irreps.show(show_irreps=show_irreps)
def write_yaml_irreps(self, show_irreps=False):
self._irreps.write_yaml(show_irreps=show_irreps)
# Group velocity
def set_group_velocity(self, q_length=None):
if self._dynamical_matrix is None:
print("Warning: Dynamical matrix has not yet built.")
self._group_velocity = None
return False
self._group_velocity = GroupVelocity(
self._dynamical_matrix,
q_length=q_length,
symmetry=self._primitive_symmetry,
frequency_factor_to_THz=self._factor)
return True
def get_group_velocity(self):
return self._group_velocity.get_group_velocity()
def get_group_velocity_at_q(self, q_point):
if self._group_velocity is None:
self.set_group_velocity()
self._group_velocity.set_q_points([q_point])
return self._group_velocity.get_group_velocity()[0]
# Moment
def set_moment(self,
order=1,
is_projection=False,
freq_min=None,
freq_max=None):
if self._mesh is None:
print("Warning: set_mesh has to be done before set_moment")
return False
else:
if is_projection:
if self._mesh.get_eigenvectors() is None:
print("Warning: Eigenvectors have to be calculated.")
return False
moment = PhononMoment(
self._mesh.get_frequencies(),
weights=self._mesh.get_weights(),
eigenvectors=self._mesh.get_eigenvectors())
else:
moment = PhononMoment(
self._mesh.get_frequencies(),
weights=self._mesh.get_weights())
if freq_min is not None or freq_max is not None:
moment.set_frequency_range(freq_min=freq_min,
freq_max=freq_max)
moment.run(order=order)
self._moment = moment.get_moment()
return True
def get_moment(self):
return self._moment
#################
# Local methods #
#################
def _run_force_constants_from_forces(self,
distributed_atom_list=None,
decimals=None,
computation_algorithm="svd"):
if self._displacement_dataset is not None:
self._force_constants = get_fc2(
self._supercell,
self._symmetry,
self._displacement_dataset,
atom_list=distributed_atom_list,
decimals=decimals,
computation_algorithm=computation_algorithm)
def _set_dynamical_matrix(self):
self._dynamical_matrix = None
if (self._supercell is None or self._primitive is None):
print("Bug: Supercell or primitive is not created.")
return False
elif self._force_constants is None:
print("Warning: Force constants are not prepared.")
return False
elif self._primitive.get_masses() is None:
print("Warning: Atomic masses are not correctly set.")
return False
else:
if self._nac_params is None:
self._dynamical_matrix = DynamicalMatrix(
self._supercell,
self._primitive,
self._force_constants,
decimals=self._dynamical_matrix_decimals,
symprec=self._symprec)
else:
self._dynamical_matrix = DynamicalMatrixNAC(
self._supercell,
self._primitive,
self._force_constants,
nac_params=self._nac_params,
decimals=self._dynamical_matrix_decimals,
symprec=self._symprec)
return True
def _search_symmetry(self):
self._symmetry = Symmetry(self._supercell,
self._symprec,
self._is_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 _build_supercell(self):
self._supercell = get_supercell(self._unitcell,
self._supercell_matrix,
self._symprec)
def _build_supercells_with_displacements(self):
supercells = []
for disp in self._displacement_dataset['first_atoms']:
positions = self._supercell.get_positions()
positions[disp['number']] += disp['displacement']
supercells.append(Atoms(
numbers=self._supercell.get_atomic_numbers(),
masses=self._supercell.get_masses(),
magmoms=self._supercell.get_magnetic_moments(),
positions=positions,
cell=self._supercell.get_cell(),
pbc=True))
self._supercells_with_displacements = supercells
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)
self._primitive = get_primitive(
self._supercell, trans_mat, self._symprec)
num_satom = self._supercell.get_number_of_atoms()
num_patom = self._primitive.get_number_of_atoms()
if abs(num_satom * np.linalg.det(trans_mat) - num_patom) < 0.1:
return True
else:
return False