Context Navigation

source: trunk/GSASIIspc.py @ 1957

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

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

Download in other formats: