source: trunk/GSASIIspc.py @ 1637

Last change on this file since 1637 was 1637, checked in by vondreele, 8 years ago

fixes to peak indexing routines; new Inst argument for getHKLpeak messed up indexing routines. Now optional at end of arguments.
some more work on SS constraints.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Date Author Revision URL Id
File size: 125.4 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-02-06 21:09:50 +0000 (Fri, 06 Feb 2015) $
12# $Author: vondreele $
13# $Revision: 1637 $
14# $URL: trunk/GSASIIspc.py $
15# $Id: GSASIIspc.py 1637 2015-02-06 21:09:50Z 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: 1637 $")
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 = HKL+[0,]
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    Sdtau = np.array(Sdtau)
1505    SdIndx = np.argsort(Sdtau)
1506    print SdIndx
1507    OpText =  [MT2text(s).replace(' ','') for s in Sop]         #debug?
1508    SSOpText = [SSMT2text(ss).replace(' ','') for ss in SSop]   #debug?
1509    print 'special pos super operators: ',SSOpText
1510    #setup displacement arrays
1511    tau = np.linspace(0,1,49,True)
1512    delt2 = np.eye(2)*0.001
1513    delt4 = np.eye(4)*0.001
1514    delt6 = np.eye(6)*0.001
1515    delt12 = np.eye(12)*0.0001
1516    #make modulation arrays - one parameter at a time
1517    #site fractions
1518    CSI['Sfrac'] = [np.zeros((2),dtype='i'),np.ones(2)]
1519    if 'Crenel' in waveType:
1520        dF = fracCrenel(tau,delt2[:1],delt2[1:]).squeeze()
1521    else:
1522        dF = fracFourier(tau,nH,delt2[:1],delt2[1:]).squeeze()
1523    dFT = np.zeros_like(dF)
1524    #positions       
1525    if 'Fourier' in waveType:
1526        dX = posFourier(tau,nH,delt6[:3],delt6[3:]) #+np.array(XYZ)[:,np.newaxis,np.newaxis]
1527          #3x6x12 modulated position array (X,Spos,tau)& force positive
1528        CSI['Spos'] = [np.zeros((6,3),dtype='i'),np.zeros((6,3))]
1529    elif waveType == 'Sawtooth':
1530        CSI['Spos'] = [np.array([[1,],[2,],[3,],[4,]]),np.array([[1.0,],[1.0,],[1.0,],[1.0,]])]
1531    elif waveType == 'ZigZag':
1532        CSI['Spos'] = [np.array([[1,],[2,],[3,],[4,]]),np.array([[1.0,],[1.0,],[1.0,],[1.0,]])]
1533    #anisotropic thermal motion
1534    dU = posFourier(tau,nH,delt12[:6],delt12[6:])                  #Uij modulations - 6x12x12 array
1535    CSI['Sadp'] = [np.zeros((12,3),dtype='i'),np.zeros((12,3))]
1536       
1537    FSC = np.ones(2,dtype='i')
1538    VFSC = np.ones(2)
1539    XSC = np.ones(6,dtype='i')
1540    USC = np.ones(12,dtype='i')
1541    dFTP = []
1542    dXTP = []
1543    dUTP = []
1544    for i in SdIndx:
1545        sop = Sop[i]
1546        ssop = SSop[i]
1547        fsc = np.ones(2,dtype='i')
1548        xsc = np.ones(6,dtype='i')
1549        ssopinv = nl.inv(ssop[0])
1550        mst = ssopinv[3][:3]
1551        epsinv = ssopinv[3][3]
1552        sdet = nl.det(sop[0])
1553        ssdet = nl.det(ssop[0])
1554        dtau = mst*(XYZ-sop[1])-epsinv*ssop[1][3]
1555        dT = 1.0
1556        if np.any(dtau%.5):
1557            dT = np.tan(np.pi*np.sum(dtau))
1558        tauT = np.inner(mst,XYZ-sop[1])+epsinv*(tau-ssop[1][3])
1559        if waveType == 'Fourier':
1560            dXT = posFourier(np.sort(tauT),nH,delt6[:3],delt6[3:])   #+np.array(XYZ)[:,np.newaxis,np.newaxis]
1561        elif waveType == 'Sawtooth':
1562            dXT = posSawtooth(tauT,delt4[0],delt4[1:])+np.array(XYZ)[:,np.newaxis,np.newaxis]
1563        elif waveType == 'ZigZag':
1564            dXT = posZigZag(tauT,delt4[0],delt4[1:])+np.array(XYZ)[:,np.newaxis,np.newaxis]           
1565        dXT = np.inner(sop[0],dXT.T)
1566        dXT = np.swapaxes(dXT,1,2)
1567        dXT[:,:3,:] *= ssdet
1568        dXTP.append(dXT)
1569        if waveType == 'Fourier':
1570            if np.any(dtau%.5) and ('1/2' in SSGData['modSymb'] or '1' in SSGData['modSymb']):
1571                dt = sdet*dT**sdet
1572                CSI['Spos'] = [[[1,0,0],[2,0,0],[3,0,0], [1,0,0],[2,0,0],[3,0,0]],
1573                    [[1.,0.,0.],[1.,0.,0.],[1.,0.,0.], [1.,0.,0.],[1.,0.,0.],[1.,0.,0.]]]
1574                if '(x)' in siteSym:
1575                    CSI['Spos'][1][3:] = [1./dt,0.,0.],[-dt,0.,0.],[-dt,0.,0.]
1576                elif '(y)' in siteSym:
1577                    CSI['Spos'][1][3:] = [-dt,0.,0.],[1./dt,0.,0.],[-dt,0.,0.]
1578                elif '(z)' in siteSym:
1579                    CSI['Spos'][1][3:] = [-dt,0.,0.],[-dt,0.,0.],[1./dt,0.,0.]
1580            else:
1581                for i in range(3):
1582                    if np.allclose(dX[i,i,:],dXT[i,i,:]*sdet):
1583                        xsc[i] = 1
1584                    else:
1585                        xsc[i] = 0
1586                    if np.allclose(dX[i,i+3,:],dXT[i,i+3,:]):
1587                        xsc[i+3] = 1
1588                    else:
1589                        xsc[i+3] = 0
1590            XSC &= xsc
1591           
1592        fsc = np.ones(2,dtype='i')
1593        if 'Crenel' in waveType:
1594            dFT = fracCrenel(tauT,delt2[:1],delt2[1:]).squeeze()
1595            fsc = [1,1]
1596        else:
1597            dFT = fracFourier(tauT,nH,delt2[:1],delt2[1:]).squeeze()
1598            dFT = nl.det(sop[0])*dFT
1599            dFT = dFT[:,np.argsort(tauT)]
1600            dFT[0] *= ssdet
1601            dFT[1] *= sdet
1602            dFTP.append(dFT)
1603       
1604            if np.any(dtau%.5) and ('1/2' in SSGData['modSymb'] or '1' in SSGData['modSymb']):
1605                dt = dT     #**sdet
1606                fsc = [1,1]
1607                CSI['Sfrac'] = [[[1,0],[1,0]],[[1.,0.],[1/dt,0.]]]
1608            else:
1609                for i in range(2):
1610                    if np.allclose(dF[i,:],dFT[i,:],atol=1.e-6):
1611                        fsc[i] = 1
1612                    else:
1613                        fsc[i] = 0
1614        FSC &= fsc
1615           
1616        usc = np.ones(12,dtype='i')
1617        # make 12x12x4x4 with tau layers?
1618        dUT = posFourier(tauT,nH,delt12[:6],delt12[6:])                  #Uij modulations - 6x12x12 array
1619        dUijT = np.rollaxis(np.rollaxis(np.array(Uij2U(dUT)),3),3)    #convert dUT to 12x12x3x3
1620        dUijT = np.rollaxis(np.inner(np.inner(sop[0],dUijT),sop[0].T),3)
1621        dUT = np.array(U2Uij(dUijT))
1622        dUT = dUT[:,:,np.argsort(tauT)]
1623        dUT[:,:6,:] *= ssdet*sdet
1624        dUTP.append(dUT)
1625        if np.any(dtau%.5) and ('1/2' in SSGData['modSymb'] or '1' in SSGData['modSymb']):
1626            dt = dT     #**sdet
1627            CSI['Sadp'] = [[[1,0,0],[2,0,0],[3,0,0],[4,0,0],[5,0,0],[6,0,0], 
1628            [1,0,0],[2,0,0],[3,0,0],[4,0,0],[5,0,0],[6,0,0]],
1629            [[1.,0.,0.],[1.,0.,0.],[1.,0.,0.], [1.,0.,0.],[1.,0.,0.],[1.,0.,0.],
1630            [1./dt,0.,0.],[1./dt,0.,0.],[1./dt,0.,0.], [1.,0.,0.],[1.,0.,0.],[1.,0.,0.]]]
1631            if '(x)' in siteSym:
1632                CSI['Sadp'][1][9:] = [-dt,0.,0.],[-dt,0.,0.],[1./dt,0.,0.]
1633            elif '(y)' in siteSym:
1634                CSI['Sadp'][1][9:] = [-dt,0.,0.],[1./dt,0.,0.],[-dt,0.,0.]
1635            elif '(z)' in siteSym:
1636                CSI['Sadp'][1][9:] = [1./dt,0.,0.],[-dt,0.,0.],[-dt,0.,0.]
1637        else:
1638            for i in range(6):
1639                if np.allclose(dU[i,i,:],dUT[i,i,:]):
1640                    usc[i] = 1
1641                else:
1642                    usc[i] = 0
1643                if np.allclose(dU[i,i+6,:],dUT[i,i+6,:]):
1644                    usc[i+6] = 1
1645                else:
1646                    usc[i+6] = 0
1647        USC &= usc
1648    if not np.any(dtau%.5):
1649        n = -1
1650        for i,U in enumerate(USC):
1651            if U:
1652                n += 1
1653                CSI['Sadp'][0][i][0] = n+1
1654                CSI['Sadp'][1][i][0] = 1.0
1655        if waveType == 'Fourier':
1656            n = -1
1657            for i,X in enumerate(XSC):
1658                if X:
1659                    n += 1
1660                    CSI['Spos'][0][i][0] = n+1
1661                    CSI['Spos'][1][i][0] = 1.0
1662        n = -1
1663        for i,F in enumerate(FSC):
1664            if F:
1665                n += 1
1666                CSI['Sfrac'][0][i] = n+1
1667                CSI['Sfrac'][1][i] = 1.0
1668            else:
1669                CSI['Sfrac'][0][i] = 0
1670                CSI['Sfrac'][1][i] = 0.           
1671    if debug:
1672        return CSI,[tau,tauT],[dF,dFTP],[dX,dXTP],[dU,dUTP]
1673    else:
1674        return CSI
1675   
1676def MustrainNames(SGData):
1677    'Needs a doc string'
1678    laue = SGData['SGLaue']
1679    uniq = SGData['SGUniq']
1680    if laue in ['m3','m3m']:
1681        return ['S400','S220']
1682    elif laue in ['6/m','6/mmm','3m1']:
1683        return ['S400','S004','S202']
1684    elif laue in ['31m','3']:
1685        return ['S400','S004','S202','S211']
1686    elif laue in ['3R','3mR']:
1687        return ['S400','S220','S310','S211']
1688    elif laue in ['4/m','4/mmm']:
1689        return ['S400','S004','S220','S022']
1690    elif laue in ['mmm']:
1691        return ['S400','S040','S004','S220','S202','S022']
1692    elif laue in ['2/m']:
1693        SHKL = ['S400','S040','S004','S220','S202','S022']
1694        if uniq == 'a':
1695            SHKL += ['S013','S031','S211']
1696        elif uniq == 'b':
1697            SHKL += ['S301','S103','S121']
1698        elif uniq == 'c':
1699            SHKL += ['S130','S310','S112']
1700        return SHKL
1701    else:
1702        SHKL = ['S400','S040','S004','S220','S202','S022']
1703        SHKL += ['S310','S103','S031','S130','S301','S013']
1704        SHKL += ['S211','S121','S112']
1705        return SHKL
1706       
1707def HStrainVals(HSvals,SGData):
1708    laue = SGData['SGLaue']
1709    uniq = SGData['SGUniq']
1710    DIJ = np.zeros(6)
1711    if laue in ['m3','m3m']:
1712        DIJ[:3] = [HSvals[0],HSvals[0],HSvals[0]]
1713    elif laue in ['6/m','6/mmm','3m1','31m','3']:
1714        DIJ[:4] = [HSvals[0],HSvals[0],HSvals[1],HSvals[0]]
1715    elif laue in ['3R','3mR']:
1716        DIJ = [HSvals[0],HSvals[0],HSvals[0],HSvals[1],HSvals[1],HSvals[1]]
1717    elif laue in ['4/m','4/mmm']:
1718        DIJ[:3] = [HSvals[0],HSvals[0],HSvals[1]]
1719    elif laue in ['mmm']:
1720        DIJ[:3] = [HSvals[0],HSvals[1],HSvals[2]]
1721    elif laue in ['2/m']:
1722        DIJ[:3] = [HSvals[0],HSvals[1],HSvals[2]]
1723        if uniq == 'a':
1724            DIJ[5] = HSvals[3]
1725        elif uniq == 'b':
1726            DIJ[4] = HSvals[3]
1727        elif uniq == 'c':
1728            DIJ[3] = HSvals[3]
1729    else:
1730        DIJ = [HSvals[0],HSvals[1],HSvals[2],HSvals[3],HSvals[4],HSvals[5]]
1731    return DIJ
1732
1733def HStrainNames(SGData):
1734    'Needs a doc string'
1735    laue = SGData['SGLaue']
1736    uniq = SGData['SGUniq']
1737    if laue in ['m3','m3m']:
1738        return ['D11','eA']         #add cubic strain term
1739    elif laue in ['6/m','6/mmm','3m1','31m','3']:
1740        return ['D11','D33']
1741    elif laue in ['3R','3mR']:
1742        return ['D11','D12']
1743    elif laue in ['4/m','4/mmm']:
1744        return ['D11','D33']
1745    elif laue in ['mmm']:
1746        return ['D11','D22','D33']
1747    elif laue in ['2/m']:
1748        Dij = ['D11','D22','D33']
1749        if uniq == 'a':
1750            Dij += ['D23']
1751        elif uniq == 'b':
1752            Dij += ['D13']
1753        elif uniq == 'c':
1754            Dij += ['D12']
1755        return Dij
1756    else:
1757        Dij = ['D11','D22','D33','D12','D13','D23']
1758        return Dij
1759   
1760def MustrainCoeff(HKL,SGData):
1761    'Needs a doc string'
1762    #NB: order of terms is the same as returned by MustrainNames
1763    laue = SGData['SGLaue']
1764    uniq = SGData['SGUniq']
1765    h,k,l = HKL
1766    Strm = []
1767    if laue in ['m3','m3m']:
1768        Strm.append(h**4+k**4+l**4)
1769        Strm.append(3.0*((h*k)**2+(h*l)**2+(k*l)**2))
1770    elif laue in ['6/m','6/mmm','3m1']:
1771        Strm.append(h**4+k**4+2.0*k*h**3+2.0*h*k**3+3.0*(h*k)**2)
1772        Strm.append(l**4)
1773        Strm.append(3.0*((h*l)**2+(k*l)**2+h*k*l**2))
1774    elif laue in ['31m','3']:
1775        Strm.append(h**4+k**4+2.0*k*h**3+2.0*h*k**3+3.0*(h*k)**2)
1776        Strm.append(l**4)
1777        Strm.append(3.0*((h*l)**2+(k*l)**2+h*k*l**2))
1778        Strm.append(4.0*h*k*l*(h+k))
1779    elif laue in ['3R','3mR']:
1780        Strm.append(h**4+k**4+l**4)
1781        Strm.append(3.0*((h*k)**2+(h*l)**2+(k*l)**2))
1782        Strm.append(2.0*(h*l**3+l*k**3+k*h**3)+2.0*(l*h**3+k*l**3+l*k**3))
1783        Strm.append(4.0*(k*l*h**2+h*l*k**2+h*k*l**2))
1784    elif laue in ['4/m','4/mmm']:
1785        Strm.append(h**4+k**4)
1786        Strm.append(l**4)
1787        Strm.append(3.0*(h*k)**2)
1788        Strm.append(3.0*((h*l)**2+(k*l)**2))
1789    elif laue in ['mmm']:
1790        Strm.append(h**4)
1791        Strm.append(k**4)
1792        Strm.append(l**4)
1793        Strm.append(3.0*(h*k)**2)
1794        Strm.append(3.0*(h*l)**2)
1795        Strm.append(3.0*(k*l)**2)
1796    elif laue in ['2/m']:
1797        Strm.append(h**4)
1798        Strm.append(k**4)
1799        Strm.append(l**4)
1800        Strm.append(3.0*(h*k)**2)
1801        Strm.append(3.0*(h*l)**2)
1802        Strm.append(3.0*(k*l)**2)
1803        if uniq == 'a':
1804            Strm.append(2.0*k*l**3)
1805            Strm.append(2.0*l*k**3)
1806            Strm.append(4.0*k*l*h**2)
1807        elif uniq == 'b':
1808            Strm.append(2.0*l*h**3)
1809            Strm.append(2.0*h*l**3)
1810            Strm.append(4.0*h*l*k**2)
1811        elif uniq == 'c':
1812            Strm.append(2.0*h*k**3)
1813            Strm.append(2.0*k*h**3)
1814            Strm.append(4.0*h*k*l**2)
1815    else:
1816        Strm.append(h**4)
1817        Strm.append(k**4)
1818        Strm.append(l**4)
1819        Strm.append(3.0*(h*k)**2)
1820        Strm.append(3.0*(h*l)**2)
1821        Strm.append(3.0*(k*l)**2)
1822        Strm.append(2.0*k*h**3)
1823        Strm.append(2.0*h*l**3)
1824        Strm.append(2.0*l*k**3)
1825        Strm.append(2.0*h*k**3)
1826        Strm.append(2.0*l*h**3)
1827        Strm.append(2.0*k*l**3)
1828        Strm.append(4.0*k*l*h**2)
1829        Strm.append(4.0*h*l*k**2)
1830        Strm.append(4.0*k*h*l**2)
1831    return Strm
1832   
1833def Muiso2Shkl(muiso,SGData,cell):
1834    "this is to convert isotropic mustrain to generalized Shkls"
1835    import GSASIIlattice as G2lat
1836    A = G2lat.cell2AB(cell)[0]
1837   
1838    def minMus(Shkl,muiso,H,SGData,A):
1839        U = np.inner(A.T,H)
1840        S = np.array(MustrainCoeff(U,SGData))
1841        Sum = np.sqrt(np.sum(np.multiply(S,Shkl[:,np.newaxis]),axis=0))
1842        rad = np.sqrt(np.sum((Sum[:,np.newaxis]*H)**2,axis=1))
1843        return (muiso-rad)**2
1844       
1845    laue = SGData['SGLaue']
1846    PHI = np.linspace(0.,360.,60,True)
1847    PSI = np.linspace(0.,180.,60,True)
1848    X = np.outer(npsind(PHI),npsind(PSI))
1849    Y = np.outer(npcosd(PHI),npsind(PSI))
1850    Z = np.outer(np.ones(np.size(PHI)),npcosd(PSI))
1851    HKL = np.dstack((X,Y,Z))
1852    if laue in ['m3','m3m']:
1853        S0 = [1000.,1000.]
1854    elif laue in ['6/m','6/mmm','3m1']:
1855        S0 = [1000.,1000.,1000.]
1856    elif laue in ['31m','3']:
1857        S0 = [1000.,1000.,1000.,1000.]
1858    elif laue in ['3R','3mR']:
1859        S0 = [1000.,1000.,1000.,1000.]
1860    elif laue in ['4/m','4/mmm']:
1861        S0 = [1000.,1000.,1000.,1000.]
1862    elif laue in ['mmm']:
1863        S0 = [1000.,1000.,1000.,1000.,1000.,1000.]
1864    elif laue in ['2/m']:
1865        S0 = [1000.,1000.,1000.,0.,0.,0.,0.,0.,0.]
1866    else:
1867        S0 = [1000.,1000.,1000.,1000.,1000., 1000.,1000.,1000.,1000.,1000., 
1868            1000.,1000.,0.,0.,0.]
1869    S0 = np.array(S0)
1870    HKL = np.reshape(HKL,(-1,3))
1871    result = so.leastsq(minMus,S0,(np.ones(HKL.shape[0])*muiso,HKL,SGData,A))
1872    return result[0]
1873       
1874def SytSym(XYZ,SGData):
1875    '''
1876    Generates the number of equivalent positions and a site symmetry code for a specified coordinate and space group
1877
1878    :param XYZ: an array, tuple or list containing 3 elements: x, y & z
1879    :param SGData: from SpcGroup
1880    :Returns: a two element tuple:
1881
1882     * The 1st element is a code for the site symmetry (see GetKNsym)
1883     * The 2nd element is the site multiplicity
1884
1885    '''
1886    def PackRot(SGOps):
1887        IRT = []
1888        for ops in SGOps:
1889            M = ops[0]
1890            irt = 0
1891            for j in range(2,-1,-1):
1892                for k in range(2,-1,-1):
1893                    irt *= 3
1894                    irt += M[k][j]
1895            IRT.append(int(irt))
1896        return IRT
1897       
1898    SymName = ''
1899    Mult = 1
1900    Isym = 0
1901    if SGData['SGLaue'] in ['3','3m1','31m','6/m','6/mmm']:
1902        Isym = 1073741824
1903    Jdup = 0
1904    Xeqv = GenAtom(XYZ,SGData,True)
1905    IRT = PackRot(SGData['SGOps'])
1906    L = -1
1907    for ic,cen in enumerate(SGData['SGCen']):
1908        for invers in range(int(SGData['SGInv']+1)):
1909            for io,ops in enumerate(SGData['SGOps']):
1910                irtx = (1-2*invers)*IRT[io]
1911                L += 1
1912                if not Xeqv[L][1]:
1913                    Jdup += 1
1914                    jx = GetOprPtrName(str(irtx))
1915                    if jx[2] < 39:
1916                        Isym += 2**(jx[2]-1)
1917    if Isym == 1073741824: Isym = 0
1918    Mult = len(SGData['SGOps'])*len(SGData['SGCen'])*(int(SGData['SGInv'])+1)/Jdup
1919         
1920    return GetKNsym(str(Isym)),Mult
1921   
1922def ElemPosition(SGData):
1923    ''' Under development.
1924    Object here is to return a list of symmetry element types and locations suitable
1925    for say drawing them.
1926    So far I have the element type... getting all possible locations without lookup may be impossible!
1927    '''
1928    SymElements = []
1929    Inv = SGData['SGInv']
1930    Cen = SGData['SGCen']
1931    eleSym = {-3:['','-1'],-2:['',-6],-1:['2','-4'],0:['3','-3'],1:['4','m'],2:['6',''],3:['1','']}
1932    # get operators & expand if centrosymmetric
1933    Ops = SGData['SGOps']
1934    opM = np.array([op[0].T for op in Ops])
1935    opT = np.array([op[1] for op in Ops])
1936    if Inv:
1937        opM = np.concatenate((opM,-opM))
1938        opT = np.concatenate((opT,-opT))
1939    opMT = zip(opM,opT)
1940    for M,T in opMT[1:]:        #skip I
1941        Dt = int(nl.det(M))
1942        Tr = int(np.trace(M))
1943        Dt = -(Dt-1)/2
1944        Es = eleSym[Tr][Dt]
1945        if Dt:              #rotation-inversion
1946            I = np.eye(3)
1947            if Tr == 1:     #mirrors/glides
1948                if np.any(T):       #glide
1949                    M2 = np.inner(M,M)
1950                    MT = np.inner(M,T)+T
1951                    print 'glide',Es,MT
1952                    print M2
1953                else:               #mirror
1954                    print 'mirror',Es,T
1955                    print I-M
1956                X = [-1,-1,-1]
1957            elif Tr == -3:  # pure inversion
1958                X = np.inner(nl.inv(I-M),T)
1959                print 'inversion',Es,X
1960            else:           #other rotation-inversion
1961                M2 = np.inner(M,M)
1962                MT = np.inner(M,T)+T
1963                print 'rot-inv',Es,MT
1964                print M2
1965                X = [-1,-1,-1]
1966        else:               #rotations
1967            print 'rotation',Es
1968            X = [-1,-1,-1]
1969        #SymElements.append([Es,X])
1970       
1971    return #SymElements
1972   
1973def ApplyStringOps(A,SGData,X,Uij=[]):
1974    'Needs a doc string'
1975    SGOps = SGData['SGOps']
1976    SGCen = SGData['SGCen']
1977    Ax = A.split('+')
1978    Ax[0] = int(Ax[0])
1979    iC = 0
1980    if Ax[0] < 0:
1981        iC = 1
1982    Ax[0] = abs(Ax[0])
1983    nA = Ax[0]%100-1
1984    cA = Ax[0]/100
1985    Cen = SGCen[cA]
1986    M,T = SGOps[nA]
1987    if len(Ax)>1:
1988        cellA = Ax[1].split(',')
1989        cellA = np.array([int(a) for a in cellA])
1990    else:
1991        cellA = np.zeros(3)
1992    newX = (1-2*iC)*(Cen+np.inner(M,X)+T)+cellA
1993    if len(Uij):
1994        U = Uij2U(Uij)
1995        U = np.inner(M,np.inner(U,M).T)
1996        newUij = U2Uij(U)
1997        return [newX,newUij]
1998    else:
1999        return newX
2000       
2001def StringOpsProd(A,B,SGData):
2002    """
2003    Find A*B where A & B are in strings '-' + '100*c+n' + '+ijk'
2004    where '-' indicates inversion, c(>0) is the cell centering operator,
2005    n is operator number from SgOps and ijk are unit cell translations (each may be <0).
2006    Should return resultant string - C. SGData - dictionary using entries:
2007
2008       *  'SGCen': cell centering vectors [0,0,0] at least
2009       *  'SGOps': symmetry operations as [M,T] so that M*x+T = x'
2010
2011    """
2012    SGOps = SGData['SGOps']
2013    SGCen = SGData['SGCen']
2014    #1st split out the cell translation part & work on the operator parts
2015    Ax = A.split('+'); Bx = B.split('+')
2016    Ax[0] = int(Ax[0]); Bx[0] = int(Bx[0])
2017    iC = 0
2018    if Ax[0]*Bx[0] < 0:
2019        iC = 1
2020    Ax[0] = abs(Ax[0]); Bx[0] = abs(Bx[0])
2021    nA = Ax[0]%100-1;  nB = Bx[0]%100-1
2022    cA = Ax[0]/100;  cB = Bx[0]/100
2023    Cen = (SGCen[cA]+SGCen[cB])%1.0
2024    cC = np.nonzero([np.allclose(C,Cen) for C in SGCen])[0][0]
2025    Ma,Ta = SGOps[nA]; Mb,Tb = SGOps[nB]
2026    Mc = np.inner(Ma,Mb.T)
2027#    print Ma,Mb,Mc
2028    Tc = (np.add(np.inner(Mb,Ta)+1.,Tb))%1.0
2029#    print Ta,Tb,Tc
2030#    print [np.allclose(M,Mc)&np.allclose(T,Tc) for M,T in SGOps]
2031    nC = np.nonzero([np.allclose(M,Mc)&np.allclose(T,Tc) for M,T in SGOps])[0][0]
2032    #now the cell translation part
2033    if len(Ax)>1:
2034        cellA = Ax[1].split(',')
2035        cellA = [int(a) for a in cellA]
2036    else:
2037        cellA = [0,0,0]
2038    if len(Bx)>1:
2039        cellB = Bx[1].split(',')
2040        cellB = [int(b) for b in cellB]
2041    else:
2042        cellB = [0,0,0]
2043    cellC = np.add(cellA,cellB)
2044    C = str(((nC+1)+(100*cC))*(1-2*iC))+'+'+ \
2045        str(int(cellC[0]))+','+str(int(cellC[1]))+','+str(int(cellC[2]))
2046    return C
2047           
2048def U2Uij(U):
2049    #returns the UIJ vector U11,U22,U33,U12,U13,U23 from tensor U
2050    return [U[0][0],U[1][1],U[2][2],2.*U[0][1],2.*U[0][2],2.*U[1][2]]
2051   
2052def Uij2U(Uij):
2053    #returns the thermal motion tensor U from Uij as numpy array
2054    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]]])
2055
2056def StandardizeSpcName(spcgroup):
2057    '''Accept a spacegroup name where spaces may have not been used
2058    in the names according to the GSAS convention (spaces between symmetry
2059    for each axis) and return the space group name as used in GSAS
2060    '''
2061    rspc = spcgroup.replace(' ','').upper()
2062    # deal with rhombohedral and hexagonal setting designations
2063    rhomb = ''
2064    if rspc[-1:] == 'R':
2065        rspc = rspc[:-1]
2066        rhomb = ' R'
2067    elif rspc[-1:] == 'H': # hexagonal is assumed and thus can be ignored
2068        rspc = rspc[:-1]
2069    # look for a match in the spacegroup lists
2070    for i in spglist.values():
2071        for spc in i:
2072            if rspc == spc.replace(' ','').upper():
2073                return spc + rhomb
2074    # how about the post-2002 orthorhombic names?
2075    for i,spc in sgequiv_2002_orthorhombic:
2076        if rspc == i.replace(' ','').upper():
2077            return spc
2078    # not found
2079    return ''
2080
2081   
2082spglist = {}
2083'''A dictionary of space groups as ordered and named in the pre-2002 International
2084Tables Volume A, except that spaces are used following the GSAS convention to
2085separate the different crystallographic directions.
2086Note that the symmetry codes here will recognize many non-standard space group
2087symbols with different settings. They are ordered by Laue group
2088'''
2089spglist = {
2090    'P1' : ('P 1','P -1',), # 1-2
2091    'P2/m': ('P 2','P 21','P m','P a','P c','P n',
2092        '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
2093    'C2/m':('C 2','C m','C c','C n',
2094        'C 2/m','C 2/c','C 2/n',),
2095    'Pmmm':('P 2 2 2',
2096        'P 2 2 21','P 21 2 2','P 2 21 2',
2097        'P 21 21 2','P 2 21 21','P 21 2 21',
2098        'P 21 21 21',
2099        'P m m 2','P 2 m m','P m 2 m',
2100        'P m c 21','P 21 m a','P b 21 m','P m 21 b','P c m 21','P 21 a m',
2101        'P c c 2','P 2 a a','P b 2 b',
2102        'P m a 2','P 2 m b','P c 2 m','P m 2 a','P b m 2','P 2 c m',
2103        'P c a 21','P 21 a b','P c 21 b','P b 21 a','P b c 21','P 21 c a',
2104        'P n c 2','P 2 n a','P b 2 n','P n 2 b','P c n 2','P 2 a n',
2105        'P m n 21','P 21 m n','P n 21 m','P m 21 n','P n m 21','P 21 n m',
2106        'P b a 2','P 2 c b','P c 2 a',
2107        'P n a 21','P 21 n b','P c 21 n','P n 21 a','P b n 21','P 21 c n',
2108        'P n n 2','P 2 n n','P n 2 n',
2109        'P m m m','P n n n',
2110        'P c c m','P m a a','P b m b',
2111        'P b a n','P n c b','P c n a',
2112        'P m m a','P b m m','P m c m','P m a m','P m m b','P c m m',
2113        'P n n a','P b n n','P n c n','P n a n','P n n b','P c n n',
2114        'P m n a','P b m n','P n c m','P m a n','P n m b','P c n m',
2115        'P c c a','P b a a','P b c b','P b a b','P c c b','P c a a',
2116        'P b a m','P m c b','P c m a',
2117        'P c c n','P n a a','P b n b',
2118        'P b c m','P m c a','P b m a','P c m b','P c a m','P m a b',
2119        'P n n m','P m n n','P n m n',
2120        'P m m n','P n m m','P m n m',
2121        'P b c n','P n c a','P b n a','P c n b','P c a n','P n a b',
2122        'P b c a','P c a b',
2123        'P n m a','P b n m','P m c n','P n a m','P m n b','P c m n',
2124        ),
2125    'Cmmm':('C 2 2 21','C 2 2 2','C m m 2',
2126        'C m c 21','C c m 21','C c c 2','C m 2 m','C 2 m m',
2127        'C m 2 a','C 2 m b','C c 2 m','C 2 c m','C c 2 a','C 2 c b',
2128        'C m c m','C m c a','C c m b',
2129        'C m m m','C c c m','C m m a','C m m b','C c c a','C c c b',),
2130    'Immm':('I 2 2 2','I 21 21 21',
2131        'I m m 2','I m 2 m','I 2 m m',
2132        'I b a 2','I 2 c b','I c 2 a',
2133        'I m a 2','I 2 m b','I c 2 m','I m 2 a','I b m 2','I 2 c m',
2134        'I m m m','I b a m','I m c b','I c m a',
2135        'I b c a','I c a b',
2136        'I m m a','I b m m ','I m c m','I m a m','I m m b','I c m m',),
2137    'Fmmm':('F 2 2 2','F m m m', 'F d d d',
2138        'F m m 2','F m 2 m','F 2 m m',
2139        'F d d 2','F d 2 d','F 2 d d',),
2140    'P4/mmm':('P 4','P 41','P 42','P 43','P -4','P 4/m','P 42/m','P 4/n','P 42/n',
2141        'P 4 2 2','P 4 21 2','P 41 2 2','P 41 21 2','P 42 2 2',
2142        'P 42 21 2','P 43 2 2','P 43 21 2','P 4 m m','P 4 b m','P 42 c m',
2143        'P 42 n m','P 4 c c','P 4 n c','P 42 m c','P 42 b c','P -4 2 m',
2144        'P -4 2 c','P -4 21 m','P -4 21 c','P -4 m 2','P -4 c 2','P -4 b 2',
2145        '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',
2146        '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',
2147        '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',
2148        'P 42/n c m',),
2149    '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',
2150        'I 4 c m','I 41 m d','I 41 c d',
2151        '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',
2152        'I 41/a m d','I 41/a c d'),
2153    'R3-H':('R 3','R -3','R 3 2','R 3 m','R 3 c','R -3 m','R -3 c',),
2154    'P6/mmm': ('P 3','P 31','P 32','P -3','P 3 1 2','P 3 2 1','P 31 1 2',
2155        'P 31 2 1','P 32 1 2','P 32 2 1', 'P 3 m 1','P 3 1 m','P 3 c 1',
2156        'P 3 1 c','P -3 1 m','P -3 1 c','P -3 m 1','P -3 c 1','P 6','P 61',
2157        'P 65','P 62','P 64','P 63','P -6','P 6/m','P 63/m','P 6 2 2',
2158        'P 61 2 2','P 65 2 2','P 62 2 2','P 64 2 2','P 63 2 2','P 6 m m',
2159        'P 6 c c','P 63 c m','P 63 m c','P -6 m 2','P -6 c 2','P -6 2 m',
2160        'P -6 2 c','P 6/m m m','P 6/m c c','P 63/m c m','P 63/m m c',),
2161    'Pm3m': ('P 2 3','P 21 3','P m 3','P n 3','P a 3','P 4 3 2','P 42 3 2',
2162        'P 43 3 2','P 41 3 2','P -4 3 m','P -4 3 n','P m 3 m','P n 3 n',
2163        'P m 3 n','P n 3 m',),
2164    'Im3m':('I 2 3','I 21 3','I m -3','I a -3', 'I 4 3 2','I 41 3 2',
2165        'I -4 3 m', 'I -4 3 d','I m -3 m','I m 3 m','I a -3 d',),
2166    'Fm3m':('F 2 3','F m -3','F d -3','F 4 3 2','F 41 3 2','F -4 3 m',
2167        'F -4 3 c','F m -3 m','F m 3 m','F m -3 c','F d -3 m','F d -3 c',),
2168}
2169
2170ssdict = {}
2171'''A dictionary of superspace group symbols allowed for each entry in spglist
2172(except cubics). Monoclinics are all b-unique setting.
2173'''
2174ssdict = {
2175#1,2
2176    'P 1':['(abg)',],'P -1':['(abg)',],
2177#monoclinic - done
2178#3
2179    'P 2':['(a0g)','(a1/2g)','(0b0)','(0b0)s','(1/2b0)','(0b1/2)',],
2180#4       
2181    'P 21':['(a0g)','(0b0)','(1/2b0)','(0b1/2)',],
2182#5
2183    'C 2':['(a0g)','(0b0)','(0b0)s','(0b1/2)',],
2184#6
2185    'P m':['(a0g)','(a0g)s','(a1/2g)','(0b0)','(1/2b0)','(0b1/2)',],
2186#7
2187    'P a':['(a0g)','(a1/2g)','(0b0)','(0b1/2)',],
2188    'P c':['(a0g)','(a1/2g)','(0b0)','(1/2b0)',],
2189    'P n':['(a0g)','(a1/2g)','(0b0)','(1/2b1/2)',],
2190#8       
2191    'C m':['(a0g)','(a0g)s','(0b0)','(0b1/2)',],
2192#9       
2193    'C c':['(a0g)','(a0g)s','(0b0)',],
2194    'C n':['(a0g)','(a0g)s','(0b0)',],
2195#10       
2196    'P 2/m':['(a0g)','(a0g)0s','(a1/2g)','(0b0)','(0b0)s0','(1/2b0)','(0b1/2)',],
2197#11
2198    'P 21/m':['(a0g)','(a0g)0s','(0b0)','(0b0)s0','(1/2b0)','(0b1/2)',],
2199#12       
2200    'C 2/m':['(a0g)','(a0g)0s','(0b0)','(0b0)s0','(0b1/2)',],
2201#13
2202    'P 2/c':['(a0g)','(a0g)0s','(a1/2g)','(0b0)','(0b0)s0','(1/2b0)',],
2203    'P 2/a':['(a0g)','(a0g)0s','(a1/2g)','(0b0)','(0b0)s0','(0b1/2)',],
2204    'P 2/n':['(a0g)','(a0g)0s','(a1/2g)','(0b0)','(0b0)s0','(1/2b1/2)',],
2205#14
2206    'P 21/c':['(a0g)','(0b0)','(1/2b0)',],
2207    'P 21/a':['(a0g)','(0b0)','(0b1/2)',],
2208    'P 21/n':['(a0g)','(0b0)','(1/2b1/2)',],
2209#15
2210    'C 2/c':['(a0g)','(0b0)','(0b0)s0',],
2211    'C 2/n':['(a0g)','(0b0)','(0b0)s0',],
2212#orthorhombic
2213#16   
2214    'P 2 2 2':['(00g)','(00g)00s','(01/2g)','(1/20g)','(1/21/2g)',
2215        '(a00)','(a00)s00','(a01/2)','(a1/20)','(a1/21/2)',
2216        '(0b0)','(0b0)0s0','(1/2b0)','(0b1/2)','(1/2b1/2)',],
2217#17       
2218    'P 2 2 21':['(00g)','(01/2g)','(1/20g)','(1/21/2g)',
2219        '(a00)','(a00)s00','(a1/20)','(0b0)','(0b0)0s0','(1/2b0)',],
2220    'P 21 2 2':['(a00)','(a01/2)','(a1/20)','(a1/21/2)',
2221        '(0b0)','(0b0)0s0','(1/2b0)','(00g)','(00g)00s','(1/20g)',],
2222    'P 2 21 2':['(0b0)','(0b1/2)','(1/2b0)','(1/2b1/2)',
2223        '(00g)','(00g)00s','(1/20g)','(a00)','(a00)s00','(a1/20)',],
2224#18       
2225    'P 21 21 2':['(00g)','(00g)00s','(a00)','(a01/2)','(0b0)','(0b1/2)',],
2226    'P 2 21 21':['(a00)','(a00)s00','(0b0)','(0b1/2)','(00g)','(01/2g)',],
2227    'P 21 2 21':['(0b0)','(0b0)0s0','(00g)','(01/2g)','(a00)','(a01/2)',],
2228#19       
2229    'P 21 21 21':['(00g)','(a00)','(0b0)',],
2230#20       
2231    'C 2 2 21':['(00g)','(10g)','(01g)','(a00)','(a00)s00','(0b0)','(0b0)0s0',],
2232    'A 21 2 2':['(a00)','(a10)','(a01)','(0b0)','(0b0)0s0','(00g)','(00g)00s',],
2233    'B 2 21 2':['(0b0)','(1b0)','(0b1)','(00g)','(00g)00s','(a00)','(a00)s00',],
2234#21       
2235    'C 2 2 2':['(00g)','(00g)00s','(10g)','(10g)00s','(01g)','(01g)00s',
2236        '(a00)','(a00)s00','(a01/2)','(0b0)','(0b0)0s0','(0b1/2)',],
2237    'A 2 2 2':['(a00)','(a00)s00','(a10)','(a10)s00','(a01)','(a01)s00',
2238        '(0b0)','(0b0)0s0','(0b1/2)','(00g)','(00g)00s','(01/2g)',],
2239    'B 2 2 2':['(0b0)','(0b0)0s0','(1b0)','(1b0)0s0','(0b1)','(0b1)0s0',
2240        '(00g)','(00g)00s','(01/2g)','(a00)','(a00)s00','(a01/2)',],
2241#22       
2242    'F 2 2 2':['(00g)','(00g)00s','(10g)','(01g)',
2243        '(a00)','(a00)s00','(a10)','(a01)',
2244        '(0b0)','(0b0)0s0','(1b0)','(0b1)',],
2245#23       
2246    'I 2 2 2':['(00g)','(00g)00s','(a00)','(a00)s00','(0b0)','(0b0)0s0',],
2247#24       
2248    'I 21 21 21':['(00g)','(00g)00s','(a00','(a00)s00','(0b0)','(0b0)0s0',],
2249#25       
2250    'P m m 2':['(00g)','(00g)s0s','(00g)0ss','(00g)ss0',
2251        '(01/2g)','(01/2g)s0s','(1/20g)','(1/20g)0ss','(1/21/2g)',
2252        '(a00)','(a00)0s0','(a1/20)','(a01/2)','(a01/2)0s0','(a1/21/2)',
2253        '(0b0)','(0b0)s00','(0b1/2)','(0b1/2)s00','(1/2b0)','(1/2b1/2)',],       
2254    'P 2 m m':['(a00)','(a00)ss0','(a00)s0s','(a00)0ss',
2255        '(a01/2)','(a01/2)ss0','(a1/20)','(a1/20)s0s','(a1/21/2)',
2256        '(0b0)','(0b0)00s','(1/2b0)','(0b1/2)','(0b1/2)00s','(1/2b1/2)',
2257        '(00g)','(00g)0s0','(01/2g)','(01/2g)0s0','(1/20g)','(1/21/2g)',],
2258    'P m 2 m':['(0b0)','(0b0)ss0','(0b0)0ss','(0b0)s0s',
2259        '(0b1/2)','(0b1/2)ss0','(1/2b0)','(1/2b0)0ss','(1/2b1/2)',
2260        '(00g)','(00g)s00','(1/20g)','(01/2g)','(01/2g)s00','(1/21/2g)',
2261        '(a00)','(a00)0s0','(a01/2)','(a01/2)0s0','(a1/20)','(a1/21/2)',],       
2262#26       
2263    'P m c 21':['(00g)','(00g)s0s','(01/2g)','(01/2g)s0s','(1/20g)','(1/21/2g)',
2264        '(a00)','(a00)0s0','(a1/20)','(0b0)','(0b0)s00','(0b1/2)',],
2265    'P 21 m a':['(a00)','(a00)ss0','(a01/2)','(a01/2)ss0','(a1/20)','(a1/21/2)',
2266        '(0b0)','(0b0)00s','(1/2b0)','(00g)','(00g)0s0','(01/2g)',],
2267    'P b 21 m':['(0b0)','(0b0)ss0','(0b1/2)','(0b1/2)ss0','(1/2b0)','(1/2b1/2)',
2268        '(00g)','(00g)s00','(1/20g)','(a00)','(a00)0s0','(a01/2)',],
2269    'P m 21 b':['(a00)','(a00)ss0','(a01/2)','(a01/2)ss0','(a1/20)','(a1/21/2)',
2270        '(00g)','(00g)0s0','(01/2g)','(0b0)','(0b0)s00','(0b1/2)',],
2271    'P c m 21':['(00g)','(00g)0ss','(1/20g)','(1/20g)0ss','(01/2g)','(1/21/2g)',
2272        '(0b0)','(0a0)s00','(1/2b0)','(a00)','(a00)0s0','(a01/2)',],
2273    'P 21 a m':['(0b0)','(0b0)ss0','(0b1/2)','(0b1/2)ss0','(1/2b0)','(1/2b1/2)',
2274        '(a00)','(a00)00s','(a1/20)','(00g)','(00g)s00','(1/20g)',],
2275#27       
2276    'P c c 2':['(00g)','(00g)s0s','(00g)0ss','(01/2g)','(1/20g)','(1/21/2g)',
2277        '(a00)','(a00)0s0','(a1/20)','(0b0)','(0b0)s00','(1/2b0)',],
2278    'P 2 a a':['(a00)','(a00)ss0','(a00)s0s','(a01/2)','(a1/20)','(a1/21/2)',
2279        '(0b0)','(0b0)00s','(0b1/2)','(00g)','(00g)0s0','(01/2g)',],
2280    'P b 2 b':['(0b0)','(0b0)0ss','(0b0)ss0','(1/2b0)','(0b1/2)','(1/2b1/2)',
2281        '(00g)','(00g)s00','(1/20g)','(a00)','(a00)00s','(a01/2)',],
2282#28       
2283    'P m a 2':['(00g)','(00g)s0s','(00g)ss0','(00g)0ss','(01/2g)','(01/2g)s0s',
2284        '(a00)','(a01/2)','(a1/20)','(a1/21/2)','(0b0)','(0b0)s00',],
2285    'P 2 m b':[],
2286    'P c 2 m':[],
2287    'P m 2 a':[],
2288    'P b m 2':[],
2289    'P 2 c m':[],
2290#29       
2291    'P c a 21':['(00g)','(00g)0ss','(01/2g)','(1/20g)',
2292        '(a00)','(a00)0s0','(a1/20)','(0b0)','(0b0)s00','(1/2b0)',],
2293    'P 21 a b':[],
2294    'P c 21 b':[],
2295    'P b 21 a':[],
2296    'P b c 21':[],
2297    'P 21 c a':[],
2298#30       
2299    'P c n 2':[],
2300    'P 2 a n':[],
2301    'P n 2 b':[],
2302    'P b 2 n':[],
2303    'P n c 2':[],
2304    'P 2 n a':[],
2305#31       
2306    'P m n 21':[],
2307    'P 21 m n':[],
2308    'P n 21 m':[],
2309    'P m 21 n':[],
2310    'P n m 21':[],
2311    'P 21 n m':[],
2312#32       
2313    'P b a 2':['(00g)','(00g)s0s','(00g)0ss','(00g)ss0','(1/21/2g)qq0',
2314        '(a00)','(a01/2)','(0b0)','(0b1/2)',],
2315    'P 2 c b':['(a00)','(a00)ss0','(a00)s0s','(a00)0ss','(a1/21/2)0qq',
2316        '(0b0)','(1/2b0)','(00g)','(1/20g)',],
2317    'P c 2 a':['(0b0)','(0b0)ss0','(0b0)0ss','(0b0)s0s','(1/2b1/2)q0q',
2318        '(00g)','01/2g)','(a00)','(a1/20)',],
2319#33       
2320    'P n a 21':[],
2321    'P 21 n b':[],
2322    'P c 21 n':[],
2323    'P n 21 a':[],
2324    'P b n 21':[],
2325    'P 21 c n':[],
2326#34       
2327    'P n n 2':['(00g)','(00g)s0s','(00g)0ss','(1/21/2g)qq0',
2328        '(a00)','(a1/21/2)0q0','(a1/21/2)00q','(0b0)','(1/2b1/2)q00','(1/2b1/2)00q',],
2329    'P 2 n n':['(a00)','(a00)ss0','(a00)s0s','(a1/21/2)0qq',
2330        '(0b0)','(1/2b1/2)q00','(1/2b1/2)00q','(00g)','(1/21/2b)0q0','(1/21/2g)q00',],
2331    'P n 2 n':['(0b0)','(0b0)ss0','(0b0)0ss','(1/2b1/2)q0q',
2332        '(00g)','(1/21/2g)0q0','(1/21/2g)q00','(a00)','(a1/21/2)00q','(b1/21/2)0q0',],
2333#35       
2334    'C m m 2':['(00g)','(00g)s0s','(00g)0ss','(00g)ss0','(10g)','(10g)s0s','(10g)0ss','(10g)ss0',
2335        '(01g)','(01g)s0s','(01g)0ss','(01g)ss0','(a00)','(a00)0s0','(a01/2)','(a01/2)0s0',
2336        '(0b0)','(0b0)s00','(0b1/2)','(0b1/2)s00',],
2337    'A 2 m m':['(a00)','(a00)s0s','(a00)0ss','(a00)ss0','(a10)','(a10)s0s','(a10)0ss','(a10)ss0',
2338        '(a01)','(a01)s0s','(a01)0ss','(a01)ss0','(0b0)','(0b0)00s','(1/2b0)','(1/2b0)00s',
2339        '(00g)','(00g)0s0','(01/2g)','(01/2g)0s0',],
2340    'B m 2 m':['(0b0)','(0b0)s0s','(0b0)0ss','(0b0)ss0','(1b0)','(1b0)s0s','(1b0)0ss','(1b0)ss0',
2341        '(0b1)','(0b1)s0s','(0b1)0ss','(0b1)ss0','(a00)','(a00)00s','(a01/2)','(a01/2)00s',
2342        '(00g)','(00g)s00','(1/20g)','(1/20g)s00',],
2343#36
2344    'C m c 21':['(00g)','(00g)s0s','(10g)','(10g)s0s','(a00)','(a00)0s0','(0b0)','(0b0)s00',],
2345    'A 21 m a':['(a00)','(a00)ss0','(a10)','(a10)ss0','(0b0)','(0b0)00s','(00g)','(00g)0s0',],
2346    'B m 21 b':['(0b0)','(0b0)ss0','(1b0)','(1b0)ss0','(a00)','(a00)00s','(00g)','(00g)s00',],
2347    'B b 21 m':['(0b0)','(0b0)0ss','(0b1)','(0b1)ss0','(a00)','(a00)00s','(00g)','(00g)s00',],
2348    'C c m 21':['(00g)','(00g)0ss','(01g)','(01g)0ss','(a00)','(a00)0s0','(0b0)','(0b0)s00',],
2349    'A 21 a m':['(a00)','(a00)s0s','(a01)','(a01)s0s','(0b0)','(0b0)00s','(00g)','(00g)0s0',],
2350#37
2351    'C c c 2':['(00g)','(00g)s0s','(00g)0ss','(10g)','(10g)s0s','(10g)0ss','(01g)','(01g)s0s','(01g)0ss',
2352        '(a00)','(a00)0s0','(0b0)','(0b0)s00',],
2353    'A 2 a a':['(a00)','(a00)ss0','(a00)s0s','(a10)','(a10)ss0','(a10)ss0','(a01)','(a01)ss0','(a01)ss0',
2354        '(0b0)','(0b0)00s','(00g)','(00g)0s0',],
2355    'B b 2 b':['(0b0)','(0b0)0ss','(0b0)ss0','(0b1)','(0b1)0ss','(0b1)ss0','(1b0)','(1b0)0ss','(1b0)ss0',
2356        '(a00)','(a00)00s','(00g)','(00g)s00',],
2357#38
2358    'A m m 2':[],
2359    'B 2 m m':[],
2360    'C m 2 m':[],
2361    'A m 2 m':[],
2362    'B m m 2':[],
2363    'C 2 m m':[],
2364#39
2365    'A b m 2':[],
2366    'B 2 c m':[],
2367    'C m 2 a':[],
2368    'A c 2 m':[],
2369    'B m a 2':[],
2370    'C 2 m b':[],
2371#40       
2372    'A m a 2':[],
2373    'B 2 m b':[],
2374    'C c 2 m':[],
2375    'A m 2 a':[],
2376    'B b m 2':[],
2377    'C 2 c m':[],
2378#41
2379    'A b a 2':[],
2380    'B 2 c b':[],
2381    'C c 2 a':[],
2382    'A c 2 a':[],
2383    'B b a 2':[],
2384    'C 2 c b':[],
2385       
2386#42       
2387    'F m m 2':['(00g)','(00g)s0s','(00g)0ss','(00g)ss0','(10g)','(10g)ss0','(10g)s0s',
2388        '(01g)','(01g)ss0','(01g)0ss','(a00)','(a00)0s0','(a01)','(a01)0s0',
2389        '(0b0)','(0b0)s00','(0b1)','(0b1)s00',],       
2390    'F 2 m m':['(a00)','(a00)ss0','(a00)s0s','(a00)0ss','(a10)','(a10)0ss','(a10)ss0',
2391        '(a01)','(a01)0ss','(a01)s0s','(0b0)','(0b0)00s','(1b0)','(1b0)00s',
2392        '(00g)','(00g)0s0','(10g)','(10g)0s0',],
2393    'F m 2 m':['(0b0)','(0b0)0ss','(0b0)ss0','(0b0)s0s','(0b1)','(0b1)s0s','(0b1)0ss',
2394        '(1b0)','(1b0)s0s','(1b0)ss0','(00g)','(00g)s00','(01g)','(01g)s00',
2395        '(a00)','(a00)00s','(a10)','(a10)00s',],       
2396#43       
2397    'F d d 2':['(00g)','(00g)0ss','(00g)s0s','(a00)','(0b0)',],
2398    'F 2 d d':['(a00)','(a00)s0s','(a00)ss0','(00g)','(0b0)',],       
2399    'F d 2 d':['(0b0)','(0b0)0ss','(0b0)ss0','(a00)','(00g)',],
2400#44
2401    'I m m 2':['(00g)','(00g)ss0','(00g)s0s','(00g)0ss','(a00)','(a00)0s0','(0b0)','(0b0)s00',],
2402    'I 2 m m':['(a00)','(00g)0ss','(00g)ss0','(00g)s0s','(0b0)','(0b0)00s','(00g)','(00g)0s0',],
2403    'I m 2 m':['(0b0)','(0b0)s0s','(0b0)0ss','(0b0)ss0','(00g)','(00g)s00','(a00)','(a00)00s',],
2404#45       
2405    'I b a 2':['(00g)','(00g)ss0','(00g)s0s','(00g)0ss','(a00)','(a00)0s0','(0b0)','(0b0)s00',],
2406    'I 2 c b':['(0b0)','(0b0)s0s','(0b0)0ss','(0b0)ss0','(00g)','(00g)s00','(a00)','(a00)00s',],
2407    'I c 2 a':['(a00)','(00g)0ss','(00g)ss0','(00g)s0s','(0b0)','(0b0)00s','(00g)','(00g)0s0',],
2408#46       
2409    'I m a 2':['(a00)','(00g)0ss','(00g)ss0','(00g)s0s','(0b0)','(0b0)00s','(00g)','(00g)0s0',],
2410    'I 2 m b':['(0b0)','(0b0)s0s','(0b0)0ss','(0b0)ss0','(00g)','(00g)s00','(a00)','(a00)00s',],       
2411    'I c 2 m':['(a00)','(00g)0ss','(00g)ss0','(00g)s0s','(0b0)','(0b0)00s','(00g)','(00g)0s0',],
2412    'I m 2 a':['(a00)','(00g)0ss','(00g)ss0','(00g)s0s','(0b0)','(0b0)00s','(00g)','(00g)0s0',],
2413    'I b m 2':['(a00)','(00g)0ss','(00g)ss0','(00g)s0s','(0b0)','(0b0)00s','(00g)','(00g)0s0',],
2414    'I 2 c m':['(0b0)','(0b0)s0s','(0b0)0ss','(0b0)ss0','(00g)','(00g)s00','(a00)','(a00)00s',],
2415#47       
2416    'P m m m':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(01/2g)','(01/2g)s00','(1/20g)','(1/20g)s00','(1/21/2g)',
2417        '(a00)','(a00)0s0','(a00)00s','(a00)0ss','(a01/2)','(a01/2)0s0','(a1/20)','(a1/20)00s','(a1/21/2)',
2418        '(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s','(1/2b0)','(1/2b0)00s','(0b1/2)','(0b1/2)s00','(1/2b1/2)',],
2419#48 o@i qq0,0qq,q0q ->000
2420    'P n n n':['(00g)','(00g)s00','(00g)0s0','(1/21/2g)',
2421        '(a00)','(a00)0s0','(a00)00s','(a1/21/2)',
2422        '(0b0)','(0b0)s00','(0b0)00s','(1/2b1/2)',],
2423#49       
2424    'P c c m':['(00g)','(00g)s00','(00g)0s0','(01/2g)','(1/20g)','(1/21/2g)',
2425        '(a00)','(a00)0s0','(a00)00s','(a00)0ss','(a1/20)','(a1/20)00s',
2426        '(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s','(1/2b0)','(1/2b0)00s',],       
2427    'P m a a':['(a00)','(a00)0s0','(a00)00s','(a01/2)','(a1/20)','(a1/21/2)',
2428        '(0b0)','(0b0)00s','(0b0)s00','(0b0)s0s','(0b1/2)','(0b1/2)s00',
2429        '(00g)','(00g)0s0','(00g)s00','(00g)ss0','(01/2g)','(01/2g)s00',],       
2430    'P b m b':['(0b0)','(0b0)00s','(0b0)s00','(0b1/2)','(1/2b0)','(1/2b1/2)',
2431        '(00g)','(00g)s00','(00g)0s0','(00g)ss0','(1/20g)','(1/20g)0s0',
2432        '(a00)','(a00)00s','(a00)0s0','(a00)0ss','(a01/2)','(a01/2)0s0',],
2433#50 o@i qq0,0qq,q0q ->000
2434    'P b a n':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(1/21/2g)',
2435        '(a00)','(a00)0s0','(a01/2)','(0b0)','(0b0)s00','(0b1/2)',],
2436    'P n c b':['(a00)','(a00)0s0','(a00)00s','(a00)0ss','(a1/21/2)',
2437        '(0b0)','(0b0)00s','(1/2b0)','(00g)','(00g)0s0','(1/20g)',],
2438    'P c n a':['(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s','(1/2b1/2)',
2439        '(00g)','(00g)s00','(01/2a)','(a00)','(a00)00s','(a1/20)',],
2440#51       
2441    'P m m a':[],
2442    'P b m m':[],
2443    'P m c m':[],
2444    'P m a m':[],
2445    'P m m b':[],
2446    'P c m m':[],
2447#52   o@i qq0,0qq,q0q ->000     
2448    'P n n a':['(00g)','(00g)s00','(00g)0s0','(a00)','(a00)00s',
2449        '(0b0)','(0b0)00s','(a1/21/2)','(1/2b1/2)',],
2450    'P b n n':['(a00)','(a00)0s0','(a00)00s','(0b0)','(0b0)s00',
2451        '(00g)','(00g)s00','(1/2b1/2)','(1/21/2g)',],
2452    'P n c n':['(0b0)','(0b0)s00','(0b0)00s','(00g)','(00g)0s0',
2453        '(a00)','(a00)0s0','(1/21/2g)','(a1/21/2)',],
2454    'P n a n':['(0b0)','(0b0)s00','(0b0)00s','(00g)','(00g)0s0',
2455        '(a00)','(a00)0s0','(1/21/2g)','(a1/21/2)',],
2456    'P n n b':['(00g)','(00g)s00','(00g)0s0','(a00)','(a00)00s',
2457        '(0b0)','(0b0)00s','(a1/21/2)','(1/2b1/2)',],
2458    'P c n n':['(a00)','(a00)0s0','(a00)00s','(0b0)','(0b0)s00',
2459        '(00g)','(00g)s00','(1/2b1/2)','(1/21/2g)',],
2460#53       
2461    'P m n a':[],
2462    'P b m n':[],
2463    'P n c m':[],
2464    'P m a n':[],
2465    'P n m b':[],
2466    'P c n m':[],
2467#54       
2468    'P c c a':[],
2469    'P b a a':[],
2470    'P b c b':[],
2471    'P b a b':[],
2472    'P c c b':[],
2473    'P c a a':[],
2474#55       
2475    'P b a m':['(00g)','(00g)s00','(00g)0s0','(00g)ss0',
2476        '(a00)','(a00)00s','(a01/2)','(0b0)','(0b0)00s','(0b1/2)'],
2477    'P m c b':['(a00)','(a00)0s0','(a00)00s','(a00)0ss',
2478        '(0b0)','(0b0)s00','(1/2b0)','(00g)','(00g)s00','(1/20g)'],
2479    'P c m a':['(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s',
2480        '(a00)','(a00)0s0','(a1/20)','(00g)','(00g)0s0','(01/2g)'],
2481#56       
2482    'P c c n':['(00g)','(00g)s00','(00g)0s0','(a00)','(a00)0s0',
2483        '(0b0)','(0b0)s00'],
2484    'P n a a':['(a00)','(a00)0s0','(a00)00s','(0b0)','(0b0)00s',
2485        '(00g)','(00g)0s0'],
2486    'P b n b':['(0b0)','(0b0)s00','(0b0)00s','(a00)','(a00)00s',
2487        '(00g)','(00g)s00'],
2488#57       
2489    'P b c m':[],
2490    'P m c a':[],
2491    'P b m a':[],
2492    'P c m b':[],
2493    'P c a m':[],
2494    'P m a b':[],
2495#58       
2496    'P n n m':['(00g)','(00g)s00','(00g)0s0','(a00)',
2497        '(a00)00s','(0b0)','(0b0)00s'],
2498    'P m n n':['(00g)','(00g)s00','(a00)','(a00)0s0',
2499        '(a00)00s','(0b0)','(0b0)s00'],
2500    'P n m n':['(00g)','(00g)0s0','(a00)','(a00)0s0',
2501        '(0b0)','(0b0)s00','(0b0)00s',],
2502#59 o@i
2503    'P m m n':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(a00)','(a00)0s0',
2504        '(a01/2)','(a01/2)0s0','(0b0)','(0b0)s00','(0b1/2)','(0b1/2)s00',],
2505    'P n m m':['(a00)','(a00)0s0','(a00)00s','(a00)0ss','(00g)','(00g)0s0',
2506        '(1/20g)','(1/20g)0s0','(0b0)','(0b0)00s','(1/2b0)','(1/2b0)00s'],
2507    'P m n m':['(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s','(00g)','(00g)s00',
2508        '(01/2g)','(01/2g)s00','(a00)','(a00)00s','(a1/20)','(a1/20)00s'],
2509#60       
2510    'P b c n':['(00g)','(00g)s00','(00g)0s0','(a00)','(a00)0s0',
2511        '(a00)00s','(0b0)','(0b0)s00','(0b0)00s'],
2512    'P n c a':['(00g)','(00g)s00','(00g)0s0','(a00)','(a00)0s0',
2513        '(a00)00s','(0b0)','(0b0)s00','(0b0)00s'],
2514    'P b n a':['(00g)','(00g)s00','(00g)0s0','(a00)','(a00)0s0',
2515        '(a00)00s','(0b0)','(0b0)s00','(0b0)00s'],
2516    'P c n b':['(00g)','(00g)s00','(00g)0s0','(a00)','(a00)0s0',
2517        '(a00)00s','(0b0)','(0b0)s00','(0b0)00s'],
2518    'P c a n':['(00g)','(00g)s00','(00g)0s0','(a00)','(a00)0s0',
2519        '(a00)00s','(0b0)','(0b0)s00','(0b0)00s'],
2520    'P n a b':['(00g)','(00g)s00','(00g)0s0','(a00)','(a00)0s0',
2521        '(a00)00s','(0b0)','(0b0)s00','(0b0)00s'],
2522#61       
2523    'P b c a':['(00g)','(00g)s00','(00g)0s0','(a00)','(a00)0s0','(a00)00s',
2524        '(0b0)','(0b0)s00','(0b0)00s'],
2525    'P c a b':['(00g)','(00g)s00','(00g)0s0','(a00)','(a00)0s0','(a00)00s',
2526        '(0b0)','(0b0)s00','(0b0)00s'],
2527#62       
2528    'P n m a':['(00g)','(00g)0s0','(a00)','(a00)0s0','(0b0)','(0b0)00s'],
2529    'P b n m':['(00g)','(00g)s00','(a00)','(a00)00s','(0b0)','(0b0)00s'],
2530    'P m c n':['(00g)','(00g)s00','(a00)','(a00)0s0','(0b0)','(0b0)s00'],
2531    'P n a m':['(00g)','(00g)0s0','(a00)','(a00)00s','(0b0)','(0b0)00s'],
2532    'P m n b':['(00g)','(00g)s00','(a00)','(a00)00s','(0b0)','(0b0)s00'],
2533    'P c m n':['(00g)','(00g)0s0','(a00)','(a00)0s0','(0b0)','(0b0)s00'],
2534#63
2535    'C m c m':[],
2536    'A m m a':[],
2537    'B b m m':[],
2538    'B m m b':[],
2539    'C c m m':[],
2540    'A m a m':[],
2541#64       
2542    'C m c a':['(00g)','(00g)s00','(10g)','(10g)s00','(a00)',],
2543    'A b m a':[],
2544    'B b c m':[],
2545    'B m a b':[],
2546    'C c m b':[],
2547    'A c a m':[],
2548#65       
2549    'C m m m':[],
2550    'A m m m':[],
2551    'B m m m':[],
2552#66       
2553    'C c c m':[],
2554    'A m m a':[],
2555    'B b m b':[],
2556#67       
2557    'C m m a':[],
2558    'A b m m':[],
2559    'B m c m':[],
2560    'B m a m':[],
2561    'C m m b':[],
2562    'A c m m':[],
2563#68 o@i
2564    'C c c a':[],
2565    'A b a a':[],
2566    'B b c b':[],
2567    'B b a b':[],
2568    'C c c b':[],
2569    'A c a a':[],
2570#69       
2571    'F m m m':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(a00)','(a00)0s0',
2572        '(a00)00s','(a00)0ss','(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s',
2573        '(10g)','(10g)s00','(10g)0s0','(10g)ss0','(a10)','(a10)0s0',
2574        '(a10)00s','(a10)0ss','(0b1)','(0b1)s00','(0b1)00s','(0b1)s0s',
2575        '(01g)','(01g)s00','(01g)0s0','(01g)ss0','(a01)','(a01)0s0',
2576        '(a01)00s','(a01)0ss','(1b0)','(1b0)s00','(1b0)00s','(1b0)s0s'],
2577#70 o@i       
2578    'F d d d':['(00g)','(00g)s00','(00g)0s0','(a00)','(a00)0s0',
2579        '(a00)00s','(0b0)','(0b0)s00','(0b0)00s',],
2580       
2581#71
2582    'I m m m':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(a00)','(a00)0s0',
2583        '(a00)00s','(a00)0ss','(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s',],
2584#72       
2585    'I b a m':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(a00)','(a00)0s0',
2586        '(a00)00s','(a00)0ss','(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s'],
2587    'I m c b':['(a00)','(a00)0s0','(a00)00s','(a00)0ss','(0b0)','(0b0)00s',
2588        '(0b0)s00','(0b0)s0s','(00g)','(00g)0s0','(00g)s00','(00g)ss0'],
2589    'I c m a':['(0b0)','(0b0)00s','(0b0)s00','(0b0)s0s','(00g)','(00g)s00',
2590        '(00g)0s0','(00g)ss0','(a00)','(a00)00s','(a00)0s0','(a00)0ss'],
2591#73       
2592    'I b c a':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(a00)','(a00)0s0',
2593        '(a00)00s','(a00)0ss','(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s'],
2594    'I c a b':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(a00)','(a00)0s0',
2595        '(a00)00s','(a00)0ss','(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s'],
2596#74       
2597    'I m m a':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(a00)','(a00)0s0',
2598        '(a00)00s','(a00)0ss','(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s'],
2599    'I b m m ':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(a00)','(a00)0s0',
2600        '(a00)00s','(a00)0ss','(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s'],
2601    'I m c m':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(a00)','(a00)0s0',
2602        '(a00)00s','(a00)0ss','(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s'],
2603    'I m a m':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(a00)','(a00)0s0',
2604        '(a00)00s','(a00)0ss','(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s'],
2605    'I m m b':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(a00)','(a00)0s0',
2606        '(a00)00s','(a00)0ss','(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s'],
2607    'I c m m':['(00g)','(00g)s00','(00g)0s0','(00g)ss0','(a00)','(a00)0s0',
2608        '(a00)00s','(a00)0ss','(0b0)','(0b0)s00','(0b0)00s','(0b0)s0s'],
2609#tetragonal - done
2610#75
2611    'P 4':['(00g)','(00g)q','(00g)s','(1/21/2g)','(1/21/2g)q',],
2612#76
2613    'P 41':['(00g)','(1/21/2g)',],
2614#77
2615    'P 42':['(00g)','(00g)q','(1/21/2g)','(1/21/2g)q',],
2616#78
2617    'P 43':['(00g)','(1/21/2g)',],
2618#79
2619    'I 4':['(00g)','(00g)q','(00g)s',],
2620#80
2621    'I 41':['(00g)','(00g)q',],
2622#81
2623    'P -4':['(00g)','(1/21/2g)',],
2624#82
2625    'I -4':['(00g)',],
2626#83
2627    'P 4/m':['(00g)','(00g)s0','(1/21/2g)',],
2628#84
2629    'P 42/m':['(00g)','(1/21/2g)',],
2630#85 o@i q0 -> 00
2631    'P 4/n':['(00g)','(00g)s0','(1/21/2g)',], #q0?
2632#86 o@i q0 -> 00
2633    'P 42/n':['(00g)','(1/21/2g)',],      #q0?
2634#87
2635    'I 4/m':['(00g)','(00g)s0',],
2636#88
2637    'I 41/a':['(00g)',],
2638#89
2639    'P 4 2 2':['(00g)','(00g)q00','(00g)s00','(1/21/2g)','(1/21/2g)q00',],
2640#90
2641    'P 4 21 2':['(00g)','(00g)q00','(00g)s00',],
2642#91
2643    'P 41 2 2':['(00g)','(1/21/2g)',],
2644#92
2645    'P 41 21 2':['(00g)',],
2646#93
2647    'P 42 2 2':['(00g)','(00g)q00','(1/21/2g)','(1/21/2g)q00',],
2648#94
2649    'P 42 21 2':['(00g)','(00g)q00',],
2650#95
2651    'P 43 2 2':['(00g)','(1/21/2g)',],
2652#96
2653    'P 43 21 2':['(00g)',],
2654#97
2655    'I 4 2 2':['(00g)','(00g)q00','(00g)s00',],
2656#98
2657    'I 41 2 2':['(00g)','(00g)q00',],
2658#99
2659    'P 4 m m':['(00g)','(00g)ss0','(00g)0ss','(00g)s0s','(1/21/2g)','(1/21/2g)0ss'],
2660#100
2661    'P 4 b m':['(00g)','(00g)ss0','(00g)0ss','(00g)s0s','(1/21/2g)qq0','(1/21/2g)qqs',],
2662#101
2663    'P 42 c m':['(00g)','(00g)0ss','(1/21/2g)','(1/21/2g)0ss',],
2664#102
2665    'P 42 n m':['(00g)','(00g)0ss','(1/21/2g)qq0','(1/21/2g)qqs',],
2666#103
2667    'P 4 c c':['(00g)','(00g)ss0','(1/21/2g)',],
2668#104
2669    'P 4 n c':['(00g)','(00g)ss0','(1/21/2g)qq0',],
2670#105
2671    'P 42 m c':['(00g)','(00g)ss0','(1/21/2g)',],
2672#106
2673    'P 42 b c':['(00g)','(00g)ss0','(1/21/2g)qq0',],
2674#107
2675    'I 4 m m':['(00g)','(00g)ss0','(00g)0ss','(00g)s0s',],
2676#108
2677    'I 4 c m':['(00g)','(00g)ss0','(00g)0ss','(00g)s0s',],
2678#109
2679    'I 41 m d':['(00g)','(00g)ss0',],
2680#110
2681    'I 41 c d':['(00g)','(00g)ss0',],
2682#111
2683    'P -4 2 m':['(00g)','(00g)0ss','(1/21/2g)','(1/21/2g)0ss',],
2684#112
2685    'P -4 2 c':['(00g)','(1/21/2g)',],
2686#113
2687    'P -4 21 m':['(00g)','(00g)0ss',],
2688#114
2689    'P -4 21 c':['(00g)',],
2690#115    00s -> 0ss
2691    'P -4 m 2':['(00g)','(00g)0ss','(1/21/2g)',],
2692#116
2693    'P -4 c 2':['(00g)','(1/21/2g)',],
2694#117    00s -> 0ss
2695    'P -4 b 2':['(00g)','(00g)0s0','(1/21/2g)0q0',],
2696#118
2697    'P -4 n 2':['(00g)','(1/21/2g)0q0',],
2698#119
2699    'I -4 m 2':['(00g)','(00g)0s0',],
2700#120
2701    'I -4 c 2':['(00g)','(00g)0s0',],
2702#121    00s -> 0ss
2703    'I -4 2 m':['(00g)','(00g)0ss',],
2704#122
2705    'I -4 2 d':['(00g)',],
2706#123
2707    'P 4/m m m':['(00g)','(00g)s0s0','(00g)00ss','(00g)s00s',
2708        '(1/21/2g)','(1/21/2g)s0s0','(1/21/2g)00ss','(1/21/2g)s00s',],
2709#124
2710    'P 4/m c c':['(00g)','(00g)s0s0','(1/21/2g)',],
2711#125    o@i q0q0 -> 0000, q0qs -> 00ss
2712    'P 4/n b m':['(00g)','(00g)s0s0','(00g)00ss','(00g)s00s','(1/21/2g)','(1/21/2g)00ss',],
2713#126    o@i q0q0 -> 0000
2714    'P 4/n n c':['(00g)','(00g)s0s0','(1/21/2g)',],
2715#127
2716    'P 4/m b m':['(00g)','(00g)s0s0','(00g)00ss','(00g)s00s',],
2717#128
2718    'P 4/m n c':['(00g)','(00g)s0s0',],
2719#129
2720    'P 4/n m m':['(00g)','(00g)s0s0','(00g)00ss','(00g)s00s',],
2721#130
2722    'P 4/n c c':['(00g)','(00g)s0s0',],
2723#131
2724    'P 42/m m c':['(00g)','(00g)s0s0','(1/21/2g)',],
2725#132
2726    'P 42/m c m':['(00g)','(00g)00ss','(1/21/2g)','(1/21/2g)00ss',],
2727#133    o@i q0q0 -> 0000
2728    'P 42/n b c':['(00g)','(00g)s0s0','(1/21/2g)',],
2729#134    o@i q0q0 -> 0000, q0qs -> 00ss
2730    'P 42/n n m':['(00g)','(00g)00ss','(1/21/2g)','(1/21/2g)00ss',],
2731#135
2732    'P 42/m b c':['(00g)','(00g)s0s0',],
2733#136
2734    'P 42/m n m':['(00g)','(00g)00ss',],
2735#137
2736    'P 42/n m c':['(00g)','(00g)s0s0',],
2737#138
2738    'P 42/n c m':['(00g)','(00g)00ss',],
2739#139
2740    'I 4/m m m':['(00g)','(00g)s0s0','(00g)00ss','(00g)s00s',],
2741#140
2742    'I 4/m c m':['(00g)','(00g)s0s0','(00g)00ss','(00g)s00s',],
2743#141
2744    'I 41/a m d':['(00g)','(00g)s0s0',],
2745#142
2746    'I 41/a c d':['(00g)','(00g)s0s0',],
2747    #trigonal/rhombahedral - done & checked
2748#143
2749    'P 3':['(00g)','(00g)t','(1/31/3g)',],
2750#144
2751    'P 31':['(00g)','(1/31/3g)',],
2752#145
2753    'P 32':['(00g)','(1/31/3g)',],
2754#146
2755    'R 3':['(00g)','(00g)t',],
2756#147
2757    'P -3':['(00g)','(1/31/3g)',],
2758#148
2759    'R -3':['(00g)',],
2760#149
2761    'P 3 1 2':['(00g)','(00g)t00','(1/31/3g)',],
2762#150
2763    'P 3 2 1':['(00g)','(00g)t00',],
2764#151
2765    'P 31 1 2':['(00g)','(1/31/3g)',],
2766#152
2767    'P 31 2 1':['(00g)',],
2768#153
2769    'P 32 1 2':['(00g)','(1/31/3g)',],
2770#154
2771    'P 32 2 1':['(00g)',],
2772#155
2773    'R 3 2':['(00g)','(00g)t0',],
2774#156
2775    'P 3 m 1':['(00g)','(00g)0s0',],
2776#157
2777    'P 3 1 m':['(00g)','(00g)00s','(1/31/3g)','(1/31/3g)00s',],
2778#158
2779    'P 3 c 1':['(00g)',],
2780#159
2781    'P 3 1 c':['(00g)','(1/31/3g)',],
2782#160
2783    'R 3 m':['(00g)','(00g)0s',],
2784#161
2785    'R 3 c':['(00g)',],
2786#162
2787    'P -3 1 m':['(00g)','(00g)00s','(1/31/3g)','(1/31/3g)00s',],
2788#163
2789    'P -3 1 c':['(00g)','(1/31/3g)',],
2790#164
2791    'P -3 m 1':['(00g)','(00g)0s0',],
2792#165
2793    'P -3 c 1':['(00g)',],
2794#166       
2795    'R -3 m':['(00g)','(00g)0s',],
2796#167
2797    'R -3 c':['(00g)',],
2798    #hexagonal - done & checked
2799#168
2800    'P 6':['(00g)','(00g)h','(00g)t','(00g)s',],
2801#169
2802    'P 61':['(00g)',],
2803#170
2804    'P 65':['(00g)',],
2805#171
2806    'P 62':['(00g)','(00g)h',],
2807#172
2808    'P 64':['(00g)','(00g)h',],
2809#173
2810    'P 63':['(00g)','(00g)h',],
2811#174
2812    'P -6':['(00g)',],
2813#175
2814    'P 6/m':['(00g)','(00g)s0',],
2815#176
2816    'P 63/m':['(00g)',],
2817#177
2818    'P 6 2 2':['(00g)','(00g)h00','(00g)t00','(00g)s00',],
2819#178
2820    'P 61 2 2':['(00g)',],
2821#179
2822    'P 65 2 2':['(00g)',],
2823#180
2824    'P 62 2 2':['(00g)','(00g)h00',],
2825#181
2826    'P 64 2 2':['(00g)','(00g)h00',],
2827#182
2828    'P 63 2 2':['(00g)','(00g)h00',],
2829#183
2830    'P 6 m m':['(00g)','(00g)ss0','(00g)0ss','(00g)s0s',],
2831#184
2832    'P 6 c c':['(00g)','(00g)s0s',],
2833#185
2834    'P 63 c m':['(00g)','(00g)0ss',],
2835#186
2836    'P 63 m c':['(00g)','(00g)0ss',],
2837#187
2838    'P -6 m 2':['(00g)','(00g)0s0',],
2839#188
2840    'P -6 c 2':['(00g)',],
2841#189
2842    'P -6 2 m':['(00g)','(00g)00s',],
2843#190
2844    'P -6 2 c':['(00g)',],
2845#191
2846    'P 6/m m m':['(00g)','(00g)s0s0','(00g)00ss','(00g)s00s',],
2847#192
2848    'P 6/m c c':['(00g)','(00g)s00s',],
2849#193
2850    'P 63/m c m':['(00g)','(00g)00ss',],
2851#194
2852    'P 63/m m c':['(00g)','(00g)00ss'],
2853    }
2854
2855#'A few non-standard space groups for test use'
2856nonstandard_sglist = ('P 21 1 1','P 1 21 1','P 1 1 21','R 3 r','R 3 2 h', 
2857                      'R -3 r', 'R 3 2 r','R 3 m h', 'R 3 m r',
2858                      'R 3 c r','R -3 c r','R -3 m r',),
2859
2860#A list of orthorhombic space groups that were renamed in the 2002 Volume A,
2861# along with the pre-2002 name. The e designates a double glide-plane'''
2862sgequiv_2002_orthorhombic= (('A e m 2', 'A b m 2',),
2863                            ('A e a 2', 'A b a 2',),
2864                            ('C m c e', 'C m c a',),
2865                            ('C m m e', 'C m m a',),
2866                            ('C c c e', 'C c c a'),)
2867#Use the space groups types in this order to list the symbols in the
2868#order they are listed in the International Tables, vol. A'''
2869symtypelist = ('triclinic', 'monoclinic', 'orthorhombic', 'tetragonal', 
2870               'trigonal', 'hexagonal', 'cubic')
2871
2872# self-test materials follow. Requires files in directory testinp
2873selftestlist = []
2874'''Defines a list of self-tests'''
2875selftestquiet = True
2876def _ReportTest():
2877    'Report name and doc string of current routine when ``selftestquiet`` is False'
2878    if not selftestquiet:
2879        import inspect
2880        caller = inspect.stack()[1][3]
2881        doc = eval(caller).__doc__
2882        if doc is not None:
2883            print('testing '+__file__+' with '+caller+' ('+doc+')')
2884        else:
2885            print('testing '+__file__()+" with "+caller)
2886def test0():
2887    '''self-test #0: exercise MoveToUnitCell'''
2888    _ReportTest()
2889    msg = "MoveToUnitCell failed"
2890    assert (MoveToUnitCell([1,2,3]) == [0,0,0]).all, msg
2891    assert (MoveToUnitCell([2,-1,-2]) == [0,0,0]).all, msg
2892    assert abs(MoveToUnitCell(np.array([-.1]))[0]-0.9) < 1e-6, msg
2893    assert abs(MoveToUnitCell(np.array([.1]))[0]-0.1) < 1e-6, msg
2894selftestlist.append(test0)
2895
2896def test1():
2897    '''self-test #1: SpcGroup against previous results'''
2898    #'''self-test #1: SpcGroup and SGPrint against previous results'''
2899    _ReportTest()
2900    testdir = ospath.join(ospath.split(ospath.abspath( __file__ ))[0],'testinp')
2901    if ospath.exists(testdir):
2902        if testdir not in sys.path: sys.path.insert(0,testdir)
2903    import spctestinp
2904    def CompareSpcGroup(spc, referr, refdict, reflist): 
2905        'Compare output from GSASIIspc.SpcGroup with results from a previous run'
2906        # if an error is reported, the dictionary can be ignored
2907        msg0 = "CompareSpcGroup failed on space group %s" % spc
2908        result = SpcGroup(spc)
2909        if result[0] == referr and referr > 0: return True
2910        keys = result[1].keys()
2911        #print result[1]['SpGrp']
2912        #msg = msg0 + " in list lengths"
2913        #assert len(keys) == len(refdict.keys()), msg
2914        for key in refdict.keys():
2915            if key == 'SGOps' or  key == 'SGCen':
2916                msg = msg0 + (" in key %s length" % key)
2917                assert len(refdict[key]) == len(result[1][key]), msg
2918                for i in range(len(refdict[key])):
2919                    msg = msg0 + (" in key %s level 0" % key)
2920                    assert np.allclose(result[1][key][i][0],refdict[key][i][0]), msg
2921                    msg = msg0 + (" in key %s level 1" % key)
2922                    assert np.allclose(result[1][key][i][1],refdict[key][i][1]), msg
2923            else:
2924                msg = msg0 + (" in key %s" % key)
2925                assert result[1][key] == refdict[key], msg
2926        msg = msg0 + (" in key %s reflist" % key)
2927        #for (l1,l2) in zip(reflist, SGPrint(result[1])):
2928        #    assert l2.replace('\t','').replace(' ','') == l1.replace(' ',''), 'SGPrint ' +msg
2929        # for now disable SGPrint testing, output has changed
2930        #assert reflist == SGPrint(result[1]), 'SGPrint ' +msg
2931    for spc in spctestinp.SGdat:
2932        CompareSpcGroup(spc, 0, spctestinp.SGdat[spc], spctestinp.SGlist[spc] )
2933selftestlist.append(test1)
2934
2935def test2():
2936    '''self-test #2: SpcGroup against cctbx (sgtbx) computations'''
2937    _ReportTest()
2938    testdir = ospath.join(ospath.split(ospath.abspath( __file__ ))[0],'testinp')
2939    if ospath.exists(testdir):
2940        if testdir not in sys.path: sys.path.insert(0,testdir)
2941    import sgtbxtestinp
2942    def CompareWcctbx(spcname, cctbx_in, debug=0):
2943        'Compare output from GSASIIspc.SpcGroup with results from cctbx.sgtbx'
2944        cctbx = cctbx_in[:] # make copy so we don't delete from the original
2945        spc = (SpcGroup(spcname))[1]
2946        if debug: print spc['SpGrp']
2947        if debug: print spc['SGCen']
2948        latticetype = spcname.strip().upper()[0]
2949        # lattice type of R implies Hexagonal centering", fix the rhombohedral settings
2950        if latticetype == "R" and len(spc['SGCen']) == 1: latticetype = 'P'
2951        assert latticetype == spc['SGLatt'], "Failed: %s does not match Lattice: %s" % (spcname, spc['SGLatt'])
2952        onebar = [1]
2953        if spc['SGInv']: onebar.append(-1)
2954        for (op,off) in spc['SGOps']:
2955            for inv in onebar:
2956                for cen in spc['SGCen']:
2957                    noff = off + cen
2958                    noff = MoveToUnitCell(noff)
2959                    mult = tuple((op*inv).ravel().tolist())
2960                    if debug: print "\n%s: %s + %s" % (spcname,mult,noff)
2961                    for refop in cctbx:
2962                        if debug: print refop
2963                        # check the transform
2964                        if refop[:9] != mult: continue
2965                        if debug: print "mult match"
2966                        # check the translation
2967                        reftrans = list(refop[-3:])
2968                        reftrans = MoveToUnitCell(reftrans)
2969                        if all(abs(noff - reftrans) < 1.e-5):
2970                            cctbx.remove(refop)
2971                            break
2972                    else:
2973                        assert False, "failed on %s:\n\t %s + %s" % (spcname,mult,noff)
2974    for key in sgtbxtestinp.sgtbx:
2975        CompareWcctbx(key, sgtbxtestinp.sgtbx[key])
2976selftestlist.append(test2)
2977
2978def test3(): 
2979    '''self-test #3: exercise SytSym (includes GetOprPtrName, GenAtom, GetKNsym)
2980     for selected space groups against info in IT Volume A '''
2981    _ReportTest()
2982    def ExerciseSiteSym (spc, crdlist):
2983        'compare site symmetries and multiplicities for a specified space group'
2984        msg = "failed on site sym test for %s" % spc
2985        (E,S) = SpcGroup(spc)
2986        assert not E, msg
2987        for t in crdlist:
2988            symb, m = SytSym(t[0],S)
2989            if symb.strip() != t[2].strip() or m != t[1]:
2990                print spc,t[0],m,symb,t[2]
2991            assert m == t[1]
2992            #assert symb.strip() == t[2].strip()
2993
2994    ExerciseSiteSym('p 1',[
2995            ((0.13,0.22,0.31),1,'1'),
2996            ((0,0,0),1,'1'),
2997            ])
2998    ExerciseSiteSym('p -1',[
2999            ((0.13,0.22,0.31),2,'1'),
3000            ((0,0.5,0),1,'-1'),
3001            ])
3002    ExerciseSiteSym('C 2/c',[
3003            ((0.13,0.22,0.31),8,'1'),
3004            ((0.0,.31,0.25),4,'2(y)'),
3005            ((0.25,.25,0.5),4,'-1'),
3006            ((0,0.5,0),4,'-1'),
3007            ])
3008    ExerciseSiteSym('p 2 2 2',[
3009            ((0.13,0.22,0.31),4,'1'),
3010            ((0,0.5,.31),2,'2(z)'),
3011            ((0.5,.31,0.5),2,'2(y)'),
3012            ((.11,0,0),2,'2(x)'),
3013            ((0,0.5,0),1,'222'),
3014            ])
3015    ExerciseSiteSym('p 4/n',[
3016            ((0.13,0.22,0.31),8,'1'),
3017            ((0.25,0.75,.31),4,'2(z)'),
3018            ((0.5,0.5,0.5),4,'-1'),
3019            ((0,0.5,0),4,'-1'),
3020            ((0.25,0.25,.31),2,'4(001)'),
3021            ((0.25,.75,0.5),2,'-4(001)'),
3022            ((0.25,.75,0.0),2,'-4(001)'),
3023            ])
3024    ExerciseSiteSym('p 31 2 1',[
3025            ((0.13,0.22,0.31),6,'1'),
3026            ((0.13,0.0,0.833333333),3,'2(100)'),
3027            ((0.13,0.13,0.),3,'2(110)'),
3028            ])
3029    ExerciseSiteSym('R 3 c',[
3030            ((0.13,0.22,0.31),18,'1'),
3031            ((0.0,0.0,0.31),6,'3'),
3032            ])
3033    ExerciseSiteSym('R 3 c R',[
3034            ((0.13,0.22,0.31),6,'1'),
3035            ((0.31,0.31,0.31),2,'3(111)'),
3036            ])
3037    ExerciseSiteSym('P 63 m c',[
3038            ((0.13,0.22,0.31),12,'1'),
3039            ((0.11,0.22,0.31),6,'m(100)'),
3040            ((0.333333,0.6666667,0.31),2,'3m(100)'),
3041            ((0,0,0.31),2,'3m(100)'),
3042            ])
3043    ExerciseSiteSym('I a -3',[
3044            ((0.13,0.22,0.31),48,'1'),
3045            ((0.11,0,0.25),24,'2(x)'),
3046            ((0.11,0.11,0.11),16,'3(111)'),
3047            ((0,0,0),8,'-3(111)'),
3048            ])
3049selftestlist.append(test3)
3050
3051if __name__ == '__main__':
3052    # run self-tests
3053    selftestquiet = False
3054    for test in selftestlist:
3055        test()
3056    print "OK"
Note: See TracBrowser for help on using the repository browser.