def test_reciprocal(self): '''check calculation of reciprocal lattice.''' r1 = self.lattice.reciprocal() self.assertEqual((1, 1, 1, 90, 90, 90), r1.abcABG()) L2 = Lattice(2, 4, 8, 90, 90, 90) r2 = L2.reciprocal() self.assertEqual((0.5, 0.25, 0.125, 90, 90, 90), r2.abcABG()) rr2 = r2.reciprocal() self.assertTrue(numpy.array_equal(L2.base, rr2.base)) return
def generate(self): c = self.context excitation = dict(type=c.excitation_type) excitation.update(c.excitation_params) shape = {c.shape_type: c.shape_params} d = dict( name=c.name, packing_factor=c.packing_factor, excitation=excitation, shape=shape, temperature='300*K', ) from diffpy.Structure import Lattice if c.lattice: lattice_constants = c.lattice.totuple() lattice = Lattice(*lattice_constants) base = [','.join(map(str, v)) for v in lattice.base] lattice = dict( constants=','.join(map(str, lattice_constants)), basis_vectors=base, ) d['chemical_formula'] = c.chemical_formula d['lattice'] = lattice else: assert c.structure_file sf = c.structure_file # if isinstance(sf, str): sf = sf.encode() d['structure_file'] = sf path = os.path.join(c.work_dir, c.name + '.yaml') print("writing to %s" % path) import yaml with open(path, 'w') as outfile: yaml.safe_dump(d, outfile, default_flow_style=False) return
def test__set_lattice(self): """check Structure._set_lattice() """ lat = Lattice() self.stru.lattice = lat self.assertEqual(2 * [lat], [a.lattice for a in self.stru]) return
def parseLines(self, lines): """Parse list of lines in DISCUS format. Return PDFFitStructure instance or raise StructureFormatError. """ self.lines = lines ilines = self._linesIterator() self.stru = PDFFitStructure() record_parsers = { "cell": self._parse_cell, "format": self._parse_format, "generator": self._parse_not_implemented, "molecule": self._parse_not_implemented, "ncell": self._parse_ncell, "spcgr": self._parse_spcgr, "symmetry": self._parse_not_implemented, "title": self._parse_title, "shape": self._parse_shape, } try: # parse header for self.line in ilines: words = self.line.split() if not words or words[0][0] == '#': continue if words[0] == 'atoms': break rp = record_parsers.get(words[0], self._parse_unknown_record) rp(words) # check if cell has been defined if not self.cell_read: emsg = "%d: unit cell not defined" % self.nl raise StructureFormatError(emsg) # parse atoms for self.line in ilines: words = self.line.split() if not words or words[0][0] == '#': continue self._parse_atom(words) # self consistency check exp_natoms = reduce(lambda x, y: x * y, self.stru.pdffit['ncell']) # only check if ncell record exists if self.ncell_read and exp_natoms != len(self.stru): emsg = 'Expected %d atoms, read %d.' % \ (exp_natoms, len(self.stru)) raise StructureFormatError(emsg) # take care of superlattice if self.stru.pdffit['ncell'][:3] != [1, 1, 1]: latpars = list(self.stru.lattice.abcABG()) superlatpars = [ latpars[i] * self.stru.pdffit['ncell'][i] for i in range(3) ] + latpars[3:] superlattice = Lattice(*superlatpars) self.stru.placeInLattice(superlattice) self.stru.pdffit['ncell'] = [1, 1, 1, exp_natoms] except (ValueError, IndexError): exc_type, exc_value, exc_traceback = sys.exc_info() emsg = "%d: file is not in DISCUS format" % self.nl raise StructureFormatError, emsg, exc_traceback return self.stru
def test__get_lattice(self): """check Structure._get_lattice() """ lat = Lattice() stru = Structure() self.assertEqual((1, 1, 1, 90, 90, 90), stru.lattice.abcABG()) stru2 = Structure(lattice=lat) self.failUnless(lat is stru2.lattice) return
def test_placeInLattice(self): """check Structure.placeInLattice() -- conversion of coordinates """ stru = self.stru new_lattice = Lattice(.5, .5, .5, 90, 90, 60) stru.placeInLattice(new_lattice) a0 = stru[0] self.assertTrue(numpy.allclose(a0.xyz, [0.0, 0.0, 0.0])) a1 = stru[1] self.assertTrue(numpy.allclose(a1.xyz, [2.0, 0.0, 2.0]))
def test_writeStr_xyz(self): """check string representation of normal xyz file""" stru = self.stru stru.title = "test of writeStr" stru.lattice = Lattice(1.0, 2.0, 3.0, 90.0, 90.0, 90.0) stru[:] = [Atom('H', [1., 1., 1.]), Atom('Cl', [3., 2., 1.])] s1 = stru.writeStr(self.format) s1 = re.sub('[ \t]+', ' ', s1) s0 = "2\n%s\nH 1 2 3\nCl 3 4 3\n" % stru.title self.assertEqual(s1, s0)
def test_placeInLattice(self): """check Structure.placeInLattice() -- conversion of coordinates """ stru = self.stru new_lattice = Lattice(.5, .5, .5, 90, 90, 60) stru.placeInLattice(new_lattice) a0 = stru[0] self.assertListAlmostEqual(a0.xyz, 3*[0.0]) a1 = stru[1] self.assertListAlmostEqual(a1.xyz, [2.0, 0.0, 2.0])
def test___repr__(self): """Test representation of DiffpyStructureParSet objects. """ lat = Lattice(3, 3, 2, 90, 90, 90) atom = Atom("C", [0, 0.2, 0.5]) stru = Structure([atom], lattice=lat) dsps = DiffpyStructureParSet("dsps", stru) self.assertEqual(repr(stru), repr(dsps)) self.assertEqual(repr(lat), repr(dsps.lattice)) self.assertEqual(repr(atom), repr(dsps.atoms[0])) return
def fccNi(): atoms = [ Atom('Ni', (0, 0, 0)), Atom('Ni', (0.5, 0.5, 0)), Atom('Ni', (0.5, 0, 0.5)), Atom('Ni', (0, 0.5, 0.5)) ] a = 3.5238 alpha = 90. lattice = Lattice(a=a, b=a, c=a, alpha=alpha, beta=alpha, gamma=alpha) return Structure(atoms, lattice, sgid=225)
def fccAl(): atoms = [ Atom('Al', (0, 0, 0)), Atom('Al', (0.5, 0.5, 0)), Atom('Al', (0.5, 0, 0.5)), Atom('Al', (0, 0.5, 0.5)) ] a = 4.046 alpha = 90. lattice = Lattice(a=a, b=a, c=a, alpha=alpha, beta=alpha, gamma=alpha) return Structure(atoms, lattice, sgid=225)
def test_write_xyz(self): """check writing of normal xyz file""" stru = self.stru stru.title = "test of writeStr" stru.lattice = Lattice(1.0, 2.0, 3.0, 90.0, 90.0, 90.0) stru[:] = [Atom('H', [1., 1., 1.]), Atom('Cl', [3., 2., 1.])] stru.write(self.tmpname, self.format) f_s = open(self.tmpname).read() f_s = re.sub('[ \t]+', ' ', f_s) s_s = "2\n%s\nH 1 2 3\nCl 3 4 3\n" % stru.title self.assertEqual(f_s, s_s)
def test___init__(self): '''Check Lattice.__init__ processing of arguments. ''' self.assertRaises(ValueError, Lattice, self.lattice, c=4) self.assertRaises(ValueError, Lattice, base=self.lattice.base, baserot=self.lattice.baserot) self.assertRaises(ValueError, Lattice, 1, 2, 3) self.assertRaises(ValueError, Lattice, 1, 2, 3, 80, 90) L0 = self.lattice L0.setLatBase(L0.cartesian([[1, 1, 0], [0, 1, 1], [1, 0, 1]])) L1 = Lattice(L0) self.assertTrue(numpy.array_equal(L0.base, L1.base)) L2 = Lattice(base=L0.base) self.assertTrue(numpy.array_equal(L0.base, L2.base)) self.assertTrue(numpy.array_equal(L0.isotropicunit, L2.isotropicunit)) L3 = Lattice(*L0.abcABG(), baserot=L0.baserot) self.assertTrue(numpy.allclose(L0.base, L3.base)) self.assertTrue(numpy.allclose(L0.isotropicunit, L3.isotropicunit)) return
def setUp(self): self.stru = Structure( [ Atom('C', [0,0,0]), Atom('C', [1,1,1]) ], lattice=Lattice(1, 1, 1, 90, 90, 120) ) if not self._loaded_structures: self._loaded_structures.update([ ('cdse', Structure(filename=cdsefile)), ('tei', Structure(filename=teifile)), ('pbte', Structure(filename=pbtefile)), ]) self.__dict__.update(self._loaded_structures) self.places = 12 return
def test_latpar_properties(self): '''check assignment to a, b, c, alpha, beta, gamma. ''' lat = self.lattice lat.a = 2 lat.b = 4 lat.c = 6 lat.alpha = 80 lat.beta = 100 lat.gamma = 120 lat1 = Lattice(2, 4, 6, 80, 100, 120) self.assertAlmostEqual(-0.5, lat.cg, self.places) self.assertTrue(numpy.array_equal(lat1.base, lat.base)) return
def test_writeStr_rawxyz(self): """check writing of normal xyz file""" stru = self.stru stru.title = "test of writeStr" stru.lattice = Lattice(1.0, 2.0, 3.0, 90.0, 90.0, 90.0) # plain version stru[:] = [Atom('H', [1., 1., 1.])] s1 = stru.writeStr(self.format) s1 = re.sub('[ \t]+', ' ', s1) s0 = "H 1 2 3\n" # brutal raw version stru[0].element = "" s1 = stru.writeStr(self.format) s0 = "1 2 3\n" self.assertEqual(s1, s0)
def test___init__(self): """check Structure.__init__() """ atoms = [Atom('C', [0, 0, 0]), Atom('C', [0.5, 0.5, 0.5])] self.assertRaises(ValueError, Structure, atoms, filename=teifile) self.assertRaises(ValueError, Structure, lattice=Lattice(), filename=teifile) self.assertRaises(ValueError, Structure, title='test', filename=teifile) stru1 = Structure(title='my title') self.assertEqual('my title', stru1.title) stru2a = Structure(atoms) stru2b = Structure(iter(atoms)) stru2c = Structure(a for a in atoms) s2a = str(stru2a) self.assertEqual(s2a, str(stru2b)) self.assertEqual(s2a, str(stru2c)) return
class TestLattice(unittest.TestCase): """test methods of Lattice class""" def setUp(self): self.lattice = Lattice() self.places = 12 return def assertListAlmostEqual(self, l1, l2, places=None): """wrapper for list comparison""" if places is None: places = self.places self.assertEqual(len(l1), len(l2)) for i in range(len(l1)): self.assertAlmostEqual(l1[i], l2[i], places) return def test___init__(self): '''Check Lattice.__init__ processing of arguments. ''' self.assertRaises(ValueError, Lattice, self.lattice, c=4) self.assertRaises(ValueError, Lattice, base=self.lattice.base, baserot=self.lattice.baserot) self.assertRaises(ValueError, Lattice, 1, 2, 3) self.assertRaises(ValueError, Lattice, 1, 2, 3, 80, 90) L0 = self.lattice L0.setLatBase(L0.cartesian([[1, 1, 0], [0, 1, 1], [1, 0, 1]])) L1 = Lattice(L0) self.assertTrue(numpy.array_equal(L0.base, L1.base)) L2 = Lattice(base=L0.base) self.assertTrue(numpy.array_equal(L0.base, L2.base)) self.assertTrue(numpy.array_equal(L0.isotropicunit, L2.isotropicunit)) L3 = Lattice(*L0.abcABG(), baserot=L0.baserot) self.assertTrue(numpy.allclose(L0.base, L3.base)) self.assertTrue(numpy.allclose(L0.isotropicunit, L3.isotropicunit)) return def test_setLatPar(self): """check calculation of standard unit cell vectors""" from numpy import dot from math import radians, sqrt, cos norm = lambda x : sqrt(sum([xi**2 for xi in x])) cosd = lambda x : cos(radians(x)) self.lattice.setLatPar(1.0, 2.0, 3.0, 80, 100, 120) base = self.lattice.base self.assertAlmostEqual(1.0, norm(base[0]), self.places) self.assertAlmostEqual(2.0, norm(base[1]), self.places) self.assertAlmostEqual(3.0, norm(base[2]), self.places) self.assertAlmostEqual(cosd(80.0), dot(base[1],base[2])/(2*3), self.places) self.assertAlmostEqual(cosd(100.0), dot(base[0],base[2])/(1*3), self.places) self.assertAlmostEqual(cosd(120.0), dot(base[0],base[1])/(1*2), self.places) return def test_latpar_properties(self): '''check assignment to a, b, c, alpha, beta, gamma. ''' lat = self.lattice lat.a = 2 lat.b = 4 lat.c = 6 lat.alpha = 80 lat.beta = 100 lat.gamma = 120 lat1 = Lattice(2, 4, 6, 80, 100, 120) self.assertAlmostEqual(-0.5, lat.cg, self.places) self.assertTrue(numpy.array_equal(lat1.base, lat.base)) return def test_readonly_properties(self): '''Check that read-only properties are indeed such. ''' lat = self.lattice lat.b = 2 lat.c = 6 self.assertEqual(1.0, lat.unitvolume) self.assertRaises(AttributeError, setattr, lat, 'unitvolume', 3.33) self.assertEqual(12, lat.volume) self.assertRaises(AttributeError, setattr, lat, 'volume', 3.33) self.assertEqual(0.0, lat.ca) self.assertRaises(AttributeError, setattr, lat, 'ca', 3.33) self.assertEqual(0.0, lat.cb) self.assertRaises(AttributeError, setattr, lat, 'cb', 3.33) self.assertEqual(0.0, lat.cg) self.assertRaises(AttributeError, setattr, lat, 'cg', 3.33) self.assertEqual(1.0, lat.sa) self.assertRaises(AttributeError, setattr, lat, 'sa', 3.33) self.assertEqual(1.0, lat.sb) self.assertRaises(AttributeError, setattr, lat, 'sb', 3.33) self.assertEqual(1.0, lat.sg) self.assertRaises(AttributeError, setattr, lat, 'sg', 3.33) self.assertEqual(1.0, lat.ar) self.assertRaises(AttributeError, setattr, lat, 'ar', 3.33) self.assertEqual(0.5, lat.br) self.assertRaises(AttributeError, setattr, lat, 'br', 3.33) self.assertAlmostEqual(1.0/6, lat.cr, self.places) self.assertRaises(AttributeError, setattr, lat, 'cr', 3.33) self.assertEqual(90.0, lat.alphar) self.assertRaises(AttributeError, setattr, lat, 'alphar', 3.33) self.assertEqual(90.0, lat.betar) self.assertRaises(AttributeError, setattr, lat, 'betar', 3.33) self.assertEqual(90.0, lat.gammar) self.assertRaises(AttributeError, setattr, lat, 'gammar', 3.33) self.assertEqual(0.0, lat.car) self.assertRaises(AttributeError, setattr, lat, 'car', 3.33) self.assertEqual(0.0, lat.cbr) self.assertRaises(AttributeError, setattr, lat, 'cbr', 3.33) self.assertEqual(0.0, lat.cgr) self.assertRaises(AttributeError, setattr, lat, 'cgr', 3.33) self.assertEqual(1.0, lat.sar) self.assertRaises(AttributeError, setattr, lat, 'sar', 3.33) self.assertEqual(1.0, lat.sbr) self.assertRaises(AttributeError, setattr, lat, 'sbr', 3.33) self.assertEqual(1.0, lat.sgr) self.assertRaises(AttributeError, setattr, lat, 'sgr', 3.33) return def test_setLatBase(self): """check calculation of unit cell rotation""" base = numpy.array([[ 1.0, 1.0, 0.0], [ 0.0, 1.0, 1.0], [ 1.0, 0.0, 1.0]]) self.lattice.setLatBase(base) self.assertAlmostEqual(self.lattice.a, numpy.sqrt(2.0), self.places) self.assertAlmostEqual(self.lattice.b, numpy.sqrt(2.0), self.places) self.assertAlmostEqual(self.lattice.c, numpy.sqrt(2.0), self.places) self.assertAlmostEqual(self.lattice.alpha, 60.0, self.places) self.assertAlmostEqual(self.lattice.beta, 60.0, self.places) self.assertAlmostEqual(self.lattice.gamma, 60.0, self.places) detR0 = numalg.det(self.lattice.baserot) self.assertAlmostEqual(detR0, 1.0, self.places) # try if rotation matrix works self.assertEqual(numpy.all(base == self.lattice.base), True) self.lattice.setLatPar(alpha=44, beta=66, gamma=88) self.assertNotEqual(numpy.all(base == self.lattice.base), True) self.lattice.setLatPar(alpha=60, beta=60, gamma=60) self.assertListAlmostEqual(base[0], self.lattice.base[0]) self.assertListAlmostEqual(base[1], self.lattice.base[1]) self.assertListAlmostEqual(base[2], self.lattice.base[2]) # try base checking self.assertRaises(LatticeError, self.lattice.setLatBase, [[1, 0, 0], [1,0,0], [0,0,1]]) self.assertRaises(LatticeError, self.lattice.setLatBase, [[1, 0, 0], [0,0,1], [0,1,0]]) return def test_reciprocal(self): '''check calculation of reciprocal lattice.''' r1 = self.lattice.reciprocal() self.assertEqual((1, 1, 1, 90, 90, 90), r1.abcABG()) L2 = Lattice(2, 4, 8, 90, 90, 90) r2 = L2.reciprocal() self.assertEqual((0.5, 0.25, 0.125, 90, 90, 90), r2.abcABG()) rr2 = r2.reciprocal() self.assertTrue(numpy.array_equal(L2.base, rr2.base)) return def test_dot(self): '''check dot product of lattice vectors.''' L = self.lattice L.setLatPar(gamma=120) self.assertAlmostEqual(-0.5, L.dot([1, 0, 0], [0, 1, 0]), self.places) va5 = numpy.tile([1.0, 0.0, 0.0], (5, 1)) vb5 = numpy.tile([0.0, 1.0, 0.0], (5, 1)) self.assertTrue(numpy.array_equal(5 * [-0.5], L.dot(va5, vb5))) self.assertTrue(numpy.array_equal(5 * [-0.5], L.dot(va5[0], vb5))) self.assertTrue(numpy.array_equal(5 * [-0.5], L.dot(va5, vb5[0]))) return def test_norm(self): '''check norm of a lattice vector.''' self.assertEqual(1, self.lattice.norm([1, 0, 0])) u = numpy.array([[3, 4, 0], [1, 1, 1]]) self.assertListAlmostEqual([5, 3**0.5], self.lattice.norm(u)) self.lattice.setLatPar(gamma=120) self.assertAlmostEqual(1, self.lattice.norm([1, 1, 0]), self.places) return def test_rnorm(self): '''check norm of a reciprocal vector.''' L = self.lattice L.setLatPar(1, 1.5, 2.3, 80, 95, 115) r = L.reciprocal() hkl = [0.5, 0.3, 0.2] self.assertAlmostEqual(r.norm(hkl), L.rnorm(hkl), self.places) hkl5 = numpy.tile(hkl, (5, 1)) self.assertListAlmostEqual(5 * [r.norm(hkl)], L.rnorm(hkl5)) return def test_dist(self): '''check dist function for distance between lattice points.''' L = self.lattice L.setLatPar(1, 1.5, 2.3, 80, 95, 115) u = [0.1, 0.3, 0.7] v = [0.3, 0.7, 0.7] d0 = numalg.norm(L.cartesian(numpy.array(u) - v)) self.assertAlmostEqual(d0, L.dist(u, v), self.places) self.assertAlmostEqual(d0, L.dist(v, u), self.places) u5 = numpy.tile(u, (5, 1)) v5 = numpy.tile(v, (5, 1)) self.assertListAlmostEqual(5 * [d0], L.dist(u, v5)) self.assertListAlmostEqual(5 * [d0], L.dist(u5, v)) self.assertListAlmostEqual(5 * [d0], L.dist(v5, u5)) return def test_angle(self): '''check angle calculation between lattice vectors.''' from math import degrees, acos L = self.lattice L.setLatPar(1, 1.5, 2.3, 80, 95, 115) u = [0.1, 0.3, 0.7] v = [0.3, 0.7, 0.7] uc = L.cartesian(u) vc = L.cartesian(v) a0 = degrees(acos(numpy.dot(uc, vc) / (numalg.norm(uc) * numalg.norm(vc)))) self.assertAlmostEqual(a0, L.angle(u, v), self.places) self.assertAlmostEqual(a0, L.angle(v, u), self.places) u5 = numpy.tile(u, (5, 1)) v5 = numpy.tile(v, (5, 1)) self.assertListAlmostEqual(5 * [a0], L.angle(u, v5)) self.assertListAlmostEqual(5 * [a0], L.angle(u5, v)) self.assertListAlmostEqual(5 * [a0], L.angle(v5, u5)) return def test_repr(self): """check string representation of this lattice""" r = repr(self.lattice) self.assertEqual(r, "Lattice()") self.lattice.setLatPar(1, 2, 3, 10, 20, 30) r = repr(self.lattice) r0 = "Lattice(a=1, b=2, c=3, alpha=10, beta=20, gamma=30)" self.assertEqual(r, r0) base = [[ 1.0, 1.0, 0.0], [ 0.0, 2.0, 2.0], [ 3.0, 0.0, 3.0]] self.lattice.setLatBase(base) r = repr(self.lattice) self.assertEqual(r, "Lattice(base=%r)" % self.lattice.base)
class TestLattice(unittest.TestCase): """test methods of Lattice class""" def setUp(self): self.lattice = Lattice() self.places = 12 return def assertListAlmostEqual(self, l1, l2, places=None): """wrapper for list comparison""" if places is None: places = self.places self.assertEqual(len(l1), len(l2)) for i in range(len(l1)): self.assertAlmostEqual(l1[i], l2[i], places) return def test_setLatPar(self): """check calculation of standard unit cell vectors""" from numpy import dot from math import radians, sqrt, cos, sin norm = lambda x : sqrt(sum([xi**2 for xi in x])) cosd = lambda x : cos(radians(x)) sind = lambda x : sin(radians(x)) self.lattice.setLatPar(1.0, 2.0, 3.0, 80, 100, 120) base = self.lattice.base self.assertAlmostEqual(1.0, norm(base[0]), self.places) self.assertAlmostEqual(2.0, norm(base[1]), self.places) self.assertAlmostEqual(3.0, norm(base[2]), self.places) self.assertAlmostEqual(cosd(80.0), dot(base[1],base[2])/(2*3), self.places) self.assertAlmostEqual(cosd(100.0), dot(base[0],base[2])/(1*3), self.places) self.assertAlmostEqual(cosd(120.0), dot(base[0],base[1])/(1*2), self.places) return def test_latpar_properties(self): '''check assignment to a, b, c, alpha, beta, gamma. ''' lat = self.lattice lat.a = 2 lat.b = 4 lat.c = 6 lat.alpha = 80 lat.beta = 100 lat.gamma = 120 lat1 = Lattice(2, 4, 6, 80, 100, 120) self.assertAlmostEqual(-0.5, lat.cg, self.places) self.failUnless(numpy.array_equal(lat1.base, lat.base)) return def test_readonly_properties(self): '''Check that read-only properties are indeed such. ''' lat = self.lattice lat.b = 2 lat.c = 6 self.assertEqual(1.0, lat.unitvolume) self.assertRaises(AttributeError, setattr, lat, 'unitvolume', 3.33) self.assertEqual(12, lat.volume) self.assertRaises(AttributeError, setattr, lat, 'volume', 3.33) self.assertEqual(0.0, lat.ca) self.assertRaises(AttributeError, setattr, lat, 'ca', 3.33) self.assertEqual(0.0, lat.cb) self.assertRaises(AttributeError, setattr, lat, 'cb', 3.33) self.assertEqual(0.0, lat.cg) self.assertRaises(AttributeError, setattr, lat, 'cg', 3.33) self.assertEqual(1.0, lat.sa) self.assertRaises(AttributeError, setattr, lat, 'sa', 3.33) self.assertEqual(1.0, lat.sb) self.assertRaises(AttributeError, setattr, lat, 'sb', 3.33) self.assertEqual(1.0, lat.sg) self.assertRaises(AttributeError, setattr, lat, 'sg', 3.33) self.assertEqual(1.0, lat.ar) self.assertRaises(AttributeError, setattr, lat, 'ar', 3.33) self.assertEqual(0.5, lat.br) self.assertRaises(AttributeError, setattr, lat, 'br', 3.33) self.assertAlmostEqual(1.0/6, lat.cr, self.places) self.assertRaises(AttributeError, setattr, lat, 'cr', 3.33) self.assertEqual(90.0, lat.alphar) self.assertRaises(AttributeError, setattr, lat, 'alphar', 3.33) self.assertEqual(90.0, lat.betar) self.assertRaises(AttributeError, setattr, lat, 'betar', 3.33) self.assertEqual(90.0, lat.gammar) self.assertRaises(AttributeError, setattr, lat, 'gammar', 3.33) self.assertEqual(0.0, lat.car) self.assertRaises(AttributeError, setattr, lat, 'car', 3.33) self.assertEqual(0.0, lat.cbr) self.assertRaises(AttributeError, setattr, lat, 'cbr', 3.33) self.assertEqual(0.0, lat.cgr) self.assertRaises(AttributeError, setattr, lat, 'cgr', 3.33) self.assertEqual(1.0, lat.sar) self.assertRaises(AttributeError, setattr, lat, 'sar', 3.33) self.assertEqual(1.0, lat.sbr) self.assertRaises(AttributeError, setattr, lat, 'sbr', 3.33) self.assertEqual(1.0, lat.sgr) self.assertRaises(AttributeError, setattr, lat, 'sgr', 3.33) return def test_setLatBase(self): """check calculation of unit cell rotation""" import numpy import numpy.linalg as numalg base = numpy.array([[ 1.0, 1.0, 0.0], [ 0.0, 1.0, 1.0], [ 1.0, 0.0, 1.0]]) self.lattice.setLatBase(base) self.assertAlmostEqual(self.lattice.a, numpy.sqrt(2.0), self.places) self.assertAlmostEqual(self.lattice.b, numpy.sqrt(2.0), self.places) self.assertAlmostEqual(self.lattice.c, numpy.sqrt(2.0), self.places) self.assertAlmostEqual(self.lattice.alpha, 60.0, self.places) self.assertAlmostEqual(self.lattice.beta, 60.0, self.places) self.assertAlmostEqual(self.lattice.gamma, 60.0, self.places) detR0 = numalg.det(self.lattice.baserot) self.assertAlmostEqual(detR0, 1.0, self.places) # try if rotation matrix works self.assertEqual(numpy.all(base == self.lattice.base), True) self.lattice.setLatPar(alpha=44, beta=66, gamma=88) self.assertNotEqual(numpy.all(base == self.lattice.base), True) self.lattice.setLatPar(alpha=60, beta=60, gamma=60) self.assertListAlmostEqual(base[0], self.lattice.base[0]) self.assertListAlmostEqual(base[1], self.lattice.base[1]) self.assertListAlmostEqual(base[2], self.lattice.base[2]) # try base checking self.assertRaises(LatticeError, self.lattice.setLatBase, [[1, 0, 0], [1,0,0], [0,0,1]]) self.assertRaises(LatticeError, self.lattice.setLatBase, [[1, 0, 0], [0,0,1], [0,1,0]]) return def test_repr(self): """check string representation of this lattice""" r = repr(self.lattice) self.assertEqual(r, "Lattice()") self.lattice.setLatPar(1, 2, 3, 10, 20, 30) r = repr(self.lattice) r0 = "Lattice(a=1, b=2, c=3, alpha=10, beta=20, gamma=30)" self.assertEqual(r, r0) base = [[ 1.0, 1.0, 0.0], [ 0.0, 2.0, 2.0], [ 3.0, 0.0, 3.0]] self.lattice.setLatBase(base) r = repr(self.lattice) self.assertEqual(r, "Lattice(base=%r)" % self.lattice.base)
def parseLines(self, lines): """Parse list of lines in PDFfit format. Return Structure object or raise StructureFormatError. """ p_nl = 0 rlist = [] try: self.stru = PDFFitStructure() stru = self.stru cell_line_read = False stop = len(lines) while stop > 0 and lines[stop - 1].strip() == "": stop -= 1 ilines = iter(lines[:stop]) # read header of PDFFit file for l in ilines: p_nl += 1 words = l.split() if len(words) == 0 or words[0][0] == '#': continue elif words[0] == 'title': stru.title = l.lstrip()[5:].strip() elif words[0] == 'scale': stru.pdffit['scale'] = float(words[1]) elif words[0] == 'sharp': l1 = l.replace(',', ' ') sharp_pars = [float(w) for w in l1.split()[1:]] if len(sharp_pars) < 4: stru.pdffit['delta2'] = sharp_pars[0] stru.pdffit['sratio'] = sharp_pars[1] stru.pdffit['rcut'] = sharp_pars[2] else: stru.pdffit['delta2'] = sharp_pars[0] stru.pdffit['delta1'] = sharp_pars[1] stru.pdffit['sratio'] = sharp_pars[2] stru.pdffit['rcut'] = sharp_pars[3] elif words[0] == 'spcgr': key = 'spcgr' start = l.find(key) + len(key) value = l[start:].strip() stru.pdffit['spcgr'] = value elif words[0] == 'shape': self._parse_shape(l) elif words[0] == 'cell': cell_line_read = True l1 = l.replace(',', ' ') latpars = [float(w) for w in l1.split()[1:7]] stru.lattice = Lattice(*latpars) elif words[0] == 'dcell': l1 = l.replace(',', ' ') stru.pdffit['dcell'] = [float(w) for w in l1.split()[1:7]] elif words[0] == 'ncell': l1 = l.replace(',', ' ') stru.pdffit['ncell'] = [int(w) for w in l1.split()[1:5]] elif words[0] == 'format': if words[1] != 'pdffit': emsg = "%d: file is not in PDFfit format" % p_nl raise StructureFormatError(emsg) elif words[0] == 'atoms' and cell_line_read: break else: self.ignored_lines.append(l) # Header reading finished, check if required lines were present. if not cell_line_read: emsg = "%d: file is not in PDFfit format" % p_nl raise StructureFormatError(emsg) # Load data from atom entries. p_natoms = reduce(lambda x, y: x * y, stru.pdffit['ncell']) # we are now inside data block for l in ilines: p_nl += 1 wl1 = l.split() element = wl1[0][0].upper() + wl1[0][1:].lower() xyz = [float(w) for w in wl1[1:4]] occ = float(wl1[4]) stru.addNewAtom(element, xyz=xyz, occupancy=occ) a = stru.getLastAtom() p_nl += 1 wl2 = ilines.next().split() a.sigxyz = [float(w) for w in wl2[0:3]] a.sigo = float(wl2[3]) p_nl += 1 wl3 = ilines.next().split() p_nl += 1 wl4 = ilines.next().split() p_nl += 1 wl5 = ilines.next().split() p_nl += 1 wl6 = ilines.next().split() a.sigU = numpy.zeros((3, 3), dtype=float) a.U11 = float(wl3[0]) a.U22 = float(wl3[1]) a.U33 = float(wl3[2]) a.sigU[0, 0] = float(wl4[0]) a.sigU[1, 1] = float(wl4[1]) a.sigU[2, 2] = float(wl4[2]) a.U12 = float(wl5[0]) a.U13 = float(wl5[1]) a.U23 = float(wl5[2]) a.sigU[0, 1] = a.sigU[1, 0] = float(wl6[0]) a.sigU[0, 2] = a.sigU[2, 0] = float(wl6[1]) a.sigU[1, 2] = a.sigU[2, 1] = float(wl6[2]) if len(stru) != p_natoms: emsg = "expected %d atoms, read %d" % (p_natoms, len(stru)) raise StructureFormatError(emsg) if stru.pdffit['ncell'][:3] != [1, 1, 1]: superlatpars = [ latpars[i] * stru.pdffit['ncell'][i] for i in range(3) ] + latpars[3:] superlattice = Lattice(*superlatpars) stru.placeInLattice(superlattice) stru.pdffit['ncell'] = [1, 1, 1, p_natoms] except (ValueError, IndexError): emsg = "%d: file is not in PDFfit format" % p_nl exc_type, exc_value, exc_traceback = sys.exc_info() raise StructureFormatError, emsg, exc_traceback return stru
class P_bratoms(StructureParser): """Parser for Bruce Ravel's Atoms structure format. """ plist = ["a", "b", "c", "alpha", "beta", "gamma"] def __init__(self): StructureParser.__init__(self) self.format = "bratoms" return def parseLines(self, lines): """Parse list of lines in atoms format. Return Structure object or raise StructureFormatError. """ comlist = ["#", "%", "!", "*"] atoms = [] title = "" anext = False sg = None structure = BRAtomsStructure() meta = structure.bratoms pdict = dict.fromkeys(self.plist) # Count the lines ln = 0 try: for line in lines: ln += 1 # Strip comments from the line for c in comlist: idx = line.find(c) if idx != -1: line = line[:idx] # Move on if there is not a line if not line: continue # Move on if there was only white space in the line sline = line.split() if not sline: continue # Check if we have atoms following if sline[0].startswith("atom"): anext = True continue # Check for title if sline[0].startswith("title"): if title: title += "\n" title += line[5:] continue # Get rid of pesky "=" and "," signs while "=" in sline: sline.remove("=") while "," in sline: sline.remove(",") # space group if sline and sline[0].startswith("space"): meta["space"] = line[5:].strip() continue # output if sline and sline[0].startswith("output"): meta["output"] = line[6:].strip() continue # shift if sline and sline[0].startswith("shift"): meta["shift"] = line[5:].strip() continue # Check for other metadata while sline and sline[0].strip() in meta: key = sline.pop(0).strip() if key == "central": key = "core" meta[key] = sline.pop(0).strip() # Check for lattice information. while sline and sline[0].strip() in self.plist: key = sline.pop(0).strip() pdict[key] = float(sline.pop(0)) # Check for atom information if sline and anext: elraw = sline.pop(0).strip() el = elraw[:1].upper() + elraw[1:].lower() x = float(sline.pop(0)) y = float(sline.pop(0)) z = float(sline.pop(0)) tag = "" if sline: tag = sline.pop(0).strip() occ = 1.0 if sline: occ = float(sline.pop(0)) a = Atom( atype = el, xyz = [x,y,z], name = tag, occupancy = occ) atoms.append(a) except (ValueError, IndexError), e: emsg = "%d: file is not in Atoms format" % ln raise StructureFormatError(emsg) # Make sure we have atoms. if len(atoms) == 0: raise StructureFormatError("File contains no atoms") # Make sure we have unit cell parameters if pdict["a"] is None: emsg = "Missing definition of cell parameter" raise StructureFormatError(emsg) # Fill in optional information if it was missing. if pdict["alpha"] is None: pdict["alpha"] = 90.0 if pdict["beta"] is None: pdict["beta"] = pdict["alpha"] if pdict["gamma"] is None: pdict["gamma"] = pdict["alpha"] if pdict["b"] is None: pdict["b"] = pdict["a"] if pdict["c"] is None: pdict["c"] = pdict["a"] if meta['core'] is None: meta['core'] = atoms[0].element lat = Lattice(**pdict) structure.title = title structure.lattice = lat structure.extend(atoms) return structure
def parseLines(self, lines): """Parse list of lines in XYZ format. Return Structure object or raise StructureFormatError. """ linefields = [l.split() for l in lines] # prepare output structure stru = Structure() # find first valid record start = 0 for field in linefields: if len(field) == 0 or field[0] == "#": start += 1 else: break # first valid line gives number of atoms try: lfs = linefields[start] w1 = linefields[start][0] if len(lfs) == 1 and str(int(w1)) == w1: p_natoms = int(w1) #try to get lattice vectors from description line try: latticeVecs = list(map(float, linefields[start+1])) assert len(latticeVecs)==9, "Expect 9 numbers for the 3 basis vectors" reshaped = [latticeVecs[0:3], latticeVecs[3:6], latticeVecs[6:9]] stru.lattice = Lattice(base=reshaped) needsDescription = True except: import traceback as tb import warnings warnings.warn("Failed to parse lattice vectors: \n{}".format(tb.format_exc())) needsDescription = False stru.description = lines[start+1].strip() start += 2 else: emsg = ("%d: invalid XYZ format, missing number of atoms" % (start + 1)) raise StructureFormatError(emsg) except (IndexError, ValueError): exc_type, exc_value, exc_traceback = sys.exc_info() emsg = ("%d: invalid XYZ format, missing number of atoms" % (start + 1)) raise StructureFormatError(emsg).with_traceback(exc_traceback) # find the last valid record stop = len(lines) while stop > start and len(linefields[stop-1]) == 0: stop -= 1 # get out for empty structure if p_natoms == 0 or start >= stop: return stru # here we have at least one valid record line nfields = len(linefields[start]) if nfields != 4 and nfields != 5: emsg = "%d: invalid XYZ format, expected 4 or 5 columns" % (start + 1) raise StructureFormatError(emsg) # now try to read all record lines try: p_nl = start for fields in linefields[start:] : p_nl += 1 if fields == []: continue elif len(fields) != 4 and len(fields) !=5: emsg = ('%d: all lines must have ' + 'a symbol, position, and optionally charge') % p_nl raise StructureFormatError(emsg) symbol = fields[0] symbol = symbol[0].upper() + symbol[1:].lower() xyz = [ float(f) for f in fields[1:4] ] if len(fields)==5: charge = float(fields[4]) else: charge = 0.0 stru.addNewAtom(symbol, xyz=xyz) stru.getLastAtom().charge=charge except ValueError: exc_type, exc_value, exc_traceback = sys.exc_info() emsg = "%d: invalid number format" % p_nl raise StructureFormatError(emsg).with_traceback(exc_traceback) # finally check if all the atoms have been read if p_natoms is not None and len(stru) != p_natoms: emsg = "expected %d atoms, read %d" % (p_natoms, len(stru)) raise StructureFormatError(emsg) # if needsDescription: # stru.generateDescription() return stru
def bccFe(): atoms = [Atom('Fe', (0, 0, 0)), Atom('Fe', (0.5, 0.5, 0.5))] a = 2.856 alpha = 90. lattice = Lattice(a=a, b=a, c=a, alpha=alpha, beta=alpha, gamma=alpha) return Structure(atoms, lattice, sgid=229)
class TestLattice(unittest.TestCase): """test methods of Lattice class""" def setUp(self): self.lattice = Lattice() self.places = 12 return def assertListAlmostEqual(self, l1, l2, places=None): """wrapper for list comparison""" if places is None: places = self.places self.assertEqual(len(l1), len(l2)) for i in range(len(l1)): self.assertAlmostEqual(l1[i], l2[i], places) return def test_setLatPar(self): """check calculation of standard unit cell vectors""" from numpy import dot from math import radians, sqrt, cos, sin norm = lambda x: sqrt(sum([xi**2 for xi in x])) cosd = lambda x: cos(radians(x)) sind = lambda x: sin(radians(x)) self.lattice.setLatPar(1.0, 2.0, 3.0, 80, 100, 120) base = self.lattice.base self.assertAlmostEqual(1.0, norm(base[0]), self.places) self.assertAlmostEqual(2.0, norm(base[1]), self.places) self.assertAlmostEqual(3.0, norm(base[2]), self.places) self.assertAlmostEqual(cosd(80.0), dot(base[1], base[2]) / (2 * 3), self.places) self.assertAlmostEqual(cosd(100.0), dot(base[0], base[2]) / (1 * 3), self.places) self.assertAlmostEqual(cosd(120.0), dot(base[0], base[1]) / (1 * 2), self.places) return def test_latpar_properties(self): '''check assignment to a, b, c, alpha, beta, gamma. ''' lat = self.lattice lat.a = 2 lat.b = 4 lat.c = 6 lat.alpha = 80 lat.beta = 100 lat.gamma = 120 lat1 = Lattice(2, 4, 6, 80, 100, 120) self.assertAlmostEqual(-0.5, lat.cg, self.places) self.failUnless(numpy.array_equal(lat1.base, lat.base)) return def test_readonly_properties(self): '''Check that read-only properties are indeed such. ''' lat = self.lattice lat.b = 2 lat.c = 6 self.assertEqual(1.0, lat.unitvolume) self.assertRaises(AttributeError, setattr, lat, 'unitvolume', 3.33) self.assertEqual(12, lat.volume) self.assertRaises(AttributeError, setattr, lat, 'volume', 3.33) self.assertEqual(0.0, lat.ca) self.assertRaises(AttributeError, setattr, lat, 'ca', 3.33) self.assertEqual(0.0, lat.cb) self.assertRaises(AttributeError, setattr, lat, 'cb', 3.33) self.assertEqual(0.0, lat.cg) self.assertRaises(AttributeError, setattr, lat, 'cg', 3.33) self.assertEqual(1.0, lat.sa) self.assertRaises(AttributeError, setattr, lat, 'sa', 3.33) self.assertEqual(1.0, lat.sb) self.assertRaises(AttributeError, setattr, lat, 'sb', 3.33) self.assertEqual(1.0, lat.sg) self.assertRaises(AttributeError, setattr, lat, 'sg', 3.33) self.assertEqual(1.0, lat.ar) self.assertRaises(AttributeError, setattr, lat, 'ar', 3.33) self.assertEqual(0.5, lat.br) self.assertRaises(AttributeError, setattr, lat, 'br', 3.33) self.assertAlmostEqual(1.0 / 6, lat.cr, self.places) self.assertRaises(AttributeError, setattr, lat, 'cr', 3.33) self.assertEqual(90.0, lat.alphar) self.assertRaises(AttributeError, setattr, lat, 'alphar', 3.33) self.assertEqual(90.0, lat.betar) self.assertRaises(AttributeError, setattr, lat, 'betar', 3.33) self.assertEqual(90.0, lat.gammar) self.assertRaises(AttributeError, setattr, lat, 'gammar', 3.33) self.assertEqual(0.0, lat.car) self.assertRaises(AttributeError, setattr, lat, 'car', 3.33) self.assertEqual(0.0, lat.cbr) self.assertRaises(AttributeError, setattr, lat, 'cbr', 3.33) self.assertEqual(0.0, lat.cgr) self.assertRaises(AttributeError, setattr, lat, 'cgr', 3.33) self.assertEqual(1.0, lat.sar) self.assertRaises(AttributeError, setattr, lat, 'sar', 3.33) self.assertEqual(1.0, lat.sbr) self.assertRaises(AttributeError, setattr, lat, 'sbr', 3.33) self.assertEqual(1.0, lat.sgr) self.assertRaises(AttributeError, setattr, lat, 'sgr', 3.33) return def test_setLatBase(self): """check calculation of unit cell rotation""" import numpy import numpy.linalg as numalg base = numpy.array([[1.0, 1.0, 0.0], [0.0, 1.0, 1.0], [1.0, 0.0, 1.0]]) self.lattice.setLatBase(base) self.assertAlmostEqual(self.lattice.a, numpy.sqrt(2.0), self.places) self.assertAlmostEqual(self.lattice.b, numpy.sqrt(2.0), self.places) self.assertAlmostEqual(self.lattice.c, numpy.sqrt(2.0), self.places) self.assertAlmostEqual(self.lattice.alpha, 60.0, self.places) self.assertAlmostEqual(self.lattice.beta, 60.0, self.places) self.assertAlmostEqual(self.lattice.gamma, 60.0, self.places) detR0 = numalg.det(self.lattice.baserot) self.assertAlmostEqual(detR0, 1.0, self.places) # try if rotation matrix works self.assertEqual(numpy.all(base == self.lattice.base), True) self.lattice.setLatPar(alpha=44, beta=66, gamma=88) self.assertNotEqual(numpy.all(base == self.lattice.base), True) self.lattice.setLatPar(alpha=60, beta=60, gamma=60) self.assertListAlmostEqual(base[0], self.lattice.base[0]) self.assertListAlmostEqual(base[1], self.lattice.base[1]) self.assertListAlmostEqual(base[2], self.lattice.base[2]) # try base checking self.assertRaises(LatticeError, self.lattice.setLatBase, [[1, 0, 0], [1, 0, 0], [0, 0, 1]]) self.assertRaises(LatticeError, self.lattice.setLatBase, [[1, 0, 0], [0, 0, 1], [0, 1, 0]]) return def test_repr(self): """check string representation of this lattice""" r = repr(self.lattice) self.assertEqual(r, "Lattice()") self.lattice.setLatPar(1, 2, 3, 10, 20, 30) r = repr(self.lattice) r0 = "Lattice(a=1, b=2, c=3, alpha=10, beta=20, gamma=30)" self.assertEqual(r, r0) base = [[1.0, 1.0, 0.0], [0.0, 2.0, 2.0], [3.0, 0.0, 3.0]] self.lattice.setLatBase(base) r = repr(self.lattice) self.assertEqual(r, "Lattice(base=%r)" % self.lattice.base)
class TestLattice(unittest.TestCase): """test methods of Lattice class""" def setUp(self): self.lattice = Lattice() self.places = 12 return def assertListAlmostEqual(self, l1, l2, places=None): """wrapper for list comparison""" if places is None: places = self.places self.assertEqual(len(l1), len(l2)) for i in range(len(l1)): self.assertAlmostEqual(l1[i], l2[i], places) return def test___init__(self): '''Check Lattice.__init__ processing of arguments. ''' self.assertRaises(ValueError, Lattice, self.lattice, c=4) self.assertRaises(ValueError, Lattice, base=self.lattice.base, baserot=self.lattice.baserot) self.assertRaises(ValueError, Lattice, 1, 2, 3) self.assertRaises(ValueError, Lattice, 1, 2, 3, 80, 90) L0 = self.lattice L0.setLatBase(L0.cartesian([[1, 1, 0], [0, 1, 1], [1, 0, 1]])) L1 = Lattice(L0) self.assertTrue(numpy.array_equal(L0.base, L1.base)) L2 = Lattice(base=L0.base) self.assertTrue(numpy.array_equal(L0.base, L2.base)) self.assertTrue(numpy.array_equal(L0.isotropicunit, L2.isotropicunit)) L3 = Lattice(*L0.abcABG(), baserot=L0.baserot) self.assertTrue(numpy.allclose(L0.base, L3.base)) self.assertTrue(numpy.allclose(L0.isotropicunit, L3.isotropicunit)) return def test_setLatPar(self): """check calculation of standard unit cell vectors""" from numpy import dot from math import radians, sqrt, cos norm = lambda x: sqrt(sum([xi**2 for xi in x])) cosd = lambda x: cos(radians(x)) self.lattice.setLatPar(1.0, 2.0, 3.0, 80, 100, 120) base = self.lattice.base self.assertAlmostEqual(1.0, norm(base[0]), self.places) self.assertAlmostEqual(2.0, norm(base[1]), self.places) self.assertAlmostEqual(3.0, norm(base[2]), self.places) self.assertAlmostEqual(cosd(80.0), dot(base[1], base[2]) / (2 * 3), self.places) self.assertAlmostEqual(cosd(100.0), dot(base[0], base[2]) / (1 * 3), self.places) self.assertAlmostEqual(cosd(120.0), dot(base[0], base[1]) / (1 * 2), self.places) return def test_latpar_properties(self): '''check assignment to a, b, c, alpha, beta, gamma. ''' lat = self.lattice lat.a = 2 lat.b = 4 lat.c = 6 lat.alpha = 80 lat.beta = 100 lat.gamma = 120 lat1 = Lattice(2, 4, 6, 80, 100, 120) self.assertAlmostEqual(-0.5, lat.cg, self.places) self.assertTrue(numpy.array_equal(lat1.base, lat.base)) return def test_readonly_properties(self): '''Check that read-only properties are indeed such. ''' lat = self.lattice lat.b = 2 lat.c = 6 self.assertEqual(1.0, lat.unitvolume) self.assertRaises(AttributeError, setattr, lat, 'unitvolume', 3.33) self.assertEqual(12, lat.volume) self.assertRaises(AttributeError, setattr, lat, 'volume', 3.33) self.assertEqual(0.0, lat.ca) self.assertRaises(AttributeError, setattr, lat, 'ca', 3.33) self.assertEqual(0.0, lat.cb) self.assertRaises(AttributeError, setattr, lat, 'cb', 3.33) self.assertEqual(0.0, lat.cg) self.assertRaises(AttributeError, setattr, lat, 'cg', 3.33) self.assertEqual(1.0, lat.sa) self.assertRaises(AttributeError, setattr, lat, 'sa', 3.33) self.assertEqual(1.0, lat.sb) self.assertRaises(AttributeError, setattr, lat, 'sb', 3.33) self.assertEqual(1.0, lat.sg) self.assertRaises(AttributeError, setattr, lat, 'sg', 3.33) self.assertEqual(1.0, lat.ar) self.assertRaises(AttributeError, setattr, lat, 'ar', 3.33) self.assertEqual(0.5, lat.br) self.assertRaises(AttributeError, setattr, lat, 'br', 3.33) self.assertAlmostEqual(1.0 / 6, lat.cr, self.places) self.assertRaises(AttributeError, setattr, lat, 'cr', 3.33) self.assertEqual(90.0, lat.alphar) self.assertRaises(AttributeError, setattr, lat, 'alphar', 3.33) self.assertEqual(90.0, lat.betar) self.assertRaises(AttributeError, setattr, lat, 'betar', 3.33) self.assertEqual(90.0, lat.gammar) self.assertRaises(AttributeError, setattr, lat, 'gammar', 3.33) self.assertEqual(0.0, lat.car) self.assertRaises(AttributeError, setattr, lat, 'car', 3.33) self.assertEqual(0.0, lat.cbr) self.assertRaises(AttributeError, setattr, lat, 'cbr', 3.33) self.assertEqual(0.0, lat.cgr) self.assertRaises(AttributeError, setattr, lat, 'cgr', 3.33) self.assertEqual(1.0, lat.sar) self.assertRaises(AttributeError, setattr, lat, 'sar', 3.33) self.assertEqual(1.0, lat.sbr) self.assertRaises(AttributeError, setattr, lat, 'sbr', 3.33) self.assertEqual(1.0, lat.sgr) self.assertRaises(AttributeError, setattr, lat, 'sgr', 3.33) return def test_setLatBase(self): """check calculation of unit cell rotation""" base = numpy.array([[1.0, 1.0, 0.0], [0.0, 1.0, 1.0], [1.0, 0.0, 1.0]]) self.lattice.setLatBase(base) self.assertAlmostEqual(self.lattice.a, numpy.sqrt(2.0), self.places) self.assertAlmostEqual(self.lattice.b, numpy.sqrt(2.0), self.places) self.assertAlmostEqual(self.lattice.c, numpy.sqrt(2.0), self.places) self.assertAlmostEqual(self.lattice.alpha, 60.0, self.places) self.assertAlmostEqual(self.lattice.beta, 60.0, self.places) self.assertAlmostEqual(self.lattice.gamma, 60.0, self.places) detR0 = numalg.det(self.lattice.baserot) self.assertAlmostEqual(detR0, 1.0, self.places) # try if rotation matrix works self.assertEqual(numpy.all(base == self.lattice.base), True) self.lattice.setLatPar(alpha=44, beta=66, gamma=88) self.assertNotEqual(numpy.all(base == self.lattice.base), True) self.lattice.setLatPar(alpha=60, beta=60, gamma=60) self.assertListAlmostEqual(base[0], self.lattice.base[0]) self.assertListAlmostEqual(base[1], self.lattice.base[1]) self.assertListAlmostEqual(base[2], self.lattice.base[2]) # try base checking self.assertRaises(LatticeError, self.lattice.setLatBase, [[1, 0, 0], [1, 0, 0], [0, 0, 1]]) self.assertRaises(LatticeError, self.lattice.setLatBase, [[1, 0, 0], [0, 0, 1], [0, 1, 0]]) return def test_reciprocal(self): '''check calculation of reciprocal lattice.''' r1 = self.lattice.reciprocal() self.assertEqual((1, 1, 1, 90, 90, 90), r1.abcABG()) L2 = Lattice(2, 4, 8, 90, 90, 90) r2 = L2.reciprocal() self.assertEqual((0.5, 0.25, 0.125, 90, 90, 90), r2.abcABG()) rr2 = r2.reciprocal() self.assertTrue(numpy.array_equal(L2.base, rr2.base)) return def test_dot(self): '''check dot product of lattice vectors.''' L = self.lattice L.setLatPar(gamma=120) self.assertAlmostEqual(-0.5, L.dot([1, 0, 0], [0, 1, 0]), self.places) va5 = numpy.tile([1.0, 0.0, 0.0], (5, 1)) vb5 = numpy.tile([0.0, 1.0, 0.0], (5, 1)) self.assertTrue(numpy.array_equal(5 * [-0.5], L.dot(va5, vb5))) self.assertTrue(numpy.array_equal(5 * [-0.5], L.dot(va5[0], vb5))) self.assertTrue(numpy.array_equal(5 * [-0.5], L.dot(va5, vb5[0]))) return def test_norm(self): '''check norm of a lattice vector.''' self.assertEqual(1, self.lattice.norm([1, 0, 0])) u = numpy.array([[3, 4, 0], [1, 1, 1]]) self.assertListAlmostEqual([5, 3**0.5], self.lattice.norm(u)) self.lattice.setLatPar(gamma=120) self.assertAlmostEqual(1, self.lattice.norm([1, 1, 0]), self.places) return def test_rnorm(self): '''check norm of a reciprocal vector.''' L = self.lattice L.setLatPar(1, 1.5, 2.3, 80, 95, 115) r = L.reciprocal() hkl = [0.5, 0.3, 0.2] self.assertAlmostEqual(r.norm(hkl), L.rnorm(hkl), self.places) hkl5 = numpy.tile(hkl, (5, 1)) self.assertListAlmostEqual(5 * [r.norm(hkl)], L.rnorm(hkl5)) return def test_dist(self): '''check dist function for distance between lattice points.''' L = self.lattice L.setLatPar(1, 1.5, 2.3, 80, 95, 115) u = [0.1, 0.3, 0.7] v = [0.3, 0.7, 0.7] d0 = numalg.norm(L.cartesian(numpy.array(u) - v)) self.assertAlmostEqual(d0, L.dist(u, v), self.places) self.assertAlmostEqual(d0, L.dist(v, u), self.places) u5 = numpy.tile(u, (5, 1)) v5 = numpy.tile(v, (5, 1)) self.assertListAlmostEqual(5 * [d0], L.dist(u, v5)) self.assertListAlmostEqual(5 * [d0], L.dist(u5, v)) self.assertListAlmostEqual(5 * [d0], L.dist(v5, u5)) return def test_angle(self): '''check angle calculation between lattice vectors.''' from math import degrees, acos L = self.lattice L.setLatPar(1, 1.5, 2.3, 80, 95, 115) u = [0.1, 0.3, 0.7] v = [0.3, 0.7, 0.7] uc = L.cartesian(u) vc = L.cartesian(v) a0 = degrees( acos(numpy.dot(uc, vc) / (numalg.norm(uc) * numalg.norm(vc)))) self.assertAlmostEqual(a0, L.angle(u, v), self.places) self.assertAlmostEqual(a0, L.angle(v, u), self.places) u5 = numpy.tile(u, (5, 1)) v5 = numpy.tile(v, (5, 1)) self.assertListAlmostEqual(5 * [a0], L.angle(u, v5)) self.assertListAlmostEqual(5 * [a0], L.angle(u5, v)) self.assertListAlmostEqual(5 * [a0], L.angle(v5, u5)) return def test_repr(self): """check string representation of this lattice""" r = repr(self.lattice) self.assertEqual(r, "Lattice()") self.lattice.setLatPar(1, 2, 3, 10, 20, 30) r = repr(self.lattice) r0 = "Lattice(a=1, b=2, c=3, alpha=10, beta=20, gamma=30)" self.assertEqual(r, r0) base = [[1.0, 1.0, 0.0], [0.0, 2.0, 2.0], [3.0, 0.0, 3.0]] self.lattice.setLatBase(base) r = repr(self.lattice) self.assertEqual(r, "Lattice(base=%r)" % self.lattice.base)
def testDiffpyStructureParSet(self): """Test the structure conversion.""" a1 = Atom("Cu", xyz = numpy.array([.0, .1, .2]), Uisoequiv = 0.003) a2 = Atom("Ag", xyz = numpy.array([.3, .4, .5]), Uisoequiv = 0.002) l = Lattice(2.5, 2.5, 2.5, 90, 90, 90) dsstru = Structure([a1,a2], l) # Structure makes copies a1 = dsstru[0] a2 = dsstru[1] s = DiffpyStructureParSet("CuAg", dsstru) self.assertEquals(s.name, "CuAg") def _testAtoms(): # Check the atoms thoroughly self.assertEquals(a1.element, s.Cu0.element) self.assertEquals(a2.element, s.Ag0.element) self.assertEquals(a1.Uisoequiv, s.Cu0.Uiso.getValue()) self.assertEquals(a2.Uisoequiv, s.Ag0.Uiso.getValue()) self.assertEquals(a1.Bisoequiv, s.Cu0.Biso.getValue()) self.assertEquals(a2.Bisoequiv, s.Ag0.Biso.getValue()) for i in xrange(1,4): for j in xrange(i,4): uijstru = getattr(a1, "U%i%i"%(i,j)) uij = getattr(s.Cu0, "U%i%i"%(i,j)).getValue() uji = getattr(s.Cu0, "U%i%i"%(j,i)).getValue() self.assertEquals(uijstru, uij) self.assertEquals(uijstru, uji) bijstru = getattr(a1, "B%i%i"%(i,j)) bij = getattr(s.Cu0, "B%i%i"%(i,j)).getValue() bji = getattr(s.Cu0, "B%i%i"%(j,i)).getValue() self.assertEquals(bijstru, bij) self.assertEquals(bijstru, bji) self.assertEquals(a1.xyz[0], s.Cu0.x.getValue()) self.assertEquals(a1.xyz[1], s.Cu0.y.getValue()) self.assertEquals(a1.xyz[2], s.Cu0.z.getValue()) return def _testLattice(): # Test the lattice self.assertEquals(dsstru.lattice.a, s.lattice.a.getValue()) self.assertEquals(dsstru.lattice.b, s.lattice.b.getValue()) self.assertEquals(dsstru.lattice.c, s.lattice.c.getValue()) self.assertEquals(dsstru.lattice.alpha, s.lattice.alpha.getValue()) self.assertEquals(dsstru.lattice.beta, s.lattice.beta.getValue()) self.assertEquals(dsstru.lattice.gamma, s.lattice.gamma.getValue()) _testAtoms() _testLattice() # Now change some values from the diffpy Structure a1.xyz[1] = 0.123 a1.U11 = 0.321 a1.B32 = 0.111 dsstru.lattice.setLatPar(a=3.0, gamma=121) _testAtoms() _testLattice() # Now change values from the srfit DiffpyStructureParSet s.Cu0.x.setValue(0.456) s.Cu0.U22.setValue(0.441) s.Cu0.B13.setValue(0.550) d = dsstru.lattice.dist(a1.xyz, a2.xyz) s.lattice.b.setValue(4.6) s.lattice.alpha.setValue(91.3) _testAtoms() _testLattice() # Make sure the distance changed self.assertNotEquals(d, dsstru.lattice.dist(a1.xyz, a2.xyz)) return
def setUp(self): self.lattice = Lattice() self.places = 12 return
#!/usr/bin/env python """Express Ni FCC structure in its rhombohedral primitive cell. """ from diffpy.Structure import Structure from diffpy.Structure import Lattice from diffpy.Structure.SymmetryUtilities import equalPositions # load Ni fcc structure, Ni.stru is in tests/testdata/ nifcc = Structure(filename='Ni.stru') # base vectors for rhombohedral lattice in Cartesian coordinates rhombbase = nifcc.lattice.cartesian([[0.5, 0.5, 0.0], [0.0, 0.5, 0.5], [0.5, 0, 0.5]]) # make a deep copy of nifcc nirhomb = Structure(nifcc) nirhomb.placeInLattice(Lattice(base=rhombbase)) # collect atoms that are at equivalent position to some previous atom duplicates = set([ a1 for i0, a0 in enumerate(nirhomb) for a1 in nirhomb[i0 + 1:] if equalPositions(a0.xyz, a1.xyz, eps=1e-4) ]) # Filter out duplicate atoms. Use slice assignment so that # nirhomb is not replaced with a list. nirhomb[:] = [a for a in nirhomb if not a in duplicates] # use rstrip to avoid duplicate line feed print nirhomb.writeStr(format='discus').rstrip()