Context Navigation

source: trunk/GSASIIconstrGUI.py @ 4605

Last change on this file since 4605 was 4605, checked in by toby, 3 years ago
fix AddRB with no matchTable
Property svn:eol-style set to `native` Property svn:keywords set to `Date Author Revision URL Id`
File size: 164.7 KB

Line
1	# -- coding: utf-8 --
2	#GSASIIconstrGUI - constraint GUI routines
3	########### SVN repository information ###################
4	# $Date: 2020-10-18 01:46:40 +0000 (Sun, 18 Oct 2020) $
5	# $Author: toby $
6	# $Revision: 4605 $
7	# $URL: trunk/GSASIIconstrGUI.py $
8	# $Id: GSASIIconstrGUI.py 4605 2020-10-18 01:46:40Z toby $
9	########### SVN repository information ###################
10	'''
11	GSASIIconstrGUI: Constraint GUI routines
12	------------------------------------------
13
14	Used to define constraints and rigid bodies.
15
16	'''
17	from __future__ import division, print_function
18	import platform
19	import sys
20	import copy
21	import os.path
22	import wx
23	import wx.grid as wg
24	import wx.lib.scrolledpanel as wxscroll
25	import wx.lib.gridmovers as gridmovers
26	import random as ran
27	import numpy as np
28	import numpy.ma as ma
29	import numpy.linalg as nl
30	import GSASIIpath
31	GSASIIpath.SetVersionNumber("$Revision: 4605 $")
32	import GSASIIElem as G2elem
33	import GSASIIElemGUI as G2elemGUI
34	import GSASIIstrIO as G2stIO
35	import GSASIImapvars as G2mv
36	import GSASIImath as G2mth
37	import GSASIIlattice as G2lat
38	import GSASIIdataGUI as G2gd
39	import GSASIIctrlGUI as G2G
40	import GSASIIfiles as G2fl
41	import GSASIIplot as G2plt
42	import GSASIIobj as G2obj
43	import GSASIIspc as G2spc
44	import GSASIIpy3 as G2py3
45	import GSASIIphsGUI as G2phG
46	import GSASIIIO as G2IO
47	import GSASIIscriptable as G2sc
48	VERY_LIGHT_GREY = wx.Colour(235,235,235)
49	WACV = wx.ALIGN_CENTER_VERTICAL
50
51	class G2BoolEditor(wg.GridCellBoolEditor):
52	'''Substitute for wx.grid.GridCellBoolEditor except toggles
53	grid items immediately when opened, updates grid & table contents after every
54	item change
55	'''
56	def __init__(self):
57	self.saveVals = None
58	wx.grid.GridCellBoolEditor.__init__(self)
59
60
61	def Create(self, parent, id, evtHandler):
62	'''Create the editing control (wx.CheckBox) when cell is opened
63	for edit
64	'''
65	self._tc = wx.CheckBox(parent, -1, "")
66	self._tc.Bind(wx.EVT_CHECKBOX, self.onCheckSet)
67	self.SetControl(self._tc)
68	if evtHandler:
69	self._tc.PushEventHandler(evtHandler)
70
71	def onCheckSet(self, event):
72	'''Callback used when checkbox is toggled.
73	Makes change to table immediately (creating event)
74	'''
75	if self.saveVals:
76	self.ApplyEdit(*self.saveVals)
77
78
79	def SetSize(self, rect):
80	'''Set position/size the edit control within the cell's rectangle.
81	'''
82	# self._tc.SetDimensions(rect.x, rect.y, rect.width+2, rect.height+2, # older
83	self._tc.SetSize(rect.x, rect.y, rect.width+2, rect.height+2,
84	wx.SIZE_ALLOW_MINUS_ONE)
85
86	def BeginEdit(self, row, col, grid):
87	'''Prepares the edit control by loading the initial
88	value from the table (toggles it since you would not
89	click on it if you were not planning to change it),
90	buts saves the original, pre-change value.
91	Makes change to table immediately.
92	Saves the info needed to make updates in self.saveVals.
93	Sets the focus.
94	'''
95	self.startValue = int(grid.GetTable().GetValue(row, col))
96	self.saveVals = row, col, grid
97	# invert state and set in editor
98	if self.startValue:
99	grid.GetTable().SetValue(row, col, 0)
100	self._tc.SetValue(0)
101	else:
102	grid.GetTable().SetValue(row, col, 1)
103	self._tc.SetValue(1)
104	self._tc.SetFocus()
105	self.ApplyEdit(*self.saveVals)
106
107	def EndEdit(self, row, col, grid, oldVal=None):
108	'''End editing the cell. This is supposed to
109	return None if the value has not changed, but I am not
110	sure that actually works.
111	'''
112	val = int(self._tc.GetValue())
113	if val != oldVal: #self.startValue:?
114	return val
115	else:
116	return None
117
118	def ApplyEdit(self, row, col, grid):
119	'''Save the value into the table, and create event.
120	Called after EndEdit(), BeginEdit and onCheckSet.
121	'''
122	val = int(self._tc.GetValue())
123	grid.GetTable().SetValue(row, col, val) # update the table
124
125	def Reset(self):
126	'''Reset the value in the control back to its starting value.
127	'''
128	self._tc.SetValue(self.startValue)
129
130	def StartingClick(self):
131	'''This seems to be needed for BeginEdit to work properly'''
132	pass
133
134	def Destroy(self):
135	"final cleanup"
136	super(G2BoolEditor, self).Destroy()
137
138	def Clone(self):
139	'required'
140	return G2BoolEditor()
141
142	class DragableRBGrid(wg.Grid):
143	'''Simple grid implentation for display of rigid body positions.
144
145	:param parent: frame or panel where grid will be placed
146	:param dict rb: dict with atom labels, types and positions
147	:param function onChange: a callback used every time a value in
148	rb is changed.
149	'''
150	def __init__(self, parent, rb, onChange=None):
151	#wg.Grid.__init__(self, parent, wx.ID_ANY,size=(-1,200))
152	wg.Grid.__init__(self, parent, wx.ID_ANY)
153	self.SetTable(RBDataTable(rb,onChange), True)
154	# Enable Row moving
155	gridmovers.GridRowMover(self)
156	self.Bind(gridmovers.EVT_GRID_ROW_MOVE, self.OnRowMove, self)
157	self.SetColSize(0, 60)
158	self.SetColSize(1, 40)
159	self.SetColSize(2, 35)
160	for r in range(len(rb['RBlbls'])):
161	self.SetReadOnly(r,0,isReadOnly=True)
162	self.SetCellEditor(r, 1, G2BoolEditor())
163	self.SetCellRenderer(r, 1, wg.GridCellBoolRenderer())
164	self.SetReadOnly(r,2,isReadOnly=True)
165	self.SetCellEditor(r,3, wg.GridCellFloatEditor())
166	self.SetCellEditor(r,4, wg.GridCellFloatEditor())
167	self.SetCellEditor(r,6, wg.GridCellFloatEditor())
168
169	def OnRowMove(self,evt):
170	'called when a row move needs to take place'
171	frm = evt.GetMoveRow() # Row being moved
172	to = evt.GetBeforeRow() # Before which row to insert
173	self.GetTable().MoveRow(frm,to)
174
175	def completeEdits(self):
176	'complete any outstanding edits'
177	if self.IsCellEditControlEnabled(): # complete any grid edits in progress
178	#if GSASIIpath.GetConfigValue('debug'): print ('Completing grid edit')
179	self.SaveEditControlValue()
180	self.HideCellEditControl()
181	self.DisableCellEditControl()
182
183	class RBDataTable(wg.GridTableBase):
184	'''A Table to support :class:`DragableRBGrid`
185	'''
186	def __init__(self,rb,onChange):
187	wg.GridTableBase.__init__(self)
188	self.colLabels = ['Label','Select','Type','x','y','z']
189	self.coords = rb['RBcoords']
190	self.labels = rb['RBlbls']
191	self.types = rb['RBtypes']
192	self.index = rb['RBindex']
193	self.select = rb['RBselection']
194	self.onChange = onChange
195
196	# required methods
197	def GetNumberRows(self):
198	return len(self.labels)
199	def GetNumberCols(self):
200	return len(self.colLabels)
201	def IsEmptyCell(self, row, col):
202	return False
203	def GetValue(self, row, col):
204	row = self.index[row]
205	if col == 0:
206	return self.labels[row]
207	elif col == 1:
208	return int(self.select[row])
209	elif col == 2:
210	return self.types[row]
211	else:
212	return '{:.5f}'.format(self.coords[row][col-3])
213	def SetValue(self, row, col, value):
214	row = self.index[row]
215	try:
216	if col == 0:
217	self.labels[row] = value
218	elif col == 1:
219	self.select[row] = int(value)
220	elif col == 2:
221	self.types[row] = value
222	else:
223	self.coords[row][col-3] = float(value)
224	except:
225	pass
226	if self.onChange:
227	self.onChange()
228	# Display column & row labels
229	def GetColLabelValue(self, col):
230	return self.colLabels[col]
231	def GetRowLabelValue(self,row):
232	return str(row+1)
233
234	# Implement "row movement" by updating the pointer array
235	def MoveRow(self,frm,to):
236	grid = self.GetView()
237	if grid:
238	move = self.index[frm]
239	del self.index[frm]
240	if frm > to:
241	self.index.insert(to,move)
242	else:
243	self.index.insert(to-1,move)
244
245	# Notify the grid
246	grid.BeginBatch()
247	msg = wg.GridTableMessage(
248	self, wg.GRIDTABLE_NOTIFY_ROWS_DELETED, frm, 1
249	)
250	grid.ProcessTableMessage(msg)
251	msg = wg.GridTableMessage(
252	self, wg.GRIDTABLE_NOTIFY_ROWS_INSERTED, to, 1
253	)
254	grid.ProcessTableMessage(msg)
255	grid.EndBatch()
256	if self.onChange:
257	self.onChange()
258
259	def MakeDrawAtom(data,atom):
260	'Convert atom to format needed to draw it'
261	generalData = data['General']
262	if generalData['Type'] in ['nuclear','faulted',]:
263	atomInfo = [atom[:2]+atom[3:6]+['1',]+['vdW balls',]+
264	['',]+[[255,255,255],]+atom[9:]+[[],[]]][0]
265	ct,cs = [1,8] #type & color
266	atNum = generalData['AtomTypes'].index(atom[ct])
267	atomInfo[cs] = list(generalData['Color'][atNum])
268	return atomInfo
269
270	class ConstraintDialog(wx.Dialog):
271	'''Window to edit Constraint values
272	'''
273	def __init__(self,parent,title,text,data,separator='*',varname="",varyflag=False):
274	wx.Dialog.__init__(self,parent,-1,'Edit '+title,
275	pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
276	self.data = data[:]
277	self.newvar = [varname,varyflag]
278	panel = wx.Panel(self)
279	mainSizer = wx.BoxSizer(wx.VERTICAL)
280	topLabl = wx.StaticText(panel,-1,text)
281	mainSizer.Add((10,10),1)
282	mainSizer.Add(topLabl,0,wx.LEFT,10)
283	mainSizer.Add((10,10),1)
284	dataGridSizer = wx.FlexGridSizer(cols=3,hgap=2,vgap=2)
285	self.OkBtn = wx.Button(panel,wx.ID_OK)
286	for id in range(len(self.data)):
287	lbl1 = lbl = str(self.data[id][1])
288	if lbl[-1] != '=': lbl1 = lbl + ' ' + separator + ' '
289	name = wx.StaticText(panel,wx.ID_ANY,lbl1,style=wx.ALIGN_RIGHT)
290	scale = G2G.ValidatedTxtCtrl(panel,self.data[id],0,OKcontrol=self.DisableOK)
291	dataGridSizer.Add(name,0,wx.LEFT\|wx.RIGHT\|WACV,5)
292	dataGridSizer.Add(scale,0,wx.RIGHT,3)
293	if ':' in lbl:
294	dataGridSizer.Add(
295	wx.StaticText(panel,-1,G2obj.fmtVarDescr(lbl)),
296	0,wx.RIGHT\|WACV,3)
297	else:
298	dataGridSizer.Add((-1,-1))
299	if title == 'New Variable':
300	name = wx.StaticText(panel,wx.ID_ANY,"New variable's\nname (optional)",
301	style=wx.ALIGN_CENTER)
302	scale = G2G.ValidatedTxtCtrl(panel,self.newvar,0,notBlank=False)
303	dataGridSizer.Add(name,0,wx.LEFT\|wx.RIGHT\|WACV,5)
304	dataGridSizer.Add(scale,0,wx.RIGHT\|WACV,3)
305	self.refine = wx.CheckBox(panel,label='Refine?')
306	self.refine.SetValue(self.newvar[1]==True)
307	self.refine.Bind(wx.EVT_CHECKBOX, self.OnCheckBox)
308	dataGridSizer.Add(self.refine,0,wx.RIGHT\|WACV,3)
309
310	mainSizer.Add(dataGridSizer,0,wx.EXPAND)
311	self.OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
312	self.OkBtn.SetDefault()
313	cancelBtn = wx.Button(panel,wx.ID_CANCEL)
314	cancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
315	btnSizer = wx.BoxSizer(wx.HORIZONTAL)
316	btnSizer.Add((20,20),1)
317	btnSizer.Add(self.OkBtn)
318	btnSizer.Add((20,20),1)
319	btnSizer.Add(cancelBtn)
320	btnSizer.Add((20,20),1)
321
322	mainSizer.Add(btnSizer,0,wx.EXPAND, 10)
323	panel.SetSizer(mainSizer)
324	panel.Fit()
325	self.Fit()
326	self.CenterOnParent()
327
328	def DisableOK(self,setting):
329	if setting:
330	self.OkBtn.Enable()
331	else:
332	self.OkBtn.Disable()
333
334	def OnCheckBox(self,event):
335	self.newvar[1] = self.refine.GetValue()
336
337	def OnOk(self,event):
338	parent = self.GetParent()
339	parent.Raise()
340	self.EndModal(wx.ID_OK)
341
342	def OnCancel(self,event):
343	parent = self.GetParent()
344	parent.Raise()
345	self.EndModal(wx.ID_CANCEL)
346
347	def GetData(self):
348	return self.data
349
350	################################################################################
351	##### Constraints
352	################################################################################
353	def UpdateConstraints(G2frame,data):
354	'''Called when Constraints tree item is selected.
355	Displays the constraints in the data window
356	'''
357
358	def FindEquivVarb(name,nameList):
359	'Creates a list of variables appropriate to constrain with name'
360	outList = []
361	#phlist = []
362	items = name.split(':')
363	namelist = [items[2],]
364	if 'dA' in name:
365	namelist = ['dAx','dAy','dAz']
366	elif 'AU' in name:
367	namelist = ['AUiso','AU11','AU22','AU33','AU12','AU13','AU23']
368	elif 'AM' in name:
369	namelist = ['AMx','AMy','AMz']
370	elif items[-1] in ['A0','A1','A2','A3','A4','A5']:
371	namelist = ['A0','A1','A2','A3','A4','A5']
372	elif items[-1] in ['D11','D22','D33','D12','D13','D23']:
373	namelist = ['D11','D22','D33','D12','D13','D23']
374	elif 'Tm' in name:
375	namelist = ['Tmin','Tmax']
376	elif 'MX' in name or 'MY' in name or 'MZ' in name:
377	namelist = ['MXcos','MYcos','MZcos','MXsin','MYsin','MZsin']
378	elif 'mV' in name:
379	namelist = ['mV0','mV1','mV2']
380	elif 'RB' in name:
381	rbfx = 'RB'+items[2][2]
382	if 'T' in name and 'Tr' not in name:
383	namelist = [rbfx+'T11',rbfx+'T22',rbfx+'T33',rbfx+'T12',rbfx+'T13',rbfx+'T23']
384	if 'L' in name:
385	namelist = [rbfx+'L11',rbfx+'L22',rbfx+'L33',rbfx+'L12',rbfx+'L13',rbfx+'L23']
386	if 'S' in name:
387	namelist = [rbfx+'S12',rbfx+'S13',rbfx+'S21',rbfx+'S23',rbfx+'S31',rbfx+'S32',rbfx+'SAA',rbfx+'SBB']
388	if 'U' in name:
389	namelist = [rbfx+'U',]
390
391	for item in nameList:
392	keys = item.split(':')
393	#if keys[0] not in phlist:
394	# phlist.append(keys[0])
395	if items[1] == '*' and keys[2] in namelist: # wildcard -- select only sequential options
396	keys[1] = '*'
397	mitem = ':'.join(keys)
398	if mitem == name: continue
399	if mitem not in outList: outList.append(mitem)
400	elif keys[2] in namelist and item != name:
401	outList.append(item)
402	return outList
403
404	def SelectVarbs(page,FrstVarb,varList,legend,constType):
405	'''Select variables used in constraints after one variable has
406	been selected. This routine determines the appropriate variables to be
407	used based on the one that has been selected and asks for more to be added.
408
409	It then creates the constraint and adds it to the constraints list.
410
411	Called from OnAddEquivalence, OnAddFunction & OnAddConstraint (all but
412	OnAddHold)
413
414	:param list page: defines calling page -- type of variables to be used
415	:parm GSASIIobj.G2VarObj FrstVarb: reference to first selected variable
416	:param list varList: list of other appropriate variables to select from
417	:param str legend: header for selection dialog
418	:param str constType: type of constraint to be generated
419	:returns: a constraint, as defined in
420	:ref:`GSASIIobj <Constraint_definitions_table>`
421	'''
422	choices = [[i]+list(G2obj.VarDescr(i)) for i in varList]
423	meaning = G2obj.getDescr(FrstVarb.name)
424	if not meaning:
425	meaning = "(no definition found!)"
426	l = str(FrstVarb).split(':')
427	# make lists of phases & histograms to iterate over
428	phaselist = [l[0]]
429	if l[0]:
430	phaselbl = ['phase #'+l[0]]
431	if len(Phases) > 1:
432	phaselist += ['all']
433	phaselbl += ['all phases']
434	else:
435	phaselbl = ['']
436	histlist = [l[1]]
437	if l[1] == '*':
438	pass
439	elif l[1]:
440	histlbl = ['histogram #'+l[1]]
441	if len(Histograms) > 1:
442	histlist += ['all']
443	histlbl += ['all histograms']
444	typ = Histograms[G2obj.LookupHistName(l[1])[0]]['Instrument Parameters'][0]['Type'][1]
445	i = 0
446	for hist in Histograms:
447	if Histograms[hist]['Instrument Parameters'][0]['Type'][1] == typ: i += 1
448	if i > 1:
449	histlist += ['all='+typ]
450	histlbl += ['all '+typ+' histograms']
451	else:
452	histlbl = ['']
453	# make a list of equivalent parameter names
454	nameList = [FrstVarb.name]
455	for var in varList:
456	nam = var.split(":")[2]
457	if nam not in nameList: nameList += [nam]
458	# add "wild-card" names to the list of variables
459	if l[1] == '*':
460	pass
461	elif page[1] == 'phs':
462	if 'RB' in FrstVarb.name:
463	pass
464	elif FrstVarb.atom is None:
465	for nam in nameList:
466	for ph,plbl in zip(phaselist,phaselbl):
467	if plbl: plbl = 'For ' + plbl
468	var = ph+"::"+nam
469	if var == str(FrstVarb) or var in varList: continue
470	varList += [var]
471	choices.append([var,plbl,meaning])
472	else:
473	for nam in nameList:
474	for ph,plbl in zip(phaselist,phaselbl):
475	if plbl: plbl = ' in ' + plbl
476	for atype in ['']+TypeList:
477	if atype:
478	albl = "For "+atype+" atoms"
479	akey = "all="+atype
480	else:
481	albl = "For all atoms"
482	akey = "all"
483	var = ph+"::"+nam+":"+akey
484	if var == str(FrstVarb) or var in varList: continue
485	varList += [var]
486	choices.append([var,albl+plbl,meaning])
487	elif page[1] == 'hap':
488	if FrstVarb.name == "Scale":
489	meaning = "Phase fraction"
490	for nam in nameList:
491	for ph,plbl in zip(phaselist,phaselbl):
492	if plbl: plbl = 'For ' + plbl
493	for hst,hlbl in zip(histlist,histlbl):
494	if hlbl:
495	if plbl:
496	hlbl = ' in ' + hlbl
497	else:
498	hlbl = 'For ' + hlbl
499	var = ph+":"+hst+":"+nam
500	if var == str(FrstVarb) or var in varList: continue
501	varList += [var]
502	choices.append([var,plbl+hlbl,meaning])
503	elif page[1] == 'hst':
504	if FrstVarb.name == "Scale":
505	meaning = "Scale factor"
506	for nam in nameList:
507	for hst,hlbl in zip(histlist,histlbl):
508	if hlbl:
509	hlbl = 'For ' + hlbl
510	var = ":"+hst+":"+nam
511	if var == str(FrstVarb) or var in varList: continue
512	varList += [var]
513	choices.append([var,hlbl,meaning])
514	elif page[1] == 'glb' or page[1] == 'sym':
515	pass
516	else:
517	raise Exception('Unknown constraint page '+ page[1])
518	if len(choices):
519	l1 = l2 = 1
520	for i1,i2,i3 in choices:
521	l1 = max(l1,len(i1))
522	l2 = max(l2,len(i2))
523	fmt = "{:"+str(l1)+"s} {:"+str(l2)+"s} {:s}"
524	atchoices = [fmt.format(*i1) for i1 in choices] # reformat list as str with columns
525	dlg = G2G.G2MultiChoiceDialog(
526	G2frame,legend,
527	'Constrain '+str(FrstVarb)+' with...',atchoices,
528	toggle=False,size=(625,400),monoFont=True)
529	dlg.CenterOnParent()
530	res = dlg.ShowModal()
531	Selections = dlg.GetSelections()[:]
532	dlg.Destroy()
533	if res != wx.ID_OK: return []
534	if len(Selections) == 0:
535	dlg = wx.MessageDialog(
536	G2frame,
537	'No variables were selected to include with '+str(FrstVarb),
538	'No variables')
539	dlg.CenterOnParent()
540	dlg.ShowModal()
541	dlg.Destroy()
542	return []
543	else:
544	dlg = wx.MessageDialog(
545	G2frame,
546	'There are no appropriate variables to include with '+str(FrstVarb),
547	'No variables')
548	dlg.CenterOnParent()
549	dlg.ShowModal()
550	dlg.Destroy()
551	return []
552	# now process the variables provided by the user
553	varbs = [str(FrstVarb),] # list of selected variables
554	for sel in Selections:
555	var = varList[sel]
556	# phase(s) included
557	l = var.split(':')
558	if l[0] == "all":
559	phlist = [str(Phases[phase]['pId']) for phase in Phases]
560	else:
561	phlist = [l[0]]
562	# histogram(s) included
563	if l[1] == "all":
564	hstlist = [str(Histograms[hist]['hId']) for hist in Histograms]
565	elif '=' in l[1]:
566	htyp = l[1].split('=')[1]
567	hstlist = [str(Histograms[hist]['hId']) for hist in Histograms if
568	Histograms[hist]['Instrument Parameters'][0]['Type'][1] == htyp]
569	else:
570	hstlist = [l[1]]
571	if len(l) == 3:
572	for ph in phlist:
573	for hst in hstlist:
574	var = ph + ":" + hst + ":" + l[2]
575	if var in varbs: continue
576	varbs.append(var)
577	else: # constraints with atoms or rigid bodies
578	if len(l) == 5: # rigid body parameter
579	var = ':'.join(l)
580	if var in varbs: continue
581	varbs.append(var)
582	elif l[3] == "all":
583	for ph in phlist:
584	key = G2obj.LookupPhaseName(ph)[0]
585	for hst in hstlist: # should be blank
586	for iatm,at in enumerate(Phases[key]['Atoms']):
587	var = ph + ":" + hst + ":" + l[2] + ":" + str(iatm)
588	if var in varbs: continue
589	varbs.append(var)
590	elif '=' in l[3]:
591	for ph in phlist:
592	key = G2obj.LookupPhaseName(ph)[0]
593	cx,ct,cs,cia = Phases[key]['General']['AtomPtrs']
594	for hst in hstlist: # should be blank
595	atyp = l[3].split('=')[1]
596	for iatm,at in enumerate(Phases[key]['Atoms']):
597	if at[ct] != atyp: continue
598	var = ph + ":" + hst + ":" + l[2] + ":" + str(iatm)
599	if var in varbs: continue
600	varbs.append(var)
601	else:
602	for ph in phlist:
603	key = G2obj.LookupPhaseName(ph)[0]
604	for hst in hstlist: # should be blank
605	var = ph + ":" + hst + ":" + l[2] + ":" + l[3]
606	if var in varbs: continue
607	varbs.append(var)
608	if len(varbs) >= 1 or 'constraint' in constType:
609	constr = [[1.0,FrstVarb]]
610	for item in varbs[1:]:
611	constr += [[1.0,G2obj.G2VarObj(item)]]
612	if 'equivalence' in constType:
613	return [constr+[None,None,'e']]
614	elif 'function' in constType:
615	return [constr+[None,False,'f']]
616	elif 'constraint' in constType:
617	return [constr+[1.0,None,'c']]
618	else:
619	raise Exception('Unknown constraint type: '+str(constType))
620	else:
621	dlg = wx.MessageDialog(
622	G2frame,
623	'There are no selected variables to include with '+str(FrstVarb),
624	'No variables')
625	dlg.CenterOnParent()
626	dlg.ShowModal()
627	dlg.Destroy()
628	return []
629
630	def ConstraintsLoad(data,newcons=[]):
631	'''Load all constraints. Constraints based on symmetry (etc.)
632	are generated by running :func:`GSASIIstrIO.GetPhaseData`.
633	'''
634	G2mv.InitVars()
635	#Find all constraints
636	constraintSet = []
637	for key in data:
638	if key.startswith('_'): continue
639	constraintSet += data[key]
640	if newcons:
641	constraintSet = constraintSet + newcons
642	constDictList,fixedList,ignored = G2stIO.ProcessConstraints(constraintSet)
643	# generate symmetry constraints to check for conflicts
644	rigidbodyDict = G2frame.GPXtree.GetItemPyData(
645	G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Rigid bodies'))
646	rbIds = rigidbodyDict.get('RBIds',{'Vector':[],'Residue':[]})
647	rbVary,rbDict = G2stIO.GetRigidBodyModels(rigidbodyDict,Print=False)
648	Natoms,atomIndx,phaseVary,phaseDict,pawleyLookup,FFtables,BLtables,MFtables,maxSSwave = G2stIO.GetPhaseData(
649	Phases,RestraintDict=None,rbIds=rbIds,Print=False) # generates atom symmetry constraints
650	return constDictList,phaseDict,fixedList
651
652	def ConstraintsCheck(data,newcons=[]):
653	'''Load constraints & check them for errors. Since error checking
654	can cause changes in constraints in case of repairable conflicts
655	between equivalences, reload the constraints again after the check.
656	This could probably be done more effectively, but only reloading when
657	needed, but the reload should be quick.
658	'''
659	constDictList,phaseDict,fixedList = ConstraintsLoad(data,newcons)
660	msg = G2mv.EvaluateMultipliers(constDictList,phaseDict)
661	if msg:
662	return 'Unable to interpret multiplier(s): '+msg,''
663	res = G2mv.CheckConstraints('',constDictList,fixedList)
664	# reload constraints in case any were merged in MoveConfEquiv
665	ConstraintsLoad(data,newcons)
666	return res
667
668	def CheckAddedConstraint(newcons):
669	'''Check a new constraint that has just been input.
670	If there is an error display a message and discard the last entry
671
672	Since the varylist is not available, no warning messages
673	should be generated here
674
675	:returns: True if constraint should be added
676	'''
677
678	errmsg,warnmsg = ConstraintsCheck(data,newcons)
679	if errmsg:
680	G2frame.ErrorDialog('Constraint Error',
681	'Error with newly added constraint:\n'+errmsg+
682	'\nIgnoring newly added constraint',parent=G2frame)
683	# reset error status
684	errmsg,warnmsg = ConstraintsCheck(data)
685	if errmsg:
686	print (errmsg)
687	print (G2mv.VarRemapShow([],True))
688	return False
689	elif warnmsg:
690	print ('Unexpected contraint warning:\n'+warnmsg)
691	return True
692
693	def CheckChangedConstraint():
694	'''Check all constraints after an edit has been made.
695	If there is an error display a message and reject the change.
696
697	Since the varylist is not available, no warning messages
698	should be generated.
699
700	:returns: True if the edit should be retained
701	'''
702	errmsg,warnmsg = ConstraintsCheck(data)
703	if errmsg:
704	G2frame.ErrorDialog('Constraint Error',
705	'Error after editing constraint:\n'+errmsg+
706	'\nDiscarding last constraint edit',parent=G2frame)
707	# reset error status
708	errmsg,warnmsg = ConstraintsCheck(data)
709	if errmsg:
710	print (errmsg)
711	print (G2mv.VarRemapShow([],True))
712	return False
713	elif warnmsg:
714	print ('Unexpected contraint warning:\n'+warnmsg)
715	return True
716
717	def PageSelection(page):
718	'Decode page reference'
719	if page[1] == "phs":
720	vartype = "phase"
721	varList = G2obj.removeNonRefined(phaseList) # remove any non-refinable prms from list
722	constrDictEnt = 'Phase'
723	elif page[1] == "hap":
724	vartype = "Histogram*Phase"
725	varList = G2obj.removeNonRefined(hapList) # remove any non-refinable prms from list
726	constrDictEnt = 'HAP'
727	elif page[1] == "hst":
728	vartype = "Histogram"
729	varList = G2obj.removeNonRefined(histList) # remove any non-refinable prms from list
730	constrDictEnt = 'Hist'
731	elif page[1] == "glb":
732	vartype = "Global"
733	varList = G2obj.removeNonRefined(globalList) # remove any non-refinable prms from list
734
735	constrDictEnt = 'Global'
736	elif page[1] == "sym":
737	return None,None,None
738	else:
739	raise Exception('Should not happen!')
740	return vartype,varList,constrDictEnt
741
742	def OnAddHold(event):
743	'''Create a new Hold constraint
744
745	Hold constraints allows the user to select one variable (the list of available
746	variables depends on which tab is currently active).
747	'''
748	page = G2frame.Page
749	vartype,varList,constrDictEnt = PageSelection(page)
750	if vartype is None: return
751	varList = G2obj.SortVariables(varList)
752	title1 = "Hold "+vartype+" variable"
753	if not varList:
754	G2frame.ErrorDialog('No variables','There are no variables of type '+vartype,
755	parent=G2frame)
756	return
757	l2 = l1 = 1
758	for i in varList:
759	l1 = max(l1,len(i))
760	loc,desc = G2obj.VarDescr(i)
761	l2 = max(l2,len(loc))
762	fmt = "{:"+str(l1)+"s} {:"+str(l2)+"s} {:s}"
763	varListlbl = [fmt.format(i,*G2obj.VarDescr(i)) for i in varList]
764	#varListlbl = ["("+i+") "+G2obj.fmtVarDescr(i) for i in varList]
765	legend = "Select variables to hold (Will not be varied, even if vary flag is set)"
766	dlg = G2G.G2MultiChoiceDialog(G2frame,
767	legend,title1,varListlbl,toggle=False,size=(625,400),monoFont=True)
768	dlg.CenterOnParent()
769	if dlg.ShowModal() == wx.ID_OK:
770	for sel in dlg.GetSelections():
771	Varb = varList[sel]
772	VarObj = G2obj.G2VarObj(Varb)
773	newcons = [[[0.0,VarObj],None,None,'h']]
774	if CheckAddedConstraint(newcons):
775	data[constrDictEnt] += newcons
776	dlg.Destroy()
777	wx.CallAfter(OnPageChanged,None)
778
779	def OnAddEquivalence(event):
780	'''add an Equivalence constraint'''
781	page = G2frame.Page
782	vartype,varList,constrDictEnt = PageSelection(page)
783	if vartype is None: return
784	title1 = "Create equivalence constraint between "+vartype+" variables"
785	title2 = "Select additional "+vartype+" variable(s) to be equivalent with "
786	if not varList:
787	G2frame.ErrorDialog('No variables','There are no variables of type '+vartype,
788	parent=G2frame)
789	return
790	# legend = "Select variables to make equivalent (only one of the variables will be varied when all are set to be varied)"
791	GetAddVars(page,title1,title2,varList,constrDictEnt,'equivalence')
792
793	def OnAddAtomEquiv(event):
794	''' Add equivalences between all parameters on atoms '''
795	page = G2frame.Page
796	vartype,varList,constrDictEnt = PageSelection(page)
797	if vartype is None: return
798	title1 = "Setup equivalent atom variables"
799	title2 = "Select additional atoms(s) to be equivalent with "
800	if not varList:
801	G2frame.ErrorDialog('No variables','There are no variables of type '+vartype,
802	parent=G2frame)
803	return
804	# legend = "Select atoms to make equivalent (only one of the atom variables will be varied when all are set to be varied)"
805	GetAddAtomVars(page,title1,title2,varList,constrDictEnt,'equivalence')
806
807	def OnAddRiding(event):
808	''' Add riding equivalences between all parameters on atoms '''
809	page = G2frame.Page
810	vartype,varList,constrDictEnt = PageSelection(page)
811	if vartype is None: return
812	title1 = "Setup riding atoms "
813	title2 = "Select additional atoms(s) to ride on "
814	if not varList:
815	G2frame.ErrorDialog('No variables','There are no variables of type '+vartype,
816	parent=G2frame)
817	return
818	# legend = "Select atoms to ride (only one of the atom variables will be varied when all are set to be varied)"
819	GetAddAtomVars(page,title1,title2,varList,constrDictEnt,'riding')
820
821	def OnAddFunction(event):
822	'''add a Function (new variable) constraint'''
823	page = G2frame.Page
824	vartype,varList,constrDictEnt = PageSelection(page)
825	if vartype is None: return
826	title1 = "Setup new variable based on "+vartype+" variables"
827	title2 = "Include additional "+vartype+" variable(s) to be included with "
828	if not varList:
829	G2frame.ErrorDialog('No variables','There are no variables of type '+vartype,
830	parent=G2frame)
831	return
832	# legend = "Select variables to include in a new variable (the new variable will be varied when all included variables are varied)"
833	GetAddVars(page,title1,title2,varList,constrDictEnt,'function')
834
835	def OnAddConstraint(event):
836	'''add a constraint equation to the constraints list'''
837	page = G2frame.Page
838	vartype,varList,constrDictEnt = PageSelection(page)
839	if vartype is None: return
840	title1 = "Creating constraint on "+vartype+" variables"
841	title2 = "Select additional "+vartype+" variable(s) to include in constraint with "
842	if not varList:
843	G2frame.ErrorDialog('No variables','There are no variables of type '+vartype,
844	parent=G2frame)
845	return
846	# legend = "Select variables to include in a constraint equation (the values will be constrainted to equal a specified constant)"
847	GetAddVars(page,title1,title2,varList,constrDictEnt,'constraint')
848
849	def GetAddVars(page,title1,title2,varList,constrDictEnt,constType):
850	'''Get the variables to be added for OnAddEquivalence, OnAddFunction,
851	and OnAddConstraint. Then create and check the constraint.
852	'''
853	#varListlbl = ["("+i+") "+G2obj.fmtVarDescr(i) for i in varList]
854	if constType == 'equivalence':
855	omitVars = G2mv.GetDependentVars()
856	else:
857	omitVars = []
858	varList = G2obj.SortVariables([i for i in varList if i not in omitVars])
859	l2 = l1 = 1
860	for i in varList:
861	l1 = max(l1,len(i))
862	loc,desc = G2obj.VarDescr(i)
863	l2 = max(l2,len(loc))
864	fmt = "{:"+str(l1)+"s} {:"+str(l2)+"s} {:s}"
865	varListlbl = [fmt.format(i,*G2obj.VarDescr(i)) for i in varList]
866	dlg = G2G.G2SingleChoiceDialog(G2frame,'Select 1st variable:',
867	title1,varListlbl,monoFont=True,size=(625,400))
868	dlg.CenterOnParent()
869	if dlg.ShowModal() == wx.ID_OK:
870	if constType == 'equivalence':
871	omitVars = G2mv.GetDependentVars() + G2mv.GetIndependentVars()
872	sel = dlg.GetSelection()
873	FrstVarb = varList[sel]
874	VarObj = G2obj.G2VarObj(FrstVarb)
875	moreVarb = G2obj.SortVariables(FindEquivVarb(FrstVarb,[i for i in varList if i not in omitVars]))
876	newcons = SelectVarbs(page,VarObj,moreVarb,title2+FrstVarb,constType)
877	if len(newcons) > 0:
878	if CheckAddedConstraint(newcons):
879	data[constrDictEnt] += newcons
880	dlg.Destroy()
881	wx.CallAfter(OnPageChanged,None)
882
883	def FindNeighbors(phase,FrstName,AtNames):
884	General = phase['General']
885	cx,ct,cs,cia = General['AtomPtrs']
886	Atoms = phase['Atoms']
887	atNames = [atom[ct-1] for atom in Atoms]
888	Cell = General['Cell'][1:7]
889	Amat,Bmat = G2lat.cell2AB(Cell)
890	atTypes = General['AtomTypes']
891	Radii = np.array(General['BondRadii'])
892	AtInfo = dict(zip(atTypes,Radii)) #or General['BondRadii']
893	Orig = atNames.index(FrstName.split()[1])
894	OType = Atoms[Orig][ct]
895	XYZ = G2mth.getAtomXYZ(Atoms,cx)
896	Neigh = []
897	Dx = np.inner(Amat,XYZ-XYZ[Orig]).T
898	dist = np.sqrt(np.sum(Dx**2,axis=1))
899	sumR = AtInfo[OType]+0.5 #H-atoms only!
900	IndB = ma.nonzero(ma.masked_greater(dist-0.85*sumR,0.))
901	for j in IndB[0]:
902	if j != Orig:
903	Neigh.append(AtNames[j])
904	return Neigh
905
906	def GetAddAtomVars(page,title1,title2,varList,constrDictEnt,constType):
907	'''Get the atom variables to be added for OnAddAtomEquiv. Then create and
908	check the constraints. Riding for H atoms only.
909	'''
910	Atoms = {G2obj.VarDescr(i)[0]:[] for i in varList if 'Atom' in G2obj.VarDescr(i)[0]}
911	for item in varList:
912	atName = G2obj.VarDescr(item)[0]
913	if atName in Atoms:
914	Atoms[atName].append(item)
915	AtNames = list(Atoms.keys())
916	AtNames.sort()
917	dlg = G2G.G2SingleChoiceDialog(G2frame,'Select 1st atom:',
918	title1,AtNames,monoFont=True,size=(625,400))
919	dlg.CenterOnParent()
920	FrstAtom = ''
921	if dlg.ShowModal() == wx.ID_OK:
922	sel = dlg.GetSelection()
923	FrstAtom = AtNames[sel]
924	if 'riding' in constType:
925	phaseName = (FrstAtom.split(' in ')[1]).strip()
926	phase = Phases[phaseName]
927	AtNames = FindNeighbors(phase,FrstAtom,AtNames)
928	else:
929	AtNames.remove(FrstAtom)
930	dlg.Destroy()
931	if FrstAtom == '':
932	print ('no atom selected')
933	return
934	dlg = G2G.G2MultiChoiceDialog(
935	G2frame,title2+FrstAtom,
936	'Constrain '+str(FrstAtom)+' with...',AtNames,
937	toggle=False,size=(625,400),monoFont=True)
938	if dlg.ShowModal() == wx.ID_OK:
939	Selections = dlg.GetSelections()[:]
940	else:
941	print ('no target atom selected')
942	dlg.Destroy()
943	return
944	dlg.Destroy()
945	for name in Atoms[FrstAtom]:
946	newcons = []
947	constr = []
948	if 'riding' in constType:
949	if 'AUiso' in name:
950	constr = [[1.0,G2obj.G2VarObj(name)]]
951	elif 'AU11' in name:
952	pass
953	elif 'AU' not in name:
954	constr = [[1.0,G2obj.G2VarObj(name)]]
955	else:
956	constr = [[1.0,G2obj.G2VarObj(name)]]
957	pref = ':'+name.rsplit(':',1)[0].split(':',1)[1] #get stuff between phase id & atom id
958	for sel in Selections:
959	name2 = Atoms[AtNames[sel]][0]
960	pid = name2.split(':',1)[0] #get phase id for 2nd atom
961	id = name2.rsplit(':',1)[-1] #get atom no. for 2nd atom
962	if 'riding' in constType:
963	pref = pid+pref
964	if 'AUiso' in pref:
965	parts = pref.split('AUiso')
966	constr += [[1.2,G2obj.G2VarObj('%s:%s'%(parts[0]+'AUiso',id))]]
967	elif 'AU' not in pref:
968	constr += [[1.0,G2obj.G2VarObj('%s:%s'%(pref,id))]]
969	else:
970	constr += [[1.0,G2obj.G2VarObj('%s:%s'%(pid+pref,id))]]
971	if not constr:
972	continue
973	if 'frac' in pref and 'riding' not in constType:
974	newcons = [constr+[1.0,None,'c']]
975	else:
976	newcons = [constr+[None,None,'e']]
977	if len(newcons) > 0:
978	if CheckAddedConstraint(newcons):
979	data[constrDictEnt] += newcons
980	wx.CallAfter(OnPageChanged,None)
981
982	def MakeConstraintsSizer(name,pageDisplay):
983	'''Creates a sizer displaying all of the constraints entered of
984	the specified type.
985
986	:param str name: the type of constraints to be displayed ('HAP',
987	'Hist', 'Phase', 'Global', 'Sym-Generated')
988	:param wx.Panel pageDisplay: parent panel for sizer
989	:returns: wx.Sizer created by method
990	'''
991	if name == 'Sym-Generated': #show symmetry generated constraints
992	Sizer1 = wx.BoxSizer(wx.VERTICAL)
993	Sizer1.Add(wx.StaticText(pageDisplay,wx.ID_ANY,
994	'Equivalences generated based on cell/space group input'))
995	Sizer1.Add((-1,5))
996	Sizer = wx.FlexGridSizer(0,2,0,0)
997	Sizer1.Add(Sizer)
998	for sym in G2mv.GetSymEquiv():
999	Sizer.Add(wx.StaticText(pageDisplay,wx.ID_ANY,'EQUIV'),
1000	0,WACV\|wx.ALIGN_CENTER\|wx.RIGHT\|wx.LEFT,3)
1001	Sizer.Add(wx.StaticText(pageDisplay,wx.ID_ANY,sym))
1002	Sizer.Add((-1,-1))
1003	Sizer.Add((-1,2))
1004	return Sizer1
1005	constSizer = wx.FlexGridSizer(0,6,0,0)
1006	maxlen = 50 # characters before wrapping a constraint
1007	for Id,item in enumerate(data[name]):
1008	refineflag = False
1009	helptext = ""
1010	eqString = ['',]
1011	problemItem = False
1012	for term in item[:-3]:
1013	if str(term[1]) in G2mv.problemVars:
1014	problemItem = True
1015	if item[-1] == 'h': # Hold on variable
1016	constSizer.Add((-1,-1),0) # blank space for edit button
1017	typeString = 'FIXED'
1018	var = str(item[0][1])
1019	varMean = G2obj.fmtVarDescr(var)
1020	eqString[-1] = var +' '
1021	helptext = "Prevents variable:\n"+ var + " ("+ varMean + ")\nfrom being changed"
1022	elif item[-1] == 'f' or item[-1] == 'e' or item[-1] == 'c': # not true on original-style (2011?) constraints
1023	constEdit = wx.Button(pageDisplay,wx.ID_ANY,'Edit',style=wx.BU_EXACTFIT)
1024	constEdit.Bind(wx.EVT_BUTTON,OnConstEdit)
1025	constSizer.Add(constEdit,0,wx.LEFT\|wx.RIGHT\|WACV\|wx.ALIGN_CENTER,1) # edit button
1026	Indx[constEdit.GetId()] = [Id,name]
1027	if item[-1] == 'f':
1028	helptext = "A new variable"
1029	if item[-3]:
1030	helptext += " named "+str(item[-3])
1031	helptext += " is created from a linear combination of the following variables:\n"
1032	for term in item[:-3]:
1033	var = str(term[1])
1034	if len(eqString[-1]) > maxlen:
1035	eqString.append(' ')
1036	m = term[0]
1037	if eqString[-1] != '':
1038	if m >= 0:
1039	eqString[-1] += ' + '
1040	else:
1041	eqString[-1] += ' - '
1042	m = abs(m)
1043	if m == 1:
1044	eqString[-1] += '{:} '.format(var)
1045	else:
1046	eqString[-1] += '{:g}*{:} '.format(m,var)
1047	varMean = G2obj.fmtVarDescr(var)
1048	helptext += "\n" + var + " ("+ varMean + ")"
1049	# Add ISODISTORT help items
1050	if '_Explain' in data:
1051	# this ignores the phase number. TODO: refactor that in
1052	hlptxt = None
1053	try:
1054	hlptxt = data['_Explain'].get(item[-3])
1055	except TypeError:
1056	# note that phase RanId is item[-3].phase
1057	hlptxt = data['_Explain'].get(str(item[-3].phase)+item[-3].name)
1058	if hlptxt:
1059	helptext += '\n\n'
1060	helptext += hlptxt
1061	# typeString = 'NEWVAR'
1062	# if item[-3]:
1063	# eqString[-1] += ' = '+item[-3]
1064	# else:
1065	# eqString[-1] += ' = New Variable'
1066	if item[-3]:
1067	typeString = str(item[-3]) + ' = '
1068	else:
1069	typeString = 'New Variable = '
1070	#print 'refine',item[-2]
1071	refineflag = True
1072	elif item[-1] == 'c':
1073	helptext = "The following variables constrained to equal a constant:"
1074	for term in item[:-3]:
1075	var = str(term[1])
1076	if len(eqString[-1]) > maxlen:
1077	eqString.append(' ')
1078	m = term[0]
1079	if eqString[-1] != '':
1080	if term[0] > 0:
1081	eqString[-1] += ' + '
1082	else:
1083	eqString[-1] += ' - '
1084	m = -term[0]
1085	if m == 1:
1086	eqString[-1] += '{:} '.format(var)
1087	else:
1088	eqString[-1] += '{:g}*{:} '.format(m,var)
1089	varMean = G2obj.fmtVarDescr(var)
1090	helptext += "\n" + var + " ("+ varMean + ")"
1091	typeString = 'CONST'
1092	eqString[-1] += ' = '+str(item[-3])
1093	elif item[-1] == 'e':
1094	helptext = "The following variables are set to be equivalent, noting multipliers:"
1095	normval = item[:-3][1][0]
1096	for i,term in enumerate(item[:-3]):
1097	var = str(term[1])
1098	if term[0] == 0: term[0] = 1.0
1099	if len(eqString[-1]) > maxlen:
1100	eqString.append(' ')
1101	if i == 0: # move independent variable to end
1102	indepterm = term
1103	continue
1104	elif eqString[-1] != '':
1105	eqString[-1] += ' = '
1106	if normval/term[0] == 1:
1107	eqString[-1] += '{:}'.format(var)
1108	else:
1109	eqString[-1] += '{:g}*{:} '.format(normval/term[0],var)
1110	varMean = G2obj.fmtVarDescr(var)
1111	helptext += "\n" + var + " ("+ varMean + ")"
1112	if normval/indepterm[0] == 1:
1113	eqString[-1] += ' = {:} '.format(indepterm[1])
1114	else:
1115	eqString[-1] += ' = {:g}*{:} '.format(normval/indepterm[0],str(indepterm[1]))
1116	typeString = 'EQUIV'
1117	else:
1118	print ('Unexpected constraint'+item)
1119
1120	else:
1121	print ('Removing old-style constraints')
1122	data[name] = []
1123	return constSizer
1124	constDel = wx.Button(pageDisplay,wx.ID_ANY,'Delete',style=wx.BU_EXACTFIT)
1125	constDel.Bind(wx.EVT_BUTTON,OnConstDel)
1126	Indx[constDel.GetId()] = [Id,name]
1127	constSizer.Add(constDel,0,wx.LEFT\|wx.RIGHT\|WACV\|wx.ALIGN_CENTER,1) # delete button
1128	if helptext:
1129	ch = G2G.HelpButton(pageDisplay,helptext)
1130	constSizer.Add(ch,0,wx.LEFT\|wx.RIGHT\|WACV\|wx.ALIGN_CENTER,1)
1131	else:
1132	constSizer.Add((-1,-1))
1133	if refineflag:
1134	ch = G2G.G2CheckBox(pageDisplay,'',item,-2)
1135	constSizer.Add(ch,0,wx.LEFT\|wx.RIGHT\|WACV\|wx.ALIGN_CENTER,1)
1136	else:
1137	constSizer.Add((-1,-1))
1138	constSizer.Add(wx.StaticText(pageDisplay,wx.ID_ANY,typeString),
1139	0,WACV\|wx.ALIGN_CENTER\|wx.RIGHT\|wx.LEFT,3)
1140	if problemItem: eqString[-1] += ' -- Conflict: see console'
1141	if len(eqString) > 1:
1142	Eq = wx.BoxSizer(wx.VERTICAL)
1143	for s in eqString:
1144	line = wx.StaticText(pageDisplay,wx.ID_ANY,s)
1145	if problemItem: line.SetBackgroundColour(wx.YELLOW)
1146	Eq.Add(line,0)
1147	Eq.Add((-1,4))
1148	else:
1149	Eq = wx.StaticText(pageDisplay,wx.ID_ANY,eqString[0])
1150	if problemItem: Eq.SetBackgroundColour(wx.YELLOW)
1151	constSizer.Add(Eq,1,WACV)
1152	return constSizer
1153
1154	def OnConstDel(event):
1155	'Delete a constraint'
1156	Obj = event.GetEventObject()
1157	Id,name = Indx[Obj.GetId()]
1158	del data[name][Id]
1159	ConstraintsLoad(data)
1160	wx.CallAfter(OnPageChanged,None)
1161
1162	def OnConstEdit(event):
1163	'''Called to edit an individual contraint in response to a
1164	click on its Edit button
1165	'''
1166	Obj = event.GetEventObject()
1167	Id,name = Indx[Obj.GetId()]
1168	if data[name][Id][-1] == 'f':
1169	items = data[name][Id][:-3]
1170	constType = 'New Variable'
1171	if data[name][Id][-3]:
1172	varname = str(data[name][Id][-3])
1173	else:
1174	varname = ""
1175	lbl = 'Enter value for each term in constraint; sum = new variable'
1176	dlg = ConstraintDialog(G2frame,constType,lbl,items,
1177	varname=varname,varyflag=data[name][Id][-2])
1178	elif data[name][Id][-1] == 'c':
1179	items = data[name][Id][:-3]+[
1180	[str(data[name][Id][-3]),'fixed value =']]
1181	constType = 'Constraint'
1182	lbl = 'Edit value for each term in constant constraint sum'
1183	dlg = ConstraintDialog(G2frame,constType,lbl,items)
1184	elif data[name][Id][-1] == 'e':
1185	items = data[name][Id][:-3]
1186	constType = 'Equivalence'
1187	lbl = 'The following terms are set to be equal:'
1188	dlg = ConstraintDialog(G2frame,constType,lbl,items,'/')
1189	else:
1190	return
1191	try:
1192	prev = copy.deepcopy(data[name][Id])
1193	if dlg.ShowModal() == wx.ID_OK:
1194	result = dlg.GetData()
1195	for i in range(len(data[name][Id][:-3])):
1196	if type(data[name][Id][i]) is tuple: # fix non-mutable construct
1197	data[name][Id][i] = list(data[name][Id][i])
1198	data[name][Id][i][0] = result[i][0]
1199	if data[name][Id][-1] == 'c':
1200	data[name][Id][-3] = str(result[-1][0])
1201	elif data[name][Id][-1] == 'f':
1202	data[name][Id][-2] = dlg.newvar[1]
1203	if type(data[name][Id][-3]) is str:
1204	# process the variable name to put in global form (::var)
1205	varname = str(dlg.newvar[0]).strip().replace(' ','_')
1206	if varname.startswith('::'):
1207	varname = varname[2:]
1208	varname = varname.replace(':',';')
1209	if varname:
1210	data[name][Id][-3] = varname
1211	else:
1212	data[name][Id][-3] = ''
1213	if not CheckChangedConstraint():
1214	data[name][Id] = prev
1215	else:
1216	data[name][Id] = prev
1217	except:
1218	import traceback
1219	print (traceback.format_exc())
1220	finally:
1221	dlg.Destroy()
1222	wx.CallAfter(OnPageChanged,None)
1223
1224	def UpdateConstraintPanel(panel,typ):
1225	'''Update the contents of the selected Constraint
1226	notebook tab. Called in :func:`OnPageChanged`
1227	'''
1228	if panel.GetSizer(): panel.GetSizer().Clear(True)
1229	Siz = wx.BoxSizer(wx.VERTICAL)
1230	Siz.Add((5,5),0)
1231	Siz.Add(MakeConstraintsSizer(typ,panel),1,wx.EXPAND)
1232	panel.SetSizer(Siz,True)
1233	Size = Siz.GetMinSize()
1234	Size[0] += 40
1235	Size[1] = max(Size[1],450) + 20
1236	panel.SetSize(Size)
1237	panel.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
1238	panel.Show()
1239
1240	def OnPageChanged(event):
1241	'''Called when a tab is pressed or when a "select tab" menu button is
1242	used (see RaisePage), or to refresh the current tab contents (event=None)
1243	'''
1244	if event: #page change event!
1245	page = event.GetSelection()
1246	else: # called directly, get current page
1247	try:
1248	page = G2frame.constr.GetSelection()
1249	except:
1250	if GSASIIpath.GetConfigValue('debug'): print('DBG_gpx open error:C++ Run time error - skipped')
1251	return
1252	G2frame.constr.ChangeSelection(page)
1253	text = G2frame.constr.GetPageText(page)
1254	G2frame.dataWindow.ConstraintEdit.Enable(G2G.wxID_EQUIVALANCEATOMS,False)
1255	# G2frame.dataWindow.ConstraintEdit.Enable(G2G.wxID_ADDRIDING,False)
1256	if text == 'Histogram/Phase':
1257	enableEditCons = [False]+4*[True]
1258	G2frame.Page = [page,'hap']
1259	UpdateConstraintPanel(HAPConstr,'HAP')
1260	elif text == 'Histogram':
1261	enableEditCons = [False]+4*[True]
1262	G2frame.Page = [page,'hst']
1263	UpdateConstraintPanel(HistConstr,'Hist')
1264	elif text == 'Phase':
1265	enableEditCons = 5*[True]
1266	G2frame.Page = [page,'phs']
1267	G2frame.dataWindow.ConstraintEdit.Enable(G2G.wxID_EQUIVALANCEATOMS,True)
1268	# G2frame.dataWindow.ConstraintEdit.Enable(G2G.wxID_ADDRIDING,True)
1269	if 'DELETED' in str(PhaseConstr): #seems to be no other way to do this (wx bug)
1270	if GSASIIpath.GetConfigValue('debug'):
1271	print ('DBG_wx error: PhaseConstr not cleanly deleted after Refine')
1272	return
1273	UpdateConstraintPanel(PhaseConstr,'Phase')
1274	elif text == 'Global':
1275	enableEditCons = [False]+4*[True]
1276	G2frame.Page = [page,'glb']
1277	UpdateConstraintPanel(GlobalConstr,'Global')
1278	else:
1279	enableEditCons = 5*[False]
1280	G2frame.Page = [page,'sym']
1281	UpdateConstraintPanel(SymConstr,'Sym-Generated')
1282	# remove menu items when not allowed
1283	for obj,flag in zip(G2frame.dataWindow.ConstraintEdit.GetMenuItems(),enableEditCons):
1284	obj.Enable(flag)
1285	G2frame.dataWindow.SetDataSize()
1286
1287	def RaisePage(event):
1288	'Respond to a "select tab" menu button'
1289	try:
1290	i = (G2G.wxID_CONSPHASE,
1291	G2G.wxID_CONSHAP,
1292	G2G.wxID_CONSHIST,
1293	G2G.wxID_CONSGLOBAL,
1294	G2G.wxID_CONSSYM,
1295	).index(event.GetId())
1296	G2frame.constr.SetSelection(i)
1297	wx.CallAfter(OnPageChanged,None)
1298	except ValueError:
1299	print('Unexpected event in RaisePage')
1300
1301	def SetStatusLine(text):
1302	G2frame.GetStatusBar().SetStatusText(text,1)
1303
1304	# UpdateConstraints execution starts here
1305	if not data:
1306	data.update({'Hist':[],'HAP':[],'Phase':[],'Global':[]}) #empty dict - fill it
1307	if 'Global' not in data: #patch
1308	data['Global'] = []
1309	# DEBUG code ########################################
1310	#import GSASIIconstrGUI
1311	#reload(GSASIIconstrGUI)
1312	#reload(G2obj)
1313	#reload(G2stIO)
1314	#import GSASIIstrMain
1315	#reload(GSASIIstrMain)
1316	#reload(G2mv)
1317	#reload(G2gd)
1318	###################################################
1319	Histograms,Phases = G2frame.GetUsedHistogramsAndPhasesfromTree()
1320	if not len(Phases) or not len(Histograms):
1321	dlg = wx.MessageDialog(G2frame,'You need both phases and histograms to see Constraints',
1322	'No phases or histograms')
1323	dlg.CenterOnParent()
1324	dlg.ShowModal()
1325	dlg.Destroy()
1326	return
1327	G2obj.IndexAllIds(Histograms,Phases)
1328	for p in Phases:
1329	if 'ISODISTORT' in Phases[p]:
1330	G2frame.dataWindow.ConstraintEdit.Enable(G2G.wxID_SHOWISO,True)
1331	break
1332	##################################################################################
1333	# patch: convert old-style (str) variables in constraints to G2VarObj objects
1334	for key,value in data.items():
1335	if key.startswith('_'): continue
1336	j = 0
1337	for cons in value:
1338	#print cons # DEBUG
1339	for i in range(len(cons[:-3])):
1340	if type(cons[i][1]) is str:
1341	cons[i][1] = G2obj.G2VarObj(cons[i][1])
1342	j += 1
1343	if j:
1344	print (str(key) + ': '+str(j)+' variable(s) as strings converted to objects')
1345	##################################################################################
1346	rigidbodyDict = G2frame.GPXtree.GetItemPyData(
1347	G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Rigid bodies'))
1348	rbIds = rigidbodyDict.get('RBIds',{'Vector':[],'Residue':[]})
1349	rbVary,rbDict = G2stIO.GetRigidBodyModels(rigidbodyDict,Print=False)
1350	badPhaseParms = ['Ax','Ay','Az','Amul','AI/A','Atype','SHorder','AwaveType','FwaveType','PwaveType','MwaveType','Vol','isMag',]
1351	globalList = list(rbDict.keys())
1352	globalList.sort()
1353	try:
1354	AtomDict = dict([Phases[phase]['pId'],Phases[phase]['Atoms']] for phase in Phases)
1355	except KeyError:
1356	G2frame.ErrorDialog('Constraint Error','Constraints cannot be set until a cycle of least squares'+
1357	' has been run.\nWe suggest you refine a scale factor.')
1358	return
1359
1360	# create a list of the phase variables
1361	Natoms,atomIndx,phaseVary,phaseDict,pawleyLookup,FFtable,BLtable,MFtable,maxSSwave = G2stIO.GetPhaseData(Phases,rbIds=rbIds,Print=False)
1362	phaseList = []
1363	for item in phaseDict:
1364	if item.split(':')[2] not in badPhaseParms:
1365	phaseList.append(item)
1366	phaseList.sort()
1367	phaseAtNames = {}
1368	phaseAtTypes = {}
1369	TypeList = []
1370	for item in phaseList:
1371	Split = item.split(':')
1372	if Split[2][:2] in ['AU','Af','dA','AM']:
1373	Id = int(Split[0])
1374	phaseAtNames[item] = AtomDict[Id][int(Split[3])][0]
1375	phaseAtTypes[item] = AtomDict[Id][int(Split[3])][1]
1376	if phaseAtTypes[item] not in TypeList:
1377	TypeList.append(phaseAtTypes[item])
1378	else:
1379	phaseAtNames[item] = ''
1380	phaseAtTypes[item] = ''
1381
1382	# create a list of the hist*phase variables
1383	seqList = G2frame.testSeqRefineMode()
1384	if seqList: # for sequential refinement, only process 1st histgram in list
1385	histDict = {seqList[0]:Histograms[seqList[0]]}
1386	else:
1387	histDict = Histograms
1388	hapVary,hapDict,controlDict = G2stIO.GetHistogramPhaseData(Phases,histDict,Print=False,resetRefList=False)
1389	hapList = sorted([i for i in hapDict.keys() if i.split(':')[2] not in ('Type',)])
1390	if seqList: # convert histogram # to wildcard
1391	wildList = [] # list of variables with "*" for histogram number
1392	for i in hapList:
1393	s = i.split(':')
1394	if s[1] == "": continue
1395	s[1] = '*'
1396	sj = ':'.join(s)
1397	if sj not in wildList: wildList.append(sj)
1398	hapList = wildList
1399	histVary,histDict,controlDict = G2stIO.GetHistogramData(histDict,Print=False)
1400	histList = list(histDict.keys())
1401	histList.sort()
1402	if seqList: # convert histogram # to wildcard
1403	wildList = [] # list of variables with "*" for histogram number
1404	for i in histList:
1405	s = i.split(':')
1406	if s[1] == "": continue
1407	s[1] = '*'
1408	sj = ':'.join(s)
1409	if sj not in wildList: wildList.append(sj)
1410	histList = wildList
1411	Indx = {}
1412	G2frame.Page = [0,'phs']
1413
1414	G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.ConstraintMenu)
1415	SetStatusLine('')
1416
1417	G2frame.Bind(wx.EVT_MENU, OnAddConstraint, id=G2G.wxID_CONSTRAINTADD)
1418	G2frame.Bind(wx.EVT_MENU, OnAddFunction, id=G2G.wxID_FUNCTADD)
1419	G2frame.Bind(wx.EVT_MENU, OnAddEquivalence, id=G2G.wxID_EQUIVADD)
1420	G2frame.Bind(wx.EVT_MENU, OnAddHold, id=G2G.wxID_HOLDADD)
1421	G2frame.Bind(wx.EVT_MENU, OnAddAtomEquiv, id=G2G.wxID_EQUIVALANCEATOMS)
1422	# G2frame.Bind(wx.EVT_MENU, OnAddRiding, id=G2G.wxID_ADDRIDING)
1423	def OnShowISODISTORT(event):
1424	ShowIsoDistortCalc(G2frame)
1425	G2frame.Bind(wx.EVT_MENU, OnShowISODISTORT, id=G2G.wxID_SHOWISO)
1426	# tab commands
1427	for id in (G2G.wxID_CONSPHASE,
1428	G2G.wxID_CONSHAP,
1429	G2G.wxID_CONSHIST,
1430	G2G.wxID_CONSGLOBAL,
1431	G2G.wxID_CONSSYM,
1432	):
1433	G2frame.Bind(wx.EVT_MENU, RaisePage,id=id)
1434
1435	#G2frame.constr = G2G.GSNoteBook(parent=G2frame.dataWindow,size=G2frame.dataWindow.GetClientSize())
1436	G2frame.constr = G2G.GSNoteBook(parent=G2frame.dataWindow)
1437	G2frame.dataWindow.GetSizer().Add(G2frame.constr,1,wx.ALL\|wx.EXPAND)
1438	# note that order of pages is hard-coded in RaisePage
1439	PhaseConstr = wx.ScrolledWindow(G2frame.constr)
1440	G2frame.constr.AddPage(PhaseConstr,'Phase')
1441	HAPConstr = wx.ScrolledWindow(G2frame.constr)
1442	G2frame.constr.AddPage(HAPConstr,'Histogram/Phase')
1443	HistConstr = wx.ScrolledWindow(G2frame.constr)
1444	G2frame.constr.AddPage(HistConstr,'Histogram')
1445	GlobalConstr = wx.ScrolledWindow(G2frame.constr)
1446	G2frame.constr.AddPage(GlobalConstr,'Global')
1447	SymConstr = wx.ScrolledWindow(G2frame.constr)
1448	G2frame.constr.AddPage(SymConstr,'Sym-Generated')
1449	wx.CallAfter(OnPageChanged,None)
1450	G2frame.constr.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, OnPageChanged)
1451	# validate all the constrants -- should not see any errors here normally
1452	errmsg,warnmsg = ConstraintsCheck(data)
1453	if errmsg:
1454	G2frame.ErrorDialog('Constraint Error',
1455	'Error in constraints:\n'+errmsg+'\nCheck console output for more information',
1456	parent=G2frame)
1457	print (errmsg)
1458	print (G2mv.VarRemapShow([],True))
1459	elif warnmsg:
1460	print ('Unexpected contraint warning:\n'+warnmsg)
1461
1462	################################################################################
1463	# check scale & phase fractions, create constraint if needed
1464	################################################################################
1465	def CheckAllScalePhaseFractions(G2frame):
1466	'''Check if scale factor and all phase fractions are refined without a constraint
1467	for all used histograms, if so, offer the user a chance to create a constraint
1468	on the sum of phase fractions
1469	'''
1470	histograms, phases = G2frame.GetUsedHistogramsAndPhasesfromTree()
1471	for i,hist in enumerate(histograms):
1472	CheckScalePhaseFractions(G2frame,hist,histograms,phases)
1473
1474	def CheckScalePhaseFractions(G2frame,hist,histograms,phases):
1475	'''Check if scale factor and all phase fractions are refined without a constraint
1476	for histogram hist, if so, offer the user a chance to create a constraint
1477	on the sum of phase fractions
1478	'''
1479	if G2frame.testSeqRefineMode():
1480	histStr = '*'
1481	else:
1482	histStr = str(histograms[hist]['hId'])
1483	# Is this powder?
1484	if not hist.startswith('PWDR '): return
1485	# do this only if the scale factor is varied
1486	if not histograms[hist]['Sample Parameters']['Scale'][1]: return
1487	# are all phase fractions varied in all used histograms?
1488	phaseCount = 0
1489	for p in phases:
1490	if hist not in phases[p]['Histograms']: continue
1491	if phases[p]['Histograms'][hist]['Use'] and not phases[p]['Histograms'][hist]['Scale'][1]:
1492	return
1493	else:
1494	phaseCount += 1
1495
1496	# all phase fractions and scale factor varied, now scan through constraints
1497	sub = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Constraints')
1498	Constraints = G2frame.GPXtree.GetItemPyData(sub)
1499	for c in Constraints.get('HAP',[]):
1500	if c[-1] != 'c': continue
1501	if not c[-3]: continue
1502	if len(c[:-3]) != phaseCount: continue
1503	# got a constraint equation with right number of terms, is it on phase fractions for
1504	# the correct histogram?
1505	if all([(i[1].name == 'Scale' and i[1].varname().split(':')[1] == histStr) for i in c[:-3]]):
1506	# got a constraint, this is OK
1507	return
1508	dlg = wx.MessageDialog(G2frame,'You are refining the scale factor and all phase fractions for histogram #'+
1509	histStr+'. This will produce an unstable refinement. '+
1510	'Do you want to constrain the sum of phase fractions?','Create constraint?',wx.OK\|wx.CANCEL)
1511	if dlg.ShowModal() != wx.ID_OK:
1512	dlg.Destroy()
1513	return
1514	dlg.Destroy()
1515
1516	constr = []
1517	for p in phases:
1518	if hist not in phases[p]['Histograms']: continue
1519	if not phases[p]['Histograms'][hist]['Use']: continue
1520	constr += [[1.0,G2obj.G2VarObj(':'.join((str(phases[p]['pId']),histStr,'Scale')))]]
1521	constr += [1.0,None,'c']
1522	Constraints['HAP'] += [constr]
1523
1524	################################################################################
1525	#### Make nuclear/magnetic phase transition constraints - called by OnTransform in G2phsGUI
1526	################################################################################
1527
1528	def TransConstraints(G2frame,oldPhase,newPhase,Trans,Vec,atCodes):
1529	'''Add constraints for new magnetic phase created via transformation of old
1530	nuclear one
1531	NB: A = [G11,G22,G33,2G12,2G13,2*G23]
1532	'''
1533
1534	def SetUniqAj(pId,iA,SGData):
1535	SGLaue = SGData['SGLaue']
1536	SGUniq = SGData['SGUniq']
1537	if SGLaue in ['m3','m3m']:
1538	if iA in [0,1,2]:
1539	parm = '%d::%s'%(pId,'A0')
1540	else:
1541	parm = None
1542	elif SGLaue in ['4/m','4/mmm']:
1543	if iA in [0,1]:
1544	parm = '%d::%s'%(pId,'A0')
1545	elif iA == 2:
1546	parm = '%d::%s'%(pId,'A2')
1547	else:
1548	parm = None
1549	elif SGLaue in ['6/m','6/mmm','3m1', '31m', '3']:
1550	if iA in [0,1,3]:
1551	parm = '%d::%s'%(pId,'A0')
1552	elif iA == 2:
1553	parm = '%d::%s'%(pId,'A2')
1554	else:
1555	parm = None
1556	elif SGLaue in ['3R', '3mR']:
1557	if ia in [0,1,2]:
1558	parm = '%d::%s'%(pId,'A0')
1559	else:
1560	parm = '%d::%s'%(pId,'A3')
1561	elif SGLaue in ['mmm',]:
1562	if iA in [0,1,2]:
1563	parm = '%d::A%s'%(pId,iA)
1564	else:
1565	parm = None
1566	elif SGLaue == '2/m':
1567	if iA in [0,1,2]:
1568	parm = '%d::A%s'%(pId,iA)
1569	elif iA == 3 and SGUniq == 'c':
1570	parm = '%d::A%s'%(pId,iA)
1571	elif iA == 4 and SGUniq == 'b':
1572	parm = '%d::A%s'%(pId,iA)
1573	elif iA == 5 and SGUniq == 'a':
1574	parm = '%d::A%s'%(pId,iA)
1575	else:
1576	parm = None
1577	else:
1578	parm = '%d::A%s'%(pId,iA)
1579	return parm
1580
1581	Histograms,Phases = G2frame.GetUsedHistogramsAndPhasesfromTree()
1582	UseList = newPhase['Histograms']
1583	detTrans = np.abs(nl.det(Trans))
1584	invTrans = nl.inv(Trans)
1585	opId = oldPhase['pId']
1586	npId = newPhase['pId']
1587	cx,ct,cs,cia = newPhase['General']['AtomPtrs']
1588	nAtoms = newPhase['Atoms']
1589	oSGData = oldPhase['General']['SGData']
1590	nSGData = newPhase['General']['SGData']
1591	#oAcof = G2lat.cell2A(oldPhase['General']['Cell'][1:7])
1592	#nAcof = G2lat.cell2A(newPhase['General']['Cell'][1:7])
1593	item = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Constraints')
1594	if not item:
1595	print('Error: no constraints in Data Tree')
1596	return
1597	constraints = G2frame.GPXtree.GetItemPyData(item)
1598	xnames = ['dAx','dAy','dAz']
1599	# constraints on matching atom params between phases
1600	for ia,code in enumerate(atCodes):
1601	atom = nAtoms[ia]
1602	if not ia and atom[cia] == 'A':
1603	wx.MessageDialog(G2frame,
1604	'Anisotropic thermal motion constraints are not developed at the present time',
1605	'Anisotropic thermal constraint?',style=wx.ICON_INFORMATION).ShowModal()
1606	siteSym = G2spc.SytSym(atom[cx:cx+3],nSGData)[0]
1607	CSX = G2spc.GetCSxinel(siteSym)
1608	# CSU = G2spc.GetCSuinel(siteSym)
1609	item = code.split('+')[0]
1610	iat,opr = item.split(':')
1611	Nop = abs(int(opr))%100-1
1612	if '-' in opr:
1613	Nop *= -1
1614	Opr = oldPhase['General']['SGData']['SGOps'][abs(Nop)][0]
1615	if Nop < 0: #inversion
1616	Opr *= -1
1617	XOpr = np.inner(Opr,Trans)
1618	for i,ix in enumerate(list(CSX[0])):
1619	if not ix:
1620	continue
1621	name = xnames[i]
1622	IndpCon = [1.0,G2obj.G2VarObj('%d::%s:%d'%(npId,name,ia))]
1623	DepCons = []
1624	for iop,opval in enumerate(XOpr[i]):
1625	if opval:
1626	DepCons.append([opval,G2obj.G2VarObj('%d::%s:%s'%(opId,xnames[iop],iat))])
1627	if len(DepCons) == 1:
1628	constraints['Phase'].append([DepCons[0],IndpCon,None,None,'e'])
1629	elif len(DepCons) > 1:
1630	for Dep in DepCons:
1631	Dep[0] *= -1
1632	constraints['Phase'].append([IndpCon]+DepCons+[0.0,None,'c'])
1633	for name in ['Afrac','AUiso']:
1634	IndpCon = [1.0,G2obj.G2VarObj('%d::%s:%d'%(npId,name,ia))]
1635	DepCons = [1.0,G2obj.G2VarObj('%d::%s:%s'%(opId,name,iat))]
1636	constraints['Phase'].append([DepCons,IndpCon,None,None,'e'])
1637
1638	# unfinished Anisotropic constraint generation
1639	# Uids = [[0,0,'AU11'],[1,1,'AU22'],[2,2,'AU33'],[0,1,'AU12'],[0,2,'AU13'],[1,2,'AU23']]
1640	# DepConsDict = dict(zip(Us,[[],[],[],[],[],[]]))
1641	# for iu,Uid in enumerate(Uids):
1642	# UMT = np.zeros((3,3))
1643	# UMT[Uid[0],Uid[1]] = 1
1644	# nUMT = G2lat.prodMGMT(UMT,invTrans)
1645	# nUT = G2lat.UijtoU6(nUMT)
1646	# for iu,nU in enumerate(nUT):
1647	# if abs(nU) > 1.e-8:
1648	# parm = '%d::%s;%s'%(opId,Us[iu],iat)
1649	# DepConsDict[Uid[2]].append([abs(nU%1.),G2obj.G2VarObj(parm)])
1650	# nUcof = atom[iu:iu+6]
1651	# conStrings = []
1652	# for iU,Usi in enumerate(Us):
1653	# parm = '%d::%s;%d'%(npId,Usi,ia)
1654	# parmDict[parm] = nUcof[iU]
1655	# varyList.append(parm)
1656	# IndpCon = [1.0,G2obj.G2VarObj(parm)]
1657	# conStr = str([IndpCon,DepConsDict[Usi]])
1658	# if conStr in conStrings:
1659	# continue
1660	# conStrings.append(conStr)
1661	# if len(DepConsDict[Usi]) == 1:
1662	# if DepConsDict[Usi][0]:
1663	# constraints['Phase'].append([IndpCon,DepConsDict[Usi][0],None,None,'e'])
1664	# elif len(DepConsDict[Usi]) > 1:
1665	# for Dep in DepConsDict[Usi]:
1666	# Dep[0] *= -1
1667	# constraints['Phase'].append([IndpCon]+DepConsDict[Usi]+[0.0,None,'c'])
1668
1669	#how do I do Uij's for most Trans?
1670
1671	# constraints on lattice parameters between phases
1672	# T = nl.inv(Trans).T
1673	T = Trans.T
1674	conMat = [
1675	[T[0,0]2,T[0,1]2,T[0,2]*2,T[0,0]T[0,1],T[0,0]T[0,2],T[0,1]T[0,2]],
1676	[T[1,0]2,T[1,1]2,T[1,2]*2,T[1,0]T[1,1],T[1,0]T[1,2],T[1,1]T[1,2]],
1677	[T[2,0]2,T[2,1]2,T[2,2]*2,T[2,0]T[2,1],T[2,0]T[2,2],T[2,1]T[2,2]],
1678	[2.T[0,0]T[1,0],2.T[0,1]T[1,1],2.T[0,2]T[1,2],T[0,0]T[1,1]+T[0,1]T[1,0],T[0,0]T[1,2]+T[0,2]T[1,0],T[0,1]T[1,2]+T[0,2]T[1,1]],
1679	[2.T[0,0]T[2,0],2.T[0,1]T[2,1],2.T[0,2]T[2,2],T[0,0]T[2,1]+T[0,1]T[2,0],T[0,0]T[2,2]+T[0,2]T[2,0],T[0,1]T[2,2]+T[0,2]T[2,1]],
1680	[2.T[1,0]T[2,0],2.T[1,1]T[2,1],2.T[1,2]T[2,2],T[1,0]T[2,1]+T[1,1]T[2,0],T[1,0]T[2,2]+T[1,2]T[2,0],T[1,1]T[2,2]+T[1,2]T[2,1]]
1681	]
1682	# Gnew = conMat * A:
1683	# T00*2a0 T01*2a1 T02*2a2 T00T01a3 T00T02a4 T01T02a5
1684	# T10*2a0 T11*2a1 T12*2a2 T10T11a3 T10T12a4 T11T12a5
1685	# T20*2a0 T21*2a1 T22*2a2 T20T21a3 T20T22a4 T21T22a5
1686	# 2T00T10a0 2T01T11a1 2T02T12a2 (T00T11 + T01T10)a3 (T00T12 + T02T10)a4 (T01T12 + T02T11)a5
1687	# 2T00T20a0 2T01T21a1 2T02T22a2 (T00T21 + T01T20)a3 (T00T22 + T02T20)a4 (T01T22 + T02T21)a5
1688	# 2T10T20a0 2T11T21a1 2T12T22a2 (T10T21 + T11T20)a3 (T10T22 + T12T20)a4 (T11T22 + T12T21)a5
1689	# Generated as symbolic code using:
1690	# import sym
1691	# A0, A1, A2, A3, A4, A5 = sym.symbols('A0, A1, A2, A3, A4, A5')
1692	# G = sym.Matrix([ [A0, A3/2., A4/2.], [A3/2., A1, A5/2.], [A4/2., A5/2., A2]])
1693	# transformation matrix
1694	# T00, T10, T20, T01, T11, T21, T02, T12, T22 = sym.symbols('T00, T10, T20, T01, T11, T21, T02, T12, T22')
1695	# Tr = sym.Matrix([ [T00, T10, T20], [T01, T11, T21], [T02, T12, T22],])
1696	# Gnew = (Tr.TG)Tr
1697
1698	#print('old A',G2lat.cell2A(oldPhase['General']['Cell'][1:7]))
1699	#print('new A',G2lat.cell2A(newPhase['General']['Cell'][1:7]))
1700
1701	#this is still incorrect for hex/trig/ortho/tetragonal --> monoclinic
1702
1703	# for iAnew,Asi in enumerate(['A0','A1','A2','A3','A4','A5']): # loop through A[i] for new cell
1704	# Nparm = str(npId) + '::' + Asi
1705	# if Nparm != SetUniqAj(npId,iAnew,nSGData):
1706	# continue # skip: Ai constrained from Aj or must be zero
1707	# multDict = {}
1708	# for iAorg in range(6):
1709	# cA = conMat[iAnew][iAorg] # coeff for A[i] in constraint matrix
1710	# if abs(cA) < 1.e-8: continue
1711	# parm = SetUniqAj(opId,iAorg,oSGData) # translate to unique A[i] in original cell
1712	# if not parm: continue # must be zero
1713	# # sum coeff
1714	# if parm in multDict:
1715	# multDict[parm] += cA
1716	# else:
1717	# multDict[parm] = cA
1718	# # any non-zero multipliers?
1719	# maxMult = 0
1720	# for i in multDict:
1721	# maxMult = max(maxMult,abs(multDict[i]))
1722	# if maxMult <= 0: # Nparm computes as zero; Fix this parameter
1723	# constraints['Phase'] += [[
1724	# [0.0,G2obj.G2VarObj(Nparm)],
1725	# None,None,'h']]
1726	# elif len(multDict) == 1: # create equivalence
1727	# key = list(multDict.keys())[0]
1728	# constraints['Phase'] += [[
1729	# [1.0,G2obj.G2VarObj(key)],
1730	# [multDict[key],G2obj.G2VarObj(Nparm)],
1731	# None,None,'e']]
1732	# else: # create constraint
1733	# constr = [[-1.0,G2obj.G2VarObj(Nparm)]]
1734	# for key in multDict:
1735	# constr += [[multDict[key],G2obj.G2VarObj(key)]]
1736	# constr += [0.0,None,'c']
1737	# constraints['Phase'] += [constr]
1738
1739	# constraints on HAP Scale, etc.
1740	for hId,hist in enumerate(UseList): #HAP - seems OK
1741	ohapkey = '%d:%d:'%(opId,hId)
1742	nhapkey = '%d:%d:'%(npId,hId)
1743	IndpCon = [1.0,G2obj.G2VarObj(ohapkey+'Scale')]
1744	DepCons = [detTrans,G2obj.G2VarObj(nhapkey+'Scale')]
1745	constraints['HAP'].append([DepCons,IndpCon,None,None,'e'])
1746	for name in ['Size;i','Mustrain;i']:
1747	IndpCon = [1.0,G2obj.G2VarObj(ohapkey+name)]
1748	DepCons = [1.0,G2obj.G2VarObj(nhapkey+name)]
1749	constraints['HAP'].append([IndpCon,DepCons,None,None,'e'])
1750
1751	################################################################################
1752	#### Rigid bodies
1753	################################################################################
1754	resRBsel = None
1755	def UpdateRigidBodies(G2frame,data):
1756	'''Called when Rigid bodies tree item is selected.
1757	Displays the rigid bodies in the data window
1758	'''
1759	if not data.get('RBIds') or not data:
1760	data.update({'Vector':{'AtInfo':{}},'Residue':{'AtInfo':{}},
1761	'RBIds':{'Vector':[],'Residue':[]}}) #empty/bad dict - fill it
1762
1763	global resList,resRBsel
1764	Indx = {}
1765	resList = []
1766	plotDefaults = {'oldxy':[0.,0.],'Quaternion':[0.,0.,0.,1.],'cameraPos':30.,'viewDir':[0,0,1],}
1767
1768	G2frame.rbBook = G2G.GSNoteBook(parent=G2frame.dataWindow)
1769	G2frame.dataWindow.GetSizer().Add(G2frame.rbBook,1,wx.ALL\|wx.EXPAND)
1770	VectorRB = wx.ScrolledWindow(G2frame.rbBook)
1771	VectorRBDisplay = wx.Panel(VectorRB)
1772	G2frame.rbBook.AddPage(VectorRB,'Vector rigid bodies')
1773	ResidueRB = wx.ScrolledWindow(G2frame.rbBook)
1774	ResidueRBDisplay = wx.Panel(ResidueRB)
1775	G2frame.rbBook.AddPage(ResidueRB,'Residue rigid bodies')
1776
1777	def OnPageChanged(event):
1778	global resList
1779	resList = []
1780	if event: #page change event!
1781	page = event.GetSelection()
1782	else:
1783	try:
1784	page = G2frame.rbBook.GetSelection()
1785	except:
1786	if GSASIIpath.GetConfigValue('debug'): print('DBG_gpx open error:C++ Run time error - skipped')
1787	return
1788	G2frame.rbBook.ChangeSelection(page)
1789	text = G2frame.rbBook.GetPageText(page)
1790	if text == 'Vector rigid bodies':
1791	G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.VectorBodyMenu)
1792	G2frame.Bind(wx.EVT_MENU, AddVectorRB, id=G2G.wxID_VECTORBODYADD)
1793	G2frame.Bind(wx.EVT_MENU, ExtractPhaseRB, id=G2G.wxID_VECTORBODYIMP)
1794	G2frame.Bind(wx.EVT_MENU, AddVectTrans, id=G2G.wxID_VECTORBODYEXTD)
1795	G2frame.Bind(wx.EVT_MENU, SaveVectorRB, id=G2G.wxID_VECTORBODYSAV)
1796	G2frame.Bind(wx.EVT_MENU, ReadVectorRB, id=G2G.wxID_VECTORBODYRD)
1797	G2frame.Page = [page,'vrb']
1798	UpdateVectorRB()
1799	elif text == 'Residue rigid bodies':
1800	G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.RigidBodyMenu)
1801	G2frame.Bind(wx.EVT_MENU, AddResidueRB, id=G2G.wxID_RIGIDBODYADD)
1802	G2frame.Bind(wx.EVT_MENU, ExtractPhaseRB, id=G2G.wxID_RIGIDBODYIMP)
1803	G2frame.Bind(wx.EVT_MENU, OnImportRigidBody, id=G2G.wxID_RIGIDBODYIMPORT)
1804	G2frame.Bind(wx.EVT_MENU, OnSaveRigidBody, id=G2G.wxID_RIGIDBODYSAVE)
1805	G2frame.Bind(wx.EVT_MENU, OnDefineTorsSeq, id=G2G.wxID_RESIDUETORSSEQ) #enable only if residue RBs exist?
1806	G2frame.Bind(wx.EVT_MENU, DumpVectorRB, id=G2G.wxID_RESBODYSAV)
1807	G2frame.Bind(wx.EVT_MENU, LoadVectorRB, id=G2G.wxID_RESBODYRD)
1808	G2frame.Page = [page,'rrb']
1809	UpdateResidueRB()
1810	else:
1811	G2gd.SetDataMenuBar(G2frame)
1812	#G2frame.Page = [page,'rrb']
1813
1814	def getMacroFile(macName):
1815	defDir = os.path.join(os.path.split(__file__)[0],'GSASIImacros')
1816	dlg = wx.FileDialog(G2frame,message='Choose '+macName+' rigid body macro file',
1817	defaultDir=defDir,defaultFile="",wildcard="GSAS-II macro file (.mac)\|.mac",
1818	style=wx.FD_OPEN \| wx.FD_CHANGE_DIR)
1819	try:
1820	if dlg.ShowModal() == wx.ID_OK:
1821	macfile = dlg.GetPath()
1822	macro = open(macfile,'Ur')
1823	head = macro.readline()
1824	if macName not in head:
1825	print (head)
1826	print ('** ERROR - wrong restraint macro file selected, try again **')
1827	macro = []
1828	else: # cancel was pressed
1829	macro = []
1830	finally:
1831	dlg.Destroy()
1832	return macro #advanced past 1st line
1833
1834	def getTextFile():
1835	dlg = wx.FileDialog(G2frame,'Choose rigid body text file', G2frame.LastGPXdir, '',
1836	"GSAS-II text file (.txt)\|.txt\|XYZ file (.xyz)\|.xyz\|"
1837	"Sybyl mol2 file (.mol2)\|.mol2\|PDB file (.pdb;.ent)\|.pdb;.ent",
1838	wx.FD_OPEN \| wx.FD_CHANGE_DIR)
1839	try:
1840	if dlg.ShowModal() == wx.ID_OK:
1841	txtfile = dlg.GetPath()
1842	ext = os.path.splitext(txtfile)[1]
1843	text = open(txtfile,'Ur')
1844	else: # cancel was pressed
1845	ext = ''
1846	text = []
1847	finally:
1848	dlg.Destroy()
1849	if 'ent' in ext:
1850	ext = '.pdb'
1851	return text,ext.lower()
1852
1853	def OnImportRigidBody(event):
1854	page = G2frame.rbBook.GetSelection()
1855	if 'Vector' in G2frame.rbBook.GetPageText(page):
1856	pass
1857	elif 'Residue' in G2frame.rbBook.GetPageText(page):
1858	ImportResidueRB()
1859
1860	def OnSaveRigidBody(event):
1861	page = G2frame.rbBook.GetSelection()
1862	if 'Vector' in G2frame.rbBook.GetPageText(page):
1863	pass
1864	elif 'Residue' in G2frame.rbBook.GetPageText(page):
1865	SaveResidueRB()
1866
1867	def DumpVectorRB(event):
1868	global resRBsel
1869	if resRBsel not in data['Residue']:
1870	return
1871	rbData = data['Residue'][resRBsel]
1872	pth = G2G.GetExportPath(G2frame)
1873	dlg = wx.FileDialog(G2frame, 'Choose file to save residue rigid body',
1874	pth, '', 'RRB files (.resbody)\|.resbody',
1875	wx.FD_SAVE\|wx.FD_OVERWRITE_PROMPT)
1876	try:
1877	if dlg.ShowModal() == wx.ID_OK:
1878	filename = dlg.GetPath()
1879	filename = os.path.splitext(filename)[0]+'.resbody' # set extension
1880	fp = open(filename,'w')
1881	fp.write('Name: '+rbData['RBname']+'\n')
1882	fp.write('atNames: ')
1883	for i in rbData['atNames']:
1884	fp.write(str(i)+" ")
1885	fp.write('\n')
1886	for item in rbData['rbSeq']:
1887	fp.write('rbSeq: ')
1888	fp.write('{:d} {:d} {:.1f}: '.format(*item[:3]))
1889	for num in item[3]:
1890	fp.write('{:d} '.format(num))
1891	fp.write('\n')
1892	for i,sym in enumerate(rbData['rbTypes']):
1893	fp.write("{:3s}".format(sym))
1894	fp.write('{:8.5f}{:9.5f}{:9.5f} '
1895	.format(*rbData['rbXYZ'][i]))
1896	fp.write('\n')
1897	fp.close()
1898	print ('Vector rigid body saved to: '+filename)
1899
1900	finally:
1901	dlg.Destroy()
1902
1903	def LoadVectorRB(event):
1904	AtInfo = data['Residue']['AtInfo']
1905	pth = G2G.GetExportPath(G2frame)
1906	dlg = wx.FileDialog(G2frame, 'Choose file to read vector rigid body',
1907	pth, '', 'RRB files (.resbody)\|.resbody',
1908	wx.FD_OPEN)
1909	try:
1910	if dlg.ShowModal() == wx.ID_OK:
1911	filename = dlg.GetPath()
1912	filename = os.path.splitext(filename)[0]+'.resbody' # set extension
1913	fp = open(filename,'r')
1914	l = fp.readline().strip()
1915	if 'Name' not in l:
1916	fp.close()
1917	G2frame.ErrorDialog('Read Error',
1918	'File '+filename+' does not start with Name\nFirst line ='
1919	+l+'\ninvalid file',parent=G2frame)
1920	return
1921	name = l.split(':')[1].strip()
1922	line = fp.readline().strip().split(':')[1].split()
1923	atNames = [i for i in line]
1924	types = []
1925	coords = []
1926	l = fp.readline().strip()
1927	rbSeq = []
1928	while 'rbSeq' in l:
1929	tag,vals,lst = l.split(':')
1930	seq = []
1931	for t,v in zip((int,int,float),vals.split()):
1932	seq.append(t(v))
1933	seq.append([])
1934	for num in lst.split():
1935	seq[-1].append(int(num))
1936	rbSeq.append(seq)
1937	l = fp.readline().strip()
1938	while l:
1939	nums = l.strip().split()
1940	types.append(nums.pop(0))
1941	t = types[-1]
1942	if t not in AtInfo:
1943	Info = G2elem.GetAtomInfo(t)
1944	AtInfo[t] = [Info['Drad'],Info['Color']]
1945	coords.append([float(nums.pop(0)) for j in range(3)])
1946	l = fp.readline().strip()
1947	fp.close()
1948	else:
1949	return
1950	finally:
1951	dlg.Destroy()
1952	coords = np.array(coords)
1953	rbid = ran.randint(0,sys.maxsize)
1954	namelist = [data['Residue'][key]['RBname'] for key in data['Residue']
1955	if 'RBname' in data['Residue'][key]]
1956	name = G2obj.MakeUniqueLabel(name,namelist)
1957	data['Residue'][rbid] = {'RBname':name,
1958	'rbXYZ': coords,
1959	'rbRef':[0,1,2,False],
1960	'rbTypes':types, 'atNames':atNames,
1961	'useCount':0,
1962	'rbSeq':rbSeq, 'SelSeq':[0,0],}
1963	data['RBIds']['Residue'].append(rbid)
1964	UpdateResidueRB()
1965
1966	def AddVectorRB(event):
1967	'Create a new vector rigid body'
1968	AtInfo = data['Vector']['AtInfo']
1969	dlg = G2G.MultiIntegerDialog(G2frame,'New Rigid Body',['No. atoms','No. translations'],[3,1])
1970	if dlg.ShowModal() == wx.ID_OK:
1971	nAtoms,nTrans = dlg.GetValues()
1972	if nAtoms < 3:
1973	dlg.Destroy()
1974	G2G.G2MessageBox(G2frame,'A vector rigid body must have 3 or more atoms')
1975	return
1976	rbid = ran.randint(0,sys.maxsize)
1977	vecMag = [1.0 for i in range(nTrans)]
1978	vecRef = [False for i in range(nTrans)]
1979	vecVal = [np.zeros((nAtoms,3)) for j in range(nTrans)]
1980	rbTypes = ['C' for i in range(nAtoms)]
1981	Info = G2elem.GetAtomInfo('C')
1982	AtInfo['C'] = [Info['Drad'],Info['Color']]
1983	name = 'UNKRB'
1984	namelist = [data['Vector'][key]['RBname'] for key in data['Vector']
1985	if 'RBname' in data['Vector'][key]]
1986	name = G2obj.MakeUniqueLabel(name,namelist)
1987	data['Vector'][rbid] = {'RBname':name,'VectMag':vecMag,'rbXYZ':np.zeros((nAtoms,3)),
1988	'rbRef':[0,1,2,False],'VectRef':vecRef,'rbTypes':rbTypes,'rbVect':vecVal,'useCount':0}
1989	data['RBIds']['Vector'].append(rbid)
1990	dlg.Destroy()
1991	UpdateVectorRB()
1992
1993	def ExtractPhaseRB(event):
1994	'Extract a rigid body from a file with a phase'
1995	def SetupDrawing(atmData):
1996	'''Add the dicts needed for G2plt.PlotStructure to work to the
1997	reader .Phase object
1998	'''
1999	generalData = atmData['General']
2000	generalData['BondRadii'] = []
2001
2002	G2phG.SetDrawingDefaults(atmData['Drawing'])
2003	atmData['Drawing'].update(
2004	{'oldxy':[0.,0.],'Quaternion':[0.,0.,0.,1.],'cameraPos':150.,
2005	'viewDir':[0,0,1],'atomPtrs': [2, 1, 6, 17],
2006	})
2007	atmData['Drawing']['showRigidBodies'] = False
2008	generalData['Map'] = {'MapType':False, 'rho':[]}
2009	generalData['AtomTypes'] = []
2010	generalData['BondRadii'] = []
2011	generalData['AngleRadii'] = []
2012	generalData['vdWRadii'] = []
2013	generalData['Color'] = []
2014	generalData['Isotopes'] = {}
2015	generalData['Isotope'] = {}
2016	cx,ct,cs,cia = generalData['AtomPtrs']
2017	generalData['Mydir'] = G2frame.dirname
2018	for iat,atom in enumerate(atmData['Atoms']):
2019	atom[ct] = atom[ct].lower().capitalize() #force elem symbol to standard form
2020	if atom[ct] not in generalData['AtomTypes'] and atom[ct] != 'UNK':
2021	Info = G2elem.GetAtomInfo(atom[ct])
2022	if not Info:
2023	atom[ct] = 'UNK'
2024	continue
2025	atom[ct] = Info['Symbol'] # N.B. symbol might be changed by GetAtomInfo
2026	generalData['AtomTypes'].append(atom[ct])
2027	generalData['Z'] = Info['Z']
2028	generalData['Isotopes'][atom[ct]] = Info['Isotopes']
2029	generalData['BondRadii'].append(Info['Drad'])
2030	generalData['AngleRadii'].append(Info['Arad'])
2031	generalData['vdWRadii'].append(Info['Vdrad'])
2032	if atom[ct] in generalData['Isotope']:
2033	if generalData['Isotope'][atom[ct]] not in generalData['Isotopes'][atom[ct]]:
2034	isotope = list(generalData['Isotopes'][atom[ct]].keys())[-1]
2035	generalData['Isotope'][atom[ct]] = isotope
2036	else:
2037	generalData['Isotope'][atom[ct]] = 'Nat. Abund.'
2038	if 'Nat. Abund.' not in generalData['Isotopes'][atom[ct]]:
2039	isotope = list(generalData['Isotopes'][atom[ct]].keys())[-1]
2040	generalData['Isotope'][atom[ct]] = isotope
2041	generalData['Color'].append(Info['Color'])
2042	if generalData['Type'] == 'magnetic':
2043	if len(landeg) < len(generalData['AtomTypes']):
2044	landeg.append(2.0)
2045	atmData['Drawing']['Atoms'] = []
2046	for atom in atmData['Atoms']:
2047	atmData['Drawing']['Atoms'].append(MakeDrawAtom(atmData,atom))
2048
2049	def onCancel(event,page=0):
2050	'complete or bail out from RB define, cleaning up'
2051	G2frame.rbBook.DeletePage(G2frame.rbBook.FindPage(pagename))
2052	G2frame.rbBook.SetSelection(page)
2053
2054	def Page1():
2055	'''Show the GUI for first stage of the rigid body with all atoms in
2056	phase in crystal coordinates. Select the atoms to go onto the
2057	next stage
2058	'''
2059	def ShowSelection(selections):
2060	'respond to change in atom selections'
2061	ct,cs = [1,8]
2062	generalData = rd.Phase['General']
2063	for i,atom in enumerate(rd.Phase['Drawing']['Atoms']):
2064	if i in selections:
2065	factor = 1
2066	else:
2067	factor = 2.5
2068	atNum = generalData['AtomTypes'].index(atom[ct])
2069	atom[cs] = list(np.array(generalData['Color'][atNum])//factor)
2070	draw(*drawArgs)
2071	def onPage1OK(event):
2072	'1st section has been completed, move onto next'
2073	G2frame.G2plotNB.Delete(rd.Phase['General']['Name'])
2074	GetCoords(atmsel)
2075	Page2()
2076
2077	if 'macromolecular' == rd.Phase['General']['Type']:
2078	# for PDB imports, lets see if a quick reformat of atoms list will work
2079	rd.Phase['Atoms'] = [a[3:] for a in rd.Phase['Atoms']]
2080	rd.Phase['General']['AtomPtrs'] = [i-3 for i in rd.Phase['General']['AtomPtrs']]
2081	rd.Phase['General']['Type'] = 'nuclear'
2082	SetupDrawing(rd.Phase) # add information to reader object to allow plotting
2083	atomlist = [atom[0] for atom in rd.Phase['Atoms']]
2084	atmsel = list(range(len(rd.Phase['Atoms'])))
2085	# broken -- # why no bonds?
2086	#for atm in rd.Phase['Drawing']['Atoms']:
2087	# atm[6] = 'balls & sticks'
2088
2089	draw,drawArgs = G2plt.PlotStructure(G2frame,rd.Phase,True)
2090	ShowSelection(atmsel)
2091
2092	if G2frame.rbBook.FindPage(pagename) is not None:
2093	G2frame.rbBook.DeletePage(G2frame.rbBook.FindPage(pagename))
2094
2095	RBImp = wx.ScrolledWindow(G2frame.rbBook)
2096	RBImpPnl = wx.Panel(RBImp)
2097	G2frame.rbBook.AddPage(RBImp,pagename)
2098	G2frame.rbBook.SetSelection(G2frame.rbBook.FindPage(pagename))
2099
2100	mainSizer = G2G.G2MultiChoiceWindow(RBImpPnl,
2101	'Select atoms to import',
2102	atomlist,atmsel,OnChange=ShowSelection)
2103
2104	# OK/Cancel buttons
2105	btnsizer = wx.StdDialogButtonSizer()
2106	OKbtn = wx.Button(RBImpPnl, wx.ID_OK, 'Continue')
2107	OKbtn.SetDefault()
2108	btnsizer.AddButton(OKbtn)
2109	OKbtn.Bind(wx.EVT_BUTTON,onPage1OK)
2110	btn = wx.Button(RBImpPnl, wx.ID_CANCEL)
2111	btn.Bind(wx.EVT_BUTTON,onCancel)
2112	btnsizer.AddButton(btn)
2113	btnsizer.Realize()
2114	mainSizer.Add(btnsizer,0,wx.ALIGN_CENTER,50)
2115
2116	RBImpPnl.SetSizer(mainSizer,True)
2117
2118	mainSizer.Layout()
2119	Size = mainSizer.GetMinSize()
2120	Size[0] += 40
2121	Size[1] = max(Size[1],G2frame.GetSize()[1]-200) + 20
2122	RBImpPnl.SetSize(Size)
2123	RBImp.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
2124	RBImp.Scroll(0,0)
2125
2126	def Page2():
2127	'''Show the GUI for the second stage, where selected atoms are
2128	now in Cartesian space, manipulate the axes and export selected
2129	atoms to a vector or residue rigid body.
2130	'''
2131	def UpdateDraw(event=None):
2132	'Called when info changes in grid, replots'
2133	UpdateVectorBody(rbData)
2134	DrawCallback()
2135
2136	def onSetAll(event):
2137	'Set all atoms as selected'
2138	grid.completeEdits()
2139	for i in range(len(rd.Phase['RBselection'])):
2140	rd.Phase['RBselection'][i] = 1 # table needs 0/1 for T/F
2141	grid.ForceRefresh()
2142	UpdateDraw()
2143
2144	def onToggle(event):
2145	'Toggles selection state for all atoms'
2146	grid.completeEdits()
2147	for i in range(len(rd.Phase['RBselection'])):
2148	rd.Phase['RBselection'][i] = int(not rd.Phase['RBselection'][i])
2149	grid.ForceRefresh()
2150	UpdateDraw()
2151
2152	def onSetOrigin(event):
2153	'Resets origin to midpoint between all selected atoms'
2154	grid.completeEdits()
2155	center = np.array([0.,0.,0.])
2156	count = 0
2157	for i in range(len(rd.Phase['RBselection'])):
2158	if rd.Phase['RBselection'][i]:
2159	count += 1
2160	center += rd.Phase['RBcoords'][i]
2161	if count:
2162	rd.Phase['RBcoords'] -= center/count
2163	grid.ForceRefresh()
2164	UpdateDraw()
2165
2166	def onSetX(event):
2167	grid.completeEdits()
2168	center = np.array([0.,0.,0.])
2169	count = 0
2170	for i in range(len(rd.Phase['RBselection'])):
2171	if rd.Phase['RBselection'][i]:
2172	count += 1
2173	center += rd.Phase['RBcoords'][i]
2174	if not count:
2175	G2G.G2MessageBox(G2frame,'No atoms selected',
2176	'Selection required')
2177	return
2178	XYZP = center/count
2179	if np.sqrt(sum(XYZP**2)) < 0.1:
2180	G2G.G2MessageBox(G2frame,
2181	'The selected atom(s) are too close to the origin',
2182	'near origin')
2183	return
2184	if bntOpts['direction'] == 'y':
2185	YP = XYZP / np.sqrt(np.sum(XYZP**2))
2186	ZP = np.cross((1,0,0),YP)
2187	if sum(ZP*ZP) < .1: # pathological condition: Y' along X
2188	ZP = np.cross((0,0,1),YP)
2189	XP = np.cross(YP,ZP)
2190	elif bntOpts['direction'] == 'z':
2191	ZP = XYZP / np.sqrt(np.sum(XYZP**2))
2192	XP = np.cross((0,1,0),ZP)
2193	if sum(XP*XP) < .1: # pathological condition: X' along Y
2194	XP = np.cross((0,0,1),ZP)
2195	YP = np.cross(ZP,XP)
2196	else:
2197	XP = XYZP / np.sqrt(np.sum(XYZP**2))
2198	YP = np.cross((0,0,1),XP)
2199	if sum(YP*YP) < .1: # pathological condition: X' along Z
2200	YP = np.cross((0,1,0),XP)
2201	ZP = np.cross(XP,YP)
2202	trans = np.array((XP,YP,ZP))
2203	# update atoms in place
2204	rd.Phase['RBcoords'][:] = np.inner(trans,rd.Phase['RBcoords']).T
2205	grid.ForceRefresh()
2206	UpdateDraw()
2207
2208	def onSetPlane(event):
2209	'''Compute least-squares plane for selected atoms;
2210	move atoms so that LS plane aligned with x-y plane,
2211	with minimum required change to x
2212	'''
2213	grid.completeEdits()
2214	selList = [i==1 for i in rd.Phase['RBselection']]
2215	XYZ = rd.Phase['RBcoords'][selList]
2216	if len(XYZ) < 3:
2217	G2G.G2MessageBox(G2frame,'A plane requires three or more atoms',
2218	'Need more atoms')
2219	return
2220	# fit 3 ways (in case of singularity) and take result with lowest residual
2221	X,Y,Z = [XYZ[:,i] for i in (0,1,2)]
2222	XZ = copy.copy(XYZ)
2223	XZ[:,1] = 1
2224	(a,d,b), resd, rank, sing = nl.lstsq(XZ, -Y)
2225	resid_min = resd
2226	normal = a,1,b
2227	YZ = copy.copy(XYZ)
2228	YZ[:,0] = 1
2229	(d,a,b), resd, rank, sing = nl.lstsq(YZ, -X)
2230	if resid_min > resd:
2231	resid_min = resd
2232	normal = 1,a,b
2233	XY = copy.copy(XYZ)
2234	XY[:,2] = 1
2235	(a,b,d), resd, rank, sing = nl.lstsq(XY, -Z)
2236	if resid_min > resd:
2237	resid_min = resd
2238	normal = a,b,1
2239	# solve for ax + bx + z + c = 0 or equivalently ax + bx + c = -z
2240	# try:
2241	# except:
2242	# G2G.G2MessageBox(G2frame,
2243	# 'Error computing plane; are atoms in a line?',
2244	# 'Computation error')
2245	# return
2246	if bntOpts['plane'] == 'xy':
2247	# new coordinate system is
2248	# ZP, z' normal to plane
2249	# YP, y' = z' cross x (= [0,1,-b])
2250	# XP, x' = (z' cross x) cross z'
2251	# this puts XP as close as possible to X with XP & YP in plane
2252	ZP = np.array(normal)
2253	ZP /= np.sqrt(np.sum(ZP**2))
2254	YP = np.cross(ZP,[1,0,0])
2255	if sum(YP*YP) < .1: # pathological condition: z' along x
2256	YP = np.cross(ZP,[0,1,0])
2257	YP /= np.sqrt(np.sum(YP**2))
2258	XP = np.cross(YP,ZP)
2259	elif bntOpts['plane'] == 'yz':
2260	# new coordinate system is
2261	# XP, x' normal to plane
2262	# ZP, z' = x' cross y
2263	# YP, y' = (x' cross y) cross x'
2264	# this puts y' as close as possible to y with z' & y' in plane
2265	XP = np.array(normal)
2266	XP /= np.sqrt(np.sum(XP**2))
2267	ZP = np.cross(XP,[0,1,0])
2268	if sum(ZP*ZP) < .1: # pathological condition: x' along y
2269	ZP = np.cross(XP,(0,0,1))
2270	ZP /= np.sqrt(np.sum(ZP**2))
2271	YP = np.cross(ZP,XP)
2272	elif bntOpts['plane'] == 'xz':
2273	# new coordinate system is
2274	# YP, y' normal to plane
2275	# ZP, z' = x cross y'
2276	# XP, y' = (x cross y') cross z'
2277	# this puts XP as close as possible to X with XP & YP in plane
2278	YP = np.array(normal)
2279	YP /= np.sqrt(np.sum(YP**2))
2280	ZP = np.cross([1,0,0],YP)
2281	if sum(ZP*ZP) < .1: # pathological condition: y' along x
2282	ZP = np.cross([0,1,0],YP)
2283	ZP /= np.sqrt(np.sum(ZP**2))
2284	XP = np.cross(YP,ZP)
2285	else:
2286	print('unexpected plane',bntOpts['plane'])
2287	return
2288	trans = np.array((XP,YP,ZP))
2289	# update atoms in place
2290	rd.Phase['RBcoords'][:] = np.inner(trans,rd.Phase['RBcoords']).T
2291	grid.ForceRefresh()
2292	UpdateDraw()
2293
2294	def onWriteXYZ(event):
2295	'''Writes selected atoms in a .xyz file for use in Avogadro, etc.
2296	'''
2297	grid.completeEdits()
2298	center = np.array([0.,0.,0.])
2299	count = 0
2300	for i in range(len(rd.Phase['RBselection'])):
2301	if rd.Phase['RBselection'][i]:
2302	count += 1
2303	center += rd.Phase['RBcoords'][i]
2304	if count:
2305	center /= count
2306	else:
2307	print('nothing selected')
2308	return
2309	obj = G2IO.ExportBaseclass(G2frame,'XYZ','.xyz')
2310	#obj.InitExport(None)
2311	if obj.ExportSelect(): # set export parameters; ask for file name
2312	return
2313	fp = obj.OpenFile()
2314	obj.Write(str(count))
2315	obj.Write('')
2316	for i in range(len(rd.Phase['RBselection'])):
2317	if rd.Phase['RBselection'][i]:
2318	line = ' ' + rd.Phase['RBtypes'][i]
2319	for xyz in rd.Phase['RBcoords'][i]:
2320	line += ' ' + str(xyz)
2321	obj.Write(line)
2322	obj.CloseFile()
2323	#GSASIIpath.IPyBreak()
2324
2325	def onAddVector(event):
2326	'''Adds selected atoms as a new vector rigid body.
2327	Closes out the importer tab when done.
2328	'''
2329	grid.completeEdits()
2330	name = os.path.splitext(os.path.split(filename)[1])[0]
2331	namelist = [data['Vector'][key]['RBname'] for key in
2332	data['Vector'] if 'RBname' in data['Vector'][key]]
2333	name = G2obj.MakeUniqueLabel(name,namelist)
2334	rb = MakeVectorBody(name)
2335	UpdateVectorBody(rb,True)
2336	if len(rb['rbTypes']) < 3: return # must have at least 3 atoms
2337	rbid = ran.randint(0,sys.maxsize)
2338	data['Vector'][rbid] = rb
2339	data['RBIds']['Vector'].append(rbid)
2340	AtInfo = data['Vector']['AtInfo']
2341	for t in rb['rbTypes']:
2342	if t in data['Vector']['AtInfo']: continue
2343	Info = G2elem.GetAtomInfo(t)
2344	data['Vector']['AtInfo'][t] = [Info['Drad'],Info['Color']]
2345	G2frame.G2plotNB.Delete('Rigid body')
2346	onCancel(event,0)
2347
2348	def onAddResidue(event):
2349	'''Adds selected atoms as a new residue rigid body.
2350	Closes out the importer tab when done.
2351	'''
2352	grid.completeEdits()
2353	name = os.path.split(filename)[1]
2354	rbXYZ = []
2355	rbTypes = []
2356	atNames = []
2357	for i in rd.Phase['RBindex']:
2358	if rd.Phase['RBselection'][i]:
2359	rbXYZ.append(rd.Phase['RBcoords'][i])
2360	rbTypes.append(rd.Phase['RBtypes'][i])
2361	atNames.append(rd.Phase['RBlbls'][i])
2362	if len(rbTypes) < 3: return # must have at least 3 atoms
2363	rbXYZ = np.array(rbXYZ)
2364	rbid = ran.randint(0,sys.maxsize)
2365	namelist = [data['Residue'][key]['RBname'] for key in
2366	data['Residue'] if 'RBname' in data['Residue'][key]]
2367	name = G2obj.MakeUniqueLabel(name,namelist)
2368	data['Residue'][rbid] = {'RBname':name,'rbXYZ':rbXYZ,
2369	'rbTypes':rbTypes,'atNames':atNames,'rbRef':[0,1,2,False],
2370	'rbSeq':[],'SelSeq':[0,0],'useCount':0}
2371	data['RBIds']['Residue'].append(rbid)
2372	AtInfo = data['Residue']['AtInfo']
2373	for t in rbTypes:
2374	if t in data['Residue']['AtInfo']: continue
2375	Info = G2elem.GetAtomInfo(t)
2376	data['Residue']['AtInfo'][t] = [Info['Drad'],Info['Color']]
2377
2378	print ('Rigid body added')
2379	G2frame.G2plotNB.Delete('Rigid body')
2380	onCancel(event,1)
2381
2382	if G2frame.rbBook.FindPage(pagename) is not None:
2383	G2frame.rbBook.DeletePage(G2frame.rbBook.FindPage(pagename))
2384	RBImp = wx.ScrolledWindow(G2frame.rbBook)
2385	RBImpPnl = wx.Panel(RBImp)
2386	G2frame.rbBook.AddPage(RBImp,pagename)
2387	G2frame.rbBook.SetSelection(G2frame.rbBook.FindPage(pagename))
2388	generalData = rd.Phase['General']
2389	AtInfo = {}
2390	ct = 1
2391	for t in rd.Phase['RBtypes']:
2392	if t in AtInfo: continue
2393	Info = G2elem.GetAtomInfo(t)
2394	AtInfo[t] = [Info['Drad'],Info['Color']]
2395	plotDefaults = {'oldxy':[0.,0.],'Quaternion':[0.,0.,0.,1.],'cameraPos':30.,'viewDir':[0,0,1],}
2396
2397	rd.Phase['RBindex'] = list(range(len(rd.Phase['RBtypes'])))
2398	rd.Phase['RBselection'] = len(rd.Phase['RBtypes']) * [1]
2399	name = 'UNKRB'
2400	namelist = [data['Vector'][key]['RBname'] for key in
2401	data['Vector'] if 'RBname' in data['Vector'][key]]
2402	name = G2obj.MakeUniqueLabel(name,namelist)
2403	rbData = MakeVectorBody()
2404	DrawCallback = G2plt.PlotRigidBody(G2frame,'Vector',AtInfo,rbData,plotDefaults)
2405
2406	mainSizer = wx.BoxSizer(wx.HORIZONTAL)
2407	btnSizer = wx.BoxSizer(wx.VERTICAL)
2408	btnSizer.Add(wx.StaticText(RBImpPnl,wx.ID_ANY,'Reorder atoms by dragging'),0,wx.ALL)
2409	btnSizer.Add((-1,15))
2410	btn = wx.Button(RBImpPnl, wx.ID_ANY, 'Set All')
2411	btn.Bind(wx.EVT_BUTTON,onSetAll)
2412	btnSizer.Add(btn,0,wx.ALIGN_CENTER)
2413	btn = wx.Button(RBImpPnl, wx.ID_ANY, 'Toggle')
2414	btn.Bind(wx.EVT_BUTTON,onToggle)
2415	btnSizer.Add(btn,0,wx.ALIGN_CENTER)
2416	btnSizer.Add((-1,15))
2417	btnSizer.Add(wx.StaticText(RBImpPnl,wx.ID_ANY,'Reorient using selected\natoms...'),0,wx.ALL)
2418	btnSizer.Add((-1,5))
2419	btn = wx.Button(RBImpPnl, wx.ID_ANY, 'Set origin')
2420	btn.Bind(wx.EVT_BUTTON,onSetOrigin)
2421	btnSizer.Add(btn,0,wx.ALIGN_CENTER)
2422
2423	bntOpts = {'plane':'xy','direction':'x'}
2424	inSizer = wx.BoxSizer(wx.HORIZONTAL)
2425	btn = wx.Button(RBImpPnl, wx.ID_ANY, 'Place in plane')
2426	btn.Bind(wx.EVT_BUTTON,onSetPlane)
2427	inSizer.Add(btn)
2428	inSizer.Add(G2G.G2ChoiceButton(RBImpPnl,('xy','yz','xz'),None,None,bntOpts,'plane'))
2429	btnSizer.Add(inSizer,0,wx.ALIGN_CENTER)
2430
2431	inSizer = wx.BoxSizer(wx.HORIZONTAL)
2432	btn = wx.Button(RBImpPnl, wx.ID_ANY, 'Define as')
2433	btn.Bind(wx.EVT_BUTTON,onSetX)
2434	inSizer.Add(btn)
2435	inSizer.Add(G2G.G2ChoiceButton(RBImpPnl,('x','y','z'),None,None,bntOpts,'direction'))
2436	btnSizer.Add(inSizer,0,wx.ALIGN_CENTER)
2437
2438	btnSizer.Add((-1,15))
2439	btnSizer.Add(wx.StaticText(RBImpPnl,wx.ID_ANY,'Use selected atoms to\ncreate...'),0,wx.ALL)
2440	btnSizer.Add((-1,5))
2441	btn = wx.Button(RBImpPnl, wx.ID_ANY, 'export as xyz')
2442	btn.Bind(wx.EVT_BUTTON,onWriteXYZ)
2443	btnSizer.Add(btn,0,wx.ALIGN_CENTER)
2444	btnSizer.Add((-1,10))
2445	btn = wx.Button(RBImpPnl, wx.ID_ANY, 'a Vector Body')
2446	btn.Bind(wx.EVT_BUTTON,onAddVector)
2447	btnSizer.Add(btn,0,wx.ALIGN_CENTER)
2448	btn = wx.Button(RBImpPnl, wx.ID_ANY, 'a Residue Body')
2449	btn.Bind(wx.EVT_BUTTON,onAddResidue)
2450	btnSizer.Add(btn,0,wx.ALIGN_CENTER)
2451	btn = wx.Button(RBImpPnl, wx.ID_CANCEL)
2452	btn.Bind(wx.EVT_BUTTON,onCancel)
2453	btnSizer.Add((-1,10))
2454	btnSizer.Add(btn,0,wx.ALIGN_CENTER)
2455
2456	mainSizer.Add(btnSizer)
2457	mainSizer.Add((5,5))
2458	grid = DragableRBGrid(RBImpPnl,rd.Phase,UpdateDraw)
2459	mainSizer.Add(grid)
2460	RBImpPnl.SetSizer(mainSizer,True)
2461	mainSizer.Layout()
2462	Size = mainSizer.GetMinSize()
2463	Size[0] += 40
2464	Size[1] = max(Size[1],G2frame.GetSize()[1]-200) + 20
2465	RBImpPnl.SetSize(Size)
2466	RBImp.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
2467	RBImp.Scroll(0,0)
2468
2469	def GetCoords(atmsel):
2470	'''Create orthogonal coordinates for selected atoms.
2471	Place the origin at the center of the body
2472	'''
2473	atms = rd.Phase['Atoms']
2474	cell = rd.Phase['General']['Cell'][1:7]
2475	Amat,Bmat = G2lat.cell2AB(cell)
2476	rd.Phase['RBcoords'] = np.array([np.inner(Amat,atms[i][3:6]) for i in atmsel])
2477	rd.Phase['RBcoords'] -= rd.Phase['RBcoords'].mean(axis=0) # origin to middle
2478	rd.Phase['RBtypes'] = [atms[i][1] for i in atmsel]
2479	rd.Phase['RBlbls'] = [atms[i][0] for i in atmsel]
2480
2481	def UpdateVectorBody(rb,useSelection=False):
2482	'''Put the atoms in order to pass for plotting or for storage as
2483	a vector rigid body.
2484
2485	:param dict rb: rigid body contents created in :func:`MakeVectorBody`
2486	:param bool useSelection: True if the rd.Phase['RBselection']
2487	values will be used to select which atoms are included in the
2488	rigid body. If False (default) they are included in rb
2489	and are used for plotting.
2490	'''
2491	coordlist = []
2492	typeslist = []
2493	sellist = []
2494	for i in rd.Phase['RBindex']:
2495	use = True
2496	if useSelection and not rd.Phase['RBselection'][i]: use = False
2497	if use:
2498	coordlist.append(rd.Phase['RBcoords'][i])
2499	typeslist.append(rd.Phase['RBtypes'][i])
2500	sellist.append(rd.Phase['RBselection'][i])
2501	coordlist = np.array(coordlist)
2502	rb['rbXYZ'] = coordlist
2503	rb['rbVect'] = [coordlist]
2504	rb['rbTypes'] = typeslist
2505	if not useSelection:
2506	rb['Selection'] = sellist
2507	elif 'Selection' in rb:
2508	del rb['Selection']
2509
2510	def MakeVectorBody(name=''):
2511	'''Make the basic vector rigid body dict (w/o coordinates) used for
2512	export and for plotting
2513	'''
2514	nTrans = 1
2515	vecMag = [1.0]
2516	vecRef = [False]
2517	rb = {'RBname':name,'VectMag':vecMag,
2518	'rbRef':[0,1,2,False],'VectRef':vecRef,
2519	'useCount':0}
2520	UpdateVectorBody(rb)
2521	return rb
2522
2523	# too lazy to figure out why wx crashes
2524	if wx.__version__.split('.')[0] != '4':
2525	wx.MessageBox('Sorry, wxPython 4.x is required to run this command',
2526	caption='Update Python',
2527	style=wx.ICON_EXCLAMATION)
2528	return
2529	if platform.python_version()[:1] == '2':
2530	wx.MessageBox('Sorry, Python >=3.x is required to run this command',
2531	caption='Update Python',
2532	style=wx.ICON_EXCLAMATION)
2533	return
2534
2535	# get importer type and a phase file of that type
2536	G2sc.LoadG2fil()
2537	choices = [rd.formatName for rd in G2sc.Readers['Phase']]
2538	dlg = G2G.G2SingleChoiceDialog(G2frame,'Select the format of the file',
2539	'select format',choices)
2540	dlg.CenterOnParent()
2541	try:
2542	if dlg.ShowModal() == wx.ID_OK:
2543	col = dlg.GetSelection()
2544	else:
2545	col = None
2546	return
2547	finally:
2548	dlg.Destroy()
2549	reader = G2sc.Readers['Phase'][col]
2550
2551	choices = reader.formatName + " file ("
2552	w = ""
2553	for extn in reader.extensionlist:
2554	if w != "": w += ";"
2555	w += "*" + extn
2556	choices += w + ")\|" + w
2557	#choices += "\|zip archive (.zip)\|*.zip"
2558	if not reader.strictExtension:
2559	choices += "\|any file (.)\|."
2560	typ = '( type '+reader.formatName+')'
2561	filelist = G2G.GetImportFile(G2frame,
2562	message="Choose phase input file"+typ,
2563	defaultFile="",wildcard=choices,style=wx.FD_OPEN)
2564	if len(filelist) != 1: return
2565
2566	# read in the phase file
2567	filename = filelist[0]
2568	rd = reader
2569	with open(filename, 'Ur') as fp:
2570	rd.ReInitialize()
2571	rd.errors = ""
2572	if not rd.ContentsValidator(filename): # Report error
2573	G2fl.G2Print("Warning: File {} has a validation error".format(filename))
2574	return
2575	if len(rd.selections) > 1:
2576	print("File {} has {} phases. This is unexpected."
2577	.format(filename,len(rd.selections)))
2578	return
2579
2580	rd.objname = os.path.basename(filename)
2581	try:
2582	flag = rd.Reader(filename)
2583	except Exception as msg:
2584	G2fl.G2Print("Warning: read of file {} failed\n{}".format(
2585	filename,rd.errors))
2586	if GSASIIpath.GetConfigValue('debug'):
2587	print(msg)
2588	import traceback
2589	print (traceback.format_exc())
2590	GSASIIpath.IPyBreak()
2591	return
2592
2593	pagename = 'Rigid body importer'
2594	Page1()
2595	return
2596
2597	def AddVectTrans(event):
2598	'Add a translation to an existing vector rigid body'
2599	choices = []
2600	rbIdlist = []
2601	for rbid in data['RBIds']['Vector']:
2602	if rbid != 'AtInfo':
2603	rbIdlist.append(rbid)
2604	choices.append(data['Vector'][rbid]['RBname'])
2605	if len(choices) == 0:
2606	G2G.G2MessageBox(G2frame,'No Vector Rigid Bodies found',
2607	'No VR Bodies')
2608	return
2609	elif len(choices) == 1:
2610	rbid = rbIdlist[0]
2611	else:
2612	dlg = G2G.G2SingleChoiceDialog(G2frame,'Select the rigid body to save',
2613	'select format',choices)
2614	try:
2615	if dlg.ShowModal() == wx.ID_OK:
2616	rbid = rbIdlist[dlg.GetSelection()]
2617	else:
2618	return
2619	finally:
2620	dlg.Destroy()
2621	data['Vector'][rbid]['VectMag'] += [1.0]
2622	data['Vector'][rbid]['VectRef'] += [False]
2623	nAtoms = len(data['Vector'][rbid]['rbXYZ'])
2624	data['Vector'][rbid]['rbVect'] += [np.zeros((nAtoms,3))]
2625	UpdateVectorRB()
2626
2627	def SaveVectorRB(event):
2628	choices = []
2629	rbIdlist = []
2630	for rbid in data['RBIds']['Vector']:
2631	if rbid != 'AtInfo':
2632	rbIdlist.append(rbid)
2633	choices.append(data['Vector'][rbid]['RBname'])
2634	if len(choices) == 0:
2635	G2G.G2MessageBox(G2frame,'No Vector Rigid Bodies found',
2636	'No VR Bodies')
2637	return
2638	elif len(choices) == 1:
2639	rbid = rbIdlist[0]
2640	else:
2641	dlg = G2G.G2SingleChoiceDialog(G2frame,'Select the rigid body to save',
2642	'select format',choices)
2643	try:
2644	if dlg.ShowModal() == wx.ID_OK:
2645	rbid = rbIdlist[dlg.GetSelection()]
2646	else:
2647	return
2648	finally:
2649	dlg.Destroy()
2650
2651	pth = G2G.GetExportPath(G2frame)
2652	dlg = wx.FileDialog(G2frame, 'Choose file to save vector rigid body',
2653	pth, '', 'VRB files (.vecbody)\|.vecbody',
2654	wx.FD_SAVE\|wx.FD_OVERWRITE_PROMPT)
2655	try:
2656	if dlg.ShowModal() == wx.ID_OK:
2657	filename = dlg.GetPath()
2658	filename = os.path.splitext(filename)[0]+'.vecbody' # set extension
2659	fp = open(filename,'w')
2660	fp.write('Name: '+data['Vector'][rbid]['RBname']+'\n')
2661	fp.write('Trans: ')
2662	for i in data['Vector'][rbid]['VectMag']:
2663	fp.write(str(i)+" ")
2664	fp.write('\n')
2665	ntrans = len(data['Vector'][rbid]['VectMag'])
2666	for i,sym in enumerate(data['Vector'][rbid]['rbTypes']):
2667	fp.write("{:3s}".format(sym))
2668	for j in range(ntrans):
2669	fp.write('{:8.5f}{:9.5f}{:9.5f} '
2670	.format(*data['Vector'][rbid]['rbVect'][j][i]))
2671	fp.write('\n')
2672	fp.close()
2673	print ('Vector rigid body saved to: '+filename)
2674	finally:
2675	dlg.Destroy()
2676
2677	def ReadVectorRB(event):
2678	AtInfo = data['Vector']['AtInfo']
2679	pth = G2G.GetExportPath(G2frame)
2680	dlg = wx.FileDialog(G2frame, 'Choose file to read vector rigid body',
2681	pth, '', 'VRB files (.vecbody)\|.vecbody',
2682	wx.FD_OPEN)
2683	try:
2684	if dlg.ShowModal() == wx.ID_OK:
2685	filename = dlg.GetPath()
2686	filename = os.path.splitext(filename)[0]+'.vecbody' # set extension
2687	fp = open(filename,'r')
2688	l = fp.readline().strip()
2689	if 'Name' not in l:
2690	fp.close()
2691	G2frame.ErrorDialog('Read Error',
2692	'File '+filename+' does not start with Name\nFirst line ='
2693	+l+'\ninvalid file',parent=G2frame)
2694	return
2695	name = l.split(':')[1].strip()
2696	trans = fp.readline().strip().split(':')[1].split()
2697	vecMag = [float(i) for i in trans]
2698	ntrans = len(trans)
2699	vecs = [[] for i in range(ntrans)]
2700	types = []
2701	l = fp.readline().strip()
2702	while l:
2703	nums = l.strip().split()
2704	types.append(nums.pop(0))
2705	t = types[-1]
2706	if t not in AtInfo:
2707	Info = G2elem.GetAtomInfo(t)
2708	AtInfo[t] = [Info['Drad'],Info['Color']]
2709	for i in range(ntrans):
2710	vecs[i].append([float(nums.pop(0)) for j in range(3)])
2711	l = fp.readline().strip()
2712	fp.close()
2713	else:
2714	return
2715	finally:
2716	dlg.Destroy()
2717	natoms = len(types)
2718	vecs = [np.array(vecs[i]) for i in range(ntrans)]
2719	rbid = ran.randint(0,sys.maxsize)
2720	namelist = [data['Vector'][key]['RBname'] for key in data['Vector']
2721	if 'RBname' in data['Vector'][key]]
2722	name = G2obj.MakeUniqueLabel(name,namelist)
2723	data['Vector'][rbid] = {'RBname':name,'VectMag':vecMag,
2724	'rbXYZ':np.zeros((natoms,3)),
2725	'rbRef':[0,1,2,False],'VectRef':ntrans*[False],
2726	'rbTypes':types,
2727	'rbVect':vecs,'useCount':0}
2728	data['RBIds']['Vector'].append(rbid)
2729	UpdateVectorRB()
2730
2731	def AddResidueRB(event):
2732	global resRBsel
2733	AtInfo = data['Residue']['AtInfo']
2734	macro = getMacroFile('rigid body')
2735	if not macro:
2736	return
2737	macStr = macro.readline()
2738	while macStr:
2739	items = macStr.split()
2740	if 'I' == items[0]:
2741	resRBsel = ran.randint(0,sys.maxsize)
2742	rbName = items[1]
2743	rbTypes = []
2744	rbXYZ = []
2745	rbSeq = []
2746	atNames = []
2747	nAtms,nSeq,nOrig,mRef,nRef = [int(items[i]) for i in [2,3,4,5,6]]
2748	for iAtm in range(nAtms):
2749	macStr = macro.readline().split()
2750	atName = macStr[0]
2751	atType = macStr[1]
2752	atNames.append(atName)
2753	rbXYZ.append([float(macStr[i]) for i in [2,3,4]])
2754	rbTypes.append(atType)
2755	if atType not in AtInfo:
2756	Info = G2elem.GetAtomInfo(atType)
2757	AtInfo[atType] = [Info['Drad'],Info['Color']]
2758	rbXYZ = np.array(rbXYZ)-np.array(rbXYZ[nOrig-1])
2759	for iSeq in range(nSeq):
2760	macStr = macro.readline().split()
2761	mSeq = int(macStr[0])
2762	for jSeq in range(mSeq):
2763	macStr = macro.readline().split()
2764	iBeg = int(macStr[0])-1
2765	iFin = int(macStr[1])-1
2766	angle = 0.0
2767	nMove = int(macStr[2])
2768	iMove = [int(macStr[i])-1 for i in range(3,nMove+3)]
2769	rbSeq.append([iBeg,iFin,angle,iMove])
2770	namelist = [data['Residue'][key]['RBname'] for key in
2771	data['Residue'] if 'RBname' in data['Residue'][key]]
2772	rbName = G2obj.MakeUniqueLabel(rbName,namelist)
2773	data['Residue'][resRBsel] = {'RBname':rbName,'rbXYZ':rbXYZ,'rbTypes':rbTypes,
2774	'atNames':atNames,'rbRef':[nOrig-1,mRef-1,nRef-1,True],'rbSeq':rbSeq,
2775	'SelSeq':[0,0],'useCount':0,'molCent':None}
2776	data['RBIds']['Residue'].append(resRBsel)
2777	print ('Rigid body '+rbName+' added')
2778	macStr = macro.readline()
2779	macro.close()
2780	UpdateResidueRB()
2781
2782	def ImportResidueRB():
2783	global resRBsel
2784	AtInfo = data['Residue']['AtInfo']
2785	text,ext = getTextFile()
2786	if not text:
2787	return
2788	resRBsel = ran.randint(0,sys.maxsize)
2789	rbTypes = []
2790	rbXYZ = []
2791	atNames = []
2792	txtStr = text.readline()
2793	if 'xyz' in ext:
2794	txtStr = text.readline()
2795	txtStr = text.readline()
2796	elif 'mol2' in ext:
2797	while 'ATOM' not in txtStr:
2798	txtStr = text.readline()
2799	txtStr = text.readline()
2800	elif 'pdb' in ext:
2801	while 'ATOM' not in txtStr[:6] and 'HETATM' not in txtStr[:6]:
2802	txtStr = text.readline()
2803	items = txtStr.split()
2804	nat = 1
2805	while len(items):
2806	if 'txt' in ext:
2807	atName = items[0]
2808	atType = items[1]
2809	rbXYZ.append([float(items[i]) for i in [2,3,4]])
2810	elif 'xyz' in ext:
2811	atType = items[0]
2812	rbXYZ.append([float(items[i]) for i in [1,2,3]])
2813	atName = '%s%d'%(atType,nat)
2814	elif 'mol2' in ext:
2815	atType = items[1]
2816	atName = items[1]+items[0]
2817	rbXYZ.append([float(items[i]) for i in [2,3,4]])
2818	elif 'pdb' in ext:
2819	atType = items[-1]
2820	if not items[2][-1].isnumeric():
2821	atName = '%s%d'%(items[2],nat)
2822	else:
2823	atName = '5s'%items[2]
2824	xyz = txtStr[30:55].split()
2825	rbXYZ.append([float(x) for x in xyz])
2826	atNames.append(atName)
2827	rbTypes.append(atType)
2828	if atType not in AtInfo:
2829	Info = G2elem.GetAtomInfo(atType)
2830	AtInfo[atType] = [Info['Drad'],Info['Color']]
2831	txtStr = text.readline()
2832	if 'mol2' in ext and 'BOND' in txtStr:
2833	break
2834	if 'pdb' in ext and ('ATOM' not in txtStr[:6] and 'HETATM' not in txtStr[:6]):
2835	break
2836	items = txtStr.split()
2837	nat += 1
2838	if len(atNames) < 3:
2839	G2G.G2MessageBox(G2frame,'Not enough atoms in rigid body; must be 3 or more')
2840	else:
2841	rbXYZ = np.array(rbXYZ)-np.array(rbXYZ[0])
2842	Xxyz = rbXYZ[1]
2843	X = Xxyz/np.sqrt(np.sum(Xxyz**2))
2844	Yxyz = rbXYZ[2]
2845	Y = Yxyz/np.sqrt(np.sum(Yxyz**2))
2846	Mat = G2mth.getRBTransMat(X,Y)
2847	rbXYZ = np.inner(Mat,rbXYZ).T
2848	name = 'UNKRB'
2849	namelist = [data['Residue'][key]['RBname'] for key in data['Residue']
2850	if 'RBname' in data['Residue'][key]]
2851	name = G2obj.MakeUniqueLabel(name,namelist)
2852	data['Residue'][resRBsel] = {'RBname':name,'rbXYZ':rbXYZ,'rbTypes':rbTypes,
2853	'atNames':atNames,'rbRef':[0,1,2,False],'rbSeq':[],'SelSeq':[0,0],'useCount':0,'molCent':False}
2854	data['RBIds']['Residue'].append(resRBsel)
2855	print ('Rigid body UNKRB added')
2856	text.close()
2857	UpdateResidueRB()
2858
2859	def SaveResidueRB():
2860	global resRBsel
2861	pth = G2G.GetExportPath(G2frame)
2862	dlg = wx.FileDialog(G2frame, 'Choose PDB file for Atom XYZ', pth, '',
2863	'PDB files (.pdb)\|.pdb',wx.FD_SAVE\|wx.FD_OVERWRITE_PROMPT)
2864	try:
2865	if dlg.ShowModal() == wx.ID_OK:
2866	filename = dlg.GetPath()
2867	filename = os.path.splitext(filename)[0]+'.pdb' # make extension .pdb
2868	File = open(filename,'w')
2869	rbData = data['Residue'][resRBsel]
2870	for iat,xyz in enumerate(rbData['rbXYZ']):
2871	File.write('ATOM %6d %-4s%3s 1 %8.3f%8.3f%8.3f 1.00 0.00 %2s\n'%(
2872	iat,rbData['atNames'][iat],rbData['RBname'][:3],xyz[0],xyz[1],xyz[2],rbData['rbTypes'][iat]))
2873	File.close()
2874	print ('Atom XYZ saved to: '+filename)
2875	finally:
2876	dlg.Destroy()
2877
2878
2879	def FindNeighbors(Orig,XYZ,atTypes,atNames,AtInfo):
2880	Radii = []
2881	for Atype in atTypes:
2882	Radii.append(AtInfo[Atype][0])
2883	Radii = np.array(Radii)
2884	Neigh = []
2885	Dx = XYZ-XYZ[Orig]
2886	dist = np.sqrt(np.sum(Dx**2,axis=1))
2887	sumR = Radii[Orig]+Radii
2888	IndB = ma.nonzero(ma.masked_greater(dist-0.85*sumR,0.))
2889	for j in IndB[0]:
2890	if j != Orig and atTypes[j] != 'H':
2891	Neigh.append(atNames[j])
2892	return Neigh
2893
2894	def FindAllNeighbors(XYZ,atTypes,atNames,AtInfo):
2895	NeighDict = {}
2896	for iat,xyz in enumerate(atNames):
2897	NeighDict[atNames[iat]] = FindNeighbors(iat,XYZ,atTypes,atNames,AtInfo)
2898	return NeighDict
2899
2900	def FindRiding(Orig,Pivot,NeighDict):
2901	riding = [Orig,Pivot]
2902	iAdd = 1
2903	new = True
2904	while new:
2905	newAtms = NeighDict[riding[iAdd]]
2906	for At in newAtms:
2907	new = False
2908	if At not in riding:
2909	riding.append(At)
2910	new = True
2911	iAdd += 1
2912	if iAdd < len(riding):
2913	new = True
2914	return riding[2:]
2915
2916	def OnDefineTorsSeq(event):
2917	global resRBsel
2918	rbData = data['Residue'][resRBsel]
2919	if not len(rbData):
2920	return
2921	atNames = rbData['atNames']
2922	AtInfo = data['Residue']['AtInfo']
2923	atTypes = rbData['rbTypes']
2924	XYZ = rbData['rbXYZ']
2925	neighDict = FindAllNeighbors(XYZ,atTypes,atNames,AtInfo)
2926	TargList = []
2927	dlg = wx.SingleChoiceDialog(G2frame,'Select origin atom for torsion sequence','Origin atom',rbData['atNames'])
2928	if dlg.ShowModal() == wx.ID_OK:
2929	Orig = dlg.GetSelection()
2930	TargList = neighDict[atNames[Orig]]
2931	dlg.Destroy()
2932	if not len(TargList):
2933	return
2934	dlg = wx.SingleChoiceDialog(G2frame,'Select pivot atom for torsion sequence','Pivot atom',TargList)
2935	if dlg.ShowModal() == wx.ID_OK:
2936	Piv = atNames.index(TargList[dlg.GetSelection()])
2937	riding = FindRiding(atNames[Orig],atNames[Piv],neighDict)
2938	Riding = []
2939	for atm in riding:
2940	Riding.append(atNames.index(atm))
2941	rbData['rbSeq'].append([Orig,Piv,0.0,Riding])
2942	dlg.Destroy()
2943	UpdateResidueRB()
2944
2945	def UpdateVectorRB(Scroll=0):
2946	'''Display & edit a selected Vector RB
2947	'''
2948	def rbNameSizer(rbid,rbData):
2949
2950	def OnRBName(event):
2951	event.Skip()
2952	Obj = event.GetEventObject()
2953	name = Obj.GetValue()
2954	namelist = [data['Vector'][key]['RBname'] for key in
2955	data['Vector'] if 'RBname' in data['Vector'][key]]
2956	name = G2obj.MakeUniqueLabel(name,namelist)
2957	rbData['RBname'] = name
2958
2959	def OnDelRB(event):
2960	Obj = event.GetEventObject()
2961	rbid = Indx[Obj.GetId()]
2962	if rbid in data['Vector']:
2963	del data['Vector'][rbid]
2964	data['RBIds']['Vector'].remove(rbid)
2965	rbData['useCount'] -= 1
2966	wx.CallAfter(UpdateVectorRB)
2967	def OnPlotRB(event):
2968	Obj = event.GetEventObject()
2969	G2plt.PlotRigidBody(G2frame,'Vector',AtInfo,rbData,plotDefaults)
2970
2971	nameSizer = wx.BoxSizer(wx.HORIZONTAL)
2972	nameSizer.Add(wx.StaticText(VectorRBDisplay,-1,'Rigid body name: '),0,WACV)
2973	RBname = wx.TextCtrl(VectorRBDisplay,-1,rbData['RBname'])
2974	Indx[RBname.GetId()] = rbid
2975	RBname.Bind(wx.EVT_LEAVE_WINDOW, OnRBName)
2976	RBname.Bind(wx.EVT_TEXT_ENTER,OnRBName)
2977	RBname.Bind(wx.EVT_KILL_FOCUS,OnRBName)
2978	nameSizer.Add(RBname,0,WACV)
2979	nameSizer.Add((5,0),)
2980	plotRB = wx.Button(VectorRBDisplay,wx.ID_ANY,'Plot',style=wx.BU_EXACTFIT)
2981	plotRB.Bind(wx.EVT_BUTTON, OnPlotRB)
2982	Indx[plotRB.GetId()] = rbid
2983	nameSizer.Add(plotRB,0,WACV)
2984	nameSizer.Add((5,0),)
2985	if not rbData['useCount']:
2986	delRB = wx.Button(VectorRBDisplay,wx.ID_ANY,"Delete",style=wx.BU_EXACTFIT)
2987	delRB.Bind(wx.EVT_BUTTON, OnDelRB)
2988	Indx[delRB.GetId()] = rbid
2989	nameSizer.Add(delRB,0,WACV)
2990	return nameSizer
2991
2992	def rbRefAtmSizer(rbid,rbData):
2993
2994	def OnRefSel(event):
2995	Obj = event.GetEventObject()
2996	iref = Indx[Obj.GetId()]
2997	sel = Obj.GetValue()
2998	rbData['rbRef'][iref] = atNames.index(sel)
2999	FillRefChoice(rbid,rbData)
3000
3001	refAtmSizer = wx.BoxSizer(wx.HORIZONTAL)
3002	atNames = [name+str(i) for i,name in enumerate(rbData['rbTypes'])]
3003	rbRef = rbData.get('rbRef',[0,1,2,False])
3004	rbData['rbRef'] = rbRef
3005	if rbData['useCount']:
3006	refAtmSizer.Add(wx.StaticText(VectorRBDisplay,-1,
3007	'Orientation reference atoms A-B-C: %s, %s, %s'%(atNames[rbRef[0]], \
3008	atNames[rbRef[1]],atNames[rbRef[2]])),0)
3009	else:
3010	refAtmSizer.Add(wx.StaticText(VectorRBDisplay,-1,
3011	'Orientation reference atoms A-B-C: '),0,WACV)
3012	for i in range(3):
3013	choices = [atNames[j] for j in refChoice[rbid][i]]
3014	refSel = wx.ComboBox(VectorRBDisplay,-1,value='',
3015	choices=choices,style=wx.CB_READONLY\|wx.CB_DROPDOWN)
3016	refSel.SetValue(atNames[rbRef[i]])
3017	refSel.Bind(wx.EVT_COMBOBOX, OnRefSel)
3018	Indx[refSel.GetId()] = i
3019	refAtmSizer.Add(refSel,0,WACV)
3020	refHelpInfo = '''
3021	The Orientation reference control is used to tranform
3022	the Cartesian
3023	axes for rigid bodies with three atoms, A, B and C.
3024	The vector from A to B defines the x-axis and the y axis is placed
3025	in the plane defined by A to B and A to C.
3026	'''
3027	hlp = G2G.HelpButton(VectorRBDisplay,refHelpInfo,wrap=400)
3028	refAtmSizer.Add(hlp,0,wx.LEFT\|wx.RIGHT\|wx.ALIGN_CENTER_VERTICAL,2)
3029	return refAtmSizer
3030
3031	def rbVectMag(rbid,imag,rbData):
3032
3033	def OnRBVectorMag(event):
3034	event.Skip()
3035	Obj = event.GetEventObject()
3036	rbid,imag = Indx[Obj.GetId()]
3037	try:
3038	val = float(Obj.GetValue())
3039	if val <= 0.:
3040	raise ValueError
3041	rbData['VectMag'][imag] = val
3042	except ValueError:
3043	pass
3044	Obj.SetValue('%8.4f'%(val))
3045	wx.CallAfter(UpdateVectorRB,VectorRB.GetScrollPos(wx.VERTICAL))
3046	G2plt.PlotRigidBody(G2frame,'Vector',AtInfo,data['Vector'][rbid],plotDefaults)
3047
3048	def OnRBVectorRef(event):
3049	Obj = event.GetEventObject()
3050	rbid,imag = Indx[Obj.GetId()]
3051	rbData['VectRef'][imag] = Obj.GetValue()
3052
3053	magSizer = wx.BoxSizer(wx.HORIZONTAL)
3054	magSizer.Add(wx.StaticText(VectorRBDisplay,-1,'Translation magnitude: '),0,WACV)
3055	magValue = wx.TextCtrl(VectorRBDisplay,-1,'%8.4f'%(rbData['VectMag'][imag]))
3056	Indx[magValue.GetId()] = [rbid,imag]
3057	magValue.Bind(wx.EVT_TEXT_ENTER,OnRBVectorMag)
3058	magValue.Bind(wx.EVT_KILL_FOCUS,OnRBVectorMag)
3059	magSizer.Add(magValue,0,WACV)
3060	magSizer.Add((5,0),)
3061	magref = wx.CheckBox(VectorRBDisplay,label=' Refine?')
3062	magref.SetValue(rbData['VectRef'][imag])
3063	magref.Bind(wx.EVT_CHECKBOX,OnRBVectorRef)
3064	Indx[magref.GetId()] = [rbid,imag]
3065	magSizer.Add(magref,0,WACV)
3066	return magSizer
3067
3068	def rbVectors(rbid,imag,mag,XYZ,rbData):
3069
3070	def TypeSelect(event):
3071	AtInfo = data['Vector']['AtInfo']
3072	r,c = event.GetRow(),event.GetCol()
3073	if vecGrid.GetColLabelValue(c) == 'Type':
3074	PE = G2elemGUI.PickElement(G2frame,oneOnly=True)
3075	if PE.ShowModal() == wx.ID_OK:
3076	if PE.Elem != 'None':
3077	El = PE.Elem.strip().lower().capitalize()
3078	if El not in AtInfo:
3079	Info = G2elem.GetAtomInfo(El)
3080	AtInfo[El] = [Info['Drad'],Info['Color']]
3081	rbData['rbTypes'][r] = El
3082	vecGrid.SetCellValue(r,c,El)
3083	PE.Destroy()
3084	wx.CallAfter(UpdateVectorRB,VectorRB.GetScrollPos(wx.VERTICAL))
3085
3086	def ChangeCell(event):
3087	r,c = event.GetRow(),event.GetCol()
3088	if r >= 0 and (0 <= c < 3):
3089	try:
3090	val = float(vecGrid.GetCellValue(r,c))
3091	rbData['rbVect'][imag][r][c] = val
3092	except ValueError:
3093	pass
3094	G2plt.PlotRigidBody(G2frame,'Vector',AtInfo,data['Vector'][rbid],plotDefaults)
3095	wx.CallAfter(UpdateVectorRB,VectorRB.GetScrollPos(wx.VERTICAL))
3096
3097	vecSizer = wx.BoxSizer()
3098	Types = 3[wg.GRID_VALUE_FLOAT+':10,5',]+[wg.GRID_VALUE_STRING,]+3[wg.GRID_VALUE_FLOAT+':10,5',]
3099	colLabels = ['Vector x','Vector y','Vector z','Type','Cart x','Cart y','Cart z']
3100	table = []
3101	rowLabels = []
3102	for ivec,xyz in enumerate(rbData['rbVect'][imag]):
3103	table.append(list(xyz)+[rbData['rbTypes'][ivec],]+list(XYZ[ivec]))
3104	rowLabels.append(str(ivec))
3105	vecTable = G2G.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
3106	vecGrid = G2G.GSGrid(VectorRBDisplay)
3107	vecGrid.SetTable(vecTable, True)
3108	if 'phoenix' in wx.version():
3109	vecGrid.Bind(wg.EVT_GRID_CELL_CHANGED, ChangeCell)
3110	else:
3111	vecGrid.Bind(wg.EVT_GRID_CELL_CHANGE, ChangeCell)
3112	if not imag:
3113	vecGrid.Bind(wg.EVT_GRID_CELL_LEFT_DCLICK, TypeSelect)
3114	attr = wx.grid.GridCellAttr()
3115	attr.IncRef()
3116	attr.SetEditor(G2G.GridFractionEditor(vecGrid))
3117	for c in range(3):
3118	attr.IncRef()
3119	vecGrid.SetColAttr(c, attr)
3120	for row in range(vecTable.GetNumberRows()):
3121	if imag:
3122	vecGrid.SetCellStyle(row,3,VERY_LIGHT_GREY,True)
3123	for col in [4,5,6]:
3124	vecGrid.SetCellStyle(row,col,VERY_LIGHT_GREY,True)
3125	# vecGrid.SetScrollRate(0,0)
3126	vecGrid.AutoSizeColumns(False)
3127	vecSizer.Add(vecGrid)
3128	return vecSizer
3129
3130	def FillRefChoice(rbid,rbData):
3131	choiceIds = [i for i in range(len(rbData['rbTypes']))]
3132
3133	rbRef = rbData.get('rbRef',[-1,-1,-1,False])
3134	for i in range(3):
3135	if rbRef[i] in choiceIds: choiceIds.remove(rbRef[i])
3136	refChoice[rbid] = [choiceIds[:],choiceIds[:],choiceIds[:]]
3137	for i in range(3):
3138	refChoice[rbid][i].append(rbRef[i])
3139	refChoice[rbid][i].sort()
3140
3141	# beginning of UpdateVectorRB
3142	AtInfo = data['Vector']['AtInfo']
3143	refChoice = {}
3144	if 'DELETED' in str(G2frame.GetStatusBar()): #seems to be no other way to do this (wx bug)
3145	if GSASIIpath.GetConfigValue('debug'):
3146	print ('DBG_wx error: Rigid Body/Status not cleanly deleted after Refine')
3147	return
3148	SetStatusLine(' You may use e.g. "c60" or "s60" for a vector entry')
3149	if VectorRB.GetSizer(): VectorRB.GetSizer().Clear(True)
3150	VectorRBSizer = wx.BoxSizer(wx.VERTICAL)
3151	first = True
3152	for rbid in data['RBIds']['Vector']:
3153	if rbid == 'AtInfo': continue
3154	rbData = data['Vector'][rbid]
3155	FillRefChoice(rbid,rbData)
3156	if not first:
3157	G2G.HorizontalLine(VectorRBSizer,VectorRBDisplay)
3158	VectorRBSizer.Add(rbNameSizer(rbid,rbData),0)
3159	VectorRBSizer.Add(rbRefAtmSizer(rbid,rbData),0)
3160	XYZ = np.array([[0.,0.,0.] for Ty in rbData['rbTypes']])
3161	for imag,mag in enumerate(rbData['VectMag']):
3162	XYZ += mag*rbData['rbVect'][imag]
3163	VectorRBSizer.Add(rbVectMag(rbid,imag,rbData),0)
3164	VectorRBSizer.Add(rbVectors(rbid,imag,mag,XYZ,rbData),0)
3165	VectorRBSizer.Add((5,5),0)
3166	data['Vector'][rbid]['rbXYZ'] = XYZ
3167	first = False
3168	VectorRBSizer.Layout()
3169	VectorRBDisplay.SetSizer(VectorRBSizer,True)
3170	Size = VectorRBSizer.GetMinSize()
3171	Size[0] += 40
3172	Size[1] = max(Size[1],450) + 20
3173	VectorRBDisplay.SetSize(Size)
3174	VectorRB.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
3175	VectorRB.Scroll(0,Scroll)
3176
3177	def UpdateResidueRB():
3178	'''Draw the contents of the Residue Rigid Body tab for Rigid Bodies tree entry
3179	'''
3180	global resRBsel
3181	def rbNameSizer(rbid,rbData):
3182	def OnRBName(event):
3183	event.Skip()
3184	Obj = event.GetEventObject()
3185	name = Obj.GetValue()
3186	if name == rbData['RBname']: return # no change
3187	namelist = [data['Residue'][key]['RBname'] for key in
3188	data['Residue'] if 'RBname' in data['Residue'][key]]
3189	name = G2obj.MakeUniqueLabel(name,namelist)
3190	rbData['RBname'] = name
3191	wx.CallAfter(UpdateResidueRB)
3192
3193	def OnDelRB(event):
3194	Obj = event.GetEventObject()
3195	rbid = Indx[Obj.GetId()]
3196	if rbid in data['Residue']:
3197	del data['Residue'][rbid]
3198	data['RBIds']['Residue'].remove(rbid)
3199	wx.CallAfter(UpdateResidueRB)
3200
3201	def OnStripH(event):
3202	Obj = event.GetEventObject()
3203	rbid = Indx[Obj.GetId()]
3204	if rbid in data['Residue']:
3205	newNames = []
3206	newTypes = []
3207	newXYZ = []
3208	for i,atype in enumerate(rbData['rbTypes']):
3209	if atype != 'H':
3210	newNames.append(rbData['atNames'][i])
3211	newTypes.append(rbData['rbTypes'][i])
3212	newXYZ.append(rbData['rbXYZ'][i])
3213	rbData['atNames'] = newNames
3214	rbData['rbTypes'] = newTypes
3215	rbData['rbXYZ'] = newXYZ
3216	G2plt.PlotRigidBody(G2frame,'Residue',AtInfo,rbData,plotDefaults)
3217	wx.CallAfter(UpdateResidueRB)
3218
3219	def OnPlotRB(event):
3220	Obj = event.GetEventObject()
3221	G2plt.PlotRigidBody(G2frame,'Residue',AtInfo,rbData,plotDefaults)
3222
3223	# start of rbNameSizer
3224	nameSizer = wx.BoxSizer(wx.HORIZONTAL)
3225	nameSizer.Add(wx.StaticText(ResidueRBDisplay,-1,'Residue name: '),
3226	0,WACV)
3227	RBname = wx.TextCtrl(ResidueRBDisplay,-1,rbData['RBname'])
3228	RBname.Bind(wx.EVT_LEAVE_WINDOW, OnRBName)
3229	RBname.Bind(wx.EVT_TEXT_ENTER,OnRBName)
3230	RBname.Bind(wx.EVT_KILL_FOCUS,OnRBName)
3231	nameSizer.Add(RBname,0,WACV)
3232	nameSizer.Add((5,0),)
3233	plotRB = wx.Button(ResidueRBDisplay,wx.ID_ANY,'Plot',style=wx.BU_EXACTFIT)
3234	plotRB.Bind(wx.EVT_BUTTON, OnPlotRB)
3235	Indx[plotRB.GetId()] = rbid
3236	nameSizer.Add(plotRB,0,WACV)
3237	nameSizer.Add((5,0),)
3238	if not rbData['useCount']:
3239	delRB = wx.Button(ResidueRBDisplay,wx.ID_ANY,"Delete",
3240	style=wx.BU_EXACTFIT)
3241	delRB.Bind(wx.EVT_BUTTON, OnDelRB)
3242	Indx[delRB.GetId()] = rbid
3243	nameSizer.Add(delRB,0,WACV)
3244	if 'H' in rbData['rbTypes']:
3245	stripH = wx.Button(ResidueRBDisplay,wx.ID_ANY,
3246	"Strip H-atoms",
3247	style=wx.BU_EXACTFIT)
3248	stripH.Bind(wx.EVT_BUTTON, OnStripH)
3249	Indx[stripH.GetId()] = rbid
3250	nameSizer.Add(stripH,0,WACV)
3251	return nameSizer
3252
3253	def rbResidues(rbid,rbData):
3254
3255	def TypeSelect(event):
3256	AtInfo = data['Residue']['AtInfo']
3257	r,c = event.GetRow(),event.GetCol()
3258	if resGrid.GetColLabelValue(c) == 'Type':
3259	PE = G2elemGUI.PickElement(G2frame,oneOnly=True)
3260	if PE.ShowModal() == wx.ID_OK:
3261	if PE.Elem != 'None':
3262	El = PE.Elem.strip().lower().capitalize()
3263	if El not in AtInfo:
3264	Info = G2elem.GetAtomInfo(El)
3265	AtInfo[El] = [Info['Drad'],Info['Color']]
3266	rbData['rbTypes'][r] = El
3267	resGrid.SetCellValue(r,c,El)
3268	PE.Destroy()
3269
3270	def ChangeCell(event):
3271	r,c = event.GetRow(),event.GetCol()
3272	if c == 0:
3273	rbData['atNames'][r] = resGrid.GetCellValue(r,c)
3274	if r >= 0 and (2 <= c <= 4):
3275	try:
3276	val = float(resGrid.GetCellValue(r,c))
3277	rbData['rbXYZ'][r][c-2] = val
3278	except ValueError:
3279	pass
3280
3281	def OnRefSel(event):
3282	Obj = event.GetEventObject()
3283	iref,res,jref = Indx[Obj.GetId()]
3284	sel = Obj.GetValue()
3285	ind = atNames.index(sel)
3286	if rbData['rbTypes'][ind] == 'H':
3287	G2G.G2MessageBox(G2frame,'You should not select an H-atom for rigid body orientation')
3288	rbData['rbRef'][iref] = ind
3289	FillRefChoice(rbid,rbData)
3290	for i,ref in enumerate(RefObjs[jref]):
3291	ref.SetItems([atNames[j] for j in refChoice[rbid][i]])
3292	ref.SetValue(atNames[rbData['rbRef'][i]])
3293	rbXYZ = rbData['rbXYZ']
3294	if not iref: #origin change
3295	rbXYZ -= rbXYZ[ind]
3296	#TODO - transform all atom XYZ by axis choices
3297	Xxyz = rbXYZ[rbData['rbRef'][1]]
3298	X = Xxyz/np.sqrt(np.sum(Xxyz**2))
3299	Yxyz = rbXYZ[rbData['rbRef'][2]]
3300	Y = Yxyz/np.sqrt(np.sum(Yxyz**2))
3301	Mat = G2mth.getRBTransMat(X,Y)
3302	rbXYZ = np.inner(Mat,rbXYZ).T
3303	rbData['rbXYZ'] = rbXYZ
3304	rbData['molCent'] = False
3305	res.ClearSelection()
3306	resTable = res.GetTable()
3307	for r in range(res.GetNumberRows()):
3308	row = resTable.GetRowValues(r)
3309	row[2:4] = rbXYZ[r]
3310	resTable.SetRowValues(r,row)
3311	res.ForceRefresh()
3312	G2plt.PlotRigidBody(G2frame,'Residue',AtInfo,rbData,plotDefaults)
3313
3314	def OnMolCent(event):
3315	rbData['molCent'] = not rbData['molCent']
3316	if rbData['molCent']:
3317	Obj = event.GetEventObject()
3318	res = Indx[Obj.GetId()]
3319	rbXYZ = rbData['rbXYZ']
3320	rbCent = np.array([np.sum(rbXYZ[:,0]),np.sum(rbXYZ[:,1]),np.sum(rbXYZ[:,2])])/rbXYZ.shape[0]
3321	rbXYZ -= rbCent
3322	rbData['rbXYZ'] = rbXYZ
3323	res.ClearSelection()
3324	resTable = res.GetTable()
3325	for r in range(res.GetNumberRows()):
3326	row = resTable.GetRowValues(r)
3327	row[2:4] = rbXYZ[r]
3328	resTable.SetRowValues(r,row)
3329	res.ForceRefresh()
3330	G2plt.PlotRigidBody(G2frame,'Residue',AtInfo,rbData,plotDefaults)
3331
3332
3333	Types = 2[wg.GRID_VALUE_STRING,]+3[wg.GRID_VALUE_FLOAT+':10,5',]
3334	colLabels = ['Name','Type','Cart x','Cart y','Cart z']
3335	table = []
3336	rowLabels = []
3337	for ivec,xyz in enumerate(rbData['rbXYZ']):
3338	table.append([rbData['atNames'][ivec],]+[rbData['rbTypes'][ivec],]+list(xyz))
3339	rowLabels.append(str(ivec))
3340	vecTable = G2G.Table(table,rowLabels=rowLabels,colLabels=colLabels,types=Types)
3341	resGrid = G2G.GSGrid(ResidueRBDisplay)
3342	Indx[resGrid.GetId()] = rbid
3343	resList.append(resGrid)
3344	resGrid.SetTable(vecTable, True)
3345	if 'phoenix' in wx.version():
3346	resGrid.Bind(wg.EVT_GRID_CELL_CHANGED, ChangeCell)
3347	else:
3348	resGrid.Bind(wg.EVT_GRID_CELL_CHANGE, ChangeCell)
3349	resGrid.Bind(wg.EVT_GRID_CELL_LEFT_DCLICK, TypeSelect)
3350	for c in range(2,5):
3351	attr = wx.grid.GridCellAttr()
3352	attr.IncRef()
3353	attr.SetEditor(G2G.GridFractionEditor(resGrid))
3354	resGrid.SetColAttr(c, attr)
3355	for row in range(vecTable.GetNumberRows()):
3356	resGrid.SetReadOnly(row,1,True)
3357	resGrid.AutoSizeColumns(False)
3358	vecSizer = wx.BoxSizer()
3359	vecSizer.Add(resGrid)
3360
3361	refAtmSizer = wx.BoxSizer(wx.HORIZONTAL)
3362	atNames = rbData['atNames']
3363	rbRef = rbData['rbRef']
3364	if rbData['rbRef'][3] or rbData['useCount']:
3365	refAtmSizer.Add(wx.StaticText(ResidueRBDisplay,-1,
3366	'Orientation reference non-H atoms A-B-C: %s, %s, %s'%(atNames[rbRef[0]], \
3367	atNames[rbRef[1]],atNames[rbRef[2]])),0)
3368	else:
3369	refAtmSizer.Add(wx.StaticText(ResidueRBDisplay,-1,
3370	'Orientation reference non-H atoms A-B-C: '),0,WACV)
3371	refObj = [0,0,0]
3372	for i in range(3):
3373	choices = [atNames[j] for j in refChoice[rbid][i]]
3374	refSel = wx.ComboBox(ResidueRBDisplay,-1,value='',
3375	choices=choices,style=wx.CB_READONLY\|wx.CB_DROPDOWN)
3376	refSel.SetValue(atNames[rbRef[i]])
3377	refSel.Bind(wx.EVT_COMBOBOX, OnRefSel)
3378	Indx[refSel.GetId()] = [i,resGrid,len(RefObjs)]
3379	refObj[i] = refSel
3380	refAtmSizer.Add(refSel,0,WACV)
3381	RefObjs.append(refObj)
3382	if 'molCent' not in rbData: rbData['molCent'] = False #patch
3383	molcent = wx.Button(ResidueRBDisplay,label=' Center RB?')
3384	molcent.Bind(wx.EVT_BUTTON,OnMolCent)
3385	Indx[molcent.GetId()] = resGrid
3386	refAtmSizer.Add(molcent,0,WACV)
3387	refHelpInfo = '''
3388	* The "Orientation Reference" control is used to tranform
3389	the Cartesian
3390	axes for rigid bodies with three atoms, A, B and C.
3391	The vector from A to B defines the x-axis and the y axis is placed
3392	in the plane defined by A to B and A to C.
3393
3394	%%* The "Center RB?" button will redefine the origin of the
3395	rigid body to the midpoint of all atoms in the body (not mass weighted)
3396	'''
3397	hlp = G2G.HelpButton(ResidueRBDisplay,refHelpInfo,wrap=400)
3398	refAtmSizer.Add(hlp,0,wx.LEFT\|wx.RIGHT\|wx.ALIGN_CENTER_VERTICAL,2)
3399
3400	mainSizer = wx.BoxSizer(wx.VERTICAL)
3401	mainSizer.Add(refAtmSizer)
3402	mainSizer.Add(vecSizer)
3403	return mainSizer
3404
3405	def Add2SeqSizer(seqSizer,angSlide,rbid,iSeq,Seq,atNames):
3406
3407	def ChangeAngle(event):
3408	event.Skip()
3409	Obj = event.GetEventObject()
3410	rbid,Seq = Indx[Obj.GetId()][:2]
3411	val = Seq[2]
3412	try:
3413	val = float(Obj.GetValue())
3414	Seq[2] = val
3415	except ValueError:
3416	pass
3417	Obj.SetValue('%8.2f'%(val))
3418	G2plt.PlotRigidBody(G2frame,'Residue',AtInfo,data['Residue'][rbid],plotDefaults)
3419
3420	def OnRadBtn(event):
3421	Obj = event.GetEventObject()
3422	Seq,iSeq,angId = Indx[Obj.GetId()]
3423	data['Residue'][rbid]['SelSeq'] = [iSeq,angId]
3424	angSlide.SetValue(int(100*Seq[2]))
3425
3426	def OnDelBtn(event):
3427	Obj = event.GetEventObject()
3428	rbid,Seq = Indx[Obj.GetId()]
3429	data['Residue'][rbid]['rbSeq'].remove(Seq)
3430	wx.CallAfter(UpdateResidueRB)
3431
3432	iBeg,iFin,angle,iMove = Seq
3433	ang = wx.TextCtrl(ResidueRBDisplay,wx.ID_ANY,
3434	'%8.2f'%(angle),size=(70,-1),style=wx.TE_PROCESS_ENTER)
3435	if not iSeq:
3436	radBt = wx.RadioButton(ResidueRBDisplay,wx.ID_ANY,
3437	'',style=wx.RB_GROUP)
3438	data['Residue'][rbid]['SelSeq'] = [iSeq,ang.GetId()]
3439	radBt.SetValue(True)
3440	else:
3441	radBt = wx.RadioButton(ResidueRBDisplay,wx.ID_ANY,'')
3442	radBt.Bind(wx.EVT_RADIOBUTTON,OnRadBtn)
3443	seqSizer.Add(radBt)
3444	delBt = wx.Button(ResidueRBDisplay,wx.ID_ANY,'Del',
3445	style=wx.BU_EXACTFIT)
3446	delBt.Bind(wx.EVT_BUTTON,OnDelBtn)
3447	seqSizer.Add(delBt)
3448	bond = wx.StaticText(ResidueRBDisplay,wx.ID_ANY,
3449	'%s %s'%(atNames[iBeg],atNames[iFin]),size=(50,20))
3450	seqSizer.Add(bond,0,WACV)
3451	Indx[radBt.GetId()] = [Seq,iSeq,ang.GetId()]
3452	Indx[delBt.GetId()] = [rbid,Seq]
3453	Indx[ang.GetId()] = [rbid,Seq,ang]
3454	ang.Bind(wx.EVT_TEXT_ENTER,ChangeAngle)
3455	ang.Bind(wx.EVT_KILL_FOCUS,ChangeAngle)
3456	seqSizer.Add(ang,0,WACV)
3457	atms = ''
3458	for i in iMove:
3459	atms += ' %s,'%(atNames[i])
3460	moves = wx.StaticText(ResidueRBDisplay,wx.ID_ANY,
3461	atms[:-1],size=(200,20))
3462	seqSizer.Add(moves,1,WACV\|wx.EXPAND\|wx.RIGHT)
3463	return seqSizer
3464
3465	def SlideSizer():
3466
3467	def OnSlider(event):
3468	Obj = event.GetEventObject()
3469	rbData = Indx[Obj.GetId()]
3470	iSeq,angId = rbData['SelSeq']
3471	val = float(Obj.GetValue())/100.
3472	rbData['rbSeq'][iSeq][2] = val
3473	Indx[angId][2].SetValue('%8.2f'%(val))
3474	G2plt.PlotRigidBody(G2frame,'Residue',AtInfo,rbData,plotDefaults)
3475
3476	slideSizer = wx.BoxSizer(wx.HORIZONTAL)
3477	slideSizer.Add(wx.StaticText(ResidueRBDisplay,-1,'Selected torsion angle:'),0)
3478	iSeq,angId = rbData['SelSeq']
3479	angSlide = wx.Slider(ResidueRBDisplay,-1,
3480	int(100*rbData['rbSeq'][iSeq][2]),0,36000,size=(200,20),
3481	style=wx.SL_HORIZONTAL)
3482	angSlide.Bind(wx.EVT_SLIDER, OnSlider)
3483	Indx[angSlide.GetId()] = rbData
3484	slideSizer.Add(angSlide,0)
3485	return slideSizer,angSlide
3486
3487	def FillRefChoice(rbid,rbData):
3488	choiceIds = [i for i in range(len(rbData['atNames']))]
3489	for seq in rbData['rbSeq']:
3490	for i in seq[3]:
3491	try:
3492	choiceIds.remove(i)
3493	except ValueError:
3494	pass
3495	rbRef = rbData['rbRef']
3496	for i in range(3):
3497	try:
3498	choiceIds.remove(rbRef[i])
3499	except ValueError:
3500	pass
3501	refChoice[rbid] = [choiceIds[:],choiceIds[:],choiceIds[:]]
3502	for i in range(3):
3503	refChoice[rbid][i].append(rbRef[i])
3504	refChoice[rbid][i].sort()
3505
3506	def OnRBSelect(event):
3507	global resRBsel
3508	sel = rbSelect.GetSelection()
3509	if sel == 0: return # 1st entry is blank
3510	rbname = rbchoice[sel-1]
3511	resRBsel = RBnames[rbname]
3512	wx.CallLater(100,UpdateResidueRB)
3513
3514	#----- beginning of UpdateResidueRB -----------------------------------------------
3515	AtInfo = data['Residue']['AtInfo']
3516	refChoice = {}
3517	RefObjs = []
3518
3519	GS = ResidueRBDisplay.GetSizer()
3520	if GS:
3521	try: #get around a c++ error in wx 4.0; doing is again seems to be OK
3522	GS.Clear(True)
3523	except:
3524	GS.Clear(True)
3525
3526	RBnames = {}
3527	for rbid in data['RBIds']['Residue']:
3528	RBnames.update({data['Residue'][rbid]['RBname']:rbid,})
3529	if not RBnames:
3530	return
3531	rbchoice = list(RBnames.keys())
3532	rbchoice.sort()
3533	if GS:
3534	ResidueRBSizer = GS
3535	else:
3536	ResidueRBSizer = wx.BoxSizer(wx.VERTICAL)
3537	if resRBsel not in data['RBIds']['Residue']:
3538	resRBsel = RBnames[rbchoice[0]]
3539	if len(RBnames) > 1:
3540	selSizer = wx.BoxSizer(wx.HORIZONTAL)
3541	selSizer.Add(wx.StaticText(ResidueRBDisplay,
3542	label=' Select residue to view:'),0)
3543	rbSelect = wx.ComboBox(ResidueRBDisplay,choices=['']+rbchoice)
3544	name = data['Residue'][resRBsel]['RBname']
3545	rbSelect.SetSelection(1+rbchoice.index(name))
3546	rbSelect.Bind(wx.EVT_COMBOBOX,OnRBSelect)
3547	selSizer.Add(rbSelect,0)
3548	ResidueRBSizer.Add(selSizer,0)
3549	rbData = data['Residue'][resRBsel]
3550	FillRefChoice(resRBsel,rbData)
3551	ResidueRBSizer.Add(rbNameSizer(resRBsel,rbData),0)
3552	ResidueRBSizer.Add(rbResidues(resRBsel,rbData),0)
3553	if len(rbData['rbSeq']):
3554	ResidueRBSizer.Add((-1,15),0)
3555	slideSizer,angSlide = SlideSizer()
3556	seqSizer = wx.FlexGridSizer(0,5,4,8)
3557	for lbl in 'Sel','','Bond','Angle','Riding atoms':
3558	seqSizer.Add(wx.StaticText(ResidueRBDisplay,wx.ID_ANY,lbl))
3559	ResidueRBSizer.Add(seqSizer)
3560	# for iSeq,Seq in enumerate(rbData['rbSeq']):
3561	# ResidueRBSizer.Add(SeqSizer(angSlide,resRBsel,iSeq,Seq,rbData['atNames']))
3562	for iSeq,Seq in enumerate(rbData['rbSeq']):
3563	Add2SeqSizer(seqSizer,angSlide,resRBsel,iSeq,Seq,rbData['atNames'])
3564	ResidueRBSizer.Add(slideSizer,)
3565
3566	ResidueRBSizer.Add((5,25),)
3567	ResidueRBSizer.Layout()
3568	ResidueRBDisplay.SetSizer(ResidueRBSizer,True)
3569	ResidueRBDisplay.SetAutoLayout(True)
3570	Size = ResidueRBSizer.GetMinSize()
3571	ResidueRBDisplay.SetSize(Size)
3572
3573	Size[0] += 40
3574	Size[1] = max(Size[1],450) + 20
3575	ResidueRB.SetSize(Size)
3576	ResidueRB.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
3577	G2frame.dataWindow.SendSizeEvent()
3578
3579	ResidueRBDisplay.Show()
3580
3581	def SetStatusLine(text):
3582	G2frame.GetStatusBar().SetStatusText(text,1)
3583
3584	G2gd.SetDataMenuBar(G2frame,G2frame.dataWindow.RigidBodyMenu)
3585	SetStatusLine('')
3586	UpdateVectorRB()
3587	G2frame.rbBook.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, OnPageChanged)
3588	wx.CallAfter(OnPageChanged,None)
3589
3590	def ShowIsoDistortCalc(G2frame,phase=None):
3591	'''Compute the ISODISTORT mode values from the current coordinates.
3592	Called in response to the (Phase/Atoms tab) AtomCompute or
3593	Constraints/Edit Constr. "Show ISODISTORT modes" menu item, which
3594	should be enabled only when Phase['ISODISTORT'] is defined.
3595	'''
3596	def _onClose(event):
3597	dlg.EndModal(wx.ID_CANCEL)
3598	def fmtHelp(item,fullname):
3599	helptext = "A new variable"
3600	if item[-3]:
3601	helptext += " named "+str(item[-3])
3602	helptext += " is a linear combination of the following parameters:\n"
3603	first = True
3604	for term in item[:-3]:
3605	line = ''
3606	var = str(term[1])
3607	m = term[0]
3608	if first:
3609	first = False
3610	line += ' = '
3611	else:
3612	if m >= 0:
3613	line += ' + '
3614	else:
3615	line += ' - '
3616	m = abs(m)
3617	line += '%.3f*%s '%(m,var)
3618	varMean = G2obj.fmtVarDescr(var)
3619	helptext += "\n" + line + " ("+ varMean + ")"
3620	helptext += '\n\nISODISTORT full name: '+str(fullname)
3621	return helptext
3622
3623	Histograms,Phases = G2frame.GetUsedHistogramsAndPhasesfromTree() # init for constraint
3624	isophases = [p for p in Phases if 'ISODISTORT' in Phases[p]]
3625
3626	if not isophases:
3627	G2frame.ErrorDialog('no ISODISTORT phases',
3628	'Unexpected error: no ISODISTORT phases')
3629	return
3630	if phase and phase not in isophases:
3631	G2frame.ErrorDialog('not ISODISTORT phase',
3632	'Unexpected error: selected phase is not an ISODISTORT phase')
3633	print('Unexpected error: selected phase is not an ISODISTORT phase',
3634	phase,isophases)
3635	elif not phase and len(isophases) == 1:
3636	phase = isophases[0]
3637	elif not phase:
3638	dlg = wx.SingleChoiceDialog(G2frame,'Select phase from ISODISTORT phases',
3639	'Select Phase',isophases)
3640	if dlg.ShowModal() == wx.ID_OK:
3641	sel = dlg.GetSelection()
3642	phase = isophases[sel]
3643	else:
3644	return
3645	# if len(data.get('Histograms',[])) == 0:
3646	# G2frame.ErrorDialog(
3647	# 'No data',
3648	# 'Sorry, this computation requires that a histogram first be added to the phase'
3649	# )
3650	# return
3651
3652	covdata = G2frame.GPXtree.GetItemPyData(
3653	G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Covariance'))
3654	# make a lookup table for named NewVar Phase constraints
3655	sub = G2gd.GetGPXtreeItemId(G2frame,G2frame.root,'Constraints')
3656	Constraints = G2frame.GPXtree.GetItemPyData(sub)
3657	constDict = {}
3658	for c in Constraints['Phase']:
3659	if c[-1] != 'f' or not c[-3]: continue
3660	constDict[str(c[-3])] = c
3661
3662	parmDict,varyList = G2frame.MakeLSParmDict()
3663
3664	dlg = wx.Dialog(G2frame,wx.ID_ANY,'ISODISTORT mode values',#size=(630,400),
3665	style=wx.DEFAULT_DIALOG_STYLE\|wx.RESIZE_BORDER)
3666	mainSizer = wx.BoxSizer(wx.VERTICAL)
3667	if 'ISODISTORT' not in Phases[phase]:
3668	G2frame.ErrorDialog('not ISODISTORT phase',
3669	'Unexpected error: selected phase is not an ISODISTORT phase')
3670	return
3671	data = Phases[phase]
3672	ISO = data['ISODISTORT']
3673	mainSizer.Add(wx.StaticText(dlg,wx.ID_ANY,
3674	'ISODISTORT mode computation for cordinates in phase '+
3675	str(data['General'].get('Name'))))
3676	aSizer = wx.BoxSizer(wx.HORIZONTAL)
3677	panel1 = wxscroll.ScrolledPanel(
3678	dlg, wx.ID_ANY,#size=(100,200),
3679	style = wx.TAB_TRAVERSAL\|wx.SUNKEN_BORDER)
3680	subSizer1 = wx.FlexGridSizer(cols=2,hgap=5,vgap=2)
3681	panel2 = wxscroll.ScrolledPanel(
3682	dlg, wx.ID_ANY,#size=(100,200),
3683	style = wx.TAB_TRAVERSAL\|wx.SUNKEN_BORDER)
3684	subSizer2 = wx.FlexGridSizer(cols=3,hgap=5,vgap=2)
3685	subSizer1.Add(wx.StaticText(panel1,wx.ID_ANY,'Parameter name '))
3686	subSizer1.Add(wx.StaticText(panel1,wx.ID_ANY,' value'),0,wx.ALIGN_RIGHT)
3687	subSizer2.Add((-1,-1))
3688	subSizer2.Add(wx.StaticText(panel2,wx.ID_ANY,'Mode name '))
3689	subSizer2.Add(wx.StaticText(panel2,wx.ID_ANY,' value'),0,wx.ALIGN_RIGHT)
3690	# ISODISTORT displacive modes
3691	if 'G2VarList' in ISO:
3692	deltaList = []
3693	for gv,Ilbl in zip(ISO['G2VarList'],ISO['IsoVarList']):
3694	dvar = gv.varname()
3695	var = dvar.replace('::dA','::A')
3696	albl = Ilbl[:Ilbl.rfind('_')]
3697	v = Ilbl[Ilbl.rfind('_')+1:]
3698	pval = ISO['ParentStructure'][albl][['dx','dy','dz'].index(v)]
3699	if var in parmDict:
3700	cval = parmDict[var][0]
3701	else:
3702	dlg.EndModal(wx.ID_CANCEL)
3703	G2frame.ErrorDialog('Atom not found',"No value found for parameter "+str(var))
3704	return
3705	deltaList.append(cval-pval)
3706	modeVals = np.inner(ISO['Var2ModeMatrix'],deltaList)
3707	for lbl,xyz,var,val,norm,G2mode in zip(
3708	ISO['IsoVarList'],deltaList,
3709	ISO['IsoModeList'],modeVals,ISO['NormList'],ISO['G2ModeList'] ):
3710	#GSASIIpath.IPyBreak()
3711	if str(G2mode) in constDict:
3712	ch = G2G.HelpButton(panel2,fmtHelp(constDict[str(G2mode)],var))
3713	subSizer2.Add(ch,0,wx.LEFT\|wx.RIGHT\|WACV\|wx.ALIGN_CENTER,1)
3714	else:
3715	subSizer2.Add((-1,-1))
3716	subSizer1.Add(wx.StaticText(panel1,wx.ID_ANY,str(lbl)))
3717	try:
3718	value = G2py3.FormatSigFigs(xyz)
3719	except TypeError:
3720	value = str(xyz)
3721	subSizer1.Add(wx.StaticText(panel1,wx.ID_ANY,value),0,wx.ALIGN_RIGHT)
3722	subSizer2.Add(wx.StaticText(panel2,wx.ID_ANY,str(var)))
3723	try:
3724	value = G2py3.FormatSigFigs(val/norm)
3725	if 'varyList' in covdata:
3726	if str(G2mode) in covdata['varyList']:
3727	sig = covdata['sig'][covdata['varyList'].index(str(G2mode))]
3728	value = G2mth.ValEsd(val/norm,sig/norm)
3729	except TypeError:
3730	value = '?'
3731	subSizer2.Add(wx.StaticText(panel2,wx.ID_ANY,value),0,wx.ALIGN_RIGHT)
3732	#GSASIIpath.IPyBreak()
3733	# ISODISTORT occupancy modes
3734	if 'G2OccVarList' in ISO:
3735	deltaList = []
3736	for gv,Ilbl in zip(ISO['G2OccVarList'],ISO['OccVarList']):
3737	var = gv.varname()
3738	albl = Ilbl[:Ilbl.rfind('_')]
3739	pval = ISO['BaseOcc'][albl]
3740	if var in parmDict:
3741	cval = parmDict[var][0]
3742	else:
3743	dlg.EndModal(wx.ID_CANCEL)
3744	G2frame.ErrorDialog('Atom not found',"No value found for parameter "+str(var))
3745	return
3746	deltaList.append(cval-pval)
3747	modeVals = np.inner(ISO['Var2OccMatrix'],deltaList)
3748	for lbl,delocc,var,val,norm,G2mode in zip(
3749	ISO['OccVarList'],deltaList,
3750	ISO['OccModeList'],modeVals,ISO['OccNormList'],ISO['G2OccModeList']):
3751	if str(G2mode) in constDict:
3752	ch = G2G.HelpButton(panel2,fmtHelp(constDict[str(G2mode)],var))
3753	subSizer2.Add(ch,0,wx.LEFT\|wx.RIGHT\|WACV\|wx.ALIGN_CENTER,1)
3754	else:
3755	subSizer2.Add((-1,-1))
3756	subSizer1.Add(wx.StaticText(panel1,wx.ID_ANY,str(lbl)))
3757	try:
3758	value = G2py3.FormatSigFigs(delocc)
3759	except TypeError:
3760	value = str(delocc)
3761	subSizer1.Add(wx.StaticText(panel1,wx.ID_ANY,value),0,wx.ALIGN_RIGHT)
3762	#subSizer.Add((10,-1))
3763	subSizer2.Add(wx.StaticText(panel2,wx.ID_ANY,str(var)))
3764	try:
3765	value = G2py3.FormatSigFigs(val/norm)
3766	if 'varyList' in covdata:
3767	if str(G2mode) in covdata['varyList']:
3768	sig = covdata['sig'][covdata['varyList'].index(str(G2mode))]
3769	value = G2mth.ValEsd(val/norm,sig/norm)
3770	except TypeError:
3771	value = '?'
3772	subSizer2.Add(wx.StaticText(panel2,wx.ID_ANY,value),0,wx.ALIGN_RIGHT)
3773
3774	# finish up ScrolledPanel
3775	panel1.SetSizer(subSizer1)
3776	panel2.SetSizer(subSizer2)
3777	panel1.SetAutoLayout(1)
3778	panel1.SetupScrolling()
3779	panel2.SetAutoLayout(1)
3780	panel2.SetupScrolling()
3781	# Allow window to be enlarged but not made smaller
3782	dlg.SetSizer(mainSizer)
3783	w1,l1 = subSizer1.GetSize()
3784	w2,l2 = subSizer2.GetSize()
3785	panel1.SetMinSize((w1+10,200))
3786	panel2.SetMinSize((w2+20,200))
3787	aSizer.Add(panel1,1, wx.ALL\|wx.EXPAND,1)
3788	aSizer.Add(panel2,2, wx.ALL\|wx.EXPAND,1)
3789	mainSizer.Add(aSizer,1, wx.ALL\|wx.EXPAND,1)
3790
3791	# make OK button
3792	btnsizer = wx.BoxSizer(wx.HORIZONTAL)
3793	btn = wx.Button(dlg, wx.ID_CLOSE)
3794	btn.Bind(wx.EVT_BUTTON,_onClose)
3795	btnsizer.Add(btn)
3796	mainSizer.Add(btnsizer, 0, wx.ALIGN_CENTER\|wx.ALL, 5)
3797
3798	mainSizer.Fit(dlg)
3799	dlg.SetMinSize(dlg.GetSize())
3800	dlg.ShowModal()
3801	dlg.Destroy()

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

Download in other formats: