def set_cell(self, cell):
Cell.__init__(self,
lattice=cell.lattice,
magmoms=cell.get_magnetic_moments(),
masses=cell.get_masses(),
numbers=cell.numbers,
points=cell.get_points())
def set_cell(self, cell):
Cell.__init__(self,
lattice=cell.get_lattice(),
magmoms=cell.get_magnetic_moments(),
masses=cell.get_masses(),
numbers=cell.get_numbers(),
points=cell.get_points())
def _set_vasp_cell(self):
symbols = [self._cell.get_symbols()[i] for i in self._atom_order]
if self._cell.get_magnetic_moments() is not None:
magmoms = self._cell.get_magnetic_moments()[self._atom_order]
else:
magmoms = None
Cell.__init__(self,
lattice=self._cell.lattice,
points=(self._cell.get_points().T)[self._atom_order].T,
symbols=symbols,
magmoms=magmoms,
masses=self._cell.get_masses()[self._atom_order])
def get_crystallographic_cell(cell, tolerance=1e-5):
points = cell.get_points()
lattice = cell.get_lattice()
numbers = cell.get_numbers()
brv_lattice, brv_points, brv_numbers = spg.get_crystallographic_cell(
lattice, points, numbers, tolerance)
return Cell(lattice=brv_lattice, points=brv_points, numbers=brv_numbers)
def get_simple_supercell(multi, cell):
lattice = cell.get_lattice()
points = cell.get_points()
masses = cell.get_masses()
magmoms = cell.get_magnetic_moments()
symbols = cell.get_symbols()
points_scell = []
symbols_scell = []
masses_scell = []
if magmoms == None:
magmoms_scell = None
else:
magmoms_scell = []
for l, pos in enumerate(points.T):
for i in range(multi[2]):
for j in range(multi[1]):
for k in range(multi[0]):
points_scell.append([(pos[0] + k) / multi[0],
(pos[1] + j) / multi[1],
(pos[2] + i) / multi[2]])
symbols_scell.append(symbols[l])
masses_scell.append(masses[l])
if not magmoms == None:
magmoms_scell.append(magmoms[l])
return Cell(lattice=np.dot(lattice, np.diag(multi)),
points=np.transpose(points_scell),
symbols=symbols_scell,
masses=masses_scell,
magmoms=magmoms_scell)
def reduce_points(tmat, cell, tolerance=1e-5):
lattice = cell.get_lattice()
points_prim = []
symbols_prim = []
masses_prim = []
points = cell.get_points()
symbols = cell.get_symbols()
masses = cell.get_masses()
magmoms = cell.get_magnetic_moments()
if magmoms == None:
magmoms_prim = None
else:
magmoms_prim = []
for i, p in enumerate(np.dot(np.linalg.inv(tmat), points).T):
is_different = True
for p_prim in points_prim:
diff = p_prim - p
diff -= diff.round()
if (np.linalg.norm(np.dot(lattice, diff)) < tolerance).all():
is_different = False
break
if is_different:
points_prim.append(p - np.floor(p))
symbols_prim.append(symbols[i])
masses_prim.append(masses[i])
if magmoms != None:
magmoms_prim.append(magmoms[i])
return Cell(lattice=np.dot(cell.get_lattice(), tmat),
points=np.transpose(points_prim),
symbols=symbols_prim,
magmoms=magmoms_prim,
masses=masses_prim)
def get_primitive_cell(cell, tolerance=1e-5):
points = cell.get_points()
lattice = cell.get_lattice()
numbers = cell.get_numbers()
(prim_lattice, prim_points,
prim_numbers) = spg.get_primitive_cell(lattice, points, numbers,
tolerance)
return Cell(lattice=prim_lattice, points=prim_points, numbers=prim_numbers)
def _get_cell_with_modulation(self, modulation):
points = np.dot(self._lattice_inv, self._positions + modulation.real)
for p in points.T:
p -= np.floor(p)
return Cell(lattice=self._lattice,
points=points,
masses=self._supercell.get_masses(),
numbers=self._supercell.get_numbers())
def _shuffle(self, cell):
indices = range(len(cell.get_symbols()))
random.shuffle(indices)
points = np.zeros(cell.get_points().shape, dtype=float)
for i, j in enumerate(indices):
points[:,i] = cell.get_points()[:,j]
return Cell(lattice = cell.get_lattice(),
points = points,
symbols = self._symbols)
def parse_poscar(lines):
isvasp5 = False
symbols = []
for w in lines[0].split():
if w.strip() in atomic_symbols:
symbols.append(w)
for w in lines[5].split():
if not w.isdigit():
isvasp5 = True
break
if isvasp5:
symbols_vasp5 = []
for w in lines[5].split():
if w.strip() in atomic_symbols:
symbols_vasp5.append(w)
lines.pop(5)
# Read lines in VASP 4 style
scale = float(lines[1])
lattice = np.zeros((3, 3), dtype=float)
lattice[:, 0] = [float(x) for x in lines[2].split()]
lattice[:, 1] = [float(x) for x in lines[3].split()]
lattice[:, 2] = [float(x) for x in lines[4].split()]
lattice *= scale
num_atoms = np.array([int(x) for x in lines[5].split()])
# Check if symbols in VASP 5 style is valid
if isvasp5:
if len(num_atoms) == len(symbols_vasp5):
symbols = symbols_vasp5
# Assume Direct
if lines[6][0] in 'CcKk':
print "Cartesian is not supported"
raise
points = np.zeros((3, num_atoms.sum()), dtype=float)
for i in range(num_atoms.sum()):
points[:, i] = [float(x) for x in lines[i + 7].split()]
# Expand symbols
symbols_expanded = []
if len(symbols) == len(num_atoms):
for i, n in enumerate(num_atoms):
symbols_expanded += [symbols[i]] * n
else:
print "Chemical symbols are not found."
raise
return Cell(lattice=lattice, points=points, symbols=symbols_expanded)
def read_yaml(filename):
import yaml
data = yaml.load(open(filename))
if 'status' in data:
if (not data['status'] == 'terminate' and 'lattice' in data
and 'points' in data and 'symbols' in data):
lattice = np.transpose(data['lattice'])
points = np.transpose(data['points'])
symbols = data['symbols']
return Cell(lattice=lattice, points=points, symbols=symbols)
return None
def setUp(self):
symbols = ['Si', 'O', 'O', 'Si', 'O', 'O']
lattice = [[4.65, 0, 0],
[0, 4.75, 0],
[0, 0, 3.25]]
points=np.transpose([[0.0, 0.0, 0.0],
[0.3, 0.3, 0.0],
[0.7, 0.7, 0.0],
[0.5, 0.5, 0.5],
[0.2, 0.8, 0.5],
[0.8, 0.2, 0.5]])
self._cell = Cell(lattice=lattice,
points=points,
symbols=symbols)
def _random(self):
lattice = np.eye(3, dtype=float) * self._volume ** (1.0/3)
points = [[0., 0., 0.]]
for i in range(len(self._symbols) - 1):
x = self._get_random_point(lattice, points)
if x:
points.append(x)
if len(points) == len(self._symbols):
break
if len(points) < len(self._symbols):
return None
else:
return Cell(lattice = lattice,
points = np.transpose(points),
symbols = self._symbols)
def _get_cell_with_modulation(self, modulation):
supercell = self._supercell
lattice = supercell.get_lattice()
max_mod = 0.0
for mod in modulation.T:
if max_mod < np.linalg.norm(mod):
max_mod = np.linalg.norm(mod)
points = np.dot(
np.linalg.inv(lattice),
np.dot(lattice, supercell.get_points()) +
modulation / max_mod * self._max_displacement)
for p in points.T:
p -= np.floor(p)
return Cell(lattice=lattice,
points=points,
masses=supercell.get_masses(),
numbers=supercell.get_numbers())
def cell(lattice=None, points=None, symbols=None, masses=None, numbers=None):
""" """
return Cell(lattice, points, symbols, masses, numbers)
def get_cell(self):
return Cell(lattice=self._lattice,
magmoms=self._magmoms,
masses=self._masses,
numbers=self._numbers,
points=self._points)
def get_cells(self):
cells = []
if len(self._all_points) == len(self._all_lattice):
for p, l in zip(self._all_points, self._all_lattice):
cells.append(Cell(lattice=l, points=p, symbols=self._symbols))
return cells
def atoms2cell(phonopy_cell):
return Cell(lattice=phonopy_cell.get_cell().T,
points=phonopy_cell.get_scaled_positions().T,
masses=phonopy_cell.get_masses(),
magmoms=phonopy_cell.get_magnetic_moments(),
symbols=phonopy_cell.symbols)
class TestCell(unittest.TestCase):
def setUp(self):
symbols = ['Si', 'O', 'O', 'Si', 'O', 'O']
lattice = [[4.65, 0, 0],
[0, 4.75, 0],
[0, 0, 3.25]]
points=np.transpose([[0.0, 0.0, 0.0],
[0.3, 0.3, 0.0],
[0.7, 0.7, 0.0],
[0.5, 0.5, 0.5],
[0.2, 0.8, 0.5],
[0.8, 0.2, 0.5]])
self._cell = Cell(lattice=lattice,
points=points,
symbols=symbols)
def tearDown(self):
pass
def _test_str(self):
print(self._cell)
def _test_sort_cell_by_symbols(self):
print(sort_cell_by_symbols(self._cell))
def test_lattice(self):
lattice = self._cell.lattice
self._cell.lattice = lattice
np.testing.assert_allclose(lattice, self._cell.lattice)
self._cell.set_lattice(lattice)
self._cell.get_lattice()
np.testing.assert_allclose(lattice, self._cell.get_lattice())
def test_points(self):
points = self._cell.points
self._cell.points = points
np.testing.assert_allclose(points, self._cell.points)
self._cell.set_points(points)
self._cell.get_points()
np.testing.assert_allclose(points, self._cell.get_points())
def test_numbers(self):
numbers = self._cell.numbers
self._cell.numbers = numbers
np.testing.assert_array_equal(numbers, self._cell.numbers)
self._cell.set_numbers(numbers)
self._cell.get_numbers()
np.testing.assert_array_equal(numbers, self._cell.get_numbers())
def test_symbols(self):
symbols = self._cell.symbols
self._cell.symbols = symbols
for s, ss in zip(symbols, self._cell.symbols):
self.assertEqual(s, ss)
self._cell.set_symbols(symbols)
self._cell.get_symbols()
for s, ss in zip(symbols, self._cell.get_symbols()):
self.assertEqual(s, ss)
def test_masses(self):
masses = self._cell.masses
self._cell.masses = masses
np.testing.assert_allclose(masses, self._cell.masses)
self._cell.set_masses(masses)
self._cell.get_masses()
np.testing.assert_allclose(masses, self._cell.get_masses())
def test_magnetic_moments(self):
magnetic_moments = self._cell.magnetic_moments
self._cell.magnetic_moments = magnetic_moments
if magnetic_moments is None:
self.assertEqual(magnetic_moments, self._cell.magnetic_moments)
else:
np.testing.assert_allclose(magnetic_moments, self._cell.magnetic_moments)
self._cell.get_magnetic_moments()
self._cell.set_magnetic_moments(magnetic_moments)
def test_volume(self):
volume = self._cell.volume
self._cell.get_volume()
self.assertTrue(abs(volume - self._cell.get_volume()) < 1e-8)
