Context Navigation

source: trunk/GSASIIspc.py @ 1615

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

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

Download in other formats: