Context Navigation

source: trunk/GSASIIspc.py @ 1715

Last change on this file since 1715 was 1715, checked in by vondreele, 8 years ago
make plot styles global instead of individual; now qplot, dplot work for multiplots
Property svn:eol-style set to `native` Property svn:keywords set to `Date Author Revision URL Id`
File size: 130.3 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: