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)