Merge branch 'lookup-sg-by-symops'

* resolve CIF spacegroup from a list of symmetry operations
* add function FindSpaceGroup
* fix incorrect symop list for sg1008 B11m
* add utility function `_hashSymOpList`

Resolve #20

Author: pavoljuhas

src/diffpy/structure/mmlibspacegroups.py

@@ -7231,9 +7231,9 @@
     pdb_name                = "B 1 1 m",
     symop_list = [
         SymOp(Rot_X_Y_Z,     Tr_0_0_0),
-        SymOp(Rot_X_mY_Z,    Tr_0_0_0),
-        SymOp(Rot_X_Y_Z,     Tr_12_12_0),
-        SymOp(Rot_X_mY_Z,    Tr_12_12_0)])
+        SymOp(Rot_X_Y_mZ,    Tr_0_0_0),
+        SymOp(Rot_X_Y_Z,     Tr_12_0_12),
+        SymOp(Rot_X_Y_mZ,    Tr_12_0_12)])
 
 sg1009 = SpaceGroup(
     number                  = 1009,

src/diffpy/structure/parsers/p_cif.py

@@ -20,7 +20,6 @@
 
 import sys
 import re
-import copy
 from contextlib import contextmanager
 import numpy
 import six
@@ -447,6 +446,7 @@ def _parse_space_group_symop_operation_xyz(self, block):
         """
         from diffpy.structure.spacegroups import IsSpaceGroupIdentifier
         from diffpy.structure.spacegroups import SpaceGroup, GetSpaceGroup
+        from diffpy.structure.spacegroups import FindSpaceGroup
         self.asymmetric_unit = list(self.stru)
         sym_synonyms = ('_space_group_symop_operation_xyz',
                         '_symmetry_equiv_pos_as_xyz')
@@ -469,21 +469,16 @@ def _parse_space_group_symop_operation_xyz(self, block):
         sgid = (int(block.get('_space_group_IT_number', '0')) or
                 int(block.get('_symmetry_Int_Tables_number', '0')) or
                 sg_nameHM)
-        # try to reuse existing space group
         self.spacegroup = None
-        if sgid and IsSpaceGroupIdentifier(sgid):
-            sgstd = GetSpaceGroup(sgid)
-            oprep_std = [str(op) for op in sgstd.iter_symops()]
-            oprep_std.sort()
-            oprep_cif = [str(op) for op in symop_list]
-            oprep_cif.sort()
-            # make sure symmetry operations have the same order
-            if oprep_std == oprep_cif:
-                self.spacegroup = copy.copy(sgstd)
-                self.spacegroup.symop_list = symop_list
-            # use standard definition when symmetry operations were not listed
-            elif not symop_list:
-                self.spacegroup = sgstd
+        # try to reuse existing space group from symmetry operations
+        if symop_list:
+            try:
+                self.spacegroup = FindSpaceGroup(symop_list)
+            except ValueError:
+                pass
+        # otherwise lookup the space group from its identifier
+        if self.spacegroup is None and sgid and IsSpaceGroupIdentifier(sgid):
+            self.spacegroup = GetSpaceGroup(sgid)
         # define new spacegroup when symmetry operations were listed, but
         # there is no match to an existing definition
         if symop_list and self.spacegroup is None:

src/diffpy/structure/spacegroups.py

@@ -73,6 +73,66 @@ def IsSpaceGroupIdentifier(sgid):
     return rv
 
 
+def FindSpaceGroup(symops, shuffle=False):
+    """Lookup SpaceGroup from a given list of symmetry operations.
+
+    Parameters
+    ----------
+    symops : list
+        The list of `SymOp` objects for which to find SpaceGroup.
+    shuffle : bool, optional
+        Flag for allowing different order of symops in the returned
+        SpaceGroup.  The default is ``False``.
+
+    Returns
+    -------
+    SpaceGroup
+        The SpaceGroup object with equivalent list of symmetry
+        operations.  Return predefined SpaceGroup instance when
+        symmetry operations have the same order or when the
+        `shuffle` flag is set.
+
+    Raises
+    ------
+    ValueError
+        When `symops` do not match any known SpaceGroup.
+    """
+    import copy
+    from six.moves import zip_longest
+    tb = _getSGHashLookupTable()
+    hh = _hashSymOpList(symops)
+    if not hh in tb:
+        raise ValueError('Cannot find SpaceGroup for the specified symops.')
+    rv = tb[hh]
+    if not shuffle:
+        zz = zip_longest(rv.iter_symops(), symops, fillvalue='')
+        sameorder = all(str(o0) == str(o1) for o0, o1 in zz)
+        if not sameorder:
+            rv = copy.copy(rv)
+            rv.symop_list = symops
+    return rv
+
+
+def _hashSymOpList(symops):
+    """Return hash value for a sequence of `SymOp` objects.
+
+    The symops are sorted so the results is independent of symops order.
+
+    Parameters
+    ----------
+    symops : sequence
+        The sequence of `SymOp` objects to be hashed
+
+    Returns
+    -------
+    int
+        The hash value.
+    """
+    ssop = sorted(str(o) for o in symops)
+    rv = hash(tuple(ssop))
+    return rv
+
+
 def _buildSGLookupTable():
     """Rebuild space group lookup table from the SpaceGroupList data.
 
@@ -116,6 +176,19 @@ def _buildSGLookupTable():
     return
 _sg_lookup_table = {}
 
+
+def _getSGHashLookupTable():
+    """Return lookup table of symop hashes to standard SpaceGroup objects.
+    """
+    if _sg_hash_lookup_table:
+        return _sg_hash_lookup_table
+    for sg in SpaceGroupList:
+        h = _hashSymOpList(sg.symop_list)
+        _sg_hash_lookup_table[h] = sg
+    assert len(_sg_hash_lookup_table) == len(SpaceGroupList)
+    return _getSGHashLookupTable()
+_sg_hash_lookup_table = {}
+
 # Import SpaceGroup objects --------------------------------------------------
 
 from diffpy.structure.spacegroupmod import (

src/diffpy/structure/tests/testdata/customsg.cif

@@ -0,0 +1,44 @@
+data_9008569
+_chemical_name 'Graphite'
+loop_
+_publ_author_name
+'Wyckoff R W G'
+_journal_name_full "Crystal Structures"
+_journal_volume 1
+_journal_year 1963
+_journal_page_first 7
+_journal_page_last 83
+_publ_section_title
+;
+ Second edition. Interscience Publishers, New York, New York
+;
+_chemical_formula_sum 'C'
+_cell_length_a 2.456
+_cell_length_b 2.456
+_cell_length_c 6.696
+_cell_angle_alpha 90
+_cell_angle_beta 90
+_cell_angle_gamma 120
+_cell_volume 34.979
+# _symmetry_space_group_name_H-M 'P 63 m c'
+loop_
+_symmetry_equiv_pos_as_xyz
+  'x,y,z'
+  '-x,-x+y,1/2+z'
+  'x-y,x,1/2+z'
+  '-y,-x,z'
+  '-y,x-y,z'
+  'x-y,-y,1/2+z'
+# '-x,-y,1/2+z'
+# 'x,x-y,z'
+# '-x+y,-x,z'
+# 'y,x,1/2+z'
+# 'y,-x+y,1/2+z'
+# '-x+y,y,z'
+loop_
+_atom_site_label
+_atom_site_fract_x
+_atom_site_fract_y
+_atom_site_fract_z
+C1   0.00000   0.00000   0.00000
+C2   0.33333   0.66667   0.00000

src/diffpy/structure/tests/testp_cif.py

@@ -277,6 +277,18 @@ def test_badspacegroup_cif(self):
         return
 
 
+    def test_custom_spacegroup_cif(self):
+        """Test parsing of nonstandard symops-defined space group.
+        """
+        pfile = self.pfile
+        filename = datafile('customsg.cif')
+        pfile.parseFile(filename)
+        sg = pfile.spacegroup
+        self.assertEqual('CIF data', sg.short_name)
+        self.assertEqual(6, len(sg.symop_list))
+        return
+
+
     def test_getParser(self):
         """Test passing of eps keyword argument by getParser function.
         """

src/diffpy/structure/tests/testspacegroups.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# diffpy.structure  Complex Modeling Initiative
+#                   (c) 2019 Brookhaven Science Associates,
+#                   Brookhaven National Laboratory.
+#                   All rights reserved.
+#
+# File coded by:    Pavol Juhas
+#
+# See AUTHORS.txt for a list of people who contributed.
+# See LICENSE.txt for license information.
+#
+##############################################################################
+
+"""Unit tests for diffpy.structure.spacegroups
+"""
+
+
+import unittest
+
+from diffpy.structure.spacegroups import SpaceGroupList, _hashSymOpList
+from diffpy.structure.spacegroups import GetSpaceGroup, FindSpaceGroup
+
+# ----------------------------------------------------------------------------
+
+class TestRoutines(unittest.TestCase):
+
+    def setUp(self):
+        return
+
+
+    def test_FindSpaceGroup(self):
+        "check FindSpaceGroup function"
+        sg123 = GetSpaceGroup(123)
+        ops123 = list(sg123.iter_symops())
+        self.assertRaises(ValueError, FindSpaceGroup, [])
+        self.assertRaises(ValueError, FindSpaceGroup, 2 * ops123)
+        self.assertIs(sg123, FindSpaceGroup(ops123))
+        sg123r = FindSpaceGroup(ops123[::-1])
+        self.assertIsNot(sg123, sg123r)
+        self.assertIsNot(sg123.symop_list, sg123r.symop_list)
+        self.assertEqual(ops123[::-1], sg123r.symop_list)
+        self.assertEqual(_hashSymOpList(sg123.symop_list),
+                         _hashSymOpList(sg123r.symop_list))
+        self.assertIs(sg123, FindSpaceGroup(ops123[::-1], shuffle=True))
+        return
+
+
+    def test__hashSymOpList(self):
+        "verify _hashSymOpList is unique for each spacegroup"
+        hset = set(_hashSymOpList(sg.symop_list) for sg in SpaceGroupList)
+        self.assertEqual(len(SpaceGroupList), len(hset))
+        return
+
+# End of class TestRoutines
+
+# ----------------------------------------------------------------------------
+
+if __name__ == '__main__':
+    unittest.main()