Context Navigation

source: trunk/GSASIIspc.py @ 1709

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

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

Download in other formats: