source: trunk/GSASIIspc.py @ 1695

Last change on this file since 1695 was 1695, checked in by vondreele, 7 years ago

4/m ss site symmetries seem now all ok

  • Property svn:eol-style set to native
  • Property svn:keywords set to Date Author Revision URL Id
File size: 129.0 KB
Line 
1# -*- coding: utf-8 -*-
2"""
3*GSASIIspc: Space group module*
4-------------------------------
5
6Space group interpretation routines. Note that space group information is
7stored in a :ref:`Space Group (SGData)<SGData_table>` object.
8
9"""
10########### SVN repository information ###################
11# $Date: 2015-03-11 20:57:09 +0000 (Wed, 11 Mar 2015) $
12# $Author: vondreele $
13# $Revision: 1695 $
14# $URL: trunk/GSASIIspc.py $
15# $Id: GSASIIspc.py 1695 2015-03-11 20:57:09Z vondreele $
16########### SVN repository information ###################
17import numpy as np
18import numpy.ma as ma
19import numpy.linalg as nl
20import scipy.optimize as so
21import math
22import sys
23import copy
24import os.path as ospath
25
26import GSASIIpath
27GSASIIpath.SetVersionNumber("$Revision: 1695 $")
28import pyspg
29
30npsind = lambda x: np.sin(x*np.pi/180.)
31npcosd = lambda x: np.cos(x*np.pi/180.)
32DEBUG = False
33   
34################################################################################
35#### Space group codes
36################################################################################
37
38def SpcGroup(SGSymbol):
39    """
40    Determines cell and symmetry information from a short H-M space group name
41
42    :param SGSymbol: space group symbol (string) with spaces between axial fields
43    :returns: (SGError,SGData)
44       * SGError = 0 for no errors; >0 for errors (see SGErrors below for details)
45       * SGData - is a dict (see :ref:`Space Group object<SGData_table>`) with entries:
46       
47             * 'SpGrp': space group symbol, slightly cleaned up
48             * 'SGLaue':  one of '-1', '2/m', 'mmm', '4/m', '4/mmm', '3R',
49               '3mR', '3', '3m1', '31m', '6/m', '6/mmm', 'm3', 'm3m'
50             * 'SGInv': boolean; True if centrosymmetric, False if not
51             * 'SGLatt': one of 'P', 'A', 'B', 'C', 'I', 'F', 'R'
52             * 'SGUniq': one of 'a', 'b', 'c' if monoclinic, '' otherwise
53             * 'SGCen': cell centering vectors [0,0,0] at least
54             * 'SGOps': symmetry operations as [M,T] so that M*x+T = x'
55             * 'SGSys': one of 'triclinic', 'monoclinic', 'orthorhombic',
56               'tetragonal', 'rhombohedral', 'trigonal', 'hexagonal', 'cubic'
57             * 'SGPolax': one of '', 'x', 'y', 'x y', 'z', 'x z', 'y z',
58               'xyz', '111' for arbitrary axes
59             * 'SGPtGrp': one of 32 point group symbols (with some permutations)
60                - filled by SGPtGroup - is external (KE) part of supersymmetry point group
61             * 'SSGKl': default internal (Kl) part of supersymmetry point group; modified
62             in supersymmetry stuff depending on chosen modulation vector for Mono & Ortho
63
64    """
65    LaueSym = ('-1','2/m','mmm','4/m','4/mmm','3R','3mR','3','3m1','31m','6/m','6/mmm','m3','m3m')
66    LattSym = ('P','A','B','C','I','F','R')
67    UniqSym = ('','','a','b','c','',)
68    SysSym = ('triclinic','monoclinic','orthorhombic','tetragonal','rhombohedral','trigonal','hexagonal','cubic')
69    SGData = {}
70    SGInfo = pyspg.sgforpy(SGSymbol)
71    SGData['SpGrp'] = SGSymbol.strip().lower().capitalize()
72    SGData['SGLaue'] = LaueSym[SGInfo[0]-1]
73    SGData['SGInv'] = bool(SGInfo[1])
74    SGData['SGLatt'] = LattSym[SGInfo[2]-1]
75    SGData['SGUniq'] = UniqSym[SGInfo[3]+1]
76    if SGData['SGLatt'] == 'P':
77        SGData['SGCen'] = np.array(([0,0,0],))
78    elif SGData['SGLatt'] == 'A':
79        SGData['SGCen'] = np.array(([0,0,0],[0,.5,.5]))
80    elif SGData['SGLatt'] == 'B':
81        SGData['SGCen'] = np.array(([0,0,0],[.5,0,.5]))
82    elif SGData['SGLatt'] == 'C':
83        SGData['SGCen'] = np.array(([0,0,0],[.5,.5,0,]))
84    elif SGData['SGLatt'] == 'I':
85        SGData['SGCen'] = np.array(([0,0,0],[.5,.5,.5]))
86    elif SGData['SGLatt'] == 'F':
87        SGData['SGCen'] = np.array(([0,0,0],[0,.5,.5],[.5,0,.5],[.5,.5,0,]))
88    elif SGData['SGLatt'] == 'R':
89        SGData['SGCen'] = np.array(([0,0,0],[1./3.,2./3.,2./3.],[2./3.,1./3.,1./3.]))
90    SGData['SGOps'] = []
91    for i in range(SGInfo[5]):
92        Mat = np.array(SGInfo[6][i])
93        Trns = np.array(SGInfo[7][i])
94        SGData['SGOps'].append([Mat,Trns])
95    if SGData['SGLaue'] in '-1':
96        SGData['SGSys'] = SysSym[0]
97    elif SGData['SGLaue'] in '2/m':
98        SGData['SGSys'] = SysSym[1]
99    elif SGData['SGLaue'] in 'mmm':
100        SGData['SGSys'] = SysSym[2]
101    elif SGData['SGLaue'] in ['4/m','4/mmm']:
102        SGData['SGSys'] = SysSym[3]
103    elif SGData['SGLaue'] in ['3R','3mR']:
104        SGData['SGSys'] = SysSym[4]
105    elif SGData['SGLaue'] in ['3','3m1','31m']:
106        SGData['SGSys'] = SysSym[5]
107    elif SGData['SGLaue'] in ['6/m','6/mmm']:
108        SGData['SGSys'] = SysSym[6]
109    elif SGData['SGLaue'] in ['m3','m3m']:
110        SGData['SGSys'] = SysSym[7]
111    SGData['SGPolax'] = SGpolar(SGData)
112    SGData['SGPtGrp'],SGData['SSGKl'] = SGPtGroup(SGData)
113    return SGInfo[8],SGData
114
115def SGErrors(IErr):
116    '''
117    Interprets the error message code from SpcGroup. Used in SpaceGroup.
118   
119    :param IErr: see SGError in :func:`SpcGroup`
120    :returns:
121        ErrString - a string with the error message or "Unknown error"
122    '''
123
124    ErrString = [' ',
125        'Less than 2 operator fields were found',
126        'Illegal Lattice type, not P, A, B, C, I, F or R',
127        'Rhombohedral lattice requires a 3-axis',
128        'Minus sign does not preceed 1, 2, 3, 4 or 6',
129        'Either a 5-axis anywhere or a 3-axis in field not allowed',
130        ' ',
131        'I for COMPUTED GO TO out of range.',
132        'An a-glide mirror normal to A not allowed',
133        'A b-glide mirror normal to B not allowed',
134        'A c-glide mirror normal to C not allowed',
135        'D-glide in a primitive lattice not allowed',
136        'A 4-axis not allowed in the 2nd operator field',
137        'A 6-axis not allowed in the 2nd operator field',
138        'More than 24 matrices needed to define group',
139        ' ',
140        'Improper construction of a rotation operator',
141        'Mirror following a / not allowed',
142        'A translation conflict between operators',
143        'The 2bar operator is not allowed',
144        '3 fields are legal only in R & m3 cubic groups',
145        'Syntax error. Expected I -4 3 d at this point',
146        ' ',
147        'A or B centered tetragonal not allowed',
148        ' ','unknown error in sgroup',' ',' ',' ',
149        'Illegal character in the space group symbol',
150        ]
151    try:
152        return ErrString[IErr]
153    except:
154        return "Unknown error"
155
156def SGpolar(SGData):
157    '''
158    Determine identity of polar axes if any
159    '''
160    POL = ('','x','y','x y','z','x z','y z','xyz','111')
161    NP = [1,2,4]
162    NPZ = [0,1]
163    for M,T in SGData['SGOps']:
164        for i in range(3):
165            if M[i][i] <= 0.: NP[i] = 0
166        if M[0][2] > 0: NPZ[0] = 8
167        if M[1][2] > 0: NPZ[1] = 0
168    NPol = (NP[0]+NP[1]+NP[2]+NPZ[0]*NPZ[1])*(1-int(SGData['SGInv']))
169    return POL[NPol]
170   
171def SGPtGroup(SGData):
172    '''
173    Determine point group of the space group - done after space group symbol has
174    been evaluated by SpcGroup. Only short symbols are allowed
175   
176    :param SGData: from :func SpcGroup
177    returns SSGPtGrp & SSGKl (only defaults for Mono & Ortho)
178    '''
179    Flds = SGData['SpGrp'].split()
180    if len(Flds) < 2:
181        return '',[]
182    if SGData['SGLaue'] == '-1':    #triclinic
183        if '-' in Flds[1]:
184            return '-1',[-1,]
185        else:
186            return '1',[1,]
187    elif SGData['SGLaue'] == '2/m': #monoclinic - default for 2D modulation vector
188        if '/' in SGData['SpGrp']:
189            return '2/m',[-1,1]
190        elif '2' in SGData['SpGrp']:
191            return '2',[-1,]
192        else:
193            return 'm',[1,]
194    elif SGData['SGLaue'] == 'mmm': #orthorhombic
195        if SGData['SpGrp'].count('2') == 3:
196            return '222',[-1,-1,-1]
197        elif SGData['SpGrp'].count('2') == 1:
198            if SGData['SGPolax'] == 'x':
199                return '2mm',[-1,1,1]
200            elif SGData['SGPolax'] == 'y':
201                return 'm2m',[1,-1,1]
202            elif SGData['SGPolax'] == 'z':
203                return 'mm2',[1,1,-1]
204        else:
205            return 'mmm',[1,1,1]
206    elif SGData['SGLaue'] == '4/m': #tetragonal
207        if '/' in SGData['SpGrp']:
208            return '4/m',[1,-1]
209        elif '-' in Flds[1]:
210            return '-4',[-1,]
211        else:
212            return '4',[1,]
213    elif SGData['SGLaue'] == '4/mmm':
214        if '/' in SGData['SpGrp']:
215            return '4/mmm',[1,-1,1,1]
216        elif '-' in Flds[1]:
217            if '2' in Flds[2]:
218                return '-42m',[-1,-1,1]
219            else:
220                return '-4m2',[-1,1,-1]             
221        elif '2' in Flds[2:]:
222            return '422',[1,-1,-1]
223        else:
224            return '4mm',[1,1,1]
225    elif SGData['SGLaue'] in ['3','3R']:  #trigonal/rhombohedral
226        if '-' in Flds[1]:
227            return '-3',[-1,]
228        else:
229            return '3',[1,]
230    elif SGData['SGLaue'] == '3mR' or 'R' in Flds[0]:
231        if '2' in Flds[2]:
232            return '32',[1,-1]
233        elif '-' in Flds[1]:
234            return '-3m',[-1,1]
235        else:
236            return '3m',[1,1]
237    elif SGData['SGLaue'] == '3m1':
238        if '2' in Flds[2]:
239            return '321',[1,-1,1]
240        elif '-' in Flds[1]:
241            return '-3m1',[-1,1,1]
242        else:
243            return '3m1',[1,1,1]
244    elif SGData['SGLaue'] == '31m':
245        if '2' in Flds[3]:
246            return '312',[1,1,-1]
247        elif '-' in Flds[1]:
248            return '-31m',[-1,1,1]
249        else:
250            return '31m',[1,1,1]
251    elif SGData['SGLaue'] == '6/m': #hexagonal
252        if '/' in SGData['SpGrp']:
253            return '6/m',[1,-1]
254        elif '-' in SGData['SpGrp']:
255            return '-6',[-1,]
256        else:
257            return '6',[1,]
258    elif SGData['SGLaue'] == '6/mmm':
259        if '/' in SGData['SpGrp']:
260            return '6/mmm',[1,-1,1,1]
261        elif '-' in Flds[1]:
262            if '2' in Flds[2]:
263                return '-62m',[-1,-1,1]
264            else:
265                return '-6m2',[-1,1,-1]                 
266        elif '2' in Flds[2:]:
267            return '622',[1,-1,-1]
268        else:
269            return '6mm',[1,1,1]   
270    elif SGData['SGLaue'] == 'm3':      #cubic - no (3+1) supersymmetry
271        if '2' in Flds[1]:
272            return '23',[]
273        else: 
274            return 'm3',[]
275    elif SGData['SGLaue'] == 'm3m':
276        if '4' in Flds[1]:
277            if '-' in Flds[1]:
278                return '-43m',[]
279            else:
280                return '432',[]
281        else:
282            return 'm-3m',[]
283   
284def SGPrint(SGData):
285    '''
286    Print the output of SpcGroup in a nicely formatted way. Used in SpaceGroup
287
288    :param SGData: from :func:`SpcGroup`
289    :returns:
290        SGText - list of strings with the space group details
291        SGTable - list of strings for each of the operations
292    '''
293    Mult = len(SGData['SGCen'])*len(SGData['SGOps'])*(int(SGData['SGInv'])+1)
294    SGText = []
295    SGText.append(' Space Group: '+SGData['SpGrp'])
296    CentStr = 'centrosymmetric'
297    if not SGData['SGInv']:
298        CentStr = 'non'+CentStr
299    if SGData['SGLatt'] in 'ABCIFR':
300        SGText.append(' The lattice is '+CentStr+' '+SGData['SGLatt']+'-centered '+SGData['SGSys'].lower())
301    else:
302        SGText.append(' The lattice is '+CentStr+' '+'primitive '+SGData['SGSys'].lower()) 
303    SGText.append(' The Laue symmetry is '+SGData['SGLaue'])
304    if 'SGPtGrp' in SGData:         #patch
305        SGText.append(' The lattice point group is '+SGData['SGPtGrp'])
306    SGText.append(' Multiplicity of a general site is '+str(Mult))
307    if SGData['SGUniq'] in ['a','b','c']:
308        SGText.append(' The unique monoclinic axis is '+SGData['SGUniq'])
309    if SGData['SGInv']:
310        SGText.append(' The inversion center is located at 0,0,0')
311    if SGData['SGPolax']:
312        SGText.append(' The location of the origin is arbitrary in '+SGData['SGPolax'])
313    SGText.append(' ')
314    if SGData['SGLatt'] == 'P':
315        SGText.append(' The equivalent positions are:\n')
316    else:   
317        SGText.append(' The equivalent positions are:')
318        SGText.append(' ('+Latt2text(SGData['SGLatt'])+')+\n')
319    SGTable = []
320    for i,Opr in enumerate(SGData['SGOps']):
321        SGTable.append('(%2d) %s'%(i+1,MT2text(Opr)))
322    return SGText,SGTable
323
324def AllOps(SGData):
325    '''
326    Returns a list of all operators for a space group, including those for
327    centering and a center of symmetry
328   
329    :param SGData: from :func:`SpcGroup`
330    :returns: (SGTextList,offsetList,symOpList,G2oprList) where
331
332      * SGTextList: a list of strings with formatted and normalized
333        symmetry operators.
334      * offsetList: a tuple of (dx,dy,dz) offsets that relate the GSAS-II
335        symmetry operation to the operator in SGTextList and symOpList.
336        these dx (etc.) values are added to the GSAS-II generated
337        positions to provide the positions that are generated
338        by the normalized symmetry operators.       
339      * symOpList: a list of tuples with the normalized symmetry
340        operations as (M,T) values
341        (see ``SGOps`` in the :ref:`Space Group object<SGData_table>`)
342      * G2oprList: The GSAS-II operations for each symmetry operation as
343        a tuple with (center,mult,opnum), where center is (0,0,0), (0.5,0,0),
344        (0.5,0.5,0.5),...; where mult is 1 or -1 for the center of symmetry
345        and opnum is the number for the symmetry operation, in ``SGOps``
346        (starting with 0).
347    '''
348    SGTextList = []
349    offsetList = []
350    symOpList = []
351    G2oprList = []
352    onebar = (1,)
353    if SGData['SGInv']:
354        onebar += (-1,)
355    for cen in SGData['SGCen']:
356        for mult in onebar:
357            for j,(M,T) in enumerate(SGData['SGOps']):
358                offset = [0,0,0]
359                Tprime = (mult*T)+cen
360                for i in range(3):
361                    while Tprime[i] < 0:
362                        Tprime[i] += 1
363                        offset[i] += 1
364                    while Tprime[i] >= 1:
365                        Tprime[i] += -1
366                        offset[i] += -1
367                Opr = [mult*M,Tprime]
368                OPtxt = MT2text(Opr)
369                SGTextList.append(OPtxt.replace(' ',''))
370                offsetList.append(tuple(offset))
371                symOpList.append((mult*M,Tprime))
372                G2oprList.append((cen,mult,j))
373    return SGTextList,offsetList,symOpList,G2oprList
374   
375def MT2text(Opr):
376    "From space group matrix/translation operator returns text version"
377    XYZ = ('-Z','-Y','-X','X-Y','ERR','Y-X','X','Y','Z')
378    TRA = ('   ','ERR','1/6','1/4','1/3','ERR','1/2','ERR','2/3','3/4','5/6','ERR')
379    Fld = ''
380    M,T = Opr
381    for j in range(3):
382        IJ = int(round(2*M[j][0]+3*M[j][1]+4*M[j][2]+4))%12
383        IK = int(round(T[j]*12))%12
384        if IK:
385            if IJ < 3:
386                Fld += (TRA[IK]+XYZ[IJ]).rjust(5)
387            else:
388                Fld += (TRA[IK]+'+'+XYZ[IJ]).rjust(5)
389        else:
390            Fld += XYZ[IJ].rjust(5)
391        if j != 2: Fld += ', '
392    return Fld
393   
394def Latt2text(Latt):
395    "From lattice type ('P',A', etc.) returns ';' delimited cell centering vectors"
396    lattTxt = {'A':'0,0,0; 0,1/2,1/2','B':'0,0,0; 1/2,0,1/2',
397        'C':'0,0,0; 1/2,1/2,0','I':'0,0,0; 1/2,1/2,1/2',
398        'F':'0,0,0; 0,1/2,1/2; 1/2,0,1/2; 1/2,1/2,0',
399        'R':'0,0,0; 1/3,2/3,2/3; 2/3,1/3,1/3','P':'0,0,0'}
400    return lattTxt[Latt]   
401       
402def SpaceGroup(SGSymbol):
403    '''
404    Print the output of SpcGroup in a nicely formatted way.
405
406    :param SGSymbol: space group symbol (string) with spaces between axial fields
407    :returns: nothing
408    '''
409    E,A = SpcGroup(SGSymbol)
410    if E > 0:
411        print SGErrors(E)
412        return
413    for l in SGPrint(A):
414        print l
415       
416################################################################################
417#### Superspace group codes
418################################################################################
419       
420def SSpcGroup(SGData,SSymbol):
421    """
422    Determines supersymmetry information from superspace group name; currently only for (3+1) superlattices
423
424    :param SGData: space group data structure as defined in SpcGroup above.
425    :param SSymbol: superspace group symbol extension (string) defining modulation direction & generator info.
426    :returns: (SSGError,SSGData)
427       * SGError = 0 for no errors; >0 for errors (see SGErrors below for details)
428       * SSGData - is a dict (see :ref:`Superspace Group object<SSGData_table>`) with entries:
429       
430             * 'SSpGrp': superspace group symbol extension to space group symbol, accidental spaces removed
431             * 'SSGCen': 4D cell centering vectors [0,0,0,0] at least
432             * 'SSGOps': 4D symmetry operations as [M,T] so that M*x+T = x'
433
434    """
435   
436    def checkModSym():
437        '''
438        Checks to see if proposed modulation form is allowed for Laue group
439        '''
440        if LaueId in [0,] and LaueModId in [0,]:
441            return True
442        elif LaueId in [1,]:
443            try:
444                if modsym.index('1/2') != ['A','B','C'].index(SGData['SGLatt']):
445                    return False
446                if 'I'.index(SGData['SGLatt']) and modsym.count('1/2') not in [0,2]:
447                    return False
448            except ValueError:
449                pass
450            if SGData['SGUniq'] == 'a' and LaueModId in [5,6,7,8,9,10,]:
451                return True
452            elif SGData['SGUniq'] == 'b' and LaueModId in [3,4,13,14,15,16,]:
453                return True
454            elif SGData['SGUniq'] == 'c' and LaueModId in [1,2,19,20,21,22,]:
455                return True
456        elif LaueId in [2,] and LaueModId in [i+7 for i in range(18)]:
457            try:
458                if modsym.index('1/2') != ['A','B','C'].index(SGData['SGLatt']):
459                    return False
460                if SGData['SGLatt'] in ['I','F',] and modsym.index('1/2'):
461                    return False
462            except ValueError:
463                pass
464            return True
465        elif LaueId in [3,4,] and LaueModId in [19,22,]:
466            try:
467                if SGData['SGLatt'] == 'I' and modsym.count('1/2'):
468                    return False
469            except ValueError:
470                pass
471            return True
472        elif LaueId in [7,8,9,] and LaueModId in [19,25,]:
473            if (SGData['SGLatt'] == 'R' or SGData['SGPtGrp'] in ['3m1','-3m1']) and modsym.count('1/3'):
474                return False
475            return True
476        elif LaueId in [10,11,] and LaueModId in [19,]:
477            return True
478        return False
479       
480    def fixMonoOrtho():
481        mod = ''.join(modsym).replace('1/2','0').replace('1','0')
482        if SGData['SGPtGrp'] in ['2','m']:  #OK
483            if mod in ['a00','0b0','00g']:
484                result = [i*-1 for i in SGData['SSGKl']]
485            else:
486                result = SGData['SSGKl'][:]
487            if '/' in mod:
488                return [i*-1 for i in result]
489            else:
490                return result
491        elif SGData['SGPtGrp'] == '2/m':    #OK
492            if mod in ['a00','0b0','00g']:
493                result =  SGData['SSGKl'][:]
494            else:
495                result = [i*-1 for i in SGData['SSGKl']]
496            if '/' in mod:
497                return [i*-1 for i in result]
498            else:
499                return result
500        else:   #orthorhombic
501            return [-SSGKl[i] if mod[i] in ['a','b','g'] else SSGKl[i] for i in range(3)]
502               
503    def extendSSGOps(SSGOps):
504        nOps = len(SSGOps)
505        for OpA in SSGOps:
506            OpAtxt = SSMT2text(OpA)
507            if 't' not in OpAtxt:
508                continue
509            for OpB in SSGOps:
510                OpBtxt = SSMT2text(OpB)
511                if 't' not in OpBtxt:
512                    continue
513                OpC = list(SGProd(OpB,OpA))
514                OpC[1] %= 1.
515                OpCtxt = SSMT2text(OpC)
516#                print OpAtxt.replace(' ','')+' * '+OpBtxt.replace(' ','')+' = '+OpCtxt.replace(' ','')
517                for k,OpD in enumerate(SSGOps):
518                    OpDtxt = SSMT2text(OpD)
519                    if 't' in OpDtxt:
520                        continue
521#                    print '    ('+OpCtxt.replace(' ','')+' = ? '+OpDtxt.replace(' ','')+')'
522                    if OpCtxt == OpDtxt:
523                        continue
524                    elif OpCtxt.split(',')[:3] == OpDtxt.split(',')[:3]:
525                        if 't' not in OpDtxt:
526                            SSGOps[k] = OpC
527#                            print k,'   new:',OpCtxt.replace(' ','')
528                            break
529                        else:
530                            OpCtxt = OpCtxt.replace(' ','')
531                            OpDtxt = OpDtxt.replace(' ','')
532                            Txt = OpCtxt+' conflict with '+OpDtxt
533                            print Txt
534                            return False,Txt
535        return True,SSGOps
536       
537    def findMod(modSym):
538        for a in ['a','b','g']:
539            if a in modSym:
540                return a
541               
542    def genSSGOps():
543        SSGOps = SSGData['SSGOps'][:]
544        iFrac = {}
545        for i,frac in enumerate(SSGData['modSymb']):
546            if frac in ['1/2','1/3','1/4','1/6','1']:
547                iFrac[i] = frac+'.'
548#        print SGData['SpGrp']+SSymbol
549#        print 'SSGKl',SSGKl,'genQ',genQ,'iFrac',iFrac,'modSymb',SSGData['modSymb']
550# set identity & 1,-1; triclinic
551        SSGOps[0][0][3,3] = 1.
552## expand if centrosymmetric
553#        if SGData['SGInv']:
554#            SSGOps += [[-1*M,V] for M,V in SSGOps[:]]
555# monoclinic - all done & all checked
556        if SGData['SGPtGrp'] in ['2','m']:  #OK
557            SSGOps[1][0][3,3] = SSGKl[0]
558            SSGOps[1][1][3] = genQ[0]
559            for i in iFrac:
560                SSGOps[1][0][3,i] = -SSGKl[0]
561        elif SGData['SGPtGrp'] == '2/m':    #OK
562            SSGOps[1][0][3,3] = SSGKl[1]
563            if gensym:
564                SSGOps[1][1][3] = 0.5
565            for i in iFrac:
566                SSGOps[1][0][3,i] = SSGKl[0]
567           
568# orthorhombic - all OK not fully checked
569        elif SGData['SGPtGrp'] in ['222','mm2','m2m','2mm']:    #OK
570            if SGData['SGPtGrp'] == '222':
571                OrOps = {'g':{0:[1,3],1:[2,3]},'a':{1:[1,2],2:[1,3]},'b':{2:[3,2],0:[1,2]}} #OK
572            elif SGData['SGPtGrp'] == 'mm2':
573                OrOps = {'g':{0:[1,3],1:[2,3]},'a':{1:[2,1],2:[3,1]},'b':{0:[1,2],2:[3,2]}} #OK
574            elif SGData['SGPtGrp'] == 'm2m':
575                OrOps = {'b':{0:[1,2],2:[3,2]},'g':{0:[1,3],1:[2,3]},'a':{1:[2,1],2:[3,1]}} #OK
576            elif SGData['SGPtGrp'] == '2mm':
577                OrOps = {'a':{1:[2,1],2:[3,1]},'b':{0:[1,2],2:[3,2]},'g':{0:[1,3],1:[2,3]}} #OK
578            a = findMod(SSGData['modSymb'])
579            OrFrac = OrOps[a]
580            for j in iFrac:
581                for i in OrFrac[j]:
582                    SSGOps[i][0][3,j] = -2.*eval(iFrac[j])*SSGKl[i-1]
583            for i in [0,1,2]:
584                SSGOps[i+1][0][3,3] = SSGKl[i]
585                SSGOps[i+1][1][3] = genQ[i]
586                E,SSGOps = extendSSGOps(SSGOps)
587                if not E:
588                    return E,SSGOps
589        elif SGData['SGPtGrp'] == 'mmm':    #OK
590            OrOps = {'g':{0:[1,3],1:[2,3]},'a':{1:[2,1],2:[3,1]},'b':{0:[1,2],2:[3,2]}} 
591            a = findMod(SSGData['modSymb'])
592            if a == 'g':
593                SSkl = [1,1,1]
594            elif a == 'a':
595                SSkl = [-1,1,-1]
596            else:
597                SSkl = [1,-1,-1]
598            OrFrac = OrOps[a]
599            for j in iFrac:
600                for i in OrFrac[j]:
601                    SSGOps[i][0][3,j] = -2.*eval(iFrac[j])*SSkl[i-1]
602            for i in [0,1,2]:
603                SSGOps[i+1][0][3,3] = SSkl[i]
604                SSGOps[i+1][1][3] = genQ[i]
605                E,SSGOps = extendSSGOps(SSGOps)
606                if not E:
607                    return E,SSGOps               
608# tetragonal - all done & checked
609        elif SGData['SGPtGrp'] == '4':  #OK
610            SSGOps[1][0][3,3] = SSGKl[0]
611            SSGOps[1][1][3] = genQ[0]
612            if '1/2' in SSGData['modSymb']:
613                SSGOps[1][0][3,1] = -1
614        elif SGData['SGPtGrp'] == '-4': #OK
615            SSGOps[1][0][3,3] = SSGKl[0]
616            if '1/2' in SSGData['modSymb']:
617                SSGOps[1][0][3,1] = 1
618        elif SGData['SGPtGrp'] in ['4/m',]: #OK
619            if '1/2' in SSGData['modSymb']:
620                SSGOps[1][0][3,1] = -SSGKl[0]
621            for i,j in enumerate([1,3]):
622                SSGOps[j][0][3,3] = 1
623                if genQ[i]:
624                    SSGOps[j][1][3] = genQ[i]
625                E,SSGOps = extendSSGOps(SSGOps)
626                if not E:
627                    return E,SSGOps
628        elif SGData['SGPtGrp'] in ['422','4mm','-42m','-4m2',]: #OK
629            iGens = [1,4,5]
630            if SGData['SGPtGrp'] in ['4mm','-4m2',]:
631                iGens = [1,6,7]
632            for i,j in enumerate(iGens):
633                if '1/2' in SSGData['modSymb'] and i < 2:
634                    SSGOps[j][0][3,1] = SSGKl[i]
635                SSGOps[j][0][3,3] = SSGKl[i]
636                if genQ[i]:
637                    if 's' in gensym and j == 6:
638                        SSGOps[j][1][3] = -genQ[i]
639                    else:
640                        SSGOps[j][1][3] = genQ[i]
641                E,SSGOps = extendSSGOps(SSGOps)
642                if not E:
643                    return E,SSGOps
644        elif SGData['SGPtGrp'] in ['4/mmm',]:#OK
645            if '1/2' in SSGData['modSymb']:
646                SSGOps[1][0][3,1] = -SSGKl[0]
647                SSGOps[6][0][3,1] = SSGKl[1]
648                if modsym:
649                   SSGOps[1][1][3]  = -genQ[3]
650            for i,j in enumerate([1,2,6,7]):
651                SSGOps[j][0][3,3] = 1
652                SSGOps[j][1][3] = genQ[i]
653                E,Result = extendSSGOps(SSGOps)
654                if not E:
655                    return E,Result
656                else:
657                    SSGOps = Result
658               
659# trigonal - all done & checked
660        elif SGData['SGPtGrp'] == '3':  #OK
661            SSGOps[1][0][3,3] = SSGKl[0]
662            if '1/3' in SSGData['modSymb']:
663                SSGOps[1][0][3,1] = -1
664            SSGOps[1][1][3] = genQ[0]
665        elif SGData['SGPtGrp'] == '-3': #OK
666            SSGOps[1][0][3,3] = -SSGKl[0]
667            if '1/3' in SSGData['modSymb']:
668                SSGOps[1][0][3,1] = -1
669            SSGOps[1][1][3] = genQ[0]
670        elif SGData['SGPtGrp'] in ['312','3m','-3m','-3m1','3m1']:   #OK
671            if '1/3' in SSGData['modSymb']:
672                SSGOps[1][0][3,1] = -1
673            for i,j in enumerate([1,5]):
674                if SGData['SGPtGrp'] in ['3m','-3m']:
675                    SSGOps[j][0][3,3] = 1
676                else:                   
677                    SSGOps[j][0][3,3] = SSGKl[i+1]
678                if genQ[i]:
679                    SSGOps[j][1][3] = genQ[i]
680        elif SGData['SGPtGrp'] in ['321','32']:   #OK
681            for i,j in enumerate([1,4]):
682                SSGOps[j][0][3,3] = SSGKl[i]
683                if genQ[i]:
684                    SSGOps[j][1][3] = genQ[i]
685        elif SGData['SGPtGrp'] in ['31m','-31m']:   #OK
686            ids = [1,3]
687            if SGData['SGPtGrp'] == '-31m':
688                ids = [1,3]
689            if '1/3' in SSGData['modSymb']:
690                SSGOps[ids[0]][0][3,1] = -SSGKl[0]
691            for i,j in enumerate(ids):
692                SSGOps[j][0][3,3] = 1
693                if genQ[i+1]:
694                    SSGOps[j][1][3] = genQ[i+1]
695                     
696# hexagonal all done & checked
697        elif SGData['SGPtGrp'] == '6':  #OK
698            SSGOps[1][0][3,3] = SSGKl[0]
699            SSGOps[1][1][3] = genQ[0]
700        elif SGData['SGPtGrp'] == '-6': #OK
701            SSGOps[1][0][3,3] = SSGKl[0]
702        elif SGData['SGPtGrp'] in ['6/m',]: #OK
703            SSGOps[1][0][3,3] = -SSGKl[1]
704            SSGOps[1][1][3] = genQ[0]
705            SSGOps[2][1][3] = genQ[1]
706        elif SGData['SGPtGrp'] in ['622',]: #OK
707            for i,j in enumerate([1,8,9]):
708                SSGOps[j][0][3,3] = SSGKl[i]
709                if genQ[i]:
710                    SSGOps[j][1][3] = genQ[i]
711                E,SSGOps = extendSSGOps(SSGOps)
712           
713        elif SGData['SGPtGrp'] in ['6mm','-62m','-6m2',]: #OK
714            for i,j in enumerate([1,6,7]):
715                SSGOps[j][0][3,3] = SSGKl[i]
716                if genQ[i]:
717                    SSGOps[j][1][3] = genQ[i]
718                E,SSGOps = extendSSGOps(SSGOps)
719        elif SGData['SGPtGrp'] in ['6/mmm',]: # OK
720            for i,j in enumerate([1,2,10,11]):
721                SSGOps[j][0][3,3] = 1
722                if genQ[i]:
723                    SSGOps[j][1][3] = genQ[i]
724                E,SSGOps = extendSSGOps(SSGOps)
725        elif SGData['SGPtGrp'] in ['1','-1']: #triclinic - done
726            return True,SSGOps
727        E,SSGOps = extendSSGOps(SSGOps)
728        return E,SSGOps
729       
730    def specialGen(gensym,modsym):
731        sym = ''.join(gensym)
732        if SGData['SGPtGrp'] in ['2/m',] and 'n' in SGData['SpGrp']:
733            if 's' in sym:
734                gensym = 'ss'
735        if SGData['SGPtGrp'] in ['-62m',] and sym == '00s':
736            gensym = '0ss'
737        elif SGData['SGPtGrp'] in ['222',]:
738            if sym == '00s':
739                gensym = '0ss'
740            elif sym == '0s0':
741                gensym = 'ss0'
742            elif sym == 's00':
743                gensym = 's0s'
744        elif SGData['SGPtGrp'] in ['mmm',]:
745            if 'g' in modsym:
746                if sym == 's00':
747                    gensym = 's0s'
748                elif sym == '0s0':
749                    gensym = '0ss'
750            elif 'a' in modsym:
751                if sym == '0s0':
752                    gensym = 'ss0'
753                elif sym == '00s':
754                    gensym = 's0s'
755            elif 'b' in modsym:
756                if sym == '00s':
757                    gensym = '0ss'
758                elif sym == 's00':
759                    gensym = 'ss0'
760        return gensym
761                   
762    def checkGen(gensym):
763        sym = ''.join(gensym)
764# monoclinic - all done
765        if str(SSGKl) == '[-1]' and sym == 's':
766            return False
767        elif SGData['SGPtGrp'] in ['2/m',]:
768            if str(SSGKl) == '[-1, 1]' and sym == '0s':
769                return False
770            elif str(SSGKl) == '[1, -1]' and sym == 's0':
771                return False
772#orthorhombic - all
773        elif SGData['SGPtGrp'] in ['222',] and sym not in ['','s00','0s0','00s']:
774            return False 
775        elif SGData['SGPtGrp'] in ['2mm','m2m','mm2','mmm'] and sym not in ['',]+GenSymList[4:15]:
776            return False 
777#tetragonal - all done
778        elif SGData['SGPtGrp'] in ['4',] and sym not in ['','s','q']:
779            return False 
780        elif SGData['SGPtGrp'] in ['-4',] and sym not in ['',]:
781            return False             
782        elif SGData['SGPtGrp'] in ['4/m',] and sym not in ['','s0','q0']:
783            return False
784        elif SGData['SGPtGrp'] in ['422',] and sym not in ['','q00','s00']:
785            return False         
786        elif SGData['SGPtGrp'] in ['4mm',] and sym not in ['','ss0','s0s','0ss','00s','qq0','qqs']:
787            return False
788        elif SGData['SGPtGrp'] in ['-4m2',] and sym not in ['','0s0','0q0']:
789            return False
790        elif SGData['SGPtGrp'] in ['-42m',] and sym not in ['','0ss','00q',]:
791            return False
792        elif SGData['SGPtGrp'] in ['4/mmm',] and sym not in ['','s00s','s0s0','00ss','000s',]:
793            return False
794#trigonal/rhombohedral - all done
795        elif SGData['SGPtGrp'] in ['3',] and sym not in ['','t']:
796            return False 
797        elif SGData['SGPtGrp'] in ['-3',] and sym not in ['',]:
798            return False 
799        elif SGData['SGPtGrp'] in ['32',] and sym not in ['','t0']:
800            return False 
801        elif SGData['SGPtGrp'] in ['321','312'] and sym not in ['','t00']:
802            return False 
803        elif SGData['SGPtGrp'] in ['3m','-3m'] and sym not in ['','0s']:
804            return False 
805        elif SGData['SGPtGrp'] in ['3m1','-3m1'] and sym not in ['','0s0']:
806            return False 
807        elif SGData['SGPtGrp'] in ['31m','-31m'] and sym not in ['','00s']:
808            return False 
809#hexagonal - all done
810        elif SGData['SGPtGrp'] in ['6',] and sym not in ['','s','h','t']:
811            return False 
812        elif SGData['SGPtGrp'] in ['-6',] and sym not in ['',]:
813            return False
814        elif SGData['SGPtGrp'] in ['6/m',] and sym not in ['','s0']:
815            return False
816        elif SGData['SGPtGrp'] in ['622',] and sym not in ['','h00','t00','s00']:
817            return False         
818        elif SGData['SGPtGrp'] in ['6mm',] and sym not in ['','ss0','s0s','0ss']:
819            return False
820        elif SGData['SGPtGrp'] in ['-6m2',] and sym not in ['','0s0']:
821            return False
822        elif SGData['SGPtGrp'] in ['-62m',] and sym not in ['','00s']:
823            return False
824        elif SGData['SGPtGrp'] in ['6/mmm',] and sym not in ['','s00s','s0s0','00ss']:
825            return False
826        return True
827       
828    LaueModList = [
829        'abg','ab0','ab1/2','a0g','a1/2g',  '0bg','1/2bg','a00','a01/2','a1/20',
830        'a1/21/2','a01','a10','0b0','0b1/2', '1/2b0','1/2b1/2','0b1','1b0','00g',
831        '01/2g','1/20g','1/21/2g','01g','10g', '1/31/3g']
832    LaueList = ['-1','2/m','mmm','4/m','4/mmm','3R','3mR','3','3m1','31m','6/m','6/mmm','m3','m3m']
833    GenSymList = ['','s','0s','s0', '00s','0s0','s00','s0s','ss0','0ss','q00','0q0','00q','qq0','q0q', '0qq',
834        'q','qqs','s0s0','00ss','s00s','t','t00','t0','h','h00','000s']
835    Fracs = {'1/2':0.5,'1/3':1./3,'1':1.0,'0':0.,'s':.5,'t':1./3,'q':.25,'h':1./6,'a':0.,'b':0.,'g':0.}
836    LaueId = LaueList.index(SGData['SGLaue'])
837    if SGData['SGLaue'] in ['m3','m3m']:
838        return '(3+1) superlattices not defined for cubic space groups',None
839    elif SGData['SGLaue'] in ['3R','3mR']:
840        return '(3+1) superlattices not defined for rhombohedral settings - use hexagonal setting',None
841    try:
842        modsym,gensym = splitSSsym(SSymbol)
843    except ValueError:
844        return 'Error in superspace symbol '+SSymbol,None
845    if ''.join(gensym) not in GenSymList:
846        return 'unknown generator symbol '+''.join(gensym),None
847    try:
848        LaueModId = LaueModList.index(''.join(modsym))
849    except ValueError:
850        return 'Unknown modulation symbol '+''.join(modsym),None
851    if not checkModSym():
852        return 'Modulation '+''.join(modsym)+' not consistent with space group '+SGData['SpGrp'],None
853    modQ = [Fracs[mod] for mod in modsym]
854    SSGKl = SGData['SSGKl'][:]
855    if SGData['SGLaue'] in ['2/m','mmm']:
856        SSGKl = fixMonoOrtho()
857    if len(gensym) and len(gensym) != len(SSGKl):
858        return 'Wrong number of items in generator symbol '+''.join(gensym),None
859    if not checkGen(gensym):
860        return 'Generator '+''.join(gensym)+' not consistent with space group '+SGData['SpGrp'],None
861    gensym = specialGen(gensym,modsym)
862    genQ = [Fracs[mod] for mod in gensym]
863    if not genQ:
864        genQ = [0,0,0,0]
865    SSGData = {'SSpGrp':SGData['SpGrp']+SSymbol,'modQ':modQ,'modSymb':modsym,'SSGKl':SSGKl}
866    SSCen = np.zeros((len(SGData['SGCen']),4))
867    for icen,cen in enumerate(SGData['SGCen']):
868        SSCen[icen,0:3] = cen
869    SSCen[0] = np.zeros(4)
870    SSGData['SSGCen'] = SSCen
871    SSGData['SSGOps'] = []
872    for iop,op in enumerate(SGData['SGOps']):
873        T = np.zeros(4)
874        ssop = np.zeros((4,4))
875        ssop[:3,:3] = op[0]
876        T[:3] = op[1]
877        SSGData['SSGOps'].append([ssop,T])
878    E,Result = genSSGOps()
879    if E:
880        SSGData['SSGOps'] = Result
881        if DEBUG:
882            print 'Super spacegroup operators for '+SSGData['SSpGrp']
883            for Op in Result:
884                print SSMT2text(Op).replace(' ','')
885            if SGData['SGInv']:                                 
886                for Op in Result:
887                    Op = [-Op[0],-Op[1]%1.]
888                    print SSMT2text(Op).replace(' ','')                                 
889        return None,SSGData
890    else:
891        return Result+'\nOperator conflict - incorrect superspace symbol',None
892
893def splitSSsym(SSymbol):
894    '''
895    Splits supersymmetry symbol into two lists of strings
896    '''
897    modsym,gensym = SSymbol.replace(' ','').split(')')
898    nfrac = modsym.count('/')
899    modsym = modsym.lstrip('(')
900    if nfrac == 0:
901        modsym = list(modsym)
902    elif nfrac == 1:
903        pos = modsym.find('/')
904        if pos == 1:
905            modsym = [modsym[:3],modsym[3],modsym[4]]
906        elif pos == 2:
907            modsym = [modsym[0],modsym[1:4],modsym[4]]
908        else:
909            modsym = [modsym[0],modsym[1],modsym[2:]]
910    else:
911        lpos = modsym.find('/')
912        rpos = modsym.rfind('/')
913        if lpos == 1 and rpos == 4:
914            modsym = [modsym[:3],modsym[3:6],modsym[6]]
915        elif lpos == 1 and rpos == 5:
916            modsym = [modsym[:3],modsym[3],modsym[4:]]
917        else:
918            modsym = [modsym[0],modsym[1:4],modsym[4:]]
919    gensym = list(gensym)
920    return modsym,gensym
921       
922def SSGPrint(SGData,SSGData):
923    '''
924    Print the output of SSpcGroup in a nicely formatted way. Used in SSpaceGroup
925
926    :param SGData: space group data structure as defined in SpcGroup above.
927    :param SSGData: from :func:`SSpcGroup`
928    :returns:
929        SSGText - list of strings with the superspace group details
930        SGTable - list of strings for each of the operations
931    '''
932    Mult = len(SSGData['SSGCen'])*len(SSGData['SSGOps'])
933    SSGText = []
934    SSGText.append(' Superspace Group: '+SSGData['SSpGrp'])
935    CentStr = 'centrosymmetric'
936    if not SGData['SGInv']:
937        CentStr = 'non'+CentStr
938    if SGData['SGLatt'] in 'ABCIFR':
939        SSGText.append(' The lattice is '+CentStr+' '+SGData['SGLatt']+'-centered '+SGData['SGSys'].lower())
940    else:
941        SSGText.append(' The superlattice is '+CentStr+' '+'primitive '+SGData['SGSys'].lower())       
942    SSGText.append(' The Laue symmetry is '+SGData['SGLaue'])
943    SSGText.append(' The superlattice point group is '+SGData['SGPtGrp']+','+''.join([str(i) for i in SSGData['SSGKl']]))
944    SSGText.append(' The number of superspace group generators is '+str(len(SGData['SSGKl'])))
945    SSGText.append(' Multiplicity of a general site is '+str(Mult))
946    if SGData['SGUniq'] in ['a','b','c']:
947        SSGText.append(' The unique monoclinic axis is '+SGData['SGUniq'])
948    if SGData['SGInv']:
949        SSGText.append(' The inversion center is located at 0,0,0')
950    if SGData['SGPolax']:
951        SSGText.append(' The location of the origin is arbitrary in '+SGData['SGPolax'])
952    SSGText.append(' ')
953    if len(SSGData['SSGCen']) > 1:
954        SSGText.append(' The equivalent positions are:')
955        SSGText.append(' ('+SSLatt2text(SSGData['SSGCen'])+')+\n')
956    else:
957        SSGText.append(' The equivalent positions are:\n')
958    SSGTable = []
959    for i,Opr in enumerate(SSGData['SSGOps']):
960        SSGTable.append('(%2d) %s'%(i+1,SSMT2text(Opr)))
961    return SSGText,SSGTable
962   
963def SSGModCheck(Vec,modSymb):
964    ''' Checks modulation vector compatibility with supersymmetry space group symbol.
965    Superspace group symbol takes precidence & the vector will be modified accordingly
966    '''
967    Fracs = {'1/2':0.5,'1/3':1./3,'1':1.0,'0':0.,'a':0.,'b':0.,'g':0.}
968    modQ = [Fracs[mod] for mod in modSymb]
969    Vec = [0.1 if (vec == 0.0 and mod in ['a','b','g']) else vec for [vec,mod] in zip(Vec,modSymb)]
970    return [Q if mod not in ['a','b','g'] and vec != Q else vec for [vec,mod,Q] in zip(Vec,modSymb,modQ)],  \
971        [True if mod in ['a','b','g'] else False for mod in modSymb]
972
973def SSMT2text(Opr):
974    "From superspace group matrix/translation operator returns text version"
975    XYZS = ('x','y','z','t')    #Stokes, Campbell & van Smaalen notation
976    TRA = ('   ','ERR','1/6','1/4','1/3','ERR','1/2','ERR','2/3','3/4','5/6','ERR')
977    Fld = ''
978    M,T = Opr
979    for j in range(4):
980        IJ = ''
981        for k in range(4):
982            txt = str(int(round(M[j][k])))
983            txt = txt.replace('1',XYZS[k]).replace('0','')
984            if '2' in txt:
985                txt += XYZS[k]
986            if IJ and M[j][k] > 0:
987                IJ += '+'+txt
988            else:
989                IJ += txt
990        IK = int(round(T[j]*12))%12
991        if IK:
992            if not IJ:
993                break
994            if IJ[0] == '-':
995                Fld += (TRA[IK]+IJ).rjust(8)
996            else:
997                Fld += (TRA[IK]+'+'+IJ).rjust(8)
998        else:
999            Fld += IJ.rjust(8)
1000        if j != 3: Fld += ', '
1001    return Fld
1002   
1003def SSLatt2text(SSGCen):
1004    "Lattice centering vectors to text"
1005    lattTxt = ''
1006    for vec in SSGCen:
1007        lattTxt += ' '
1008        for item in vec:
1009            if int(item*12.):
1010                lattTxt += '1/%d,'%(12/int(item*12))
1011            else:
1012                lattTxt += '0,'
1013        lattTxt = lattTxt.rstrip(',')
1014        lattTxt += ';'
1015    lattTxt = lattTxt.rstrip(';').lstrip(' ')
1016    return lattTxt
1017       
1018def SSpaceGroup(SGSymbol,SSymbol):
1019    '''
1020    Print the output of SSpcGroup in a nicely formatted way.
1021
1022    :param SGSymbol: space group symbol with spaces between axial fields.
1023    :param SSymbol: superspace group symbol extension (string).
1024    :returns: nothing
1025    '''
1026
1027    E,A = SpcGroup(SGSymbol)
1028    if E > 0:
1029        print SGErrors(E)
1030        return
1031    E,B = SSpcGroup(A,SSymbol)   
1032    if E > 0:
1033        print E
1034        return
1035    for l in SSGPrint(B):
1036        print l
1037       
1038def SGProd(OpA,OpB):
1039    '''
1040    Form space group operator product. OpA & OpB are [M,V] pairs;
1041        both must be of same dimension (3 or 4). Returns [M,V] pair
1042    '''
1043    A,U = OpA
1044    B,V = OpB
1045    M = np.inner(B,A.T)
1046    W = np.inner(B,U)+V
1047    return M,W
1048       
1049def MoveToUnitCell(xyz):
1050    '''
1051    Translates a set of coordinates so that all values are >=0 and < 1
1052
1053    :param xyz: a list or numpy array of fractional coordinates
1054    :returns: XYZ - numpy array of new coordinates now 0 or greater and less than 1
1055    '''
1056    XYZ = np.zeros(3)
1057    for i,x in enumerate(xyz):
1058        XYZ[i] = (x-int(x))%1.0
1059    return XYZ
1060       
1061def Opposite(XYZ,toler=0.0002):
1062    '''
1063    Gives opposite corner, edge or face of unit cell for position within tolerance.
1064        Result may be just outside the cell within tolerance
1065
1066    :param XYZ: 0 >= np.array[x,y,z] > 1 as by MoveToUnitCell
1067    :param toler: unit cell fraction tolerance making opposite
1068    :returns:
1069        XYZ: array of opposite positions; always contains XYZ
1070    '''
1071    perm3 = [[1,1,1],[0,1,1],[1,0,1],[1,1,0],[1,0,0],[0,1,0],[0,0,1],[0,0,0]]
1072    TB = np.where(abs(XYZ-1)<toler,-1,0)+np.where(abs(XYZ)<toler,1,0)
1073    perm = TB*perm3
1074    cperm = ['%d%d%d'%(i,j,k) for i,j,k in perm]
1075    D = dict(zip(cperm,perm))
1076    new = []
1077    for key in D:
1078        new.append(np.array(D[key])+np.array(XYZ))
1079    return new
1080       
1081def GenAtom(XYZ,SGData,All=False,Uij=[],Move=True):
1082    '''
1083    Generates the equivalent positions for a specified coordinate and space group
1084
1085    :param XYZ: an array, tuple or list containing 3 elements: x, y & z
1086    :param SGData: from :func:`SpcGroup`
1087    :param All: True return all equivalent positions including duplicates;
1088      False return only unique positions
1089    :param Uij: [U11,U22,U33,U12,U13,U23] or [] if no Uij
1090    :param Move: True move generated atom positions to be inside cell
1091      False do not move atoms       
1092    :return: [[XYZEquiv],Idup,[UijEquiv]]
1093
1094      *  [XYZEquiv] is list of equivalent positions (XYZ is first entry)
1095      *  Idup = [-][C]SS where SS is the symmetry operator number (1-24), C (if not 0,0,0)
1096      * is centering operator number (1-4) and - is for inversion
1097        Cell = unit cell translations needed to put new positions inside cell
1098        [UijEquiv] - equivalent Uij; absent if no Uij given
1099       
1100    '''
1101    XYZEquiv = []
1102    UijEquiv = []
1103    Idup = []
1104    Cell = []
1105    X = np.array(XYZ)
1106    if Move:
1107        X = MoveToUnitCell(X)
1108    for ic,cen in enumerate(SGData['SGCen']):
1109        C = np.array(cen)
1110        for invers in range(int(SGData['SGInv']+1)):
1111            for io,[M,T] in enumerate(SGData['SGOps']):
1112                idup = ((io+1)+100*ic)*(1-2*invers)
1113                XT = np.inner(M,X)+T
1114                if len(Uij):
1115                    U = Uij2U(Uij)
1116                    U = np.inner(M,np.inner(U,M).T)
1117                    newUij = U2Uij(U)
1118                if invers:
1119                    XT = -XT
1120                XT += C
1121                if Move:
1122                    newX = MoveToUnitCell(XT)
1123                else:
1124                    newX = XT
1125                cell = np.asarray(np.rint(newX-XT),dtype=np.int32)
1126                if All:
1127                    if np.allclose(newX,X,atol=0.0002):
1128                        idup = False
1129                else:
1130                    if True in [np.allclose(newX,oldX,atol=0.0002) for oldX in XYZEquiv]:
1131                        idup = False
1132                if All or idup:
1133                    XYZEquiv.append(newX)
1134                    Idup.append(idup)
1135                    Cell.append(cell)
1136                    if len(Uij):
1137                        UijEquiv.append(newUij)                   
1138    if len(Uij):
1139        return zip(XYZEquiv,UijEquiv,Idup,Cell)
1140    else:
1141        return zip(XYZEquiv,Idup,Cell)
1142
1143def GenHKLf(HKL,SGData):
1144    '''
1145    Uses old GSAS Fortran routine genhkl.for
1146
1147    :param HKL:  [h,k,l] must be integral values for genhkl.for to work
1148    :param SGData: space group data obtained from SpcGroup
1149    :returns: iabsnt,mulp,Uniq,phi
1150
1151     *   iabsnt = True if reflection is forbidden by symmetry
1152     *   mulp = reflection multiplicity including Friedel pairs
1153     *   Uniq = numpy array of equivalent hkl in descending order of h,k,l
1154     *   phi = phase offset for each equivalent h,k,l
1155
1156    '''
1157    hklf = list(HKL)+[0,]       #could be numpy array!
1158    Ops = SGData['SGOps']
1159    OpM = np.array([op[0] for op in Ops])
1160    OpT = np.array([op[1] for op in Ops])
1161    Inv = SGData['SGInv']
1162    Cen = np.array([cen for cen in SGData['SGCen']])
1163   
1164    Nuniq,Uniq,iabsnt,mulp = pyspg.genhklpy(hklf,len(Ops),OpM,OpT,SGData['SGInv'],len(Cen),Cen)
1165    h,k,l,f = Uniq
1166    Uniq=np.array(zip(h[:Nuniq],k[:Nuniq],l[:Nuniq]))
1167    phi = f[:Nuniq]
1168   
1169    return iabsnt,mulp,Uniq,phi
1170   
1171def checkSSLaue(HKL,SGData,SSGData):
1172    #Laue check here - Toss HKL if outside unique Laue part
1173    h,k,l,m = HKL
1174    if SGData['SGLaue'] == '2/m':
1175        if SGData['SGUniq'] == 'a':
1176            if 'a' in SSGData['modSymb'] and h == 0 and m < 0:
1177                return False
1178            elif 'b' in SSGData['modSymb'] and k == 0 and l ==0 and m < 0:
1179                return False
1180            else:
1181                return True
1182        elif SGData['SGUniq'] == 'b':
1183            if 'b' in SSGData['modSymb'] and k == 0 and m < 0:
1184                return False
1185            elif 'a' in SSGData['modSymb'] and h == 0 and l ==0 and m < 0:
1186                return False
1187            else:
1188                return True
1189        elif SGData['SGUniq'] == 'c':
1190            if 'g' in SSGData['modSymb'] and l == 0 and m < 0:
1191                return False
1192            elif 'a' in SSGData['modSymb'] and h == 0 and k ==0 and m < 0:
1193                return False
1194            else:
1195                return True
1196    elif SGData['SGLaue'] == 'mmm':
1197        if 'a' in SSGData['modSymb']:
1198            if h == 0 and m < 0:
1199                return False
1200            else:
1201                return True
1202        elif 'b' in SSGData['modSymb']:
1203            if k == 0 and m < 0:
1204                return False
1205            else:
1206                return True
1207        elif 'g' in SSGData['modSymb']:
1208            if l == 0 and m < 0:
1209                return False
1210            else:
1211                return True
1212    else:   #tetragonal, trigonal, hexagonal (& triclinic?)
1213        if l == 0 and m < 0:
1214            return False
1215        else:
1216            return True
1217       
1218   
1219def checkSSextc(HKL,SSGData):
1220    Ops = SSGData['SSGOps']
1221    OpM = np.array([op[0] for op in Ops])
1222    OpT = np.array([op[1] for op in Ops])
1223    HKLS = np.array([HKL,-HKL])     #Freidel's Law
1224    DHKL = np.reshape(np.inner(HKLS,OpM)-HKL,(-1,4))
1225    PHKL = np.reshape(np.inner(HKLS,OpT),(-1,))
1226    for dhkl,phkl in zip(DHKL,PHKL)[1:]:    #skip identity
1227        if dhkl.any():
1228            continue
1229        else:
1230            if phkl%1.:
1231                return False
1232    return True
1233                                 
1234def GetOprPtrName(key):
1235    'Needs a doc string'
1236    OprPtrName = {
1237        '-6643':[   2,' 1bar ', 1],'6479' :[  10,'  2z  ', 2],'-6479':[   9,'  mz  ', 3],
1238        '6481' :[   7,'  my  ', 4],'-6481':[   6,'  2y  ', 5],'6641' :[   4,'  mx  ', 6],
1239        '-6641':[   3,'  2x  ', 7],'6591' :[  28,' m+-0 ', 8],'-6591':[  27,' 2+-0 ', 9],
1240        '6531' :[  25,' m110 ',10],'-6531':[  24,' 2110 ',11],'6537' :[  61,'  4z  ',12],
1241        '-6537':[  62,' -4z  ',13],'975'  :[  68,' 3+++1',14],'6456' :[ 114,'  3z1 ',15],
1242        '-489' :[  73,' 3+-- ',16],'483'  :[  78,' 3-+- ',17],'-969' :[  83,' 3--+ ',18],
1243        '819'  :[  22,' m+0- ',19],'-819' :[  21,' 2+0- ',20],'2431' :[  16,' m0+- ',21],
1244        '-2431':[  15,' 20+- ',22],'-657' :[  19,' m101 ',23],'657'  :[  18,' 2101 ',24],
1245        '1943' :[  48,' -4x  ',25],'-1943':[  47,'  4x  ',26],'-2429':[  13,' m011 ',27],
1246        '2429' :[  12,' 2011 ',28],'639'  :[  55,' -4y  ',29],'-639' :[  54,'  4y  ',30],
1247        '-6484':[ 146,' 2010 ', 4],'6484' :[ 139,' m010 ', 5],'-6668':[ 145,' 2100 ', 6],
1248        '6668' :[ 138,' m100 ', 7],'-6454':[ 148,' 2120 ',18],'6454' :[ 141,' m120 ',19],
1249        '-6638':[ 149,' 2210 ',20],'6638' :[ 142,' m210 ',21],              #search ends here
1250        '2223' :[  68,' 3+++2',39],
1251        '6538' :[ 106,'  6z1 ',40],'-2169':[  83,' 3--+2',41],'2151' :[  73,' 3+--2',42],
1252        '2205' :[  79,'-3-+-2',43],'-2205':[  78,' 3-+-2',44],'489'  :[  74,'-3+--1',45],
1253        '801'  :[  53,'  4y1 ',46],'1945' :[  47,'  4x3 ',47],'-6585':[  62,' -4z3 ',48],
1254        '6585' :[  61,'  4z3 ',49],'6584' :[ 114,'  3z2 ',50],'6666' :[ 106,'  6z5 ',51],
1255        '6643' :[   1,' Iden ',52],'-801' :[  55,' -4y1 ',53],'-1945':[  48,' -4x3 ',54],
1256        '-6666':[ 105,' -6z5 ',55],'-6538':[ 105,' -6z1 ',56],'-2223':[  69,'-3+++2',57],
1257        '-975' :[  69,'-3+++1',58],'-6456':[ 113,' -3z1 ',59],'-483' :[  79,'-3-+-1',60],
1258        '969'  :[  84,'-3--+1',61],'-6584':[ 113,' -3z2 ',62],'2169' :[  84,'-3--+2',63],
1259        '-2151':[  74,'-3+--2',64],'0':[0,' ????',0]
1260        }
1261    return OprPtrName[key]
1262
1263def GetKNsym(key):
1264    'Needs a doc string'
1265    KNsym = {
1266        '0'         :'    1   ','1'         :'   -1   ','64'        :'    2(x)','32'        :'    m(x)',
1267        '97'        :'  2/m(x)','16'        :'    2(y)','8'         :'    m(y)','25'        :'  2/m(y)',
1268        '2'         :'    2(z)','4'         :'    m(z)','7'         :'  2/m(z)','134217728' :'   2(yz)',
1269        '67108864'  :'   m(yz)','201326593' :' 2/m(yz)','2097152'   :'  2(0+-)','1048576'   :'  m(0+-)',
1270        '3145729'   :'2/m(0+-)','8388608'   :'   2(xz)','4194304'   :'   m(xz)','12582913'  :' 2/m(xz)',
1271        '524288'    :'  2(+0-)','262144'    :'  m(+0-)','796433'    :'2/m(+0-)','1024'      :'   2(xy)',
1272        '512'       :'   m(xy)','1537'      :' 2/m(xy)','256'       :'  2(+-0)','128'       :'  m(+-0)',
1273        '385'       :'2/m(+-0)','76'        :'  mm2(x)','52'        :'  mm2(y)','42'        :'  mm2(z)',
1274        '135266336' :' mm2(yz)','69206048'  :'mm2(0+-)','8650760'   :' mm2(xz)','4718600'   :'mm2(+0-)',
1275        '1156'      :' mm2(xy)','772'       :'mm2(+-0)','82'        :'  222   ','136314944' :'  222(x)',
1276        '8912912'   :'  222(y)','1282'      :'  222(z)','127'       :'  mmm   ','204472417' :'  mmm(x)',
1277        '13369369'  :'  mmm(y)','1927'      :'  mmm(z)','33554496'  :'  4(100)','16777280'  :' -4(100)',
1278        '50331745'  :'4/m(100)','169869394' :'422(100)','84934738'  :'-42m 100','101711948' :'4mm(100)',
1279        '254804095' :'4/mmm100','536870928 ':'  4(010)','268435472' :' -4(010)','805306393' :'4/m (10)',
1280        '545783890' :'422(010)','272891986' :'-42m 010','541327412' :'4mm(010)','818675839' :'4/mmm010',
1281        '2050'      :'  4(001)','4098'      :' -4(001)','6151'      :'4/m(001)','3410'      :'422(001)',
1282        '4818'      :'-42m 001','2730'      :'4mm(001)','8191'      :'4/mmm001','8192'      :'  3(111)',
1283        '8193'      :' -3(111)','2629888'   :' 32(111)','1319040'   :' 3m(111)','3940737'   :'-3m(111)',
1284        '32768'     :'  3(+--)','32769'     :' -3(+--)','10519552'  :' 32(+--)','5276160'   :' 3m(+--)',
1285        '15762945'  :'-3m(+--)','65536'     :'  3(-+-)','65537'     :' -3(-+-)','134808576' :' 32(-+-)',
1286        '67437056'  :' 3m(-+-)','202180097' :'-3m(-+-)','131072'    :'  3(--+)','131073'    :' -3(--+)',
1287        '142737664' :' 32(--+)','71434368'  :' 3m(--+)','214040961' :'-3m(--+)','237650'    :'   23   ',
1288        '237695'    :'   m3   ','715894098' :'   432  ','358068946' :'  -43m  ','1073725439':'   m3m  ',
1289        '68157504'  :' mm2d100','4456464'   :' mm2d010','642'       :' mm2d001','153092172' :'-4m2 100',
1290        '277348404' :'-4m2 010','5418'      :'-4m2 001','1075726335':'  6/mmm ','1074414420':'-6m2 100',
1291        '1075070124':'-6m2 120','1075069650':'   6mm  ','1074414890':'   622  ','1073758215':'   6/m  ',
1292        '1073758212':'   -6   ','1073758210':'    6   ','1073759865':'-3m(100)','1075724673':'-3m(120)',
1293        '1073758800':' 3m(100)','1075069056':' 3m(120)','1073759272':' 32(100)','1074413824':' 32(120)',
1294        '1073758209':'   -3   ','1073758208':'    3   ','1074135143':'mmm(100)','1075314719':'mmm(010)',
1295        '1073743751':'mmm(110)','1074004034':' mm2z100','1074790418':' mm2z010','1073742466':' mm2z110',
1296        '1074004004':'mm2(100)','1074790412':'mm2(010)','1073742980':'mm2(110)','1073872964':'mm2(120)',
1297        '1074266132':'mm2(210)','1073742596':'mm2(+-0)','1073872930':'222(100)','1074266122':'222(010)',
1298        '1073743106':'222(110)','1073741831':'2/m(001)','1073741921':'2/m(100)','1073741849':'2/m(010)',
1299        '1073743361':'2/m(110)','1074135041':'2/m(120)','1075314689':'2/m(210)','1073742209':'2/m(+-0)',
1300        '1073741828':' m(001) ','1073741888':' m(100) ','1073741840':' m(010) ','1073742336':' m(110) ',
1301        '1074003968':' m(120) ','1074790400':' m(210) ','1073741952':' m(+-0) ','1073741826':' 2(001) ',
1302        '1073741856':' 2(100) ','1073741832':' 2(010) ','1073742848':' 2(110) ','1073872896':' 2(120) ',
1303        '1074266112':' 2(210) ','1073742080':' 2(+-0) ','1073741825':'   -1   '
1304        }
1305    return KNsym[key]       
1306
1307def GetNXUPQsym(siteSym):
1308    '''       
1309    The codes XUPQ are for lookup of symmetry constraints for position(X), thermal parm(U) & magnetic moments
1310    (P&Q-not used in GSAS-II)
1311    '''
1312    NXUPQsym = {
1313        '    1   ':(28,29,28,28),'   -1   ':( 1,29,28, 0),'    2(x)':(12,18,12,25),'    m(x)':(25,18,12,25),
1314        '  2/m(x)':( 1,18, 0,-1),'    2(y)':(13,17,13,24),'    m(y)':(24,17,13,24),'  2/m(y)':( 1,17, 0,-1),
1315        '    2(z)':(14,16,14,23),'    m(z)':(23,16,14,23),'  2/m(z)':( 1,16, 0,-1),'   2(yz)':(10,23,10,22),
1316        '   m(yz)':(22,23,10,22),' 2/m(yz)':( 1,23, 0,-1),'  2(0+-)':(11,24,11,21),'  m(0+-)':(21,24,11,21),
1317        '2/m(0+-)':( 1,24, 0,-1),'   2(xz)':( 8,21, 8,20),'   m(xz)':(20,21, 8,20),' 2/m(xz)':( 1,21, 0,-1),
1318        '  2(+0-)':( 9,22, 9,19),'  m(+0-)':(19,22, 9,19),'2/m(+0-)':( 1,22, 0,-1),'   2(xy)':( 6,19, 6,18),
1319        '   m(xy)':(18,19, 6,18),' 2/m(xy)':( 1,19, 0,-1),'  2(+-0)':( 7,20, 7,17),'  m(+-0)':(17,20, 7,17),
1320        '2/m(+-0)':( 1,20, 0,-1),'  mm2(x)':(12,10, 0,-1),'  mm2(y)':(13,10, 0,-1),'  mm2(z)':(14,10, 0,-1),
1321        ' mm2(yz)':(10,13, 0,-1),'mm2(0+-)':(11,13, 0,-1),' mm2(xz)':( 8,12, 0,-1),'mm2(+0-)':( 9,12, 0,-1),
1322        ' mm2(xy)':( 6,11, 0,-1),'mm2(+-0)':( 7,11, 0,-1),'  222   ':( 1,10, 0,-1),'  222(x)':( 1,13, 0,-1),
1323        '  222(y)':( 1,12, 0,-1),'  222(z)':( 1,11, 0,-1),'  mmm   ':( 1,10, 0,-1),'  mmm(x)':( 1,13, 0,-1),
1324        '  mmm(y)':( 1,12, 0,-1),'  mmm(z)':( 1,11, 0,-1),'  4(100)':(12, 4,12, 0),' -4(100)':( 1, 4,12, 0),
1325        '4/m(100)':( 1, 4,12,-1),'422(100)':( 1, 4, 0,-1),'-42m 100':( 1, 4, 0,-1),'4mm(100)':(12, 4, 0,-1),
1326        '4/mmm100':( 1, 4, 0,-1),'  4(010)':(13, 3,13, 0),' -4(010)':( 1, 3,13, 0),'4/m (10)':( 1, 3,13,-1),
1327        '422(010)':( 1, 3, 0,-1),'-42m 010':( 1, 3, 0,-1),'4mm(010)':(13, 3, 0,-1),'4/mmm010':(1, 3, 0,-1,),
1328        '  4(001)':(14, 2,14, 0),' -4(001)':( 1, 2,14, 0),'4/m(001)':( 1, 2,14,-1),'422(001)':( 1, 2, 0,-1),
1329        '-42m 001':( 1, 2, 0,-1),'4mm(001)':(14, 2, 0,-1),'4/mmm001':( 1, 2, 0,-1),'  3(111)':( 2, 5, 2, 0),
1330        ' -3(111)':( 1, 5, 2, 0),' 32(111)':( 1, 5, 0, 2),' 3m(111)':( 2, 5, 0, 2),'-3m(111)':( 1, 5, 0,-1),
1331        '  3(+--)':( 5, 8, 5, 0),' -3(+--)':( 1, 8, 5, 0),' 32(+--)':( 1, 8, 0, 5),' 3m(+--)':( 5, 8, 0, 5),
1332        '-3m(+--)':( 1, 8, 0,-1),'  3(-+-)':( 4, 7, 4, 0),' -3(-+-)':( 1, 7, 4, 0),' 32(-+-)':( 1, 7, 0, 4),
1333        ' 3m(-+-)':( 4, 7, 0, 4),'-3m(-+-)':( 1, 7, 0,-1),'  3(--+)':( 3, 6, 3, 0),' -3(--+)':( 1, 6, 3, 0),
1334        ' 32(--+)':( 1, 6, 0, 3),' 3m(--+)':( 3, 6, 0, 3),'-3m(--+)':( 1, 6, 0,-1),'   23   ':( 1, 1, 0, 0),
1335        '   m3   ':( 1, 1, 0, 0),'   432  ':( 1, 1, 0, 0),'  -43m  ':( 1, 1, 0, 0),'   m3m  ':( 1, 1, 0, 0),
1336        ' mm2d100':(12,13, 0,-1),' mm2d010':(13,12, 0,-1),' mm2d001':(14,11, 0,-1),'-4m2 100':( 1, 4, 0,-1),
1337        '-4m2 010':( 1, 3, 0,-1),'-4m2 001':( 1, 2, 0,-1),'  6/mmm ':( 1, 9, 0,-1),'-6m2 100':( 1, 9, 0,-1),
1338        '-6m2 120':( 1, 9, 0,-1),'   6mm  ':(14, 9, 0,-1),'   622  ':( 1, 9, 0,-1),'   6/m  ':( 1, 9,14,-1),
1339        '   -6   ':( 1, 9,14, 0),'    6   ':(14, 9,14, 0),'-3m(100)':( 1, 9, 0,-1),'-3m(120)':( 1, 9, 0,-1),
1340        ' 3m(100)':(14, 9, 0,14),' 3m(120)':(14, 9, 0,14),' 32(100)':( 1, 9, 0,14),' 32(120)':( 1, 9, 0,14),
1341        '   -3   ':( 1, 9,14, 0),'    3   ':(14, 9,14, 0),'mmm(100)':( 1,14, 0,-1),'mmm(010)':( 1,15, 0,-1),
1342        'mmm(110)':( 1,11, 0,-1),' mm2z100':(14,14, 0,-1),' mm2z010':(14,15, 0,-1),' mm2z110':(14,11, 0,-1),
1343        'mm2(100)':(12,14, 0,-1),'mm2(010)':(13,15, 0,-1),'mm2(110)':( 6,11, 0,-1),'mm2(120)':(15,14, 0,-1),
1344        'mm2(210)':(16,15, 0,-1),'mm2(+-0)':( 7,11, 0,-1),'222(100)':( 1,14, 0,-1),'222(010)':( 1,15, 0,-1),
1345        '222(110)':( 1,11, 0,-1),'2/m(001)':( 1,16,14,-1),'2/m(100)':( 1,25,12,-1),'2/m(010)':( 1,28,13,-1),
1346        '2/m(110)':( 1,19, 6,-1),'2/m(120)':( 1,27,15,-1),'2/m(210)':( 1,26,16,-1),'2/m(+-0)':( 1,20,17,-1),
1347        ' m(001) ':(23,16,14,23),' m(100) ':(26,25,12,26),' m(010) ':(27,28,13,27),' m(110) ':(18,19, 6,18),
1348        ' m(120) ':(24,27,15,24),' m(210) ':(25,26,16,25),' m(+-0) ':(17,20, 7,17),' 2(001) ':(14,16,14,23),
1349        ' 2(100) ':(12,25,12,26),' 2(010) ':(13,28,13,27),' 2(110) ':( 6,19, 6,18),' 2(120) ':(15,27,15,24),
1350        ' 2(210) ':(16,26,16,25),' 2(+-0) ':( 7,20, 7,17),'   -1   ':( 1,29,28, 0)
1351        }
1352    return NXUPQsym[siteSym]
1353
1354def GetCSxinel(siteSym): 
1355    'Needs a doc string'
1356    CSxinel = [[],                         # 0th empty - indices are Fortran style
1357        [[0,0,0],[ 0.0, 0.0, 0.0]],      #1  0  0  0
1358        [[1,1,1],[ 1.0, 1.0, 1.0]],      #2  X  X  X
1359        [[1,1,1],[ 1.0, 1.0,-1.0]],      #3  X  X -X
1360        [[1,1,1],[ 1.0,-1.0, 1.0]],      #4  X -X  X
1361        [[1,1,1],[ 1.0,-1.0,-1.0]],      #5 -X  X  X
1362        [[1,1,0],[ 1.0, 1.0, 0.0]],      #6  X  X  0
1363        [[1,1,0],[ 1.0,-1.0, 0.0]],      #7  X -X  0
1364        [[1,0,1],[ 1.0, 0.0, 1.0]],      #8  X  0  X
1365        [[1,0,1],[ 1.0, 0.0,-1.0]],      #9  X  0 -X
1366        [[0,1,1],[ 0.0, 1.0, 1.0]],      #10  0  Y  Y
1367        [[0,1,1],[ 0.0, 1.0,-1.0]],      #11 0  Y -Y
1368        [[1,0,0],[ 1.0, 0.0, 0.0]],      #12  X  0  0
1369        [[0,1,0],[ 0.0, 1.0, 0.0]],      #13  0  Y  0
1370        [[0,0,1],[ 0.0, 0.0, 1.0]],      #14  0  0  Z
1371        [[1,1,0],[ 1.0, 2.0, 0.0]],      #15  X 2X  0
1372        [[1,1,0],[ 2.0, 1.0, 0.0]],      #16 2X  X  0
1373        [[1,1,2],[ 1.0, 1.0, 1.0]],      #17  X  X  Z
1374        [[1,1,2],[ 1.0,-1.0, 1.0]],      #18  X -X  Z
1375        [[1,2,1],[ 1.0, 1.0, 1.0]],      #19  X  Y  X
1376        [[1,2,1],[ 1.0, 1.0,-1.0]],      #20  X  Y -X
1377        [[1,2,2],[ 1.0, 1.0, 1.0]],      #21  X  Y  Y
1378        [[1,2,2],[ 1.0, 1.0,-1.0]],      #22  X  Y -Y
1379        [[1,2,0],[ 1.0, 1.0, 0.0]],      #23  X  Y  0
1380        [[1,0,2],[ 1.0, 0.0, 1.0]],      #24  X  0  Z
1381        [[0,1,2],[ 0.0, 1.0, 1.0]],      #25  0  Y  Z
1382        [[1,1,2],[ 1.0, 2.0, 1.0]],      #26  X 2X  Z
1383        [[1,1,2],[ 2.0, 1.0, 1.0]],      #27 2X  X  Z
1384        [[1,2,3],[ 1.0, 1.0, 1.0]],      #28  X  Y  Z
1385        ]
1386    indx = GetNXUPQsym(siteSym)
1387    return CSxinel[indx[0]]
1388   
1389def GetCSuinel(siteSym):
1390    "returns Uij terms, multipliers, GUI flags & Uiso2Uij multipliers"
1391    CSuinel = [[],                                             # 0th empty - indices are Fortran style
1392        [[1,1,1,0,0,0],[ 1.0, 1.0, 1.0, 0.0, 0.0, 0.0],[1,0,0,0,0,0],[1.0,1.0,1.0,0.0,0.0,0.0]],    #1  A  A  A  0  0  0
1393        [[1,1,2,0,0,0],[ 1.0, 1.0, 1.0, 0.0, 0.0, 0.0],[1,0,1,0,0,0],[1.0,1.0,1.0,0.0,0.0,0.0]],    #2  A  A  C  0  0  0
1394        [[1,2,1,0,0,0],[ 1.0, 1.0, 1.0, 0.0, 0.0, 0.0],[1,1,0,0,0,0],[1.0,1.0,1.0,0.0,0.0,0.0]],    #3  A  B  A  0  0  0
1395        [[1,2,2,0,0,0],[ 1.0, 1.0, 1.0, 0.0, 0.0, 0.0],[1,1,0,0,0,0],[1.0,1.0,1.0,0.0,0.0,0.0]],    #4  A  B  B  0  0  0
1396        [[1,1,1,2,2,2],[ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],[1,0,0,1,0,0],[1.0,1.0,1.0,0.0,0.0,0.0]],    #5  A  A  A  D  D  D
1397        [[1,1,1,2,2,2],[ 1.0, 1.0, 1.0, 1.0,-1.0,-1.0],[1,0,0,1,0,0],[1.0,1.0,1.0,0.0,0.0,0.0]],    #6  A  A  A  D -D -D
1398        [[1,1,1,2,2,2],[ 1.0, 1.0, 1.0, 1.0,-1.0, 1.0],[1,0,0,1,0,0],[1.0,1.0,1.0,0.0,0.0,0.0]],    #7  A  A  A  D -D  D
1399        [[1,1,1,2,2,2],[ 1.0, 1.0, 1.0, 1.0, 1.0,-1.0],[1,0,0,1,0,0],[1.0,1.0,1.0,0.0,0.0,0.0]],    #8  A  A  A  D  D -D
1400        [[1,1,2,1,0,0],[ 1.0, 1.0, 1.0, 0.5, 0.0, 0.0],[1,0,1,0,0,0],[1.0,1.0,1.0,0.5,0.0,0.0]],    #9  A  A  C A/2 0  0
1401        [[1,2,3,0,0,0],[ 1.0, 1.0, 1.0, 0.0, 0.0, 0.0],[1,1,1,0,0,0],[1.0,1.0,1.0,0.0,0.0,0.0]],    #10  A  B  C  0  0  0
1402        [[1,1,2,3,0,0],[ 1.0, 1.0, 1.0, 1.0, 0.0, 0.0],[1,0,1,1,0,0],[1.0,1.0,1.0,0.0,0.0,0.0]],    #11  A  A  C  D  0  0
1403        [[1,2,1,0,3,0],[ 1.0, 1.0, 1.0, 0.0, 1.0, 0.0],[1,1,0,0,1,0],[1.0,1.0,1.0,0.0,0.0,0.0]],    #12  A  B  A  0  E  0
1404        [[1,2,2,0,0,3],[ 1.0, 1.0, 1.0, 0.0, 0.0, 1.0],[1,1,0,0,0,1],[1.0,1.0,1.0,0.0,0.0,0.0]],    #13  A  B  B  0  0  F
1405        [[1,2,3,2,0,0],[ 1.0, 1.0, 1.0, 0.5, 0.0, 0.0],[1,1,1,0,0,0],[1.0,1.0,1.0,0.0,0.5,0.0]],    #14  A  B  C B/2 0  0
1406        [[1,2,3,1,0,0],[ 1.0, 1.0, 1.0, 0.5, 0.0, 0.0],[1,1,1,0,0,0],[1.0,1.0,1.0,0.0,0.5,0.0]],    #15  A  B  C A/2 0  0
1407        [[1,2,3,4,0,0],[ 1.0, 1.0, 1.0, 1.0, 0.0, 0.0],[1,1,1,1,0,0],[1.0,1.0,1.0,0.0,0.0,0.0]],    #16  A  B  C  D  0  0
1408        [[1,2,3,0,4,0],[ 1.0, 1.0, 1.0, 0.0, 1.0, 0.0],[1,1,1,0,1,0],[1.0,1.0,1.0,0.0,0.0,0.0]],    #17  A  B  C  0  E  0
1409        [[1,2,3,0,0,4],[ 1.0, 1.0, 1.0, 0.0, 0.0, 1.0],[1,1,1,0,0,1],[1.0,1.0,1.0,0.0,0.0,0.0]],    #18  A  B  C  0  0  F
1410        [[1,1,2,3,4,4],[ 1.0, 1.0, 1.0, 1.0, 1.0,-1.0],[1,0,1,1,1,0],[1.0,1.0,1.0,0.0,0.0,0.0]],    #19  A  A  C  D  E -E
1411        [[1,1,2,3,4,4],[ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],[1,0,1,1,1,0],[1.0,1.0,1.0,0.0,0.0,0.0]],    #20  A  A  C  D  E  E
1412        [[1,2,1,3,4,3],[ 1.0, 1.0, 1.0, 1.0, 1.0,-1.0],[1,1,0,1,1,0],[1.0,1.0,1.0,0.0,0.0,0.0]],    #21  A  B  A  D  E -D
1413        [[1,2,1,3,4,3],[ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],[1,1,0,1,1,0],[1.0,1.0,1.0,0.0,0.0,0.0]],    #22  A  B  A  D  E  D
1414        [[1,2,2,3,3,4],[ 1.0, 1.0, 1.0, 1.0,-1.0, 1.0],[1,1,0,1,0,1],[1.0,1.0,1.0,0.0,0.0,0.0]],    #23  A  B  B  D -D  F
1415        [[1,2,2,3,3,4],[ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],[1,1,0,1,0,1],[1.0,1.0,1.0,0.0,0.0,0.0]],    #24  A  B  B  D  D  F
1416        [[1,2,3,2,4,4],[ 1.0, 1.0, 1.0, 0.5, 0.5, 1.0],[1,1,1,0,0,1],[1.0,1.0,1.0,0.5,0.0,0.0]],    #25  A  B  C B/2 F/2 F
1417        [[1,2,3,1,0,4],[ 1.0, 1.0, 1.0, 0.5, 0.0, 1.0],[1,1,1,0,0,1],[1.0,1.0,1.0,0.5,0.0,0.0]],    #26  A  B  C A/2  0  F
1418        [[1,2,3,2,4,0],[ 1.0, 1.0, 1.0, 0.5, 1.0, 0.0],[1,1,1,0,1,0],[1.0,1.0,1.0,0.5,0.0,0.0]],    #27  A  B  C B/2  E  0
1419        [[1,2,3,1,4,4],[ 1.0, 1.0, 1.0, 0.5, 1.0, 0.5],[1,1,1,0,1,0],[1.0,1.0,1.0,0.5,0.0,0.0]],    #28  A  B  C A/2  E E/2
1420        [[1,2,3,4,5,6],[ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],[1,1,1,1,1,1],[1.0,1.0,1.0,0.0,0.0,0.0]],    #29  A  B  C  D  E   F
1421        ]
1422    indx = GetNXUPQsym(siteSym)
1423    return CSuinel[indx[1]]
1424   
1425def GetSSfxuinel(waveType,nH,XYZ,SGData,SSGData,debug=False):
1426   
1427    def fracCrenel(tau,Toff,Twid):
1428        Tau = (tau-Toff)%1.
1429        A = np.where(Tau<Twid,1.,0.)
1430        return A
1431       
1432    def fracFourier(tau,nH,fsin,fcos):
1433        SA = np.sin(2.*nH*np.pi*tau)
1434        CB = np.cos(2.*nH*np.pi*tau)
1435        A = SA[np.newaxis,np.newaxis,:]*fsin[:,:,np.newaxis]
1436        B = CB[np.newaxis,np.newaxis,:]*fcos[:,:,np.newaxis]
1437        return A+B
1438       
1439    def posFourier(tau,nH,psin,pcos):
1440        SA = np.sin(2*nH*np.pi*tau)
1441        CB = np.cos(2*nH*np.pi*tau)
1442        A = SA[np.newaxis,np.newaxis,:]*psin[:,:,np.newaxis]
1443        B = CB[np.newaxis,np.newaxis,:]*pcos[:,:,np.newaxis]
1444        return A+B   
1445
1446    def posSawtooth(tau,Toff,slopes):
1447        Tau = (tau-Toff[:,np.newaxis])%1.
1448        A = slopes[:,:,np.newaxis]*Tau
1449        return A
1450   
1451    def posZigZag(tau,Toff,slopes):
1452        Tau = (tau-Toff[:,np.newaxis])%1.
1453        A = np.where(Tau <= 0.5,slopes[:,:,np.newaxis]*Tau,slopes[:,:,np.newaxis]*(1.-Tau))
1454        return A
1455       
1456    print 'super space group: ',SSGData['SSpGrp']
1457    CSI = {'Sfrac':[[[1,0],[2,0]],[[1.,0.],[1.,0.]]],
1458        'Spos':[[[1,0,0],[2,0,0],[3,0,0], [4,0,0],[5,0,0],[6,0,0]],
1459            [[1.,0.,0.],[1.,0.,0.],[1.,0.,0.], [1.,0.,0.],[1.,0.,0.],[1.,0.,0.]]],    #sin & cos
1460        'Sadp':[[[1,0,0],[2,0,0],[3,0,0],[4,0,0],[5,0,0],[6,0,0], 
1461            [7,0,0],[8,0,0],[9,0,0],[10,0,0],[11,0,0],[12,0,0]],
1462            [[1.,0.,0.],[1.,0.,0.],[1.,0.,0.], [1.,0.,0.],[1.,0.,0.],[1.,0.,0.],
1463            [1.,0.,0.],[1.,0.,0.],[1.,0.,0.], [1.,0.,0.],[1.,0.,0.],[1.,0.,0.]]],
1464        'Smag':[[[1,0,0],[2,0,0],[3,0,0], [4,0,0],[5,0,0],[6,0,0]],
1465            [[1.,0.,0.],[1.,0.,0.],[1.,0.,0.], [1.,0.,0.],[1.,0.,0.],[1.,0.,0.]]],}
1466    xyz = np.array(XYZ)%1.
1467    xyzt = np.array(XYZ+[0,])%1.
1468    SGOps = copy.deepcopy(SGData['SGOps'])
1469    siteSym = SytSym(XYZ,SGData)[0].strip()
1470    print 'siteSym: ',siteSym
1471    if siteSym == '1':   #"1" site symmetry
1472        if debug:
1473            return CSI,None,None,None,None
1474        else:
1475            return CSI
1476    elif siteSym == '-1':   #"-1" site symmetry
1477        CSI['Sfrac'][0] = [[1,0],[0,0]]
1478        CSI['Spos'][0] = [[1,0,0],[2,0,0],[3,0,0], [0,0,0],[0,0,0],[0,0,0]]
1479        CSI['Sadp'][0] = [[0,0,0],[0,0,0],[0,0,0],[0,0,0],[0,0,0],[0,0,0], 
1480        [1,0,0],[2,0,0],[3,0,0],[4,0,0],[5,0,0],[6,0,0]]
1481        if debug:
1482            return CSI,None,None,None,None
1483        else:
1484            return CSI
1485    SSGOps = copy.deepcopy(SSGData['SSGOps'])
1486    #expand ops to include inversions if any
1487    if SGData['SGInv']:
1488        for op,sop in zip(SGData['SGOps'],SSGData['SSGOps']):
1489            SGOps.append([-op[0],-op[1]%1.])
1490            SSGOps.append([-sop[0],-sop[1]%1.])
1491    #build set of sym ops around special poasition       
1492    SSop = []
1493    Sop = []
1494    Sdtau = []
1495    for iop,Op in enumerate(SGOps):         
1496        nxyz = (np.inner(Op[0],xyz)+Op[1])%1.
1497        if np.allclose(xyz,nxyz,1.e-4) and iop and MT2text(Op).replace(' ','') != '-X,-Y,-Z':
1498            SSop.append(SSGOps[iop])
1499            Sop.append(SGOps[iop])
1500            ssopinv = nl.inv(SSGOps[iop][0])
1501            mst = ssopinv[3][:3]
1502            epsinv = ssopinv[3][3]
1503            Sdtau.append(np.sum(mst*(XYZ-SGOps[iop][1])-epsinv*SSGOps[iop][1][3]))
1504    SdIndx = np.argsort(np.array(Sdtau))     # just to do in sensible order
1505    OpText =  [MT2text(s).replace(' ','') for s in Sop]         #debug?
1506    SSOpText = [SSMT2text(ss).replace(' ','') for ss in SSop]   #debug?
1507    print 'special pos super operators: ',SSOpText
1508    #setup displacement arrays
1509    tau = np.linspace(0,1,49,True)
1510    delt2 = np.eye(2)*0.001
1511    delt4 = np.eye(4)*0.001
1512    delt6 = np.eye(6)*0.001
1513    delt12 = np.eye(12)*0.0001
1514    #make modulation arrays - one parameter at a time
1515    #site fractions
1516    CSI['Sfrac'] = [np.zeros((2),dtype='i'),np.ones(2)]
1517    if 'Crenel' in waveType:
1518        dF = fracCrenel(tau,delt2[:1],delt2[1:]).squeeze()
1519    else:
1520        dF = fracFourier(tau,nH,delt2[:1],delt2[1:]).squeeze()
1521    dFT = np.zeros_like(dF)
1522    #positions       
1523    if 'Fourier' in waveType:
1524        dX = posFourier(tau,nH,delt6[:3],delt6[3:]) #+np.array(XYZ)[:,np.newaxis,np.newaxis]
1525          #3x6x12 modulated position array (X,Spos,tau)& force positive
1526        CSI['Spos'] = [np.zeros((6,3),dtype='i'),np.zeros((6,3))]
1527    elif waveType == 'Sawtooth':
1528        CSI['Spos'] = [np.array([[1,],[2,],[3,],[4,]]),np.array([[1.0,],[1.0,],[1.0,],[1.0,]])]
1529    elif waveType == 'ZigZag':
1530        CSI['Spos'] = [np.array([[1,],[2,],[3,],[4,]]),np.array([[1.0,],[1.0,],[1.0,],[1.0,]])]
1531    #anisotropic thermal motion
1532    dU = posFourier(tau,nH,delt12[:6],delt12[6:])                  #Uij modulations - 6x12x12 array
1533    CSI['Sadp'] = [np.zeros((12,3),dtype='i'),np.zeros((12,3))]
1534       
1535    FSC = np.ones(2,dtype='i')
1536    VFSC = np.ones(2)
1537    XSC = np.ones(6,dtype='i')
1538    USC = np.ones(12,dtype='i')
1539    dFTP = []
1540    dXTP = []
1541    dUTP = []
1542    for i in SdIndx:
1543        sop = Sop[i]
1544        ssop = SSop[i]
1545        fsc = np.ones(2,dtype='i')
1546        xsc = np.ones(6,dtype='i')
1547        ssopinv = nl.inv(ssop[0])
1548        mst = ssopinv[3][:3]
1549        epsinv = ssopinv[3][3]
1550        sdet = nl.det(sop[0])
1551        ssdet = nl.det(ssop[0])
1552        dtau = mst*(XYZ-sop[1])-epsinv*ssop[1][3]
1553        dT = 1.0
1554        if np.any(dtau%.5):
1555            dT = np.tan(np.pi*np.sum(dtau%.5))
1556        tauT = np.inner(mst,XYZ-sop[1])+epsinv*(tau-ssop[1][3])
1557        if waveType == 'Fourier':
1558            dXT = posFourier(np.sort(tauT),nH,delt6[:3],delt6[3:])   #+np.array(XYZ)[:,np.newaxis,np.newaxis]
1559        elif waveType == 'Sawtooth':
1560            dXT = posSawtooth(tauT,delt4[0],delt4[1:])+np.array(XYZ)[:,np.newaxis,np.newaxis]
1561        elif waveType == 'ZigZag':
1562            dXT = posZigZag(tauT,delt4[0],delt4[1:])+np.array(XYZ)[:,np.newaxis,np.newaxis]           
1563        dXT = np.inner(sop[0],dXT.T)
1564        dXT = np.swapaxes(dXT,1,2)
1565        dXT[:,:3,:] *= ssdet
1566        dXTP.append(dXT)
1567        if waveType == 'Fourier':
1568            if np.any(dtau%.5) and ('1/2' in SSGData['modSymb'] or '1' in SSGData['modSymb']):
1569                CSI['Spos'] = [[[1,0,0],[2,0,0],[3,0,0], [1,0,0],[2,0,0],[3,0,0]],
1570                    [[1.,0.,0.],[1.,0.,0.],[1.,0.,0.], [1.,0.,0.],[1.,0.,0.],[1.,0.,0.]]]                   
1571                if '(x)' in siteSym:
1572                    CSI['Spos'][1][3:] = [1./dT,0.,0.],[-dT,0.,0.],[-dT,0.,0.]
1573                    if 'm' in siteSym and len(SdIndx) == 1:
1574                        CSI['Spos'][1][3:] = [-dT,0.,0.],[1./dT,0.,0.],[1./dT,0.,0.]
1575                elif '(y)' in siteSym:
1576                    CSI['Spos'][1][3:] = [-dT,0.,0.],[1./dT,0.,0.],[-dT,0.,0.]
1577                    if 'm' in siteSym and len(SdIndx) == 1:
1578                        CSI['Spos'][1][3:] = [1./dT,0.,0.],[-dT,0.,0.],[1./dT,0.,0.]
1579                elif '(z)' in siteSym:
1580                    CSI['Spos'][1][3:] = [-dT,0.,0.],[-dT,0.,0.],[1./dT,0.,0.]
1581                    if 'm' in siteSym and len(SdIndx) == 1:
1582                        CSI['Spos'][1][3:] = [1./dT,0.,0.],[1./dT,0.,0.],[-dT,0.,0.]
1583                for i in range(3):
1584                    if not XSC[i]:
1585                        CSI['Spos'][0][i] = [0,0,0]
1586                        CSI['Spos'][1][i] = [0.,0.,0.]
1587                        CSI['Spos'][0][i+3] = [0,0,0]
1588                        CSI['Spos'][1][i+3] = [0.,0.,0.]
1589            else:
1590                for i in range(3):
1591                    if np.allclose(dX[i,i,:],dXT[i,i,:]*sdet):
1592                        xsc[i] = 1
1593                    else:
1594                        xsc[i] = 0
1595                    if np.allclose(dX[i,i+3,:],dXT[i,i+3,:]):
1596                        xsc[i+3] = 1
1597                    else:
1598                        xsc[i+3] = 0
1599            XSC &= xsc
1600           
1601        fsc = np.ones(2,dtype='i')
1602        if 'Crenel' in waveType:
1603            dFT = fracCrenel(tauT,delt2[:1],delt2[1:]).squeeze()
1604            fsc = [1,1]
1605        else:
1606            dFT = fracFourier(tauT,nH,delt2[:1],delt2[1:]).squeeze()
1607            dFT = nl.det(sop[0])*dFT
1608            dFT = dFT[:,np.argsort(tauT)]
1609            dFT[0] *= ssdet
1610            dFT[1] *= sdet
1611            dFTP.append(dFT)
1612       
1613            if np.any(dtau%.5) and ('1/2' in SSGData['modSymb'] or '1' in SSGData['modSymb']):
1614                fsc = [1,1]
1615                CSI['Sfrac'] = [[[1,0],[1,0]],[[1.,0.],[1/dT,0.]]]
1616                for i in range(2):
1617                    if not FSC[i]:
1618                        CSI['Sfrac'][0][i] = [0,0]
1619                        CSI['Sfrac'][1][i] = [0.,0.]
1620            else:
1621                for i in range(2):
1622                    if np.allclose(dF[i,:],dFT[i,:],atol=1.e-6):
1623                        fsc[i] = 1
1624                    else:
1625                        fsc[i] = 0
1626        FSC &= fsc
1627           
1628        usc = np.ones(12,dtype='i')
1629        dUT = posFourier(tauT,nH,delt12[:6],delt12[6:])                  #Uij modulations - 6x12x49 array
1630        dUijT = np.rollaxis(np.rollaxis(np.array(Uij2U(dUT)),3),3)    #convert dUT to 12x49x3x3
1631        dUijT = np.rollaxis(np.inner(np.inner(sop[0],dUijT),sop[0].T),3)
1632        dUT = np.array(U2Uij(dUijT))
1633        dUT = dUT[:,:,np.argsort(tauT)]
1634        dUTP.append(dUT)
1635        if np.any(dtau%.5) and ('1/2' in SSGData['modSymb'] or '1' in SSGData['modSymb']):
1636            CSI['Sadp'] = [[[1,0,0],[2,0,0],[3,0,0],[4,0,0],[5,0,0],[6,0,0], 
1637            [1,0,0],[2,0,0],[3,0,0],[4,0,0],[5,0,0],[6,0,0]],
1638            [[1.,0.,0.],[1.,0.,0.],[1.,0.,0.], [1.,0.,0.],[1.,0.,0.],[1.,0.,0.],
1639            [1./dT,0.,0.],[1./dT,0.,0.],[1./dT,0.,0.], [1.,0.,0.],[1.,0.,0.],[1.,0.,0.]]]
1640            if '(x)' in siteSym:
1641                CSI['Sadp'][1][9:] = [-dT,0.,0.],[-dT,0.,0.],[1./dT,0.,0.]
1642            elif '(y)' in siteSym:
1643                CSI['Sadp'][1][9:] = [-dT,0.,0.],[1./dT,0.,0.],[-dT,0.,0.]
1644            elif '(z)' in siteSym:
1645                CSI['Sadp'][1][9:] = [1./dT,0.,0.],[-dT,0.,0.],[-dT,0.,0.]
1646            for i in range(6):
1647                if not USC[i]:
1648                    CSI['Sadp'][0][i] = [0,0,0]
1649                    CSI['Sadp'][1][i] = [0.,0.,0.]
1650                    CSI['Sadp'][0][i+6] = [0,0,0]
1651                    CSI['Sadp'][1][i+6] = [0.,0.,0.]
1652        else:
1653                       
1654            for i in range(6):
1655                if np.allclose(dU[i,i,:],dUT[i,i,:]*sdet):
1656                    usc[i] = 1
1657                else:
1658                    usc[i] = 0
1659                if np.allclose(dU[i,i+6,:],dUT[i,i+6,:]):
1660                    usc[i+6] = 1
1661                else:
1662                    usc[i+6] = 0
1663            if '4/m' in siteSym and np.any(dUT[0,1,:]):
1664                CSI['Sadp'][0][6:8] = [[12,0,0],[12,0,0]]
1665                if ssop[1][3]:
1666                    CSI['Sadp'][1][6:8] = [[1.,0.,0.],[-1.,0.,0.]]
1667                    usc[9] = 1
1668                else:
1669                    CSI['Sadp'][1][6:8] = [[1.,0.,0.],[1.,0.,0.]]
1670                    usc[9] = 0
1671            elif '4' in siteSym and np.any(dUT[0,1,:]):
1672                CSI['Sadp'][0][6:8] = [[12,0,0],[12,0,0]]
1673                CSI['Sadp'][0][:2] = [[11,0,0],[11,0,0]]
1674                if ssop[1][3]:
1675                    CSI['Sadp'][1][:2] = [[1.,0.,0.],[-1.,0.,0.]]
1676                    CSI['Sadp'][1][6:8] = [[1.,0.,0.],[-1.,0.,0.]]
1677                    usc[3] = 1
1678                    usc[9] = 1
1679                else:
1680                    CSI['Sadp'][1][:2] = [[1.,0.,0.],[1.,0.,0.]]
1681                    CSI['Sadp'][1][6:8] = [[1.,0.,0.],[1.,0.,0.]]
1682                    usc[3] = 0               
1683                    usc[9] = 0
1684            print SSMT2text(ssop).replace(' ',''),sdet,ssdet,epsinv,usc
1685        USC &= usc
1686    if not np.any(dtau%.5):
1687        n = -1
1688        for i,U in enumerate(USC):
1689            if U:
1690                n += 1
1691                CSI['Sadp'][0][i][0] = n+1
1692                CSI['Sadp'][1][i][0] = 1.0
1693        if waveType == 'Fourier':
1694            n = -1
1695            for i,X in enumerate(XSC):
1696                if X:
1697                    n += 1
1698                    CSI['Spos'][0][i][0] = n+1
1699                    CSI['Spos'][1][i][0] = 1.0
1700        n = -1
1701        for i,F in enumerate(FSC):
1702            if F:
1703                n += 1
1704                CSI['Sfrac'][0][i] = n+1
1705                CSI['Sfrac'][1][i] = 1.0
1706            else:
1707                CSI['Sfrac'][0][i] = 0
1708                CSI['Sfrac'][1][i] = 0.           
1709    if debug:
1710        return CSI,[tau,tauT],[dF,dFTP],[dX,dXTP],[dU,dUTP]
1711    else:
1712        return CSI
1713   
1714def MustrainNames(SGData):
1715    'Needs a doc string'
1716    laue = SGData['SGLaue']
1717    uniq = SGData['SGUniq']
1718    if laue in ['m3','m3m']:
1719        return ['S400','S220']
1720    elif laue in ['6/m','6/mmm','3m1']:
1721        return ['S400','S004','S202']
1722    elif laue in ['31m','3']:
1723        return ['S400','S004','S202','S211']
1724    elif laue in ['3R','3mR']:
1725        return ['S400','S220','S310','S211']
1726    elif laue in ['4/m','4/mmm']:
1727        return ['S400','S004','S220','S022']
1728    elif laue in ['mmm']:
1729        return ['S400','S040','S004','S220','S202','S022']
1730    elif laue in ['2/m']:
1731        SHKL = ['S400','S040','S004','S220','S202','S022']
1732        if uniq == 'a':
1733            SHKL += ['S013','S031','S211']
1734        elif uniq == 'b':
1735            SHKL += ['S301','S103','S121']
1736        elif uniq == 'c':
1737            SHKL += ['S130','S310','S112']
1738        return SHKL
1739    else:
1740        SHKL = ['S400','S040','S004','S220','S202','S022']
1741        SHKL += ['S310','S103','S031','S130','S301','S013']
1742        SHKL += ['S211','S121','S112']
1743        return SHKL
1744       
1745def HStrainVals(HSvals,SGData):
1746    laue = SGData['SGLaue']
1747    uniq = SGData['SGUniq']
1748    DIJ = np.zeros(6)
1749    if laue in ['m3','m3m']:
1750        DIJ[:3] = [HSvals[0],HSvals[0],HSvals[0]]
1751    elif laue in ['6/m','6/mmm','3m1','31m','3']:
1752        DIJ[:4] = [HSvals[0],HSvals[0],HSvals[1],HSvals[0]]
1753    elif laue in ['3R','3mR']:
1754        DIJ = [HSvals[0],HSvals[0],HSvals[0],HSvals[1],HSvals[1],HSvals[1]]
1755    elif laue in ['4/m','4/mmm']:
1756        DIJ[:3] = [HSvals[0],HSvals[0],HSvals[1]]
1757    elif laue in ['mmm']:
1758        DIJ[:3] = [HSvals[0],HSvals[1],HSvals[2]]
1759    elif laue in ['2/m']:
1760        DIJ[:3] = [HSvals[0],HSvals[1],HSvals[2]]
1761        if uniq == 'a':
1762            DIJ[5] = HSvals[3]
1763        elif uniq == 'b':
1764            DIJ[4] = HSvals[3]
1765        elif uniq == 'c':
1766            DIJ[3] = HSvals[3]
1767    else:
1768        DIJ = [HSvals[0],HSvals[1],HSvals[2],HSvals[3],HSvals[4],HSvals[5]]
1769    return DIJ
1770
1771def HStrainNames(SGData):
1772    'Needs a doc string'
1773    laue = SGData['SGLaue']
1774    uniq = SGData['SGUniq']
1775    if laue in ['m3','m3m']:
1776        return ['D11','eA']         #add cubic strain term
1777    elif laue in ['6/m','6/mmm','3m1','31m','3']:
1778        return ['D11','D33']
1779    elif laue in ['3R','3mR']:
1780        return ['D11','D12']
1781    elif laue in ['4/m','4/mmm']:
1782        return ['D11','D33']
1783    elif laue in ['mmm']:
1784        return ['D11','D22','D33']
1785    elif laue in ['2/m']:
1786        Dij = ['D11','D22','D33']
1787        if uniq == 'a':
1788            Dij += ['D23']
1789        elif uniq == 'b':
1790            Dij += ['D13']
1791        elif uniq == 'c':
1792            Dij += ['D12']
1793        return Dij
1794    else:
1795        Dij = ['D11','D22','D33','D12','D13','D23']
1796        return Dij
1797   
1798def MustrainCoeff(HKL,SGData):
1799    'Needs a doc string'
1800    #NB: order of terms is the same as returned by MustrainNames
1801    laue = SGData['SGLaue']
1802    uniq = SGData['SGUniq']
1803    h,k,l = HKL
1804    Strm = []
1805    if laue in ['m3','m3m']:
1806        Strm.append(h**4+k**4+l**4)
1807        Strm.append(3.0*((h*k)**2+(h*l)**2+(k*l)**2))
1808    elif laue in ['6/m','6/mmm','3m1']:
1809        Strm.append(h**4+k**4+2.0*k*h**3+2.0*h*k**3+3.0*(h*k)**2)
1810        Strm.append(l**4)
1811        Strm.append(3.0*((h*l)**2+(k*l)**2+h*k*l**2))
1812    elif laue in ['31m','3']:
1813        Strm.append(h**4+k**4+2.0*k*h**3+2.0*h*k**3+3.0*(h*k)**2)
1814        Strm.append(l**4)
1815        Strm.append(3.0*((h*l)**2+(k*l)**2+h*k*l**2))
1816        Strm.append(4.0*h*k*l*(h+k))
1817    elif laue in ['3R','3mR']:
1818        Strm.append(h**4+k**4+l**4)
1819        Strm.append(3.0*((h*k)**2+(h*l)**2+(k*l)**2))
1820        Strm.append(2.0*(h*l**3+l*k**3+k*h**3)+2.0*(l*h**3+k*l**3+l*k**3))
1821        Strm.append(4.0*(k*l*h**2+h*l*k**2+h*k*l**2))
1822    elif laue in ['4/m','4/mmm']:
1823        Strm.append(h**4+k**4)
1824        Strm.append(l**4)
1825        Strm.append(3.0*(h*k)**2)
1826        Strm.append(3.0*((h*l)**2+(k*l)**2))
1827    elif laue in ['mmm']:
1828        Strm.append(h**4)
1829        Strm.append(k**4)
1830        Strm.append(l**4)
1831        Strm.append(3.0*(h*k)**2)
1832        Strm.append(3.0*(h*l)**2)
1833        Strm.append(3.0*(k*l)**2)
1834    elif laue in ['2/m']:
1835        Strm.append(h**4)
1836        Strm.append(k**4)
1837        Strm.append(l**4)
1838        Strm.append(3.0*(h*k)**2)
1839        Strm.append(3.0*(h*l)**2)
1840        Strm.append(3.0*(k*l)**2)
1841        if uniq == 'a':
1842            Strm.append(2.0*k*l**3)
1843            Strm.append(2.0*l*k**3)
1844            Strm.append(4.0*k*l*h**2)
1845        elif uniq == 'b':
1846            Strm.append(2.0*l*h**3)
1847            Strm.append(2.0*h*l**3)
1848            Strm.append(4.0*h*l*k**2)
1849        elif uniq == 'c':
1850            Strm.append(2.0*h*k**3)
1851            Strm.append(2.0*k*h**3)
1852            Strm.append(4.0*h*k*l**2)
1853    else:
1854        Strm.append(h**4)
1855        Strm.append(k**4)
1856        Strm.append(l**4)
1857        Strm.append(3.0*(h*k)**2)
1858        Strm.append(3.0*(h*l)**2)
1859        Strm.append(3.0*(k*l)**2)
1860        Strm.append(2.0*k*h**3)
1861        Strm.append(2.0*h*l**3)
1862        Strm.append(2.0*l*k**3)
1863        Strm.append(2.0*h*k**3)
1864        Strm.append(2.0*l*h**3)
1865        Strm.append(2.0*k*l**3)
1866        Strm.append(4.0*k*l*h**2)
1867        Strm.append(4.0*h*l*k**2)
1868        Strm.append(4.0*k*h*l**2)
1869    return Strm
1870   
1871def Muiso2Shkl(muiso,SGData,cell):
1872    "this is to convert isotropic mustrain to generalized Shkls"
1873    import GSASIIlattice as G2lat
1874    A = G2lat.cell2AB(cell)[0]
1875   
1876    def minMus(Shkl,muiso,H,SGData,A):
1877        U = np.inner(A.T,H)
1878        S = np.array(MustrainCoeff(U,SGData))
1879        Sum = np.sqrt(np.sum(np.multiply(S,Shkl[:,np.newaxis]),axis=0))
1880        rad = np.sqrt(np.sum((Sum[:,np.newaxis]*H)**2,axis=1))
1881        return (muiso-rad)**2
1882       
1883    laue = SGData['SGLaue']
1884    PHI = np.linspace(0.,360.,60,True)
1885    PSI = np.linspace(0.,180.,60,True)
1886    X = np.outer(npsind(PHI),npsind(PSI))
1887    Y = np.outer(npcosd(PHI),npsind(PSI))
1888    Z = np.outer(np.ones(np.size(PHI)),npcosd(PSI))
1889    HKL = np.dstack((X,Y,Z))
1890    if laue in ['m3','m3m']:
1891        S0 = [1000.,1000.]
1892    elif laue in ['6/m','6/mmm','3m1']:
1893        S0 = [1000.,1000.,1000.]
1894    elif laue in ['31m','3']:
1895        S0 = [1000.,1000.,1000.,1000.]
1896    elif laue in ['3R','3mR']:
1897        S0 = [1000.,1000.,1000.,1000.]
1898    elif laue in ['4/m','4/mmm']:
1899        S0 = [1000.,1000.,1000.,1000.]
1900    elif laue in ['mmm']:
1901        S0 = [1000.,1000.,1000.,1000.,1000.,1000.]
1902    elif laue in ['2/m']:
1903        S0 = [1000.,1000.,1000.,0.,0.,0.,0.,0.,0.]
1904    else:
1905        S0 = [1000.,1000.,1000.,1000.,1000., 1000.,1000.,1000.,1000.,1000., 
1906            1000.,1000.,0.,0.,0.]
1907    S0 = np.array(S0)
1908    HKL = np.reshape(HKL,(-1,3))
1909    result = so.leastsq(minMus,S0,(np.ones(HKL.shape[0])*muiso,HKL,SGData,A))
1910    return result[0]
1911       
1912def SytSym(XYZ,SGData):
1913    '''
1914    Generates the number of equivalent positions and a site symmetry code for a specified coordinate and space group
1915
1916    :param XYZ: an array, tuple or list containing 3 elements: x, y & z
1917    :param SGData: from SpcGroup
1918    :Returns: a two element tuple:
1919
1920     * The 1st element is a code for the site symmetry (see GetKNsym)
1921     * The 2nd element is the site multiplicity
1922
1923    '''
1924    def PackRot(SGOps):
1925        IRT = []
1926        for ops in SGOps:
1927            M = ops[0]
1928            irt = 0
1929            for j in range(2,-1,-1):
1930                for k in range(2,-1,-1):
1931                    irt *= 3
1932                    irt += M[k][j]
1933            IRT.append(int(irt))
1934        return IRT
1935       
1936    SymName = ''
1937    Mult = 1
1938    Isym = 0
1939    if SGData['SGLaue'] in ['3','3m1','31m','6/m','6/mmm']:
1940        Isym = 1073741824
1941    Jdup = 0
1942    Xeqv = GenAtom(XYZ,SGData,True)
1943    IRT = PackRot(SGData['SGOps'])
1944    L = -1
1945    for ic,cen in enumerate(SGData['SGCen']):
1946        for invers in range(int(SGData['SGInv']+1)):
1947            for io,ops in enumerate(SGData['SGOps']):
1948                irtx = (1-2*invers)*IRT[io]
1949                L += 1
1950                if not Xeqv[L][1]:
1951                    Jdup += 1
1952                    jx = GetOprPtrName(str(irtx))
1953                    if jx[2] < 39:
1954                        Isym += 2**(jx[2]-1)
1955    if Isym == 1073741824: Isym = 0
1956    Mult = len(SGData['SGOps'])*len(SGData['SGCen'])*(int(SGData['SGInv'])+1)/Jdup
1957         
1958    return GetKNsym(str(Isym)),Mult
1959   
1960def ElemPosition(SGData):
1961    ''' Under development.
1962    Object here is to return a list of symmetry element types and locations suitable
1963    for say drawing them.
1964    So far I have the element type... getting all possible locations without lookup may be impossible!
1965    '''
1966    SymElements = []
1967    Inv = SGData['SGInv']
1968    Cen = SGData['SGCen']
1969    eleSym = {-3:['','-1'],-2:['',-6],-1:['2','-4'],0:['3','-3'],1:['4','m'],2:['6',''],3:['1','']}
1970    # get operators & expand if centrosymmetric
1971    Ops = SGData['SGOps']
1972    opM = np.array([op[0].T for op in Ops])
1973    opT = np.array([op[1] for op in Ops])
1974    if Inv:
1975        opM = np.concatenate((opM,-opM))
1976        opT = np.concatenate((opT,-opT))
1977    opMT = zip(opM,opT)
1978    for M,T in opMT[1:]:        #skip I
1979        Dt = int(nl.det(M))
1980        Tr = int(np.trace(M))
1981        Dt = -(Dt-1)/2
1982        Es = eleSym[Tr][Dt]
1983        if Dt:              #rotation-inversion
1984            I = np.eye(3)
1985            if Tr == 1:     #mirrors/glides
1986                if np.any(T):       #glide
1987                    M2 = np.inner(M,M)
1988                    MT = np.inner(M,T)+T
1989                    print 'glide',Es,MT
1990                    print M2
1991                else:               #mirror
1992                    print 'mirror',Es,T
1993                    print I-M
1994                X = [-1,-1,-1]
1995            elif Tr == -3:  # pure inversion
1996                X = np.inner(nl.inv(I-M),T)
1997                print 'inversion',Es,X
1998            else:           #other rotation-inversion
1999                M2 = np.inner(M,M)
2000                MT = np.inner(M,T)+T
2001                print 'rot-inv',Es,MT
2002                print M2
2003                X = [-1,-1,-1]
2004        else:               #rotations
2005            print 'rotation',Es
2006            X = [-1,-1,-1]
2007        #SymElements.append([Es,X])
2008       
2009    return #SymElements
2010   
2011def ApplyStringOps(A,SGData,X,Uij=[]):
2012    'Needs a doc string'
2013    SGOps = SGData['SGOps']
2014    SGCen = SGData['SGCen']
2015    Ax = A.split('+')
2016    Ax[0] = int(Ax[0])
2017    iC = 0
2018    if Ax[0] < 0:
2019        iC = 1
2020    Ax[0] = abs(Ax[0])
2021    nA = Ax[0]%100-1
2022    cA = Ax[0]/100
2023    Cen = SGCen[cA]
2024    M,T = SGOps[nA]
2025    if len(Ax)>1:
2026        cellA = Ax[1].split(',')
2027        cellA = np.array([int(a) for a in cellA])
2028    else:
2029        cellA = np.zeros(3)
2030    newX = (1-2*iC)*(Cen+np.inner(M,X)+T)+cellA
2031    if len(Uij):
2032        U = Uij2U(Uij)
2033        U = np.inner(M,np.inner(U,M).T)
2034        newUij = U2Uij(U)
2035        return [newX,newUij]
2036    else:
2037        return newX
2038       
2039def StringOpsProd(A,B,SGData):
2040    """
2041    Find A*B where A & B are in strings '-' + '100*c+n' + '+ijk'
2042    where '-' indicates inversion, c(>0) is the cell centering operator,
2043    n is operator number from SgOps and ijk are unit cell translations (each may be <0).
2044    Should return resultant string - C. SGData - dictionary using entries:
2045
2046       *  'SGCen': cell centering vectors [0,0,0] at least
2047       *  'SGOps': symmetry operations as [M,T] so that M*x+T = x'
2048
2049    """
2050    SGOps = SGData['SGOps']
2051    SGCen = SGData['SGCen']
2052    #1st split out the cell translation part & work on the operator parts
2053    Ax = A.split('+'); Bx = B.split('+')
2054    Ax[0] = int(Ax[0]); Bx[0] = int(Bx[0])
2055    iC = 0
2056    if Ax[0]*Bx[0] < 0:
2057        iC = 1
2058    Ax[0] = abs(Ax[0]); Bx[0] = abs(Bx[0])
2059    nA = Ax[0]%100-1;  nB = Bx[0]%100-1
2060    cA = Ax[0]/100;  cB = Bx[0]/100
2061    Cen = (SGCen[cA]+SGCen[cB])%1.0
2062    cC = np.nonzero([np.allclose(C,Cen) for C in SGCen])[0][0]
2063    Ma,Ta = SGOps[nA]; Mb,Tb = SGOps[nB]
2064    Mc = np.inner(Ma,Mb.T)
2065#    print Ma,Mb,Mc
2066    Tc = (np.add(np.inner(Mb,Ta)+1.,Tb))%1.0
2067#    print Ta,Tb,Tc
2068#    print [np.allclose(M,Mc)&np.allclose(T,Tc) for M,T in SGOps]
2069    nC = np.nonzero([np.allclose(M,Mc)&np.allclose(T,Tc) for M,T in SGOps])[0][0]
2070    #now the cell translation part
2071    if len(Ax)>1:
2072        cellA = Ax[1].split(',')
2073        cellA = [int(a) for a in cellA]
2074    else:
2075        cellA = [0,0,0]
2076    if len(Bx)>1:
2077        cellB = Bx[1].split(',')
2078        cellB = [int(b) for b in cellB]
2079    else:
2080        cellB = [0,0,0]
2081    cellC = np.add(cellA,cellB)
2082    C = str(((nC+1)+(100*cC))*(1-2*iC))+'+'+ \
2083        str(int(cellC[0]))+','+str(int(cellC[1]))+','+str(int(cellC[2]))
2084    return C
2085           
2086def U2Uij(U):
2087    #returns the UIJ vector U11,U22,U33,U12,U13,U23 from tensor U
2088    return [U[0][0],U[1][1],U[2][2],2.*U[0][1],2.*U[0][2],2.*U[1][2]]
2089   
2090def Uij2U(Uij):
2091    #returns the thermal motion tensor U from Uij as numpy array
2092    return np.array([[Uij[0],Uij[3]/2.,Uij[4]/2.],[Uij[3]/2.,Uij[1],Uij[5]/2.],[Uij[4]/2.,Uij[5]/2.,Uij[2]]])
2093
2094def StandardizeSpcName(spcgroup):
2095    '''Accept a spacegroup name where spaces may have not been used
2096    in the names according to the GSAS convention (spaces between symmetry
2097    for each axis) and return the space group name as used in GSAS
2098    '''
2099    rspc = spcgroup.replace(' ','').upper()
2100    # deal with rhombohedral and hexagonal setting designations
2101    rhomb = ''
2102    if rspc[-1:] == 'R':
2103        rspc = rspc[:-1]
2104        rhomb = ' R'
2105    elif rspc[-1:] == 'H': # hexagonal is assumed and thus can be ignored
2106        rspc = rspc[:-1]
2107    # look for a match in the spacegroup lists
2108    for i in spglist.values():
2109        for spc in i:
2110            if rspc == spc.replace(' ','').upper():
2111                return spc + rhomb
2112    # how about the post-2002 orthorhombic names?
2113    for i,spc in sgequiv_2002_orthorhombic:
2114        if rspc == i.replace(' ','').upper():
2115            return spc
2116    # not found
2117    return ''
2118
2119   
2120spglist = {}
2121'''A dictionary of space groups as ordered and named in the pre-2002 International
2122Tables Volume A, except that spaces are used following the GSAS convention to
2123separate the different crystallographic directions.
2124Note that the symmetry codes here will recognize many non-standard space group
2125symbols with different settings. They are ordered by Laue group
2126'''
2127spglist = {
2128    'P1' : ('P 1','P -1',), # 1-2
2129    'P2/m': ('P 2','P 21','P m','P a','P c','P n',
2130        'P 2/m','P 21/m','P 2/c','P 2/a','P 2/n','P 21/c','P 21/a','P 21/n',), #3-15
2131    'C2/m':('C 2','C m','C c','C n',
2132        'C 2/m','C 2/c','C 2/n',),
2133    'Pmmm':('P 2 2 2',
2134        'P 2 2 21','P 21 2 2','P 2 21 2',
2135        'P 21 21 2','P 2 21 21','P 21 2 21',
2136        'P 21 21 21',
2137        'P m m 2','P 2 m m','P m 2 m',
2138        'P m c 21','P 21 m a','P b 21 m','P m 21 b','P c m 21','P 21 a m',
2139        'P c c 2','P 2 a a','P b 2 b',
2140        'P m a 2','P 2 m b','P c 2 m','P m 2 a','P b m 2','P 2 c m',
2141        'P c a 21','P 21 a b','P c 21 b','P b 21 a','P b c 21','P 21 c a',
2142        'P n c 2','P 2 n a','P b 2 n','P n 2 b','P c n 2','P 2 a n',
2143        'P m n 21','P 21 m n','P n 21 m','P m 21 n','P n m 21','P 21 n m',
2144        'P b a 2','P 2 c b','P c 2 a',
2145        'P n a 21','P 21 n b','P c 21 n','P n 21 a','P b n 21','P 21 c n',
2146        'P n n 2','P 2 n n','P n 2 n',
2147        'P m m m','P n n n',
2148        'P c c m','P m a a','P b m b',
2149        'P b a n','P n c b','P c n a',
2150        'P m m a','P b m m','P m c m','P m a m','P m m b','P c m m',
2151        'P n n a','P b n n','P n c n','P n a n','P n n b','P c n n',
2152        'P m n a','P b m n','P n c m','P m a n','P n m b','P c n m',
2153        'P c c a','P b a a','P b c b','P b a b','P c c b','P c a a',
2154        'P b a m','P m c b','P c m a',
2155        'P c c n','P n a a','P b n b',
2156        'P b c m','P m c a','P b m a','P c m b','P c a m','P m a b',
2157        'P n n m','P m n n','P n m n',
2158        'P m m n','P n m m','P m n m',
2159        'P b c n','P n c a','P b n a','P c n b','P c a n','P n a b',
2160        'P b c a','P c a b',
2161        'P n m a','P b n m','P m c n','P n a m','P m n b','P c m n',
2162        ),
2163    'Cmmm':('C 2 2 21','C 2 2 2','C m m 2',
2164        'C m c 21','C c m 21','C c c 2','C m 2 m','C 2 m m',
2165        'C m 2 a','C 2 m b','C c 2 m','C 2 c m','C c 2 a','C 2 c b',
2166        'C m c m','C m c a','C c m b',
2167        'C m m m','C c c m','C m m a','C m m b','C c c a','C c c b',),
2168    'Immm':('I 2 2 2','I 21 21 21',
2169        'I m m 2','I m 2 m','I 2 m m',
2170        'I b a 2','I 2 c b','I c 2 a',
2171        'I m a 2','I 2 m b','I c 2 m','I m 2 a','I b m 2','I 2 c m',
2172        'I m m m','I b a m','I m c b','I c m a',
2173        'I b c a','I c a b',
2174        'I m m a','I b m m ','I m c m','I m a m','I m m b','I c m m',),
2175    'Fmmm':('F 2 2 2','F m m m', 'F d d d',
2176        'F m m 2','F m 2 m','F 2 m m',
2177        'F d d 2','F d 2 d','F 2 d d',),
2178    'P4/mmm':('P 4','P 41','P 42','P 43','P -4','P 4/m','P 42/m','P 4/n','P 42/n',
2179        'P 4 2 2','P 4 21 2','P 41 2 2','P 41 21 2','P 42 2 2',
2180        'P 42 21 2','P 43 2 2','P 43 21 2','P 4 m m','P 4 b m','P 42 c m',
2181        'P 42 n m','P 4 c c','P 4 n c','P 42 m c','P 42 b c','P -4 2 m',
2182        'P -4 2 c','P -4 21 m','P -4 21 c','P -4 m 2','P -4 c 2','P -4 b 2',
2183        'P -4 n 2','P 4/m m m','P 4/m c c','P 4/n b m','P 4/n n c','P 4/m b m',
2184        'P 4/m n c','P 4/n m m','P 4/n c c','P 42/m m c','P 42/m c m',
2185        'P 42/n b c','P 42/n n m','P 42/m b c','P 42/m n m','P 42/n m c',
2186        'P 42/n c m',),
2187    'I4/mmm':('I 4','I 41','I -4','I 4/m','I 41/a','I 4 2 2','I 41 2 2','I 4 m m',
2188        'I 4 c m','I 41 m d','I 41 c d',
2189        'I -4 m 2','I -4 c 2','I -4 2 m','I -4 2 d','I 4/m m m','I 4/m c m',
2190        'I 41/a m d','I 41/a c d'),
2191    'R3-H':('R 3','R -3','R 3 2','R 3 m','R 3 c','R -3 m','R -3 c',),
2192    'P6/mmm': ('P 3','P 31','P 32','P -3','P 3 1 2','P 3 2 1','P 31 1 2',
2193        'P 31 2 1','P 32 1 2','P 32 2 1', 'P 3 m 1','P 3 1 m','P 3 c 1',
2194        'P 3 1 c','P -3 1 m','P -3 1 c','P -3 m 1','P -3 c 1','P 6','P 61',
2195        'P 65','P 62','P 64','P 63','P -6','P 6/m','P 63/m','P 6 2 2',
2196        'P 61 2 2','P 65 2 2','P 62 2 2','P 64 2 2','P 63 2 2','P 6 m m',
2197        'P 6 c c','P 63 c m','P 63 m c','P -6 m 2','P -6 c 2','P -6 2 m',
2198        'P -6 2 c','P 6/m m m','P 6/m c c','P 63/m c m','P 63/m m c',),
2199    'Pm3m': ('P 2 3','P 21 3','P m 3','P n 3','P a 3','P 4 3 2','P 42 3 2',
2200        'P 43 3 2','P 41 3 2','P -4 3 m','P -4 3 n','P m 3 m','P n 3 n',
2201        'P m 3 n','P n 3 m',),
2202    'Im3m':('I 2 3','I 21 3','I m -3','I a -3', 'I 4 3 2','I 41 3 2',
2203        'I -4 3 m', 'I -4 3 d','I m -3 m','I m 3 m','I a -3 d',),
2204    'Fm3m':('F 2 3','F m -3','F d -3','F 4 3 2','F 41 3 2','F -4 3 m',
2205        'F -4 3 c','F m -3 m','F m 3 m','F m -3 c','F d -3 m','F d -3 c',),
2206}
2207
2208ssdict = {}
2209'''A dictionary of superspace group symbols allowed for each entry in spglist
2210(except cubics). Monoclinics are all b-unique setting.
2211'''
2212ssdict = {
2213#1,2
2214    'P 1':['(abg)',],'P -1':['(abg)',],
2215#monoclinic - done
2216#3
2217    'P 2':['(a0g)','(a1/2g)','(0b0)','(0b0)s','(1/2b0)','(0b1/2)',],
2218#4       
2219    'P 21':['(a0g)','(0b0)','(1/2b0)','(0b1/2)',],
2220#5
2221    'C 2':['(a0g)','(0b0)','(0b0)s','(0b1/2)',],
2222#6
2223    'P m':['(a0g)','(a0g)s','(a1/2g)','(0b0)','(1/2b0)','(0b1/2)',],
2224#7
2225    'P a':['(a0g)','(a1/2g)','(0b0)','(0b1/2)',],
2226    'P c':['(a0g)','(a1/2g)','(0b0)','(1/2b0)',],
2227    'P n':['(a0g)','(a1/2g)','(0b0)','(1/2b1/2)',],
2228#8       
2229    'C m':['(a0g)','(a0g)s','(0b0)','(0b1/2)',],
2230#9       
2231    'C c':['(a0g)','(a0g)s','(0b0)',],
2232    'C n':['(a0g)','(a0g)s','(0b0)',],
2233#10       
2234    'P 2/m':['(a0g)','(a0g)0s','(a1/2g)','(0b0)','(0b0)s0','(1/2b0)','(0b1/2)',],
2235#11
2236    'P 21/m':['(a0g)','(a0g)0s','(0b0)','(0b0)s0','(1/2b0)','(0b1/2)',],
2237#12       
2238    'C 2/m':['(a0g)','(a0g)0s','(0b0)','(0b0)s0','(0b1/2)',],
2239#13
2240    'P 2/c':['(a0g)','(a0g)0s','(a1/2g)','(0b0)','(0b0)s0','(1/2b0)',],
2241    'P 2/a':['(a0g)','(a0g)0s','(a1/2g)','(0b0)','(0b0)s0','(0b1/2)',],
2242    'P 2/n':['(a0g)','(a0g)0s','(a1/2g)','(0b0)','(0b0)s0','(1/2b1/2)',],
2243#14
2244    'P 21/c':['(a0g)','(0b0)','(1/2b0)',],
2245    'P 21/a':['(a0g)','(0b0)','(0b1/2)',],
2246    'P 21/n':['(a0g)','(0b0)','(1/2b1/2)',],
2247#15
2248    'C 2/c':['(a0g)','(0b0)','(0b0)s0',],
2249    'C 2/n':['(a0g)','(0b0)','(0b0)s0',],
2250#orthorhombic
2251#16   
2252    'P 2 2 2':['(00g)','(00g)00s','(01/2g)','(1/20g)','(1/21/2g)',
2253        '(a00)','(a00)s00','(a01/2)','(a1/20)','(a1/21/2)',
2254        '(0b0)','(0b0)0s0','(1/2b0)','(0b1/2)','(1/2b1/2)',],
2255#17       
2256    'P 2 2 21':['(00g)','(01/2g)','(1/20g)','(1/21/2g)',
2257        '(a00)','(a00)s00','(a1/20)','(0b0)','(0b0)0s0','(1/2b0)',],
2258    'P 21 2 2':['(a00)','(a01/2)','(a1/20)','(a1/21/2)',
2259        '(0b0)','(0b0)0s0','(1/2b0)','(00g)','(00g)00s','(1/20g)',],
2260    'P 2 21 2':['(0b0)','(0b1/2)','(1/2b0)','(1/2b1/2)',
2261        '(00g)','(00g)00s','(1/20g)','(a00)','(a00)s00','(a1/20)',],
2262#18       
2263    'P 21 21 2':['(00g)','(00g)00s','(a00)','(a01/2)','(0b0)','(0b1/2)',],
2264    'P 2 21 21':['(a00)','(a00)s00','(0b0)','(0b1/2)','(00g)','(01/2g)',],
2265    'P 21 2 21':['(0b0)','(0b0)0s0','(00g)','(01/2g)','(a00)','(a01/2)',],
2266#19       
2267    'P 21 21 21':['(00g)','(a00)','(0b0)',],
2268#20       
2269    'C 2 2 21':['(00g)','(10g)','(01g)','(a00)','(a00)s00','(0b0)','(0b0)0s0',],
2270    'A 21 2 2':['(a00)','(a10)','(a01)','(0b0)','(0b0)0s0','(00g)','(00g)00s',],
2271    'B 2 21 2':['(0b0)','(1b0)','(0b1)','(00g)','(00g)00s','(a00)','(a00)s00',],
2272#21       
2273    'C 2 2 2':['(00g)','(00g)00s','(10g)','(10g)00s','(01g)','(01g)00s',
2274        '(a00)','(a00)s00','(a01/2)','(0b0)','(0b0)0s0','(0b1/2)',],
2275    'A 2 2 2':['(a00)','(a00)s00','(a10)','(a10)s00','(a01)','(a01)s00',
2276        '(0b0)','(0b0)0s0','(0b1/2)','(00g)','(00g)00s','(01/2g)',],
2277    'B 2 2 2':['(0b0)','(0b0)0s0','(1b0)','(1b0)0s0','(0b1)','(0b1)0s0',
2278        '(00g)','(00g)00s','(01/2g)','(a00)','(a00)s00','(a01/2)',],
2279#22       
2280    'F 2 2 2':['(00g)','(00g)00s','(10g)','(01g)',
2281        '(a00)','(a00)s00','(a10)','(a01)',
2282        '(0b0)','(0b0)0s0','(1b0)','(0b1)',],
2283#23       
2284    'I 2 2 2':['(00g)','(00g)00s','(a00)','(a00)s00','(0b0)','(0b0)0s0',],
2285#24       
2286    'I 21 21 21':['(00g)','(00g)00s','(a00','(a00)s00','(0b0)','(0b0)0s0',],
2287#25       
2288    'P m m 2':['(00g)','(00g)s0s','(00g)0ss','(00g)ss0',
2289        '(01/2g)','(01/2g)s0s','(1/20g)','(1/20g)0ss','(1/21/2g)',
2290        '(a00)','(a00)0s0','(a1/20)','(a01/2)','(a01/2)0s0','(a1/21/2)',
2291        '(0b0)','(0b0)s00','(0b1/2)','(0b1/2)s00','(1/2b0)','(1/2b1/2)',],       
2292    'P 2 m m':['(a00)','(a00)ss0','(a00)s0s','(a00)0ss',
2293        '(a01/2)','(a01/2)ss0','(a1/20)','(a1/20)s0s','(a1/21/2)',
2294        '(0b0)','(0b0)00s','(1/2b0)','(0b1/2)','(0b1/2)00s','(1/2b1/2)',
2295        '(00g)','(00g)0s0','(01/2g)','(01/2g)0s0','(1/20g)','(1/21/2g)',],
2296    'P m 2 m':['(0b0)','(0b0)ss0','(0b0)0ss','(0b0)s0s',
2297        '(0b1/2)','(0b1/2)ss0','(1/2b0)','(1/2b0)0ss','(1/2b1/2)',
2298        '(00g)','(00g)s00','(1/20g)','(01/2g)','(01/2g)s00','(1/21/2g)',
2299        '(a00)','(a00)0s0','(a01/2)','(a01/2)0s0','(a1/20)','(a1/21/2)',],       
2300#26       
2301    'P m c 21':['(00g)','(00g)s0s','(01/2g)','(01/2g)s0s','(1/20g)','(1/21/2g)',
2302        '(a00)','(a00)0s0','(a1/20)','(0b0)','(0b0)s00','(0b1/2)',],
2303    'P 21 m a':['(a00)','(a00)ss0','(a01/2)','(a01/2)ss0','(a1/20)','(a1/21/2)',
2304        '(0b0)','(0b0)00s','(1/2b0)','(00g)','(00g)0s0','(01/2g)',],
2305    'P b 21 m':['(0b0)','(0b0)ss0','(0b1/2)','(0b1/2)ss0','(1/2b0)','(1/2b1/2)',
2306        '(00g)','(00g)s00','(1/20g)','(a00)','(a00)0s0','(a01/2)',],
2307    'P m 21 b':['(a00)','(a00)ss0','(a01/2)','(a01/2)ss0','(a1/20)','(a1/21/2)',
2308        '(00g)','(00g)0s0','(01/2g)','(0b0)','(0b0)s00','(0b1/2)',],
2309    'P c m 21':['(00g)','(00g)0ss','(1/20g)','(1/20g)0ss','(01/2g)','(1/21/2g)',
2310        '(0b0)','(0a0)s00','(1/2b0)','(a00)','(a00)0s0','(a01/2)',],
2311    'P 21 a m':['(0b0)','(0b0)ss0','(0b1/2)','(0b1/2)ss0','(1/2b0)','(1/2b1/2)',
2312        '(a00)','(a00)00s','(a1/20)','(00g)','(00g)s00','(1/20g)',],
2313#27       
2314    'P c c 2':['(00g)','(00g)s0s','(00g)0ss','(01/2g)','(1/20g)','(1/21/2g)',
2315        '(a00)','(a00)0s0','(a1/20)','(0b0)','(0b0)s00','(1/2b0)',],
2316    'P 2 a a':['(a00)','(a00)ss0','(a00)s0s','(a01/2)','(a1/20)','(a1/21/2)',
2317        '(0b0)','(0b0)00s','(0b1/2)','(00g)','(00g)0s0','(01/2g)',],
2318    'P b 2 b':['(0b0)','(0b0)0ss','(0b0)ss0','(1/2b0)','(0b1/2)','(1/2b1/2)',
2319        '(00g)','(00g)s00','(1/20g)','(a00)','(a00)00s','(a01/2)',],
2320#28       
2321    'P m a 2':['(00g)','(00g)s0s','(00g)ss0','(00g)0ss','(01/2g)','(01/2g)s0s',
2322        '(0b1/2)','(0b1/2)s00','(a01/2)','(a00)','(0b0)','(0b0)0s0','(a1/20)','(a1/21/2)'],
2323    'P 2 m b':['(a00)','(a00)s0s','(a00)ss0','(a00)0ss','(a01/2)','(a01/2)s0s',
2324        '(1/20g)','(1/20g)s00','(1/2b0)','(0b0)','(00g)','(00g)0s0','(0b1/2)','(1/2b1/2)'],
2325    'P c 2 m':['(0b0)','(0b0)s0s','(0b0)ss0','(0b0)0ss','(1/2b0)','(1/2b0)s0s',
2326        '(a1/20)','(a1/20)s00','(01/2g)','(00g)','(a00)','(a00)0s0','(1/20g)','(1/21/2g)'],
2327    'P m 2 a':['(0b0)','(0b0)s0s','(0b0)ss0','(0b0)0ss','(0b1/2)','(0b1/2)s0s',
2328        '(01/2g)','(01/2g)s00','(a1/20)','(a00)','(00g)','(00g)0s0','(a01/2)','(a1/21/2)'],
2329    'P b m 2':['(00g)','(00g)s0s','(00g)ss0','(00g)0ss','(1/20g)','(1/20g)s0s',
2330        '(a01/2)','(a01/2)s00','(0b1/2)','(0b0)','(a00)','(a00)0s0','(1/2b0)','(1/2b1/2)'],
2331    'P 2 c m':['(a00)','(a00)s0s','(a00)ss0','(a00)0ss','(a1/20)','(a1/20)s0s',
2332        '(1/2b0)','(1/2b0)s00','(1/20g)','(00g)','(0b0)','(0b0)0s0','(01/2g)','(1/21/2g)'],
2333#29       
2334    'P c a 21':['(00g)','(00g)0ss','(01/2g)','(1/20g)',
2335        '(a00)','(a00)0s0','(a1/20)','(0b0)','(0b0)s00','(1/2b0)',],
2336    'P 21 a b':[],
2337    'P c 21 b':[],
2338    'P b 21 a':[],
2339    'P b c 21':[],
2340    'P 21 c a':[],
2341#30       
2342    'P c n 2':[],
2343    'P 2 a n':[],
2344    'P n 2 b':[],
2345    'P b 2 n':[],
2346    'P n c 2':[],
2347    'P 2 n a':[],
2348#31       
2349    'P m n 21':[],
2350    'P 21 m n':[],
2351    'P n 21 m':[],
2352    'P m 21 n':[],
2353    'P n m 21':[],
2354    'P 21 n m':[],
2355#32       
2356    'P b a 2':['(00g)','(00g)s0s','(00g)0ss','(00g)ss0','(1/21/2g)qq0',
2357        '(a00)','(a01/2)','(0b0)','(0b1/2)',],
2358    'P 2 c b':['(a00)','(a00)ss0','(a00)s0s','(a00)0ss','(a1/21/2)0qq',
2359        '(0b0)','(1/2b0)','(00g)','(1/20g)',],
2360    'P c 2 a':['(0b0)','(0b0)ss0','(0b0)0ss','(0b0)s0s','(1/2b1/2)q0q',
2361        '(00g)','01/2g)','(a00)','(a1/20)',],
2362#33       
2363    'P n a 21':[],
2364    'P 21 n b':[],
2365    'P c 21 n':[],
2366    'P n 21 a':[],
2367    'P b n 21':[],
2368    'P 21 c n':[],
2369#34       
2370    'P n n 2':['(00g)','(00g)s0s','(00g)0ss','(1/21/2g)qq0',
2371        '(a00)','(a1/21/2)0q0','(a1/21/2)00q','(0b0)','(1/2b1/2)q00','(1/2b1/2)00q',],
2372    'P 2 n n':['(a00)','(a00)ss0','(a00)s0s','(a1/21/2)0qq',
2373        '(0b0)','(1/2b1/2)q00','(1/2b1/2)00q','(00g)','(1/21/2b)0q0','(1/21/2g)q00',],
2374    'P n 2 n':['(0b0)','(0b0)ss0','(0b0)0ss','(1/2b1/2)q0q',
2375        '(00g)','(1/21/2g)0q0','(1/21/2g)q00','(a00)','(a1/21/2)00q','(b1/21/2)0q0',],
2376#35       
2377    'C m m 2':['(00g)','(00g)s0s','(00g)0ss','(00g)ss0','(10g)','(10g)s0s','(10g)0ss','(10g)ss0',
2378        '(01g)','(01g)s0s','(01g)0ss','(01g)ss0','(a00)','(a00)0s0','(a01/2)','(a01/2)0s0',
2379        '(0b0)','(0b0)s00','(0b1/2)','(0b1/2)s00',],
2380    'A 2 m m':['(a00)','(a00)s0s','(a00)0ss','(a00)ss0','(a10)','(a10)s0s','(a10)0ss','(a10)ss0',
2381        '(a01)','(a01)s0s','(a01)0ss','(a01)ss0','(0b0)','(0b0)00s','(1/2b0)','(1/2b0)00s',
2382        '(00g)','(00g)0s0','(01/2g)','(01/2g)0s0',],
2383    'B m 2 m':['(0b0)','(0b0)s0s','(0b0)0ss','(0b0)ss0','(1b0)','(1b0)s0s','(1b0)0ss','(1b0)ss0',
2384        '(0b1)','(0b1)s0s','(0b1)0ss','(0b1)ss0','(a00)','(a00)00s','(a01/2)','(a01/2)00s',
2385        '(00g)','(00g)s00','(1/20g)','(1/20g)s00',],
2386#36
2387    'C m c 21':['(00g)','(00g)s0s','(10g)','(10g)s0s','(a00)','(a00)0s0','(0b0)','(0b0)s00',],
2388    'A 21 m a':['(a00)','(a00)ss0','(a10)','(a10)ss0','(0b0)','(0b0)00s','(00g)','(00g)0s0',],
2389    'B m 21 b':['(0b0)','(0b0)ss0','(1b0)','(1b0)ss0','(a00)','(a00)00s','(00g)','(00g)s00',],
2390    'B b 21 m':['(0b0)','(0b0)0ss','(0b1)','(0b1)ss0','(a00)','(a00)00s','(00g)','(00g)s00',],
2391    'C c m 21':['(00g)','(00g)0ss','(01g)','(01g)0ss','(a00)','(a00)0s0','(0b0)','(0b0)s00',],
2392    'A 21 a m':['(a00)','(a00)s0s','(a01)','(a01)s0s','(0b0)','(0b0)00s','(00g)','(00g)0s0',],
2393#37
2394    'C c c 2':['(00g)','(00g)s0s','(00g)0ss','(10g)','(10g)s0s','(10g)0ss','(01g)','(01g)s0s','(01g)0ss',
2395        '(a00)','(a00)0s0','(0b0)','(0b0)s00',],
2396    'A 2 a a':['(a00)','(a00)ss0','(a00)s0s','(a10)','(a10)ss0','(a10)ss0','(a01)','(a01)ss0','(a01)ss0',
2397        '(0b0)','(0b0)00s','(00g)','(00g)0s0',],
2398    'B b 2 b':['(0b0)','(0b0)0ss','(0b0)ss0','(0b1)','(0b1)0ss','(0b1)ss0','(1b0)','(1b0)0ss','(1b0)ss0',
2399        '(a00)','(a00)00s','(00g)','(00g)s00',],
2400#38
2401    'A m m 2':[],
2402    'B 2 m m':[],
2403    'C m 2 m':[],
2404    'A m 2 m':[],
2405    'B m m 2':[],
2406    'C 2 m m':[],
2407#39
2408    'A b m 2':[],
2409    'B 2 c m':[],
2410    'C m 2 a':[],
2411    'A c 2 m':[],
2412    'B m a 2':[],
2413    'C 2 m b':[],
2414#40       
2415    'A m a 2':[],
2416    'B 2 m b':[],
2417    'C c 2 m':[],
2418    'A m 2 a':[],
2419    'B b m 2':[],
2420    'C 2 c m':[],
2421#41
2422    'A b a 2':[],
2423    'B 2 c b':[],
2424    'C c 2 a':[],
2425    'A c 2 a':[],
2426    'B b a 2':[],
2427    'C 2 c b':[],
2428       
2429#42       
2430    'F m m 2':['(00g)','(00g)s0s','(00g)0ss','(00g)ss0','(10g)','(10g)ss0','(10g)s0s',
2431        '(01g)','(01g)ss0','(01g)0ss','(a00)','(a00)0s0','(a01)','(a01)0s0',
2432        '(0b0)','(0b0)s00','(0b1)','(0b1)s00',],       
2433    'F 2 m m':['(a00)','(a00)ss0','(a00)s0s','(a00)0ss','(a10)','(a10)0ss','(a10)ss0',
2434        '(a01)','(a01)0ss','(a01)s0s','(0b0)','(0b0)00s','(1b0)','(1b0)00s',
2435        '(00g)','(00g)0s0','(10g)','(10g)0s0',],
2436    'F m 2 m':['(0b0)','(0b0)0ss','(0b0)ss0','(0b0)s0s','(0b1)','(0b1)s0s','(0b1)0ss',
2437        '(1b0)','(1b0)s0s','(1b0)ss0','(00g)','(00g)s00','(01g)','(01g)s00',
2438        '(a00)','(a00)00s','(a10)','(a10)00s',],       
2439#43       
2440    'F d d 2':['(00g)','(00g)0ss','(00g)s0s','(a00)','(0b0)',],
2441    'F 2 d d':['(a00)','(a00)s0s','(a00)ss0','(00g)','(0b0)',],       
2442    'F d 2 d':['(0b0)','(0b0)0ss','(0b0)ss0','(a00)','(00g)',],
2443#44
2444    'I m m 2':['(00g)','(00g)ss0','(00g)s0s','(00g)0ss','(a00)','(a00)0s0','(0b0)','(0b0)s00',],
2445    'I 2 m m':['(a00)','(00g)0ss','(00g)ss0','(00g)s0s','(0b0)','(0b0)00s','(00g)','(00g)0s0',],
2446    'I m 2 m':['(0b0)','(0b0)s0s','(0b0)0ss','(0b0)ss0','(00g)','(00g)s00','(a00)','(a00)00s',],
2447#45       
2448    'I b a 2':['(00g)','(00g)ss0','(00g)s0s','(00g)0ss','(a00)','(a00)0s0','(0b0)','(0b0)s00',],
2449    'I 2 c b':['(0b0)','(0b0)s0s','(0b0)0ss','(0b0)ss0','(00g)','(00g)s00','(a00)','(a00)00s',],
2450    'I c 2 a':['(a00)','(00g)0ss','(00g)ss0','(00g)s0s','(0b0)','(0b0)00s','(00g)','(00g)0s0',],
2451#46       
2452    'I m a 2':['(a00)','(00g)0ss','(00g)ss0','(00g)s0s','(0b0)','(0b0)00s','(00g)','(00g)0s0',],
2453    'I 2 m b':['(0b0)','(0b0)s0s','(0b0)0ss','(0b0)ss0','(00g)','(00g)s00','(a00)','(a00)00s',],       
2454    'I c 2 m':['(a00)','(00g)0ss','(00g)ss0','(00g)s0s','(0b0)','(0b0)00s','(00g)','(00g)0s0',],
2455    'I m 2 a':['(a00)','(00g)0ss','(00g)ss0','(00g)s0s','(0b0)','(0b0)00s','(00g)','(00g)0s0',],
2456    'I b m 2':['(a00)','(00g)0ss','(00g)ss0','(00g)s0s','(0b0)','(0b0)00s','(00g)','(00g)0s0',],
2457    'I 2 c m':['(0b0)','(0b0)s0s','(0b0)0ss','(0b0)ss0','(00g)','(00g)s00','(a00)','(a00)00s',],
2458#47       
2459    'P m m m':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(01/2g)','(01/2g)s00','(1/20g)','(1/20g)s00','(1/21/2g)',
2460        '(a00)','(a00)0s0','(a00)00s','(a00)0ss','(a01/2)','(a01/2)0s0','(a1/20)','(a1/20)00s','(a1/21/2)',
2461        '(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s','(1/2b0)','(1/2b0)00s','(0b1/2)','(0b1/2)s00','(1/2b1/2)',],
2462#48 o@i qq0,0qq,q0q ->000
2463    'P n n n':['(00g)','(00g)s00','(00g)0s0','(1/21/2g)',
2464        '(a00)','(a00)0s0','(a00)00s','(a1/21/2)',
2465        '(0b0)','(0b0)s00','(0b0)00s','(1/2b1/2)',],
2466#49       
2467    'P c c m':['(00g)','(00g)s00','(00g)0s0','(01/2g)','(1/20g)','(1/21/2g)',
2468        '(a00)','(a00)0s0','(a00)00s','(a00)0ss','(a1/20)','(a1/20)00s',
2469        '(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s','(1/2b0)','(1/2b0)00s',],       
2470    'P m a a':['(a00)','(a00)0s0','(a00)00s','(a01/2)','(a1/20)','(a1/21/2)',
2471        '(0b0)','(0b0)00s','(0b0)s00','(0b0)s0s','(0b1/2)','(0b1/2)s00',
2472        '(00g)','(00g)0s0','(00g)s00','(00g)ss0','(01/2g)','(01/2g)s00',],       
2473    'P b m b':['(0b0)','(0b0)00s','(0b0)s00','(0b1/2)','(1/2b0)','(1/2b1/2)',
2474        '(00g)','(00g)s00','(00g)0s0','(00g)ss0','(1/20g)','(1/20g)0s0',
2475        '(a00)','(a00)00s','(a00)0s0','(a00)0ss','(a01/2)','(a01/2)0s0',],
2476#50 o@i qq0,0qq,q0q ->000
2477    'P b a n':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(1/21/2g)',
2478        '(a00)','(a00)0s0','(a01/2)','(0b0)','(0b0)s00','(0b1/2)',],
2479    'P n c b':['(a00)','(a00)0s0','(a00)00s','(a00)0ss','(a1/21/2)',
2480        '(0b0)','(0b0)00s','(1/2b0)','(00g)','(00g)0s0','(1/20g)',],
2481    'P c n a':['(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s','(1/2b1/2)',
2482        '(00g)','(00g)s00','(01/2a)','(a00)','(a00)00s','(a1/20)',],
2483#51       
2484    'P m m a':[],
2485    'P b m m':[],
2486    'P m c m':[],
2487    'P m a m':[],
2488    'P m m b':[],
2489    'P c m m':[],
2490#52   o@i qq0,0qq,q0q ->000     
2491    'P n n a':['(00g)','(00g)s00','(00g)0s0','(a00)','(a00)00s',
2492        '(0b0)','(0b0)00s','(a1/21/2)','(1/2b1/2)',],
2493    'P b n n':['(a00)','(a00)0s0','(a00)00s','(0b0)','(0b0)s00',
2494        '(00g)','(00g)s00','(1/2b1/2)','(1/21/2g)',],
2495    'P n c n':['(0b0)','(0b0)s00','(0b0)00s','(00g)','(00g)0s0',
2496        '(a00)','(a00)0s0','(1/21/2g)','(a1/21/2)',],
2497    'P n a n':['(0b0)','(0b0)s00','(0b0)00s','(00g)','(00g)0s0',
2498        '(a00)','(a00)0s0','(1/21/2g)','(a1/21/2)',],
2499    'P n n b':['(00g)','(00g)s00','(00g)0s0','(a00)','(a00)00s',
2500        '(0b0)','(0b0)00s','(a1/21/2)','(1/2b1/2)',],
2501    'P c n n':['(a00)','(a00)0s0','(a00)00s','(0b0)','(0b0)s00',
2502        '(00g)','(00g)s00','(1/2b1/2)','(1/21/2g)',],
2503#53       
2504    'P m n a':[],
2505    'P b m n':[],
2506    'P n c m':[],
2507    'P m a n':[],
2508    'P n m b':[],
2509    'P c n m':[],
2510#54       
2511    'P c c a':[],
2512    'P b a a':[],
2513    'P b c b':[],
2514    'P b a b':[],
2515    'P c c b':[],
2516    'P c a a':[],
2517#55       
2518    'P b a m':['(00g)','(00g)s00','(00g)0s0','(00g)ss0',
2519        '(a00)','(a00)00s','(a01/2)','(0b0)','(0b0)00s','(0b1/2)'],
2520    'P m c b':['(a00)','(a00)0s0','(a00)00s','(a00)0ss',
2521        '(0b0)','(0b0)s00','(1/2b0)','(00g)','(00g)s00','(1/20g)'],
2522    'P c m a':['(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s',
2523        '(a00)','(a00)0s0','(a1/20)','(00g)','(00g)0s0','(01/2g)'],
2524#56       
2525    'P c c n':['(00g)','(00g)s00','(00g)0s0','(a00)','(a00)0s0',
2526        '(0b0)','(0b0)s00'],
2527    'P n a a':['(a00)','(a00)0s0','(a00)00s','(0b0)','(0b0)00s',
2528        '(00g)','(00g)0s0'],
2529    'P b n b':['(0b0)','(0b0)s00','(0b0)00s','(a00)','(a00)00s',
2530        '(00g)','(00g)s00'],
2531#57       
2532    'P b c m':[],
2533    'P m c a':[],
2534    'P b m a':[],
2535    'P c m b':[],
2536    'P c a m':[],
2537    'P m a b':[],
2538#58       
2539    'P n n m':['(00g)','(00g)s00','(00g)0s0','(a00)',
2540        '(a00)00s','(0b0)','(0b0)00s'],
2541    'P m n n':['(00g)','(00g)s00','(a00)','(a00)0s0',
2542        '(a00)00s','(0b0)','(0b0)s00'],
2543    'P n m n':['(00g)','(00g)0s0','(a00)','(a00)0s0',
2544        '(0b0)','(0b0)s00','(0b0)00s',],
2545#59 o@i
2546    'P m m n':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(a00)','(a00)0s0',
2547        '(a01/2)','(a01/2)0s0','(0b0)','(0b0)s00','(0b1/2)','(0b1/2)s00',],
2548    'P n m m':['(a00)','(a00)0s0','(a00)00s','(a00)0ss','(00g)','(00g)0s0',
2549        '(1/20g)','(1/20g)0s0','(0b0)','(0b0)00s','(1/2b0)','(1/2b0)00s'],
2550    'P m n m':['(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s','(00g)','(00g)s00',
2551        '(01/2g)','(01/2g)s00','(a00)','(a00)00s','(a1/20)','(a1/20)00s'],
2552#60       
2553    'P b c n':['(00g)','(00g)s00','(00g)0s0','(a00)','(a00)0s0',
2554        '(a00)00s','(0b0)','(0b0)s00','(0b0)00s'],
2555    'P n c a':['(00g)','(00g)s00','(00g)0s0','(a00)','(a00)0s0',
2556        '(a00)00s','(0b0)','(0b0)s00','(0b0)00s'],
2557    'P b n a':['(00g)','(00g)s00','(00g)0s0','(a00)','(a00)0s0',
2558        '(a00)00s','(0b0)','(0b0)s00','(0b0)00s'],
2559    'P c n b':['(00g)','(00g)s00','(00g)0s0','(a00)','(a00)0s0',
2560        '(a00)00s','(0b0)','(0b0)s00','(0b0)00s'],
2561    'P c a n':['(00g)','(00g)s00','(00g)0s0','(a00)','(a00)0s0',
2562        '(a00)00s','(0b0)','(0b0)s00','(0b0)00s'],
2563    'P n a b':['(00g)','(00g)s00','(00g)0s0','(a00)','(a00)0s0',
2564        '(a00)00s','(0b0)','(0b0)s00','(0b0)00s'],
2565#61       
2566    'P b c a':['(00g)','(00g)s00','(00g)0s0','(a00)','(a00)0s0','(a00)00s',
2567        '(0b0)','(0b0)s00','(0b0)00s'],
2568    'P c a b':['(00g)','(00g)s00','(00g)0s0','(a00)','(a00)0s0','(a00)00s',
2569        '(0b0)','(0b0)s00','(0b0)00s'],
2570#62       
2571    'P n m a':['(00g)','(00g)0s0','(a00)','(a00)0s0','(0b0)','(0b0)00s'],
2572    'P b n m':['(00g)','(00g)s00','(a00)','(a00)00s','(0b0)','(0b0)00s'],
2573    'P m c n':['(00g)','(00g)s00','(a00)','(a00)0s0','(0b0)','(0b0)s00'],
2574    'P n a m':['(00g)','(00g)0s0','(a00)','(a00)00s','(0b0)','(0b0)00s'],
2575    'P m n b':['(00g)','(00g)s00','(a00)','(a00)00s','(0b0)','(0b0)s00'],
2576    'P c m n':['(00g)','(00g)0s0','(a00)','(a00)0s0','(0b0)','(0b0)s00'],
2577#63
2578    'C m c m':[],
2579    'A m m a':[],
2580    'B b m m':[],
2581    'B m m b':[],
2582    'C c m m':[],
2583    'A m a m':[],
2584#64       
2585    'C m c a':['(00g)','(00g)s00','(10g)','(10g)s00','(a00)',],
2586    'A b m a':[],
2587    'B b c m':[],
2588    'B m a b':[],
2589    'C c m b':[],
2590    'A c a m':[],
2591#65       
2592    'C m m m':[],
2593    'A m m m':[],
2594    'B m m m':[],
2595#66       
2596    'C c c m':[],
2597    'A m m a':[],
2598    'B b m b':[],
2599#67       
2600    'C m m a':[],
2601    'A b m m':[],
2602    'B m c m':[],
2603    'B m a m':[],
2604    'C m m b':[],
2605    'A c m m':[],
2606#68 o@i
2607    'C c c a':['(00g)','(00g)s00','(10g)','(01g)','(10g)s00','(01g)s00',
2608        '(a00)','(a00)s00','(a00)ss0','(a00)0s0','(0b0)','(0b0)s00','(0b0)ss0','(0b0)0s0'],
2609    'A b a a':['(a00)','(a00)s00','(a10)','(a01)','(a10)s00','(a01)s00',
2610        '(0b0)','(0b0)s00','(0b0)ss0','(0b0)0s0','(00g)','(00g)s00','(00g)ss0','(00g)0s0'],
2611    'B b c b':['(0b0)','(0b0)s00','(0b1)','(1b0)','(0b1)s00','(1b0)s00',
2612        '(00g)','(00g)s00','(00g)ss0','(0b0)0s0','(a00)','(a00)s00','(a00)ss0','(a00)0s0'],
2613    'B b a b':['(0b0)','(0b0)s00','(1b0)','(0b1)','(1b0)s00','(0b1)s00',
2614        '(a00)','(a00)s00','(a00)ss0','(a00)0s0','(00g)','(00g)s00','(00g)ss0','(00g)0s0'],
2615    'C c c b':['(00g)','(00g)ss0','(01g)','(10g)','(01g)s00','(10g)s00',
2616        '(0b0)','(0b0)s00','(0b0)ss0','(0b0)0s0','(a00)','(a00)s00','(a00)ss0','(a00)0s0'],
2617    'A c a a':['(a00)','(a00)ss0','(a01)','(a10)','(a01)s00','(a10)s00',
2618        '(00g)','(00g)s00','(00g)ss0','(00g)0s0','(0b0)','(0b0)s00','(0b0)ss0','(0b0)0s0'],
2619#69       
2620    'F m m m':['(00g)','(00g)s00','(00g)ss0','(a00)','(a00)s00',
2621        '(a00)ss0','(0b0)','(0b0)s00','(0b0)ss0',
2622        '(10g)','(10g)s00','(10g)ss0','(a10)','(a10)0s0',
2623        '(a10)00s','(a10)0ss','(0b1)','(0b1)s00','(0b1)00s','(0b1)s0s',
2624        '(01g)','(01g)s00','(01g)ss0','(a01)','(a01)0s0',
2625        '(a01)00s','(a01)0ss','(1b0)','(1b0)s00','(1b0)00s','(1b0)s0s'],
2626#70 o@i       
2627    'F d d d':['(00g)','(00g)s00','(a00)','(a00)s00','(0b0)','(0b0)s00'],       
2628#71
2629    'I m m m':['(00g)','(00g)s00','(00g)ss0','(a00)','(a00)0s0',
2630        '(a00)ss0','(0b0)','(0b0)s00','(0b0)ss0'],
2631#72       
2632    'I b a m':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(a00)','(a00)0s0',
2633        '(a00)00s','(a00)0ss','(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s'],
2634    'I m c b':['(a00)','(a00)0s0','(a00)00s','(a00)0ss','(0b0)','(0b0)00s',
2635        '(0b0)s00','(0b0)s0s','(00g)','(00g)0s0','(00g)s00','(00g)ss0'],
2636    'I c m a':['(0b0)','(0b0)00s','(0b0)s00','(0b0)s0s','(00g)','(00g)s00',
2637        '(00g)0s0','(00g)ss0','(a00)','(a00)00s','(a00)0s0','(a00)0ss'],
2638#73       
2639    'I b c a':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(a00)','(a00)0s0',
2640        '(a00)00s','(a00)0ss','(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s'],
2641    'I c a b':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(a00)','(a00)0s0',
2642        '(a00)00s','(a00)0ss','(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s'],
2643#74       
2644    'I m m a':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(a00)','(a00)0s0',
2645        '(a00)00s','(a00)0ss','(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s'],
2646    'I b m m ':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(a00)','(a00)0s0',
2647        '(a00)00s','(a00)0ss','(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s'],
2648    'I m c m':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(a00)','(a00)0s0',
2649        '(a00)00s','(a00)0ss','(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s'],
2650    'I m a m':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(a00)','(a00)0s0',
2651        '(a00)00s','(a00)0ss','(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s'],
2652    'I m m b':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(a00)','(a00)0s0',
2653        '(a00)00s','(a00)0ss','(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s'],
2654    'I c m m':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(a00)','(a00)0s0',
2655        '(a00)00s','(a00)0ss','(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s'],
2656#tetragonal - done
2657#75
2658    'P 4':['(00g)','(00g)q','(00g)s','(1/21/2g)','(1/21/2g)q',],
2659#76
2660    'P 41':['(00g)','(1/21/2g)',],
2661#77
2662    'P 42':['(00g)','(00g)q','(1/21/2g)','(1/21/2g)q',],
2663#78
2664    'P 43':['(00g)','(1/21/2g)',],
2665#79
2666    'I 4':['(00g)','(00g)q','(00g)s',],
2667#80
2668    'I 41':['(00g)','(00g)q',],
2669#81
2670    'P -4':['(00g)','(1/21/2g)',],
2671#82
2672    'I -4':['(00g)',],
2673#83
2674    'P 4/m':['(00g)','(00g)s0','(1/21/2g)',],
2675#84
2676    'P 42/m':['(00g)','(1/21/2g)',],
2677#85 o@i q0 -> 00
2678    'P 4/n':['(00g)','(00g)s0','(1/21/2g)',], #q0?
2679#86 o@i q0 -> 00
2680    'P 42/n':['(00g)','(1/21/2g)',],      #q0?
2681#87
2682    'I 4/m':['(00g)','(00g)s0',],
2683#88
2684    'I 41/a':['(00g)',],
2685#89
2686    'P 4 2 2':['(00g)','(00g)q00','(00g)s00','(1/21/2g)','(1/21/2g)q00',],
2687#90
2688    'P 4 21 2':['(00g)','(00g)q00','(00g)s00',],
2689#91
2690    'P 41 2 2':['(00g)','(1/21/2g)',],
2691#92
2692    'P 41 21 2':['(00g)',],
2693#93
2694    'P 42 2 2':['(00g)','(00g)q00','(1/21/2g)','(1/21/2g)q00',],
2695#94
2696    'P 42 21 2':['(00g)','(00g)q00',],
2697#95
2698    'P 43 2 2':['(00g)','(1/21/2g)',],
2699#96
2700    'P 43 21 2':['(00g)',],
2701#97
2702    'I 4 2 2':['(00g)','(00g)q00','(00g)s00',],
2703#98
2704    'I 41 2 2':['(00g)','(00g)q00',],
2705#99
2706    'P 4 m m':['(00g)','(00g)ss0','(00g)0ss','(00g)s0s','(1/21/2g)','(1/21/2g)0ss'],
2707#100
2708    'P 4 b m':['(00g)','(00g)ss0','(00g)0ss','(00g)s0s','(1/21/2g)qq0','(1/21/2g)qqs',],
2709#101
2710    'P 42 c m':['(00g)','(00g)0ss','(1/21/2g)','(1/21/2g)0ss',],
2711#102
2712    'P 42 n m':['(00g)','(00g)0ss','(1/21/2g)qq0','(1/21/2g)qqs',],
2713#103
2714    'P 4 c c':['(00g)','(00g)ss0','(1/21/2g)',],
2715#104
2716    'P 4 n c':['(00g)','(00g)ss0','(1/21/2g)qq0',],
2717#105
2718    'P 42 m c':['(00g)','(00g)ss0','(1/21/2g)',],
2719#106
2720    'P 42 b c':['(00g)','(00g)ss0','(1/21/2g)qq0',],
2721#107
2722    'I 4 m m':['(00g)','(00g)ss0','(00g)0ss','(00g)s0s',],
2723#108
2724    'I 4 c m':['(00g)','(00g)ss0','(00g)0ss','(00g)s0s',],
2725#109
2726    'I 41 m d':['(00g)','(00g)ss0',],
2727#110
2728    'I 41 c d':['(00g)','(00g)ss0',],
2729#111
2730    'P -4 2 m':['(00g)','(00g)0ss','(1/21/2g)','(1/21/2g)0ss',],
2731#112
2732    'P -4 2 c':['(00g)','(1/21/2g)',],
2733#113
2734    'P -4 21 m':['(00g)','(00g)0ss',],
2735#114
2736    'P -4 21 c':['(00g)',],
2737#115    00s -> 0ss
2738    'P -4 m 2':['(00g)','(00g)0ss','(1/21/2g)',],
2739#116
2740    'P -4 c 2':['(00g)','(1/21/2g)',],
2741#117    00s -> 0ss
2742    'P -4 b 2':['(00g)','(00g)0s0','(1/21/2g)0q0',],
2743#118
2744    'P -4 n 2':['(00g)','(1/21/2g)0q0',],
2745#119
2746    'I -4 m 2':['(00g)','(00g)0s0',],
2747#120
2748    'I -4 c 2':['(00g)','(00g)0s0',],
2749#121    00s -> 0ss
2750    'I -4 2 m':['(00g)','(00g)0ss',],
2751#122
2752    'I -4 2 d':['(00g)',],
2753#123
2754    'P 4/m m m':['(00g)','(00g)s0s0','(00g)00ss','(00g)s00s',
2755        '(1/21/2g)','(1/21/2g)s0s0','(1/21/2g)00ss','(1/21/2g)s00s',],
2756#124
2757    'P 4/m c c':['(00g)','(00g)s0s0','(1/21/2g)',],
2758#125    o@i q0q0 -> 0000, q0qs -> 00ss
2759    'P 4/n b m':['(00g)','(00g)s0s0','(00g)00ss','(00g)s00s','(1/21/2g)','(1/21/2g)00ss',],
2760#126    o@i q0q0 -> 0000
2761    'P 4/n n c':['(00g)','(00g)s0s0','(1/21/2g)',],
2762#127
2763    'P 4/m b m':['(00g)','(00g)s0s0','(00g)00ss','(00g)s00s',],
2764#128
2765    'P 4/m n c':['(00g)','(00g)s0s0',],
2766#129
2767    'P 4/n m m':['(00g)','(00g)s0s0','(00g)00ss','(00g)s00s',],
2768#130
2769    'P 4/n c c':['(00g)','(00g)s0s0',],
2770#131
2771    'P 42/m m c':['(00g)','(00g)s0s0','(1/21/2g)',],
2772#132
2773    'P 42/m c m':['(00g)','(00g)00ss','(1/21/2g)','(1/21/2g)00ss',],
2774#133    o@i q0q0 -> 0000
2775    'P 42/n b c':['(00g)','(00g)s0s0','(1/21/2g)',],
2776#134    o@i q0q0 -> 0000, q0qs -> 00ss
2777    'P 42/n n m':['(00g)','(00g)00ss','(1/21/2g)','(1/21/2g)00ss',],
2778#135
2779    'P 42/m b c':['(00g)','(00g)s0s0',],
2780#136
2781    'P 42/m n m':['(00g)','(00g)00ss',],
2782#137
2783    'P 42/n m c':['(00g)','(00g)s0s0',],
2784#138
2785    'P 42/n c m':['(00g)','(00g)00ss',],
2786#139
2787    'I 4/m m m':['(00g)','(00g)s0s0','(00g)00ss','(00g)s00s',],
2788#140
2789    'I 4/m c m':['(00g)','(00g)s0s0','(00g)00ss','(00g)s00s',],
2790#141
2791    'I 41/a m d':['(00g)','(00g)s0s0',],
2792#142
2793    'I 41/a c d':['(00g)','(00g)s0s0',],
2794    #trigonal/rhombahedral - done & checked
2795#143
2796    'P 3':['(00g)','(00g)t','(1/31/3g)',],
2797#144
2798    'P 31':['(00g)','(1/31/3g)',],
2799#145
2800    'P 32':['(00g)','(1/31/3g)',],
2801#146
2802    'R 3':['(00g)','(00g)t',],
2803#147
2804    'P -3':['(00g)','(1/31/3g)',],
2805#148
2806    'R -3':['(00g)',],
2807#149
2808    'P 3 1 2':['(00g)','(00g)t00','(1/31/3g)',],
2809#150
2810    'P 3 2 1':['(00g)','(00g)t00',],
2811#151
2812    'P 31 1 2':['(00g)','(1/31/3g)',],
2813#152
2814    'P 31 2 1':['(00g)',],
2815#153
2816    'P 32 1 2':['(00g)','(1/31/3g)',],
2817#154
2818    'P 32 2 1':['(00g)',],
2819#155
2820    'R 3 2':['(00g)','(00g)t0',],
2821#156
2822    'P 3 m 1':['(00g)','(00g)0s0',],
2823#157
2824    'P 3 1 m':['(00g)','(00g)00s','(1/31/3g)','(1/31/3g)00s',],
2825#158
2826    'P 3 c 1':['(00g)',],
2827#159
2828    'P 3 1 c':['(00g)','(1/31/3g)',],
2829#160
2830    'R 3 m':['(00g)','(00g)0s',],
2831#161
2832    'R 3 c':['(00g)',],
2833#162
2834    'P -3 1 m':['(00g)','(00g)00s','(1/31/3g)','(1/31/3g)00s',],
2835#163
2836    'P -3 1 c':['(00g)','(1/31/3g)',],
2837#164
2838    'P -3 m 1':['(00g)','(00g)0s0',],
2839#165
2840    'P -3 c 1':['(00g)',],
2841#166       
2842    'R -3 m':['(00g)','(00g)0s',],
2843#167
2844    'R -3 c':['(00g)',],
2845    #hexagonal - done & checked
2846#168
2847    'P 6':['(00g)','(00g)h','(00g)t','(00g)s',],
2848#169
2849    'P 61':['(00g)',],
2850#170
2851    'P 65':['(00g)',],
2852#171
2853    'P 62':['(00g)','(00g)h',],
2854#172
2855    'P 64':['(00g)','(00g)h',],
2856#173
2857    'P 63':['(00g)','(00g)h',],
2858#174
2859    'P -6':['(00g)',],
2860#175
2861    'P 6/m':['(00g)','(00g)s0',],
2862#176
2863    'P 63/m':['(00g)',],
2864#177
2865    'P 6 2 2':['(00g)','(00g)h00','(00g)t00','(00g)s00',],
2866#178
2867    'P 61 2 2':['(00g)',],
2868#179
2869    'P 65 2 2':['(00g)',],
2870#180
2871    'P 62 2 2':['(00g)','(00g)h00',],
2872#181
2873    'P 64 2 2':['(00g)','(00g)h00',],
2874#182
2875    'P 63 2 2':['(00g)','(00g)h00',],
2876#183
2877    'P 6 m m':['(00g)','(00g)ss0','(00g)0ss','(00g)s0s',],
2878#184
2879    'P 6 c c':['(00g)','(00g)s0s',],
2880#185
2881    'P 63 c m':['(00g)','(00g)0ss',],
2882#186
2883    'P 63 m c':['(00g)','(00g)0ss',],
2884#187
2885    'P -6 m 2':['(00g)','(00g)0s0',],
2886#188
2887    'P -6 c 2':['(00g)',],
2888#189
2889    'P -6 2 m':['(00g)','(00g)00s',],
2890#190
2891    'P -6 2 c':['(00g)',],
2892#191
2893    'P 6/m m m':['(00g)','(00g)s0s0','(00g)00ss','(00g)s00s',],
2894#192
2895    'P 6/m c c':['(00g)','(00g)s00s',],
2896#193
2897    'P 63/m c m':['(00g)','(00g)00ss',],
2898#194
2899    'P 63/m m c':['(00g)','(00g)00ss'],
2900    }
2901
2902#'A few non-standard space groups for test use'
2903nonstandard_sglist = ('P 21 1 1','P 1 21 1','P 1 1 21','R 3 r','R 3 2 h', 
2904                      'R -3 r', 'R 3 2 r','R 3 m h', 'R 3 m r',
2905                      'R 3 c r','R -3 c r','R -3 m r',),
2906
2907#A list of orthorhombic space groups that were renamed in the 2002 Volume A,
2908# along with the pre-2002 name. The e designates a double glide-plane'''
2909sgequiv_2002_orthorhombic= (('A e m 2', 'A b m 2',),
2910                            ('A e a 2', 'A b a 2',),
2911                            ('C m c e', 'C m c a',),
2912                            ('C m m e', 'C m m a',),
2913                            ('C c c e', 'C c c a'),)
2914#Use the space groups types in this order to list the symbols in the
2915#order they are listed in the International Tables, vol. A'''
2916symtypelist = ('triclinic', 'monoclinic', 'orthorhombic', 'tetragonal', 
2917               'trigonal', 'hexagonal', 'cubic')
2918
2919# self-test materials follow. Requires files in directory testinp
2920selftestlist = []
2921'''Defines a list of self-tests'''
2922selftestquiet = True
2923def _ReportTest():
2924    'Report name and doc string of current routine when ``selftestquiet`` is False'
2925    if not selftestquiet:
2926        import inspect
2927        caller = inspect.stack()[1][3]
2928        doc = eval(caller).__doc__
2929        if doc is not None:
2930            print('testing '+__file__+' with '+caller+' ('+doc+')')
2931        else:
2932            print('testing '+__file__()+" with "+caller)
2933def test0():
2934    '''self-test #0: exercise MoveToUnitCell'''
2935    _ReportTest()
2936    msg = "MoveToUnitCell failed"
2937    assert (MoveToUnitCell([1,2,3]) == [0,0,0]).all, msg
2938    assert (MoveToUnitCell([2,-1,-2]) == [0,0,0]).all, msg
2939    assert abs(MoveToUnitCell(np.array([-.1]))[0]-0.9) < 1e-6, msg
2940    assert abs(MoveToUnitCell(np.array([.1]))[0]-0.1) < 1e-6, msg
2941selftestlist.append(test0)
2942
2943def test1():
2944    '''self-test #1: SpcGroup against previous results'''
2945    #'''self-test #1: SpcGroup and SGPrint against previous results'''
2946    _ReportTest()
2947    testdir = ospath.join(ospath.split(ospath.abspath( __file__ ))[0],'testinp')
2948    if ospath.exists(testdir):
2949        if testdir not in sys.path: sys.path.insert(0,testdir)
2950    import spctestinp
2951    def CompareSpcGroup(spc, referr, refdict, reflist): 
2952        'Compare output from GSASIIspc.SpcGroup with results from a previous run'
2953        # if an error is reported, the dictionary can be ignored
2954        msg0 = "CompareSpcGroup failed on space group %s" % spc
2955        result = SpcGroup(spc)
2956        if result[0] == referr and referr > 0: return True
2957        keys = result[1].keys()
2958        #print result[1]['SpGrp']
2959        #msg = msg0 + " in list lengths"
2960        #assert len(keys) == len(refdict.keys()), msg
2961        for key in refdict.keys():
2962            if key == 'SGOps' or  key == 'SGCen':
2963                msg = msg0 + (" in key %s length" % key)
2964                assert len(refdict[key]) == len(result[1][key]), msg
2965                for i in range(len(refdict[key])):
2966                    msg = msg0 + (" in key %s level 0" % key)
2967                    assert np.allclose(result[1][key][i][0],refdict[key][i][0]), msg
2968                    msg = msg0 + (" in key %s level 1" % key)
2969                    assert np.allclose(result[1][key][i][1],refdict[key][i][1]), msg
2970            else:
2971                msg = msg0 + (" in key %s" % key)
2972                assert result[1][key] == refdict[key], msg
2973        msg = msg0 + (" in key %s reflist" % key)
2974        #for (l1,l2) in zip(reflist, SGPrint(result[1])):
2975        #    assert l2.replace('\t','').replace(' ','') == l1.replace(' ',''), 'SGPrint ' +msg
2976        # for now disable SGPrint testing, output has changed
2977        #assert reflist == SGPrint(result[1]), 'SGPrint ' +msg
2978    for spc in spctestinp.SGdat:
2979        CompareSpcGroup(spc, 0, spctestinp.SGdat[spc], spctestinp.SGlist[spc] )
2980selftestlist.append(test1)
2981
2982def test2():
2983    '''self-test #2: SpcGroup against cctbx (sgtbx) computations'''
2984    _ReportTest()
2985    testdir = ospath.join(ospath.split(ospath.abspath( __file__ ))[0],'testinp')
2986    if ospath.exists(testdir):
2987        if testdir not in sys.path: sys.path.insert(0,testdir)
2988    import sgtbxtestinp
2989    def CompareWcctbx(spcname, cctbx_in, debug=0):
2990        'Compare output from GSASIIspc.SpcGroup with results from cctbx.sgtbx'
2991        cctbx = cctbx_in[:] # make copy so we don't delete from the original
2992        spc = (SpcGroup(spcname))[1]
2993        if debug: print spc['SpGrp']
2994        if debug: print spc['SGCen']
2995        latticetype = spcname.strip().upper()[0]
2996        # lattice type of R implies Hexagonal centering", fix the rhombohedral settings
2997        if latticetype == "R" and len(spc['SGCen']) == 1: latticetype = 'P'
2998        assert latticetype == spc['SGLatt'], "Failed: %s does not match Lattice: %s" % (spcname, spc['SGLatt'])
2999        onebar = [1]
3000        if spc['SGInv']: onebar.append(-1)
3001        for (op,off) in spc['SGOps']:
3002            for inv in onebar:
3003                for cen in spc['SGCen']:
3004                    noff = off + cen
3005                    noff = MoveToUnitCell(noff)
3006                    mult = tuple((op*inv).ravel().tolist())
3007                    if debug: print "\n%s: %s + %s" % (spcname,mult,noff)
3008                    for refop in cctbx:
3009                        if debug: print refop
3010                        # check the transform
3011                        if refop[:9] != mult: continue
3012                        if debug: print "mult match"
3013                        # check the translation
3014                        reftrans = list(refop[-3:])
3015                        reftrans = MoveToUnitCell(reftrans)
3016                        if all(abs(noff - reftrans) < 1.e-5):
3017                            cctbx.remove(refop)
3018                            break
3019                    else:
3020                        assert False, "failed on %s:\n\t %s + %s" % (spcname,mult,noff)
3021    for key in sgtbxtestinp.sgtbx:
3022        CompareWcctbx(key, sgtbxtestinp.sgtbx[key])
3023selftestlist.append(test2)
3024
3025def test3(): 
3026    '''self-test #3: exercise SytSym (includes GetOprPtrName, GenAtom, GetKNsym)
3027     for selected space groups against info in IT Volume A '''
3028    _ReportTest()
3029    def ExerciseSiteSym (spc, crdlist):
3030        'compare site symmetries and multiplicities for a specified space group'
3031        msg = "failed on site sym test for %s" % spc
3032        (E,S) = SpcGroup(spc)
3033        assert not E, msg
3034        for t in crdlist:
3035            symb, m = SytSym(t[0],S)
3036            if symb.strip() != t[2].strip() or m != t[1]:
3037                print spc,t[0],m,symb,t[2]
3038            assert m == t[1]
3039            #assert symb.strip() == t[2].strip()
3040
3041    ExerciseSiteSym('p 1',[
3042            ((0.13,0.22,0.31),1,'1'),
3043            ((0,0,0),1,'1'),
3044            ])
3045    ExerciseSiteSym('p -1',[
3046            ((0.13,0.22,0.31),2,'1'),
3047            ((0,0.5,0),1,'-1'),
3048            ])
3049    ExerciseSiteSym('C 2/c',[
3050            ((0.13,0.22,0.31),8,'1'),
3051            ((0.0,.31,0.25),4,'2(y)'),
3052            ((0.25,.25,0.5),4,'-1'),
3053            ((0,0.5,0),4,'-1'),
3054            ])
3055    ExerciseSiteSym('p 2 2 2',[
3056            ((0.13,0.22,0.31),4,'1'),
3057            ((0,0.5,.31),2,'2(z)'),
3058            ((0.5,.31,0.5),2,'2(y)'),
3059            ((.11,0,0),2,'2(x)'),
3060            ((0,0.5,0),1,'222'),
3061            ])
3062    ExerciseSiteSym('p 4/n',[
3063            ((0.13,0.22,0.31),8,'1'),
3064            ((0.25,0.75,.31),4,'2(z)'),
3065            ((0.5,0.5,0.5),4,'-1'),
3066            ((0,0.5,0),4,'-1'),
3067            ((0.25,0.25,.31),2,'4(001)'),
3068            ((0.25,.75,0.5),2,'-4(001)'),
3069            ((0.25,.75,0.0),2,'-4(001)'),
3070            ])
3071    ExerciseSiteSym('p 31 2 1',[
3072            ((0.13,0.22,0.31),6,'1'),
3073            ((0.13,0.0,0.833333333),3,'2(100)'),
3074            ((0.13,0.13,0.),3,'2(110)'),
3075            ])
3076    ExerciseSiteSym('R 3 c',[
3077            ((0.13,0.22,0.31),18,'1'),
3078            ((0.0,0.0,0.31),6,'3'),
3079            ])
3080    ExerciseSiteSym('R 3 c R',[
3081            ((0.13,0.22,0.31),6,'1'),
3082            ((0.31,0.31,0.31),2,'3(111)'),
3083            ])
3084    ExerciseSiteSym('P 63 m c',[
3085            ((0.13,0.22,0.31),12,'1'),
3086            ((0.11,0.22,0.31),6,'m(100)'),
3087            ((0.333333,0.6666667,0.31),2,'3m(100)'),
3088            ((0,0,0.31),2,'3m(100)'),
3089            ])
3090    ExerciseSiteSym('I a -3',[
3091            ((0.13,0.22,0.31),48,'1'),
3092            ((0.11,0,0.25),24,'2(x)'),
3093            ((0.11,0.11,0.11),16,'3(111)'),
3094            ((0,0,0),8,'-3(111)'),
3095            ])
3096selftestlist.append(test3)
3097
3098if __name__ == '__main__':
3099    # run self-tests
3100    selftestquiet = False
3101    for test in selftestlist:
3102        test()
3103    print "OK"
Note: See TracBrowser for help on using the repository browser.