def test_UparSymbols(self):
"""check SymmetryConstraints.UparSymbols()
"""
sg1 = GetSpaceGroup(1)
sg225 = GetSpaceGroup(225)
pos = [[0, 0, 0]]
Uijs = numpy.zeros((1, 3, 3))
sc1 = SymmetryConstraints(sg1, pos, Uijs)
self.assertEqual(6, len(sc1.UparSymbols()))
sc225 = SymmetryConstraints(sg225, pos, Uijs)
self.assertEqual(['U110'], sc225.UparSymbols())
return
def test_UparValues(self):
"""check SymmetryConstraints.UparValues()
"""
places = 12
sg1 = GetSpaceGroup(1)
sg225 = GetSpaceGroup(225)
pos = [[0, 0, 0]]
Uijs = [[[0.1, 0.4, 0.5], [0.4, 0.2, 0.6], [0.5, 0.6, 0.3]]]
sc1 = SymmetryConstraints(sg1, pos, Uijs)
duv = 0.1 * numpy.arange(1, 7) - sc1.UparValues()
self.assertAlmostEqual(0, max(numpy.fabs(duv)), places)
sc225 = SymmetryConstraints(sg225, pos, Uijs)
self.assertEqual(1, len(sc225.UparValues()))
self.assertAlmostEqual(0.2, sc225.UparValues()[0], places)
return
def setUp(self):
x, y, z = 0.07, 0.11, 0.13
self.x, self.y, self.z = x, y, z
if TestGeneratorSite.generators:
self.__dict__.update(TestGeneratorSite.generators)
return
sg117 = GetSpaceGroup(117)
sg143 = GetSpaceGroup(143)
sg164 = GetSpaceGroup(164)
sg186 = GetSpaceGroup(186)
sg227 = GetSpaceGroup(227)
g117c = GeneratorSite(sg117, [0, 0.5, 0])
g117h = GeneratorSite(sg117, [x, x + 0.5, 0.5])
g143a = GeneratorSite(sg143, [0, 0, z])
g143b = GeneratorSite(sg143, [1. / 3, 2. / 3, z])
g143c = GeneratorSite(sg143, [2. / 3, 1. / 3, z])
g143d = GeneratorSite(sg143, [x, y, z])
g164e = GeneratorSite(sg164, (0.5, 0, 0))
g164f = GeneratorSite(sg164, (0.5, 0, 0.5))
g164g = GeneratorSite(sg164, (x, 0, 0))
g164h = GeneratorSite(sg164, (x, 0, 0.5))
g186c = GeneratorSite(sg186, (0.1695, 1.0 - 0.1695, 0.6365))
g227a = GeneratorSite(sg227, [0, 0, 0])
g227c = GeneratorSite(sg227, 3 * [1. / 8])
g227oa = GeneratorSite(sg227, 3 * [1. / 8], sgoffset=3 * [1. / 8])
g227oc = GeneratorSite(sg227, [0, 0, 0], sgoffset=3 * [1. / 8])
TestGeneratorSite.generators = {
'g117c': g117c,
'g117h': g117h,
'g143a': g143a,
'g143b': g143b,
'g143c': g143c,
'g143d': g143d,
'g164e': g164e,
'g164f': g164f,
'g164g': g164g,
'g164h': g164h,
'g186c': g186c,
'g227a': g227a,
'g227c': g227c,
'g227oa': g227oa,
'g227oc': g227oc
}
self.__dict__.update(TestGeneratorSite.generators)
return
def test_Uisotropy(self):
"""check isotropy value for ADP-s at specified sites.
"""
sg225 = GetSpaceGroup(225)
corepos = [[0, 0, 0], [0.1, 0.13, 0.17]]
eau = ExpandAsymmetricUnit(sg225, corepos)
self.assertEqual([True, False], eau.Uisotropy)
sc = SymmetryConstraints(sg225, eau.expandedpos)
self.assertEqual(4 * [True] + 192 * [False], sc.Uisotropy)
return
def test_expandPosition(self):
"""check expandPosition()
"""
# ok again Ni example
fcc = GetSpaceGroup(225)
pos, pops, pmult = expandPosition(fcc, [0, 0, 0])
self.assertTrue(numpy.all(pos[0] == 0.0))
self.assertEqual(4, len(pos))
self.assertEqual(192, sum([len(l) for l in pops]))
self.assertEqual(4, pmult)
return
def test_ConstrainAsSpaceGroup_args(self):
"""Test the arguments processing of constrainAsSpaceGroup function.
"""
from diffpy.srfit.structure.sgconstraints import constrainAsSpaceGroup
from diffpy.Structure.SpaceGroups import GetSpaceGroup
stru = makeLaMnO3_P1()
parset = DiffpyStructureParSet("LaMnO3", stru)
sgpars = constrainAsSpaceGroup(parset, "P b n m")
sg = GetSpaceGroup('P b n m')
parset2 = DiffpyStructureParSet("LMO", makeLaMnO3_P1())
sgpars2 = constrainAsSpaceGroup(parset2, sg)
list(sgpars)
list(sgpars2)
self.assertEqual(sgpars.names, sgpars2.names)
return
def test_corepos(self):
"""test_corepos - find positions in the asymmetric unit.
"""
sg225 = GetSpaceGroup(225)
corepos = [[0, 0, 0], [0.1, 0.13, 0.17]]
eau = ExpandAsymmetricUnit(sg225, corepos)
sc = SymmetryConstraints(sg225, eau.expandedpos)
self.assertEqual(2, len(sc.corepos))
self.assertTrue(numpy.all(corepos[0] == sc.corepos[0]))
self.assertTrue(numpy.all(corepos[1] == sc.corepos[1]))
self.assertEqual(2, len(sc.coremap))
mapped_count = sum([len(idcs) for idcs in sc.coremap.values()])
self.assertEqual(len(sc.positions), mapped_count)
self.assertTrue(sc.coremap[0] == range(4))
self.assertTrue(sc.coremap[4] == range(4, 4 + 192))
return
def test__findUParameters(self):
"""check GeneratorSite._findUParameters()
"""
# by default all Uparameters equal zero, this would fail for NaNs
for gen in TestGeneratorSite.generators.values():
for usym, uval in gen.Uparameters:
self.assertEqual(0.0, uval)
# special test for g117h
Uij = numpy.array([[1, 3, 4], [3, 1, -4], [4, -4, 2]])
sg117 = GetSpaceGroup(117)
g117h = GeneratorSite(sg117, self.g117h.xyz, Uij)
upd = dict(g117h.Uparameters)
self.assertEqual(1, upd['U11'])
self.assertEqual(2, upd['U33'])
self.assertEqual(3, upd['U12'])
self.assertEqual(4, upd['U13'])
return
def test_UFormula_g186c_eqxyz(self):
'''Check rotated U formulas at the symmetry positions of c-site in 186.
'''
sg186 = GetSpaceGroup(186)
crules = [
{'U11': 'A', 'U22': 'A', 'U33': 'C',
'U12': 'D', 'U13': 'E', 'U23': '-E'},
{'U11': 'A', 'U22': '2*A-2*D', 'U33': 'C',
'U12': 'A-D', 'U13': 'E', 'U23': '2*E'},
{'U11': '2*A-2*D', 'U22': 'A', 'U33': 'C',
'U12': 'A-D', 'U13': '-2*E', 'U23': '-E'},
{'U11': 'A', 'U22': 'A', 'U33': 'C',
'U12': 'D', 'U13': '-E', 'U23': 'E'},
{'U11': 'A', 'U22': '2*A-2*D', 'U33': 'C',
'U12': 'A-D', 'U13': '-E', 'U23': '-2*E'},
{'U11': '2*A-2*D', 'U22': 'A', 'U33': 'C',
'U12': 'A-D', 'U13': '2*E', 'U23': 'E'},
]
self.assertEqual(6, len(self.g186c.eqxyz))
gc = self.g186c
for idx in range(6):
self.assertEqual(crules[idx], gc.UFormula(gc.eqxyz[idx], 'ABCDEF'))
uiso = numpy.array([[2, 1, 0], [1, 2, 0], [0, 0, 2]])
eau = ExpandAsymmetricUnit(sg186, [gc.xyz], [uiso])
for u in eau.expandedUijs:
du = numpy.linalg.norm((uiso - u).flatten())
self.assertAlmostEqual(0.0, du, 8)
symcon = SymmetryConstraints(sg186, sum(eau.expandedpos, []),
sum(eau.expandedUijs, []))
upd = dict(symcon.Upars)
self.assertEqual(2.0, upd['U110'])
self.assertEqual(2.0, upd['U330'])
self.assertEqual(1.0, upd['U120'])
self.assertEqual(0.0, upd['U130'])
uisod = {'U11' : 2.0, 'U22' : 2.0, 'U33' : 2.0,
'U12' : 1.0, 'U13' : 0.0, 'U23' : 0.0}
for ufms in symcon.UFormulas():
for n, fm in ufms.items():
self.assertEqual(uisod[n], eval(fm, upd))
return
def test___init__(self):
"""check SymmetryConstraints.__init__()
"""
sg225 = GetSpaceGroup(225)
# initialize from nested lists and arrays from ExpandAsymmetricUnit
eau = ExpandAsymmetricUnit(sg225, [[0, 0, 0]])
sc0 = SymmetryConstraints(sg225, eau.expandedpos)
self.assertEqual(1, len(sc0.coremap))
# initialize from list of arrays of coordinates
poslistarrays = [xyz for xyz in sc0.positions]
sc1 = SymmetryConstraints(sg225, poslistarrays)
self.assertEqual(1, len(sc1.coremap))
# initialize from list of lists of coordinates
poslistlist = [list(xyz) for xyz in poslistarrays]
sc2 = SymmetryConstraints(sg225, poslistlist)
self.assertEqual(1, len(sc2.coremap))
# initialize from nx3 array
posarray = numpy.array(poslistlist)
sc3 = SymmetryConstraints(sg225, posarray)
self.assertEqual(1, len(sc3.coremap))
# finally initialize from a single coordinate
sc4 = SymmetryConstraints(sg225, [0, 0, 0])
self.assertEqual(1, len(sc4.coremap))
return
def test_isSpaceGroupLatPar(self):
"""check isSpaceGroupLatPar()
"""
triclinic = GetSpaceGroup("P1")
monoclinic = GetSpaceGroup("P2")
orthorhombic = GetSpaceGroup("P222")
tetragonal = GetSpaceGroup("P4")
trigonal = GetSpaceGroup("P3")
hexagonal = GetSpaceGroup("P6")
cubic = GetSpaceGroup("P23")
self.assertTrue(isSpaceGroupLatPar(triclinic, 1, 2, 3, 40, 50, 60))
self.assertFalse(isSpaceGroupLatPar(monoclinic, 1, 2, 3, 40, 50, 60))
self.assertTrue(isSpaceGroupLatPar(monoclinic, 1, 2, 3, 90, 50, 90))
self.assertFalse(isSpaceGroupLatPar(orthorhombic, 1, 2, 3, 90, 50, 90))
self.assertTrue(isSpaceGroupLatPar(orthorhombic, 1, 2, 3, 90, 90, 90))
self.assertFalse(isSpaceGroupLatPar(tetragonal, 1, 2, 3, 90, 90, 90))
self.assertTrue(isSpaceGroupLatPar(tetragonal, 2, 2, 3, 90, 90, 90))
self.assertFalse(isSpaceGroupLatPar(trigonal, 2, 2, 3, 90, 90, 90))
self.assertTrue(isSpaceGroupLatPar(trigonal, 2, 2, 2, 80, 80, 80))
self.assertFalse(isSpaceGroupLatPar(hexagonal, 2, 2, 2, 80, 80, 80))
self.assertTrue(isSpaceGroupLatPar(hexagonal, 2, 2, 3, 90, 90, 120))
self.assertFalse(isSpaceGroupLatPar(cubic, 2, 2, 3, 90, 90, 120))
self.assertTrue(isSpaceGroupLatPar(cubic, 3, 3, 3, 90, 90, 90))
return
def constrainAsSpaceGroup(phase,
spacegroup,
scatterers=None,
sgoffset=[0, 0, 0],
constrainlat=True,
constrainadps=True,
adpsymbols=None,
isosymbol="Uiso"):
"""Constrain the structure to the space group.
This applies space group constraints to a StructureParSet with P1
symmetry. Passed scatterers are explicitly constrained to the
specified space group. The ADPs and lattice may be constrained as well.
Arguments:
phase -- A BaseStructure object.
spacegroup -- The space group number, symbol or an instance of
SpaceGroup class from diffpy.Structure package.
sgoffset -- Optional offset for sg origin (default [0, 0, 0]).
scatterers -- The scatterer ParameterSets to constrain. If scatterers
is None (default), then all scatterers accessible from
phase.getScatterers will be constrained.
constrainlat -- Flag indicating whether to constrain the lattice
(default True).
constrainadps -- Flag indicating whether to constrain the ADPs
(default True).
adpsymbols -- A list of the ADP names. By default this is equal to
diffpy.Structure.SymmetryUtilities.stdUsymbols (U11,
U22, etc.). The names must be given in the same order
as stdUsymbols.
isosymbol -- Symbol for isotropic ADP (default "Uiso"). If None,
isotropic ADPs will be constrainted via the anisotropic ADPs.
New Parameters that are used in constraints are created within a
SpaceGroupParameters object, which is returned from this function.
Constraints are created in ParameterSet that contains the constrained
Parameter. This will erase any constraints or constant flags on the
scatterers, lattice or ADPs if they are to be constrained.
The lattice constraints are applied as following.
Crystal System:
Triclinic -- No constraints.
Monoclinic -- alpha and beta are fixed to 90 unless alpha != beta and
alpha == gamma, in which case alpha and gamma are fixed
to 90.
Orthorhombic -- alpha, beta and gamma are fixed to 90.
Tetragonal -- b is constrained to a and alpha, beta and gamma are
fixed to 90.
Trigonal -- If gamma == 120, then b is constrained to a, alpha
and beta are fixed to 90 and gamma is fixed to 120.
Otherwise, b and c are constrained to a, beta and gamma
are fixed to alpha.
Hexagonal -- b is constrained to a, alpha and beta are fixed to 90
and gamma is fixed to 120.
Cubic -- b and c are constrained to a, and alpha, beta and
gamma are fixed to 90.
"""
from diffpy.Structure.SpaceGroups import GetSpaceGroup, SpaceGroup
sg = spacegroup
if not isinstance(spacegroup, SpaceGroup):
sg = GetSpaceGroup(spacegroup)
sgp = _constrainAsSpaceGroup(phase, sg, scatterers, sgoffset, constrainlat,
constrainadps, adpsymbols, isosymbol)
return sgp
def test_sgtbx_spacegroup_aliases(self):
"""check GetSpaceGroup for non-standard aliases from sgtbx.
"""
self.assertIs(GetSpaceGroup('Fm3m'), GetSpaceGroup(225))
self.assertIs(GetSpaceGroup('Ia3d'), GetSpaceGroup('I a -3 d'))
return
from diffpy.Structure.SymmetryUtilities import ExpandAsymmetricUnit
positions = [[0.1, 0.2, 0.2]]
from diffpy.Structure.SpaceGroups import GetSpaceGroup
sg225 = GetSpaceGroup('Fm-3m')
eau = ExpandAsymmetricUnit(sg225, positions)
pos_expanded=eau.positions[0]
