def write_geometry(self, geom):
""" Writes the geometry to the contained file """
# Check that we can write to the file
sile_raise_write(self)
# LABEL
self._write('sisl output\n')
# Scale
self._write(' 1.\n')
# Write unit-cell
fmt = (' ' + '{:18.9f}' * 3) * 2 + '\n'
tmp = np.zeros([6], np.float64)
for i in range(3):
tmp[:3] = geom.cell[i, :]
self._write(fmt.format(*tmp))
# Figure out how many species
pt = PeriodicTable()
s, d = [], []
for ia, a, idx_specie in geom.iter_species():
if idx_specie >= len(d):
s.append(pt.Z_label(a.Z))
d.append(0)
d[idx_specie] += +1
fmt = ' ' + '{:s}' * len(d) + '\n'
self._write(fmt.format(*s))
fmt = ' ' + '{:d}' * len(d) + '\n'
self._write(fmt.format(*d))
self._write('Cartesian\n')
fmt = '{:18.9f}' * 3 + '\n'
for ia in geom:
self._write(fmt.format(*geom.xyz[ia, :]))
def write_geometry(self, geometry):
""" Writes the geometry to the contained file
Parameters
----------
geometry : Geometry
geometry to be written to the file
"""
# Check that we can write to the file
sile_raise_write(self)
# LABEL
self._write('sisl output\n')
# Scale
self._write(' 1.\n')
# Write unit-cell
fmt = (' ' + '{:18.9f}' * 3) + '\n'
tmp = np.zeros([3], np.float64)
for i in range(3):
tmp[:3] = geometry.cell[i, :]
self._write(fmt.format(*tmp))
# Figure out how many species
pt = PeriodicTable()
s, d = [], []
ia = 0
while ia < geometry.na:
atom = geometry.atoms[ia]
specie = geometry.atoms.specie[ia]
ia_end = (np.diff(geometry.atoms.specie[ia:]) != 0).nonzero()[0]
if len(ia_end) == 0:
# remaining atoms
ia_end = geometry.na
else:
ia_end = ia + ia_end[0] + 1
s.append(pt.Z_label(atom.Z))
d.append(ia_end - ia)
ia += d[-1]
fmt = ' {:s}' * len(d) + '\n'
self._write(fmt.format(*s))
fmt = ' {:d}' * len(d) + '\n'
self._write(fmt.format(*d))
self._write('Cartesian\n')
fmt = '{:18.9f}' * 3 + '\n'
for ia in geometry:
self._write(fmt.format(*geometry.xyz[ia, :]))
def write_geometry(self, geometry, dynamic=True, group_species=False):
r""" Writes the geometry to the contained file
Parameters
----------
geometry : Geometry
geometry to be written to the file
dynamic : None, bool or list, optional
define which atoms are dynamic in the VASP run (default is True,
which means all atoms are dynamic).
If None, the resulting file will not contain any dynamic flags
group_species: bool, optional
before writing `geometry` first re-order species to
have species in consecutive blocks (see `geometry_group`)
Examples
--------
>>> car = carSileVASP('POSCAR', 'w')
>>> geom = geom.graphene()
>>> geom.write(car) # regular car without Selective Dynamics
>>> geom.write(car, dynamic=False) # fix all atoms
>>> geom.write(car, dynamic=[False, (True, False, True)]) # fix 1st and y coordinate of 2nd
See Also
--------
geometry_group: method used to group atoms together according to their species
"""
# Check that we can write to the file
sile_raise_write(self)
if group_species:
geometry, idx = self.geometry_group(geometry, ret_index=True)
else:
# small hack to allow dynamic
idx = _a.arangei(len(geometry))
# LABEL
self._write('sisl output\n')
# Scale
self._write(' 1.\n')
# Write unit-cell
fmt = (' ' + '{:18.9f}' * 3) + '\n'
for i in range(3):
self._write(fmt.format(*geometry.cell[i]))
# Figure out how many species
pt = PeriodicTable()
s, d = [], []
ia = 0
while ia < geometry.na:
atom = geometry.atoms[ia]
specie = geometry.atoms.specie[ia]
ia_end = (np.diff(geometry.atoms.specie[ia:]) != 0).nonzero()[0]
if len(ia_end) == 0:
# remaining atoms
ia_end = geometry.na
else:
ia_end = ia + ia_end[0] + 1
s.append(pt.Z_label(atom.Z))
d.append(ia_end - ia)
ia += d[-1]
fmt = ' {:s}' * len(d) + '\n'
self._write(fmt.format(*s))
fmt = ' {:d}' * len(d) + '\n'
self._write(fmt.format(*d))
if dynamic is None:
# We write in direct mode
dynamic = [None] * len(geometry)
def todyn(fix):
return '\n'
else:
self._write('Selective dynamics\n')
b2s = {True: 'T', False: 'F'}
def todyn(fix):
if isinstance(fix, bool):
return ' {0} {0} {0}\n'.format(b2s[fix])
return ' {} {} {}\n'.format(b2s[fix[0]], b2s[fix[1]],
b2s[fix[2]])
self._write('Cartesian\n')
if isinstance(dynamic, bool):
dynamic = [dynamic] * len(geometry)
fmt = '{:18.9f}' * 3
for ia in geometry:
self._write(
fmt.format(*geometry.xyz[ia, :]) + todyn(dynamic[idx[ia]]))
class TestAtom(object):
def setUp(self):
self.C = Atom['C']
self.C3 = Atom('C', orbs=3)
self.Au = Atom['Au']
self.PT = PeriodicTable()
def tearDown(self):
del self.C
del self.Au
del self.C3
del self.PT
def test1(self):
assert_true(self.C == Atom['C'])
assert_true(self.Au == Atom['Au'])
assert_true(self.Au != self.C)
assert_false(self.Au == self.C)
assert_true(self.Au == self.Au.copy())
def test2(self):
C = Atom('C', R=20)
assert_false(self.C == C)
Au = Atom('Au', R=20)
assert_false(self.C == Au)
C = Atom['C']
assert_false(self.Au == C)
Au = Atom['Au']
assert_false(self.C == Au)
def test3(self):
assert_true(self.C.symbol == 'C')
assert_true(self.Au.symbol == 'Au')
def test4(self):
assert_true(self.C.mass > 0)
assert_true(self.Au.mass > 0)
def test5(self):
assert_true(Atom(Z=1, mass=12).mass == 12)
assert_true(Atom(Z=31, mass=12).mass == 12)
assert_true(Atom(Z=31, mass=12).Z == 31)
def test6(self):
assert_true(Atom(Z=1, orbs=3).orbs == 3)
assert_true(len(Atom(Z=1, orbs=3)) == 3)
assert_true(Atom(Z=1, R=1.4).R == 1.4)
assert_true(Atom(Z=1, R=1.4).dR == 1.4)
assert_true(Atom(Z=1, R=[1.4, 1.8]).orbs == 2)
def test7(self):
assert_true(Atom(Z=1, orbs=3).radius() > 0.)
assert_true(len(str(Atom(Z=1, orbs=3))))
def test8(self):
a = self.PT.Z([1, 2])
assert_true(len(a) == 2)
assert_true(a[0] == 1)
assert_true(a[1] == 2)
def test9(self):
a = self.PT.Z_label(['H', 2])
assert_true(len(a) == 2)
assert_true(a[0] == 'H')
assert_true(a[1] == 'He')
a = self.PT.Z_label(1)
assert_true(a == 'H')
def test_pickle(self):
import pickle as p
sC = p.dumps(self.C)
sC3 = p.dumps(self.C3)
sAu = p.dumps(self.Au)
C = p.loads(sC)
C3 = p.loads(sC3)
Au = p.loads(sAu)
assert_false(Au == C)
assert_true(Au != C)
assert_true(C == self.C)
assert_true(C3 == self.C3)
assert_false(C == self.Au)
assert_true(Au == self.Au)
assert_true(Au != self.C)
class TestAtom(object):
def setUp(self):
self.C = Atom['C']
self.C3 = Atom('C', orbs=3)
self.Au = Atom['Au']
self.PT = PeriodicTable()
def tearDown(self):
del self.C
del self.Au
del self.C3
del self.PT
def test1(self):
assert_true(self.C == Atom['C'])
assert_true(self.C == Atom[self.C])
assert_true(self.C == Atom[Atom['C']])
assert_true(self.C == Atom[Atom(6)])
assert_true(self.Au == Atom['Au'])
assert_true(self.Au != self.C)
assert_false(self.Au == self.C)
assert_true(self.Au == self.Au.copy())
def test2(self):
C = Atom('C', R=20)
assert_false(self.C == C)
Au = Atom('Au', R=20)
assert_false(self.C == Au)
C = Atom['C']
assert_false(self.Au == C)
Au = Atom['Au']
assert_false(self.C == Au)
def test3(self):
assert_true(self.C.symbol == 'C')
assert_true(self.Au.symbol == 'Au')
def test4(self):
assert_true(self.C.mass > 0)
assert_true(self.Au.mass > 0)
def test5(self):
assert_true(Atom(Z=1, mass=12).mass == 12)
assert_true(Atom(Z=31, mass=12).mass == 12)
assert_true(Atom(Z=31, mass=12).Z == 31)
def test6(self):
assert_true(Atom(Z=1, orbs=3).orbs == 3)
assert_true(len(Atom(Z=1, orbs=3)) == 3)
assert_true(Atom(Z=1, R=1.4).R == 1.4)
assert_true(Atom(Z=1, R=1.4).maxR() == 1.4)
assert_true(Atom(Z=1, R=[1.4, 1.8]).orbs == 2)
assert_true(Atom(Z=1, R=[1.4, 1.8]).maxR() == 1.8)
def test7(self):
assert_true(Atom(Z=1, orbs=3).radius() > 0.)
assert_true(len(str(Atom(Z=1, orbs=3))))
def test8(self):
a = self.PT.Z([1, 2])
assert_true(len(a) == 2)
assert_true(a[0] == 1)
assert_true(a[1] == 2)
def test9(self):
a = self.PT.Z_label(['H', 2])
assert_true(len(a) == 2)
assert_true(a[0] == 'H')
assert_true(a[1] == 'He')
a = self.PT.Z_label(1)
assert_true(a == 'H')
def test10(self):
assert_equal(self.PT.atomic_mass(1), self.PT.atomic_mass('H'))
assert_true(np.allclose(self.PT.atomic_mass([1, 2]), self.PT.atomic_mass(['H', 'He'])))
def test11(self):
PT = self.PT
for m in ['calc', 'empirical', 'vdw']:
assert_equal(PT.radius(1, method=m), PT.radius('H', method=m))
assert_true(np.allclose(PT.radius([1, 2], method=m), PT.radius(['H', 'He'], method=m)))
@raises(KeyError)
def test12(self):
a = Atom(1.2)
def test_pickle(self):
import pickle as p
sC = p.dumps(self.C)
sC3 = p.dumps(self.C3)
sAu = p.dumps(self.Au)
C = p.loads(sC)
C3 = p.loads(sC3)
Au = p.loads(sAu)
assert_false(Au == C)
assert_true(Au != C)
assert_true(C == self.C)
assert_true(C3 == self.C3)
assert_false(C == self.Au)
assert_true(Au == self.Au)
assert_true(Au != self.C)
