Context Navigation

source: trunk/exports/G2export_CIF.py @ 3793

Last change on this file since 3793 was 3793, checked in by toby, 4 years ago
add density to CIF
Property svn:eol-style set to `native` Property svn:keywords set to `Date Author Revision URL Id`
File size: 144.6 KB

Line
1	#!/usr/bin/env python
2	# -- coding: utf-8 --
3	########### SVN repository information ###################
4	# $Date: 2019-01-22 20:05:27 +0000 (Tue, 22 Jan 2019) $
5	# $Author: toby $
6	# $Revision: 3793 $
7	# $URL: trunk/exports/G2export_CIF.py $
8	# $Id: G2export_CIF.py 3793 2019-01-22 20:05:27Z toby $
9	########### SVN repository information ###################
10	'''
11	Module G2export_CIF: CIF Exports
12	------------------------------------------------------
13
14	This implements a complex exporter :class:`ExportCIF` that can implement an
15	entire project in a complete CIF intended for submission as a
16	publication. In addition, there are three subclasses of :class:`ExportCIF`:
17	:class:`ExportProjectCIF`,
18	:class:`ExportPhaseCIF` and :class:`ExportDataCIF` where extra parameters
19	for the _Exporter() determine if a project, single phase or data set are written.
20	'''
21
22	from __future__ import division, print_function
23	import platform
24	import datetime as dt
25	import os.path
26	import sys
27	import numpy as np
28	if '2' in platform.python_version_tuple()[0]:
29	import cPickle as pickle
30	else:
31	import pickle
32	import copy
33	import re
34	try:
35	import wx
36	import wx.lib.scrolledpanel as wxscroll
37	import wx.lib.resizewidget as rw
38	except ImportError:
39	# Avoid wx dependency for CLI
40	class Placeholder(object):
41	def __init__(self):
42	self.BoxSizer = object
43	self.Button = object
44	self.Dialog = object
45	self.ScrolledPanel = object
46	wx = Placeholder()
47	wxscroll = Placeholder()
48	import GSASIIpath
49	GSASIIpath.SetVersionNumber("$Revision: 3793 $")
50	import GSASIIIO as G2IO
51	try:
52	import GSASIIctrlGUI as G2G
53	except ImportError:
54	pass
55	import GSASIIobj as G2obj
56	import GSASIImath as G2mth
57	import GSASIIspc as G2spc
58	import GSASIIstrMain as G2stMn
59	import GSASIImapvars as G2mv
60
61	DEBUG = False #True to skip printing of reflection/powder profile lists
62
63	CIFdic = None
64
65	# Refactored over here to allow access by GSASIIscriptable.py
66	def WriteCIFitem(fp, name, value=''):
67	'''Helper function for writing CIF output. Translated from exports/G2export_CIF.py'''
68	# Ignore unicode issues
69	if value:
70	if "\n" in value or len(value)> 70:
71	if name.strip():
72	fp.write(name+'\n')
73	fp.write('; '+value+'\n')
74	fp.write('; '+'\n')
75	elif " " in value:
76	if len(name)+len(value) > 65:
77	fp.write(name + '\n ' + '"' + str(value) + '"'+'\n')
78	else:
79	fp.write(name + ' ' + '"' + str(value) + '"'+'\n')
80	else:
81	if len(name)+len(value) > 65:
82	fp.write(name+'\n ' + value+'\n')
83	else:
84	fp.write(name+' ' + value+'\n')
85	else:
86	fp.write(name+'\n')
87
88
89	# Refactored over here to allow access by GSASIIscriptable.py
90	def WriteAtomsNuclear(fp, phasedict, phasenam, parmDict, sigDict, labellist):
91	'Write atom positions to CIF'
92	# phasedict = self.Phases[phasenam] # pointer to current phase info
93	General = phasedict['General']
94	cx,ct,cs,cia = General['AtomPtrs']
95	Atoms = phasedict['Atoms']
96	cfrac = cx+3
97	fpfx = str(phasedict['pId'])+'::Afrac:'
98	for i,at in enumerate(Atoms):
99	fval = parmDict.get(fpfx+str(i),at[cfrac])
100	if fval != 0.0:
101	break
102	else:
103	WriteCIFitem(fp, '\n# PHASE HAS NO ATOMS!')
104	return
105
106	WriteCIFitem(fp, '\n# ATOMIC COORDINATES AND DISPLACEMENT PARAMETERS')
107	WriteCIFitem(fp, 'loop_ '+
108	'\n _atom_site_label'+
109	'\n _atom_site_type_symbol'+
110	'\n _atom_site_fract_x'+
111	'\n _atom_site_fract_y'+
112	'\n _atom_site_fract_z'+
113	'\n _atom_site_occupancy'+
114	'\n _atom_site_adp_type'+
115	'\n _atom_site_U_iso_or_equiv'+
116	'\n _atom_site_symmetry_multiplicity')
117
118	varnames = {cx:'Ax',cx+1:'Ay',cx+2:'Az',cx+3:'Afrac',
119	cia+1:'AUiso',cia+2:'AU11',cia+3:'AU22',cia+4:'AU33',
120	cia+5:'AU12',cia+6:'AU13',cia+7:'AU23'}
121	# Empty the labellist
122	while labellist:
123	labellist.pop()
124
125	pfx = str(phasedict['pId'])+'::'
126	# loop over all atoms
127	naniso = 0
128	for i,at in enumerate(Atoms):
129	if phasedict['General']['Type'] == 'macromolecular':
130	label = '%s_%s_%s_%s'%(at[ct-1],at[ct-3],at[ct-4],at[ct-2])
131	s = PutInCol(MakeUniqueLabel(label,labellist),15) # label
132	else:
133	s = PutInCol(MakeUniqueLabel(at[ct-1],labellist),6) # label
134	fval = parmDict.get(fpfx+str(i),at[cfrac])
135	if fval == 0.0: continue # ignore any atoms that have a occupancy set to 0 (exact)
136	s += PutInCol(FmtAtomType(at[ct]),4) # type
137	if at[cia] == 'I':
138	adp = 'Uiso '
139	else:
140	adp = 'Uani '
141	naniso += 1
142	# compute Uequiv crudely
143	# correct: Defined as "1/3 trace of diagonalized U matrix".
144	# SEE cell2GS & Uij2Ueqv to GSASIIlattice. Former is needed to make the GS matrix used by the latter.
145	t = 0.0
146	for j in (2,3,4):
147	var = pfx+varnames[cia+j]+":"+str(i)
148	t += parmDict.get(var,at[cia+j])
149	for j in (cx,cx+1,cx+2,cx+3,cia,cia+1):
150	if j in (cx,cx+1,cx+2):
151	dig = 11
152	sigdig = -0.00009
153	else:
154	dig = 10
155	sigdig = -0.009
156	if j == cia:
157	s += adp
158	else:
159	var = pfx+varnames[j]+":"+str(i)
160	dvar = pfx+"d"+varnames[j]+":"+str(i)
161	if dvar not in sigDict:
162	dvar = var
163	if j == cia+1 and adp == 'Uani ':
164	val = t/3.
165	sig = sigdig
166	else:
167	#print var,(var in parmDict),(var in sigDict)
168	val = parmDict.get(var,at[j])
169	sig = sigDict.get(dvar,sigdig)
170	if dvar in G2mv.GetDependentVars(): # do not include an esd for dependent vars
171	sig = -abs(sig)
172	s += PutInCol(G2mth.ValEsd(val,sig),dig)
173	s += PutInCol(at[cs+1],3)
174	WriteCIFitem(fp, s)
175	if naniso == 0: return
176	# now loop over aniso atoms
177	WriteCIFitem(fp, '\nloop_' + '\n _atom_site_aniso_label' +
178	'\n _atom_site_aniso_U_11' + '\n _atom_site_aniso_U_22' +
179	'\n _atom_site_aniso_U_33' + '\n _atom_site_aniso_U_12' +
180	'\n _atom_site_aniso_U_13' + '\n _atom_site_aniso_U_23')
181	for i,at in enumerate(Atoms):
182	fval = parmDict.get(fpfx+str(i),at[cfrac])
183	if fval == 0.0: continue # ignore any atoms that have a occupancy set to 0 (exact)
184	if at[cia] == 'I': continue
185	s = PutInCol(labellist[i],6) # label
186	for j in (2,3,4,5,6,7):
187	sigdig = -0.0009
188	var = pfx+varnames[cia+j]+":"+str(i)
189	val = parmDict.get(var,at[cia+j])
190	sig = sigDict.get(var,sigdig)
191	s += PutInCol(G2mth.ValEsd(val,sig),11)
192	WriteCIFitem(fp, s)
193
194	def WriteAtomsMagnetic(fp, phasedict, phasenam, parmDict, sigDict, labellist):
195	'Write atom positions to CIF'
196	# phasedict = self.Phases[phasenam] # pointer to current phase info
197	General = phasedict['General']
198	cx,ct,cs,cia = General['AtomPtrs']
199	Atoms = phasedict['Atoms']
200	cfrac = cx+3
201	fpfx = str(phasedict['pId'])+'::Afrac:'
202	for i,at in enumerate(Atoms):
203	fval = parmDict.get(fpfx+str(i),at[cfrac])
204	if fval != 0.0:
205	break
206	else:
207	WriteCIFitem(fp, '\n# PHASE HAS NO ATOMS!')
208	return
209
210	WriteCIFitem(fp, '\n# ATOMIC COORDINATES AND DISPLACEMENT PARAMETERS')
211	WriteCIFitem(fp, 'loop_ '+
212	'\n _atom_site_label'+
213	'\n _atom_site_type_symbol'+
214	'\n _atom_site_fract_x'+
215	'\n _atom_site_fract_y'+
216	'\n _atom_site_fract_z'+
217	'\n _atom_site_occupancy'+
218	'\n _atom_site_adp_type'+
219	'\n _atom_site_U_iso_or_equiv'+
220	'\n _atom_site_symmetry_multiplicity')
221
222	varnames = {cx:'Ax',cx+1:'Ay',cx+2:'Az',cx+3:'Afrac',
223	cx+4:'AMx',cx+5:'AMy',cx+6:'AMz',
224	cia+1:'AUiso',cia+2:'AU11',cia+3:'AU22',cia+4:'AU33',
225	cia+5:'AU12',cia+6:'AU13',cia+7:'AU23'}
226	# Empty the labellist
227	while labellist:
228	labellist.pop()
229
230	pfx = str(phasedict['pId'])+'::'
231	# loop over all atoms
232	naniso = 0
233	for i,at in enumerate(Atoms):
234	if phasedict['General']['Type'] == 'macromolecular':
235	label = '%s_%s_%s_%s'%(at[ct-1],at[ct-3],at[ct-4],at[ct-2])
236	s = PutInCol(MakeUniqueLabel(label,labellist),15) # label
237	else:
238	s = PutInCol(MakeUniqueLabel(at[ct-1],labellist),6) # label
239	fval = parmDict.get(fpfx+str(i),at[cfrac])
240	if fval == 0.0: continue # ignore any atoms that have a occupancy set to 0 (exact)
241	s += PutInCol(FmtAtomType(at[ct]),4) # type
242	if at[cia] == 'I':
243	adp = 'Uiso '
244	else:
245	adp = 'Uani '
246	naniso += 1
247	# compute Uequiv crudely
248	# correct: Defined as "1/3 trace of diagonalized U matrix".
249	# SEE cell2GS & Uij2Ueqv to GSASIIlattice. Former is needed to make the GS matrix used by the latter.
250	t = 0.0
251	for j in (2,3,4):
252	var = pfx+varnames[cia+j]+":"+str(i)
253	t += parmDict.get(var,at[cia+j])
254	for j in (cx,cx+1,cx+2,cx+3,cia,cia+1):
255	if j in (cx,cx+1,cx+2):
256	dig = 11
257	sigdig = -0.00009
258	else:
259	dig = 10
260	sigdig = -0.009
261	if j == cia:
262	s += adp
263	else:
264	var = pfx+varnames[j]+":"+str(i)
265	dvar = pfx+"d"+varnames[j]+":"+str(i)
266	if dvar not in sigDict:
267	dvar = var
268	if j == cia+1 and adp == 'Uani ':
269	val = t/3.
270	sig = sigdig
271	else:
272	#print var,(var in parmDict),(var in sigDict)
273	val = parmDict.get(var,at[j])
274	sig = sigDict.get(dvar,sigdig)
275	if dvar in G2mv.GetDependentVars(): # do not include an esd for dependent vars
276	sig = -abs(sig)
277	s += PutInCol(G2mth.ValEsd(val,sig),dig)
278	s += PutInCol(at[cs+1],3)
279	WriteCIFitem(fp, s)
280	if naniso:
281	# now loop over aniso atoms
282	WriteCIFitem(fp, '\nloop_' + '\n _atom_site_aniso_label' +
283	'\n _atom_site_aniso_U_11' + '\n _atom_site_aniso_U_22' +
284	'\n _atom_site_aniso_U_33' + '\n _atom_site_aniso_U_12' +
285	'\n _atom_site_aniso_U_13' + '\n _atom_site_aniso_U_23')
286	for i,at in enumerate(Atoms):
287	fval = parmDict.get(fpfx+str(i),at[cfrac])
288	if fval == 0.0: continue # ignore any atoms that have a occupancy set to 0 (exact)
289	if at[cia] == 'I': continue
290	s = PutInCol(labellist[i],6) # label
291	for j in (2,3,4,5,6,7):
292	sigdig = -0.0009
293	var = pfx+varnames[cia+j]+":"+str(i)
294	val = parmDict.get(var,at[cia+j])
295	sig = sigDict.get(var,sigdig)
296	s += PutInCol(G2mth.ValEsd(val,sig),11)
297	WriteCIFitem(fp, s)
298	# now loop over mag atoms (e.g. all of them)
299	WriteCIFitem(fp, '\nloop_' + '\n _atom_site_moment.label' +
300	'\n _atom_site_moment.crystalaxis_x' +
301	'\n _atom_site_moment.crystalaxis_y' +
302	'\n _atom_site_moment.crystalaxis_z')
303	for i,at in enumerate(Atoms):
304	fval = parmDict.get(fpfx+str(i),at[cfrac])
305	if fval == 0.0: continue # ignore any atoms that have a occupancy set to 0 (exact)
306	s = PutInCol(labellist[i],6) # label
307	for j in (cx+4,cx+5,cx+6):
308	sigdig = -0.0009
309	var = pfx+varnames[j]+":"+str(i)
310	val = parmDict.get(var,at[j])
311	sig = sigDict.get(var,sigdig)
312	s += PutInCol(G2mth.ValEsd(val,sig),11)
313	WriteCIFitem(fp, s)
314
315	# Refactored over here to allow access by GSASIIscriptable.py
316	def MakeUniqueLabel(lbl, labellist):
317	lbl = lbl.strip()
318	if not lbl: # deal with a blank label
319	lbl = 'A_1'
320	if lbl not in labellist:
321	labellist.append(lbl)
322	return lbl
323	i = 1
324	prefix = lbl
325	if '_' in lbl:
326	prefix = lbl[:lbl.rfind('_')]
327	suffix = lbl[lbl.rfind('_')+1:]
328	try:
329	i = int(suffix)+1
330	except:
331	pass
332	while prefix+'_'+str(i) in labellist:
333	i += 1
334	else:
335	lbl = prefix+'_'+str(i)
336	labellist.append(lbl)
337
338
339	# Refactored over here to allow access by GSASIIscriptable.py
340	def HillSortElements(elmlist):
341	'''Sort elements in "Hill" order: C, H, others, (where others
342	are alphabetical).
343
344	:params list elmlist: a list of element strings
345
346	:returns: a sorted list of element strings
347	'''
348	newlist = []
349	oldlist = elmlist[:]
350	for elm in ('C','H'):
351	if elm in elmlist:
352	newlist.append(elm)
353	oldlist.pop(oldlist.index(elm))
354	return newlist+sorted(oldlist)
355
356
357	# Refactored over here to allow access by GSASIIscriptable.py
358	def FmtAtomType(sym):
359	'Reformat a GSAS-II atom type symbol to match CIF rules'
360	sym = sym.replace('_','') # underscores are not allowed: no isotope designation?
361	# in CIF, oxidation state sign symbols come after, not before
362	if '+' in sym:
363	sym = sym.replace('+','') + '+'
364	elif '-' in sym:
365	sym = sym.replace('-','') + '-'
366	return sym
367
368
369	# Refactored over here to allow access by GSASIIscriptable.py
370	def PutInCol(val, wid):
371	val = str(val).replace(' ', '')
372	if not val: val = '?'
373	fmt = '{:' + str(wid) + '} '
374	return fmt.format(val)
375
376
377	# Refactored over here to allow access by GSASIIscriptable.py
378	def WriteComposition(fp, phasedict, phasenam, parmDict):
379	'''determine the composition for the unit cell, crudely determine Z and
380	then compute the composition in formula units
381	'''
382	General = phasedict['General']
383	Z = General.get('cellZ',0.0)
384	cx,ct,cs,cia = General['AtomPtrs']
385	Atoms = phasedict['Atoms']
386	fpfx = str(phasedict['pId'])+'::Afrac:'
387	cfrac = cx+3
388	cmult = cs+1
389	compDict = {} # combines H,D & T
390	sitemultlist = []
391	massDict = dict(zip(General['AtomTypes'],General['AtomMass']))
392	cellmass = 0
393	for i,at in enumerate(Atoms):
394	atype = at[ct].strip()
395	if atype.find('-') != -1: atype = atype.split('-')[0]
396	if atype.find('+') != -1: atype = atype.split('+')[0]
397	atype = atype[0].upper()+atype[1:2].lower() # force case conversion
398	if atype == "D" or atype == "D": atype = "H"
399	fvar = fpfx+str(i)
400	fval = parmDict.get(fvar,at[cfrac])
401	mult = at[cmult]
402	if not massDict.get(at[ct]):
403	print('Error: No mass found for atom type '+at[ct])
404	print('Will not compute cell contents for phase '+phasenam)
405	return
406	cellmass += massDict[at[ct]]multfval
407	compDict[atype] = compDict.get(atype,0.0) + mult*fval
408	if fval == 1: sitemultlist.append(mult)
409	if len(compDict.keys()) == 0: return # no elements!
410	if Z < 1: # Z has not been computed or set by user
411	Z = 1
412	if not sitemultlist:
413	General['cellZ'] = 1
414	return
415	for i in range(2,min(sitemultlist)+1):
416	for m in sitemultlist:
417	if m % i != 0:
418	break
419	else:
420	Z = i
421	General['cellZ'] = Z # save it
422
423	# when scattering factors are included in the CIF, this needs to be
424	# added to the loop here but only in the one-block case.
425	# For multiblock CIFs, scattering factors go in the histogram
426	# blocks (for all atoms in all appropriate phases) - an example?:
427	#loop_
428	# _atom_type_symbol
429	# _atom_type_description
430	# _atom_type_scat_dispersion_real
431	# _atom_type_scat_dispersion_imag
432	# _atom_type_scat_source
433	# 'C' 'C' 0.0033 0.0016
434	# 'International Tables Vol C Tables 4.2.6.8 and 6.1.1.4'
435	# 'H' 'H' 0.0000 0.0000
436	# 'International Tables Vol C Tables 4.2.6.8 and 6.1.1.4'
437	# 'P' 'P' 0.1023 0.0942
438	# 'International Tables Vol C Tables 4.2.6.8 and 6.1.1.4'
439	# 'Cl' 'Cl' 0.1484 0.1585
440	# 'International Tables Vol C Tables 4.2.6.8 and 6.1.1.4'
441	# 'Cu' 'Cu' 0.3201 1.2651
442	# 'International Tables Vol C Tables 4.2.6.8 and 6.1.1.4'
443
444	#if oneblock: # add scattering factors for current phase here
445	WriteCIFitem(fp, '\nloop_ _atom_type_symbol _atom_type_number_in_cell')
446	formula = ''
447	for elem in HillSortElements(list(compDict.keys())):
448	WriteCIFitem(fp, ' ' + PutInCol(elem,4) +
449	G2mth.ValEsd(compDict[elem],-0.009,True))
450	if formula: formula += " "
451	formula += elem
452	if compDict[elem] == Z: continue
453	formula += G2mth.ValEsd(compDict[elem]/Z,-0.009,True)
454	WriteCIFitem(fp, '\n# Note that Z affects _cell_formula_sum and _weight')
455	WriteCIFitem(fp, '_cell_formula_units_Z',str(Z))
456	WriteCIFitem(fp, '_chemical_formula_sum',formula)
457	WriteCIFitem(fp, '_chemical_formula_weight',
458	G2mth.ValEsd(cellmass/Z,-0.09,True))
459
460
461	class ExportCIF(G2IO.ExportBaseclass):
462	'''Base class for CIF exports
463	'''
464	def __init__(self,G2frame,formatName,extension,longFormatName=None,):
465	G2IO.ExportBaseclass.__init__(self,G2frame,formatName,extension,longFormatName=None)
466	self.exporttype = []
467	self.author = ''
468	self.CIFname = ''
469
470	def ValidateAscii(self,checklist):
471	'''Validate items as ASCII'''
472	msg = ''
473	for lbl,val in checklist:
474	if not all(ord(c) < 128 for c in val):
475	if msg: msg += '\n'
476	msg += lbl + " contains unicode characters: " + val
477	if msg:
478	G2G.G2MessageBox(self.G2frame,
479	'Error: CIFs can contain only ASCII characters. Please change item(s) below:\n\n'+msg,
480	'Unicode not valid for CIF')
481	return True
482
483	def _Exporter(self,event=None,phaseOnly=None,histOnly=None,IncludeOnlyHist=None):
484	'''Basic code to export a CIF. Export can be full or simple, as set by
485	phaseOnly and histOnly which skips distances & angles, etc.
486
487	phaseOnly: used to export only one phase
488	histOnly: used to export only one histogram
489	IncludeOnlyHist: used for a full CIF that includes only one of the
490	histograms (from a sequential fit) #TODO: needs lots of work!
491	'''
492
493	#***** define functions for export method =======================================
494	def WriteAudit():
495	'Write the CIF audit values. Perhaps should be in a single element loop.'
496	WriteCIFitem(self.fp, '_audit_creation_method',
497	'created in GSAS-II')
498	WriteCIFitem(self.fp, '_audit_creation_date',self.CIFdate)
499	if self.author:
500	WriteCIFitem(self.fp, '_audit_author_name',self.author)
501	WriteCIFitem(self.fp, '_audit_update_record',
502	self.CIFdate+' Initial software-generated CIF')
503
504	def WriteOverall():
505	'''Write out overall refinement information.
506
507	More could be done here, but this is a good start.
508	'''
509	if self.ifPWDR:
510	WriteCIFitem(self.fp, '_pd_proc_info_datetime', self.CIFdate)
511	WriteCIFitem(self.fp, '_pd_calc_method', 'Rietveld Refinement')
512	#WriteCIFitem(self.fp, '_refine_ls_shift/su_max',DAT1)
513	#WriteCIFitem(self.fp, '_refine_ls_shift/su_mean',DAT2)
514	WriteCIFitem(self.fp, '_computing_structure_refinement','GSAS-II (Toby & Von Dreele, J. Appl. Cryst. 46, 544-549, 2013)')
515	if self.ifHKLF:
516	controls = self.OverallParms['Controls']
517	if controls['F**2']:
518	thresh = 'F2>%.1fu(F2)'%(controls['UsrReject']['minF/sig'])
519	else:
520	thresh = 'F>%.1fu(F)'%(controls['UsrReject']['minF/sig'])
521	WriteCIFitem(self.fp, '_reflns_threshold_expression', thresh)
522	try:
523	vars = str(len(self.OverallParms['Covariance']['varyList']))
524	except:
525	vars = '?'
526	WriteCIFitem(self.fp, '_refine_ls_number_parameters',vars)
527	try:
528	GOF = G2mth.ValEsd(self.OverallParms['Covariance']['Rvals']['GOF'],-0.009)
529	except:
530	GOF = '?'
531	WriteCIFitem(self.fp, '_refine_ls_goodness_of_fit_all',GOF)
532
533	# get restraint info
534	# restraintDict = self.OverallParms.get('Restraints',{})
535	# for i in self.OverallParms['Constraints']:
536	# print i
537	# for j in self.OverallParms['Constraints'][i]:
538	# print j
539	#WriteCIFitem(self.fp, '_refine_ls_number_restraints',TEXT)
540	# other things to consider reporting
541	# _refine_ls_number_reflns
542	# _refine_ls_goodness_of_fit_obs
543	# _refine_ls_wR_factor_obs
544	# _refine_ls_restrained_S_all
545	# _refine_ls_restrained_S_obs
546
547	# include an overall profile r-factor, if there is more than one powder histogram
548	R = '%.5f'%(self.OverallParms['Covariance']['Rvals']['Rwp']/100.)
549	WriteCIFitem(self.fp, '\n# OVERALL WEIGHTED R-FACTOR')
550	WriteCIFitem(self.fp, '_refine_ls_wR_factor_obs',R)
551	# _refine_ls_R_factor_all
552	# _refine_ls_R_factor_obs
553	WriteCIFitem(self.fp, '_refine_ls_matrix_type','full')
554	#WriteCIFitem(self.fp, '_refine_ls_matrix_type','userblocks')
555
556	def writeCIFtemplate(G2dict,tmplate,defaultname=''):
557	'''Write out the selected or edited CIF template
558	An unedited CIF template file is copied, comments intact; an edited
559	CIF template is written out from PyCifRW which of course strips comments.
560	In all cases the initial data_ header is stripped (there should only be one!)
561	'''
562	CIFobj = G2dict.get("CIF_template")
563	if defaultname:
564	defaultname = G2obj.StripUnicode(defaultname)
565	defaultname = re.sub(r'[^a-zA-Z0-9_-]','',defaultname)
566	defaultname = tmplate + "_" + defaultname + ".cif"
567	else:
568	defaultname = ''
569	templateDefName = 'template_'+tmplate+'.cif'
570	if not CIFobj: # copying a template
571	for pth in [os.getcwd()]+sys.path:
572	fil = os.path.join(pth,defaultname)
573	if os.path.exists(fil) and defaultname: break
574	else:
575	for pth in sys.path:
576	fil = os.path.join(pth,templateDefName)
577	if os.path.exists(fil): break
578	else:
579	print(CIFobj+' not found in path!')
580	return
581	fp = open(fil,'r')
582	txt = fp.read()
583	fp.close()
584	elif type(CIFobj) is not list and type(CIFobj) is not tuple:
585	if not os.path.exists(CIFobj):
586	print("Error: requested template file has disappeared: "+CIFobj)
587	return
588	fp = open(CIFobj,'r')
589	txt = fp.read()
590	fp.close()
591	else:
592	txt = dict2CIF(CIFobj[0],CIFobj[1]).WriteOut()
593	# remove the PyCifRW header, if present
594	#if txt.find('PyCifRW') > -1 and txt.find('data_') > -1:
595	txt = "# GSAS-II edited template follows "+txt[txt.index("data_")+5:]
596	#txt = txt.replace('data_','#')
597	WriteCIFitem(self.fp, txt)
598
599	def FormatSH(phasenam):
600	'Format a full spherical harmonics texture description as a string'
601	phasedict = self.Phases[phasenam] # pointer to current phase info
602	pfx = str(phasedict['pId'])+'::'
603	s = ""
604	textureData = phasedict['General']['SH Texture']
605	if textureData.get('Order'):
606	s += "Spherical Harmonics correction. Order = "+str(textureData['Order'])
607	s += " Model: " + str(textureData['Model']) + "\n Orientation angles: "
608	for name in ['omega','chi','phi']:
609	aname = pfx+'SH '+name
610	s += name + " = "
611	sig = self.sigDict.get(aname,-0.09)
612	s += G2mth.ValEsd(self.parmDict[aname],sig)
613	s += "; "
614	s += "\n"
615	s1 = " Coefficients: "
616	for name in textureData['SH Coeff'][1]:
617	aname = pfx+name
618	if len(s1) > 60:
619	s += s1 + "\n"
620	s1 = " "
621	s1 += aname + ' = '
622	sig = self.sigDict.get(aname,-0.0009)
623	s1 += G2mth.ValEsd(self.parmDict[aname],sig)
624	s1 += "; "
625	s += s1
626	return s
627
628	def FormatHAPpo(phasenam):
629	'''return the March-Dollase/SH correction for every
630	histogram in the current phase formatted into a
631	character string
632	'''
633	phasedict = self.Phases[phasenam] # pointer to current phase info
634	s = ''
635	for histogram in sorted(phasedict['Histograms']):
636	if histogram.startswith("HKLF"): continue # powder only
637	Histogram = self.Histograms.get(histogram)
638	if not Histogram: continue
639	hapData = phasedict['Histograms'][histogram]
640	if hapData['Pref.Ori.'][0] == 'MD':
641	aname = str(phasedict['pId'])+':'+str(Histogram['hId'])+':MD'
642	if self.parmDict.get(aname,1.0) != 1.0: continue
643	sig = self.sigDict.get(aname,-0.009)
644	if s != "": s += '\n'
645	s += 'March-Dollase correction'
646	if len(self.powderDict) > 1:
647	s += ', histogram '+str(Histogram['hId']+1)
648	s += ' coef. = ' + G2mth.ValEsd(self.parmDict[aname],sig)
649	s += ' axis = ' + str(hapData['Pref.Ori.'][3])
650	else: # must be SH
651	if s != "": s += '\n'
652	s += 'Simple spherical harmonic correction'
653	if len(self.powderDict) > 1:
654	s += ', histogram '+str(Histogram['hId']+1)
655	s += ' Order = '+str(hapData['Pref.Ori.'][4])+'\n'
656	s1 = " Coefficients: "
657	for item in hapData['Pref.Ori.'][5]:
658	aname = str(phasedict['pId'])+':'+str(Histogram['hId'])+':'+item
659	if len(s1) > 60:
660	s += s1 + "\n"
661	s1 = " "
662	s1 += aname + ' = '
663	sig = self.sigDict.get(aname,-0.0009)
664	s1 += G2mth.ValEsd(self.parmDict[aname],sig)
665	s1 += "; "
666	s += s1
667	return s
668
669	def FormatBackground(bkg,hId):
670	'''Display the Background information as a descriptive text string.
671
672	TODO: this needs to be expanded to show the diffuse peak and
673	Debye term information as well. (Bob)
674
675	:returns: the text description (str)
676	'''
677	hfx = ':'+str(hId)+':'
678	fxn, bkgdict = bkg
679	terms = fxn[2]
680	txt = 'Background function: "'+fxn[0]+'" function with '+str(terms)+' terms:\n'
681	l = " "
682	for i,v in enumerate(fxn[3:]):
683	name = '%sBack;%d'%(hfx,i)
684	sig = self.sigDict.get(name,-0.009)
685	if len(l) > 60:
686	txt += l + '\n'
687	l = ' '
688	l += G2mth.ValEsd(v,sig)+', '
689	txt += l
690	if bkgdict['nDebye']:
691	txt += '\n Background Debye function parameters: A, R, U:'
692	names = ['A;','R;','U;']
693	for i in range(bkgdict['nDebye']):
694	txt += '\n '
695	for j in range(3):
696	name = hfx+'Debye'+names[j]+str(i)
697	sig = self.sigDict.get(name,-0.009)
698	txt += G2mth.ValEsd(bkgdict['debyeTerms'][i][2*j],sig)+', '
699	if bkgdict['nPeaks']:
700	txt += '\n Background peak parameters: pos, int, sig, gam:'
701	names = ['pos;','int;','sig;','gam;']
702	for i in range(bkgdict['nPeaks']):
703	txt += '\n '
704	for j in range(4):
705	name = hfx+'BkPk'+names[j]+str(i)
706	sig = self.sigDict.get(name,-0.009)
707	txt += G2mth.ValEsd(bkgdict['peaksList'][i][2*j],sig)+', '
708	return txt
709
710	def FormatInstProfile(instparmdict,hId):
711	'''Format the instrumental profile parameters with a
712	string description. Will only be called on PWDR histograms
713	'''
714	s = ''
715	inst = instparmdict[0]
716	hfx = ':'+str(hId)+':'
717	if 'C' in inst['Type'][0]:
718	s = 'Finger-Cox-Jephcoat function parameters U, V, W, X, Y, SH/L:\n'
719	s += ' peak variance(Gauss) = Utan(Th)^2^+Vtan(Th)+W:\n'
720	s += ' peak HW(Lorentz) = X/cos(Th)+Ytan(Th); SH/L = S/L+H/L\n'
721	s += ' U, V, W in (centideg)^2^, X & Y in centideg\n '
722	for item in ['U','V','W','X','Y','SH/L']:
723	name = hfx+item
724	sig = self.sigDict.get(name,-0.009)
725	s += G2mth.ValEsd(inst[item][1],sig)+', '
726	elif 'T' in inst['Type'][0]: #to be tested after TOF Rietveld done
727	s = 'Von Dreele-Jorgenson-Windsor function parameters\n'+ \
728	' alpha, beta-0, beta-1, beta-q, sig-0, sig-1, sig-2, sig-q, X, Y:\n '
729	for item in ['alpha','beta-0','beta-1','beta-q','sig-0','sig-1','sig-2','sig-q','X','Y']:
730	name = hfx+item
731	sig = self.sigDict.get(name,-0.009)
732	s += G2mth.ValEsd(inst[item][1],sig)+', '
733	return s
734
735	def FormatPhaseProfile(phasenam):
736	'''Format the phase-related profile parameters (size/strain)
737	with a string description.
738	return an empty string or None if there are no
739	powder histograms for this phase.
740	'''
741	s = ''
742	phasedict = self.Phases[phasenam] # pointer to current phase info
743	SGData = phasedict['General'] ['SGData']
744	for histogram in sorted(phasedict['Histograms']):
745	if histogram.startswith("HKLF"): continue # powder only
746	Histogram = self.Histograms.get(histogram)
747	if not Histogram: continue
748	hapData = phasedict['Histograms'][histogram]
749	pId = phasedict['pId']
750	hId = Histogram['hId']
751	phfx = '%d:%d:'%(pId,hId)
752	size = hapData['Size']
753	mustrain = hapData['Mustrain']
754	hstrain = hapData['HStrain']
755	if len(self.powderDict) > 1:
756	if s:
757	s += '\n'
758	else:
759	s += ' Crystallite size model "%s" for %s (microns)\n '%(size[0],phasenam)
760	s += ' Parameters for histogram #'+str(hId)+' '+str(histogram)+'\n'
761	else:
762	s += ' Crystallite size model "%s" for %s (microns)\n '%(size[0],phasenam)
763
764	names = ['Size;i','Size;mx']
765	if 'uniax' in size[0]:
766	names = ['Size;i','Size;a','Size;mx']
767	s += 'anisotropic axis is %s\n '%(str(size[3]))
768	s += 'parameters: equatorial size, axial size, G/L mix\n '
769	for i,item in enumerate(names):
770	name = phfx+item
771	sig = self.sigDict.get(name,-0.009)
772	s += G2mth.ValEsd(size[1][i],sig)+', '
773	elif 'ellip' in size[0]:
774	s += 'parameters: S11, S22, S33, S12, S13, S23, G/L mix\n '
775	for i in range(6):
776	name = phfx+'Size:'+str(i)
777	sig = self.sigDict.get(name,-0.009)
778	s += G2mth.ValEsd(size[4][i],sig)+', '
779	sig = self.sigDict.get(phfx+'Size;mx',-0.009)
780	s += G2mth.ValEsd(size[1][2],sig)+', '
781	else: #isotropic
782	s += 'parameters: Size, G/L mix\n '
783	i = 0
784	for item in names:
785	name = phfx+item
786	sig = self.sigDict.get(name,-0.009)
787	s += G2mth.ValEsd(size[1][i],sig)+', '
788	i = 2 #skip the aniso value
789	s += '\n Mustrain model "%s" for %s (10^6^)\n '%(mustrain[0],phasenam)
790	names = ['Mustrain;i','Mustrain;mx']
791	if 'uniax' in mustrain[0]:
792	names = ['Mustrain;i','Mustrain;a','Mustrain;mx']
793	s += 'anisotropic axis is %s\n '%(str(size[3]))
794	s += 'parameters: equatorial mustrain, axial mustrain, G/L mix\n '
795	for i,item in enumerate(names):
796	name = phfx+item
797	sig = self.sigDict.get(name,-0.009)
798	s += G2mth.ValEsd(mustrain[1][i],sig)+', '
799	elif 'general' in mustrain[0]:
800	names = 'parameters: '
801	for i,name in enumerate(G2spc.MustrainNames(SGData)):
802	names += name+', '
803	if i == 9:
804	names += '\n '
805	names += 'G/L mix\n '
806	s += names
807	txt = ''
808	for i in range(len(mustrain[4])):
809	name = phfx+'Mustrain:'+str(i)
810	sig = self.sigDict.get(name,-0.009)
811	if len(txt) > 60:
812	s += txt+'\n '
813	txt = ''
814	txt += G2mth.ValEsd(mustrain[4][i],sig)+', '
815	s += txt
816	sig = self.sigDict.get(phfx+'Mustrain;mx',-0.009)
817	s += G2mth.ValEsd(mustrain[1][2],sig)+', '
818
819	else: #isotropic
820	s += ' parameters: Mustrain, G/L mix\n '
821	i = 0
822	for item in names:
823	name = phfx+item
824	sig = self.sigDict.get(name,-0.009)
825	s += G2mth.ValEsd(mustrain[1][i],sig)+', '
826	i = 2 #skip the aniso value
827	s1 = ' \n Macrostrain parameters: '
828	names = G2spc.HStrainNames(SGData)
829	for name in names:
830	s1 += name+', '
831	s1 += '\n '
832	macrostrain = False
833	for i in range(len(names)):
834	name = phfx+names[i]
835	sig = self.sigDict.get(name,-0.000009)
836	s1 += G2mth.ValEsd(hstrain[0][i],sig)+', '
837	if hstrain[0][i]: macrostrain = True
838	if macrostrain:
839	s += s1 + '\n'
840	# show revised lattice parameters here someday
841	else:
842	s += '\n'
843	return s
844
845	def MakeUniqueLabel(lbl,labellist):
846	'Make sure that every atom label is unique'
847	lbl = lbl.strip()
848	if not lbl: # deal with a blank label
849	lbl = 'A_1'
850	if lbl not in labellist:
851	labellist.append(lbl)
852	return lbl
853	i = 1
854	prefix = lbl
855	if '_' in lbl:
856	prefix = lbl[:lbl.rfind('_')]
857	suffix = lbl[lbl.rfind('_')+1:]
858	try:
859	i = int(suffix)+1
860	except:
861	pass
862	while prefix+'_'+str(i) in labellist:
863	i += 1
864	else:
865	lbl = prefix+'_'+str(i)
866	labellist.append(lbl)
867
868	# Factored out to above by Jack O'Donnell, so it
869	# could be accessed by GSASIIscriptable.py
870	# def WriteAtomsNuclear(phasenam):
871	# 'Write atom positions to CIF'
872	# phasedict = self.Phases[phasenam] # pointer to current phase info
873	# General = phasedict['General']
874	# cx,ct,cs,cia = General['AtomPtrs']
875	# Atoms = phasedict['Atoms']
876	# cfrac = cx+3
877	# fpfx = str(phasedict['pId'])+'::Afrac:'
878	# for i,at in enumerate(Atoms):
879	# fval = self.parmDict.get(fpfx+str(i),at[cfrac])
880	# if fval != 0.0:
881	# break
882	# else:
883	# WriteCIFitem(self.fp, '\n# PHASE HAS NO ATOMS!')
884	# return
885
886	# WriteCIFitem(self.fp, '\n# ATOMIC COORDINATES AND DISPLACEMENT PARAMETERS')
887	# WriteCIFitem(self.fp, 'loop_ '+
888	# '\n _atom_site_label'+
889	# '\n _atom_site_type_symbol'+
890	# '\n _atom_site_fract_x'+
891	# '\n _atom_site_fract_y'+
892	# '\n _atom_site_fract_z'+
893	# '\n _atom_site_occupancy'+
894	# '\n _atom_site_adp_type'+
895	# '\n _atom_site_U_iso_or_equiv'+
896	# '\n _atom_site_symmetry_multiplicity')
897
898	# varnames = {cx:'Ax',cx+1:'Ay',cx+2:'Az',cx+3:'Afrac',
899	# cia+1:'AUiso',cia+2:'AU11',cia+3:'AU22',cia+4:'AU33',
900	# cia+5:'AU12',cia+6:'AU13',cia+7:'AU23'}
901	# self.labellist = []
902
903	# pfx = str(phasedict['pId'])+'::'
904	# # loop over all atoms
905	# naniso = 0
906	# for i,at in enumerate(Atoms):
907	# if phasedict['General']['Type'] == 'macromolecular':
908	# label = '%s_%s_%s_%s'%(at[ct-1],at[ct-3],at[ct-4],at[ct-2])
909	# s = PutInCol(MakeUniqueLabel(label,self.labellist),15) # label
910	# else:
911	# s = PutInCol(MakeUniqueLabel(at[ct-1],self.labellist),6) # label
912	# fval = self.parmDict.get(fpfx+str(i),at[cfrac])
913	# if fval == 0.0: continue # ignore any atoms that have a occupancy set to 0 (exact)
914	# s += PutInCol(FmtAtomType(at[ct]),4) # type
915	# if at[cia] == 'I':
916	# adp = 'Uiso '
917	# else:
918	# adp = 'Uani '
919	# naniso += 1
920	# # compute Uequiv crudely
921	# # correct: Defined as "1/3 trace of diagonalized U matrix".
922	# # SEE cell2GS & Uij2Ueqv to GSASIIlattice. Former is needed to make the GS matrix used by the latter.
923	# t = 0.0
924	# for j in (2,3,4):
925	# var = pfx+varnames[cia+j]+":"+str(i)
926	# t += self.parmDict.get(var,at[cia+j])
927	# for j in (cx,cx+1,cx+2,cx+3,cia,cia+1):
928	# if j in (cx,cx+1,cx+2):
929	# dig = 11
930	# sigdig = -0.00009
931	# else:
932	# dig = 10
933	# sigdig = -0.009
934	# if j == cia:
935	# s += adp
936	# else:
937	# var = pfx+varnames[j]+":"+str(i)
938	# dvar = pfx+"d"+varnames[j]+":"+str(i)
939	# if dvar not in self.sigDict:
940	# dvar = var
941	# if j == cia+1 and adp == 'Uani ':
942	# val = t/3.
943	# sig = sigdig
944	# else:
945	# #print var,(var in self.parmDict),(var in self.sigDict)
946	# val = self.parmDict.get(var,at[j])
947	# sig = self.sigDict.get(dvar,sigdig)
948	# s += PutInCol(G2mth.ValEsd(val,sig),dig)
949	# s += PutInCol(at[cs+1],3)
950	# WriteCIFitem(self.fp, s)
951	# if naniso == 0: return
952	# # now loop over aniso atoms
953	# WriteCIFitem(self.fp, '\nloop_' + '\n _atom_site_aniso_label' +
954	# '\n _atom_site_aniso_U_11' + '\n _atom_site_aniso_U_22' +
955	# '\n _atom_site_aniso_U_33' + '\n _atom_site_aniso_U_12' +
956	# '\n _atom_site_aniso_U_13' + '\n _atom_site_aniso_U_23')
957	# for i,at in enumerate(Atoms):
958	# fval = self.parmDict.get(fpfx+str(i),at[cfrac])
959	# if fval == 0.0: continue # ignore any atoms that have a occupancy set to 0 (exact)
960	# if at[cia] == 'I': continue
961	# s = PutInCol(self.labellist[i],6) # label
962	# for j in (2,3,4,5,6,7):
963	# sigdig = -0.0009
964	# var = pfx+varnames[cia+j]+":"+str(i)
965	# val = self.parmDict.get(var,at[cia+j])
966	# sig = self.sigDict.get(var,sigdig)
967	# s += PutInCol(G2mth.ValEsd(val,sig),11)
968	# WriteCIFitem(self.fp, s)
969
970	# def HillSortElements(elmlist):
971	# '''Sort elements in "Hill" order: C, H, others, (where others
972	# are alphabetical).
973
974	# :params list elmlist: a list of element strings
975
976	# :returns: a sorted list of element strings
977	# '''
978	# newlist = []
979	# oldlist = elmlist[:]
980	# for elm in ('C','H'):
981	# if elm in elmlist:
982	# newlist.append(elm)
983	# oldlist.pop(oldlist.index(elm))
984	# return newlist+sorted(oldlist)
985
986	# Factored out to above by Jackson O'Donnell
987	# so that it can be accessed by GSASIIscriptable
988
989	# def WriteComposition(phasenam):
990	# '''determine the composition for the unit cell, crudely determine Z and
991	# then compute the composition in formula units
992	# '''
993	# phasedict = self.Phases[phasenam] # pointer to current phase info
994	# General = phasedict['General']
995	# Z = General.get('cellZ',0.0)
996	# cx,ct,cs,cia = General['AtomPtrs']
997	# Atoms = phasedict['Atoms']
998	# fpfx = str(phasedict['pId'])+'::Afrac:'
999	# cfrac = cx+3
1000	# cmult = cs+1
1001	# compDict = {} # combines H,D & T
1002	# sitemultlist = []
1003	# massDict = dict(zip(General['AtomTypes'],General['AtomMass']))
1004	# cellmass = 0
1005	# for i,at in enumerate(Atoms):
1006	# atype = at[ct].strip()
1007	# if atype.find('-') != -1: atype = atype.split('-')[0]
1008	# if atype.find('+') != -1: atype = atype.split('+')[0]
1009	# atype = atype[0].upper()+atype[1:2].lower() # force case conversion
1010	# if atype == "D" or atype == "D": atype = "H"
1011	# fvar = fpfx+str(i)
1012	# fval = self.parmDict.get(fvar,at[cfrac])
1013	# mult = at[cmult]
1014	# if not massDict.get(at[ct]):
1015	# print('Error: No mass found for atom type '+at[ct])
1016	# print('Will not compute cell contents for phase '+phasenam)
1017	# return
1018	# cellmass += massDict[at[ct]]multfval
1019	# compDict[atype] = compDict.get(atype,0.0) + mult*fval
1020	# if fval == 1: sitemultlist.append(mult)
1021	# if len(compDict.keys()) == 0: return # no elements!
1022	# if Z < 1: # Z has not been computed or set by user
1023	# Z = 1
1024	# if not sitemultlist:
1025	# General['cellZ'] = 1
1026	# return
1027	# for i in range(2,min(sitemultlist)+1):
1028	# for m in sitemultlist:
1029	# if m % i != 0:
1030	# break
1031	# else:
1032	# Z = i
1033	# General['cellZ'] = Z # save it
1034
1035	# # when scattering factors are included in the CIF, this needs to be
1036	# # added to the loop here but only in the one-block case.
1037	# # For multiblock CIFs, scattering factors go in the histogram
1038	# # blocks (for all atoms in all appropriate phases) - an example?:
1039	#loop_
1040	# _at# om_type_symbol
1041	# _at# om_type_description
1042	# _at# om_type_scat_dispersion_real
1043	# _at# om_type_scat_dispersion_imag
1044	# _at# om_type_scat_source
1045	# 'C'# 'C' 0.0033 0.0016
1046	# # 'International Tables Vol C Tables 4.2.6.8 and 6.1.1.4'
1047	# 'H'# 'H' 0.0000 0.0000
1048	# # 'International Tables Vol C Tables 4.2.6.8 and 6.1.1.4'
1049	# 'P'# 'P' 0.1023 0.0942
1050	# # 'International Tables Vol C Tables 4.2.6.8 and 6.1.1.4'
1051	# 'Cl# ' 'Cl' 0.1484 0.1585
1052	# # 'International Tables Vol C Tables 4.2.6.8 and 6.1.1.4'
1053	# 'Cu# ' 'Cu' 0.3201 1.2651
1054	# # 'International Tables Vol C Tables 4.2.6.8 and 6.1.1.4'
1055
1056	# #if oneblock: # add scattering factors for current phase here
1057	# WriteCIFitem(self.fp, '\nloop_ _atom_type_symbol _atom_type_number_in_cell')
1058	# formula = ''
1059	# for elem in HillSortElements(compDict.keys()):
1060	# WriteCIFitem(self.fp, ' ' + PutInCol(elem,4) +
1061	# G2mth.ValEsd(compDict[elem],-0.009,True))
1062	# if formula: formula += " "
1063	# formula += elem
1064	# if compDict[elem] == Z: continue
1065	# formula += G2mth.ValEsd(compDict[elem]/Z,-0.009,True)
1066	# WriteCIFitem(self.fp, '\n# Note that Z affects _cell_formula_sum and _weight')
1067	# WriteCIFitem(self.fp, '_cell_formula_units_Z',str(Z))
1068	# WriteCIFitem(self.fp, '_chemical_formula_sum',formula)
1069	# WriteCIFitem(self.fp, '_chemical_formula_weight',
1070	# G2mth.ValEsd(cellmass/Z,-0.09,True))
1071
1072	def WriteDistances(phasenam,SymOpList,offsetList,symOpList,G2oprList):
1073	'''Report bond distances and angles for the CIF
1074
1075	Note that _geom__symmetry_ fields are values of form
1076	n_klm where n is the symmetry operation in SymOpList (counted
1077	starting with 1) and (k-5, l-5, m-5) are translations to add
1078	to (x,y,z). See
1079	http://www.iucr.org/__data/iucr/cifdic_html/1/cif_core.dic/Igeom_angle_site_symmetry_.html
1080
1081	TODO: need a method to select publication flags for distances/angles
1082	'''
1083	phasedict = self.Phases[phasenam] # pointer to current phase info
1084	Atoms = phasedict['Atoms']
1085	generalData = phasedict['General']
1086	# create a dict for storing Pub flag for bonds/angles, if needed
1087	if phasedict['General'].get("DisAglHideFlag") is None:
1088	phasedict['General']["DisAglHideFlag"] = {}
1089	DisAngSel = phasedict['General']["DisAglHideFlag"]
1090	cx,ct,cs,cia = phasedict['General']['AtomPtrs']
1091	cn = ct-1
1092	fpfx = str(phasedict['pId'])+'::Afrac:'
1093	cfrac = cx+3
1094	DisAglData = {}
1095	# create a list of atoms, but skip atoms with zero occupancy
1096	xyz = []
1097	fpfx = str(phasedict['pId'])+'::Afrac:'
1098	for i,atom in enumerate(Atoms):
1099	if self.parmDict.get(fpfx+str(i),atom[cfrac]) == 0.0: continue
1100	xyz.append([i,]+atom[cn:cn+2]+atom[cx:cx+3])
1101	if 'DisAglCtls' not in generalData:
1102	# should not happen, since DisAglDialog should be called
1103	# for all phases before getting here
1104	dlg = G2G.DisAglDialog(
1105	self.G2frame,
1106	{},
1107	generalData)
1108	if dlg.ShowModal() == wx.ID_OK:
1109	generalData['DisAglCtls'] = dlg.GetData()
1110	else:
1111	dlg.Destroy()
1112	return
1113	dlg.Destroy()
1114	DisAglData['OrigAtoms'] = xyz
1115	DisAglData['TargAtoms'] = xyz
1116	SymOpList,offsetList,symOpList,G2oprList,G2opcodes = G2spc.AllOps(
1117	generalData['SGData'])
1118
1119	# xpandSGdata = generalData['SGData'].copy()
1120	# xpandSGdata.update({'SGOps':symOpList,
1121	# 'SGInv':False,
1122	# 'SGLatt':'P',
1123	# 'SGCen':np.array([[0, 0, 0]]),})
1124	# DisAglData['SGData'] = xpandSGdata
1125	DisAglData['SGData'] = generalData['SGData'].copy()
1126
1127	DisAglData['Cell'] = generalData['Cell'][1:] #+ volume
1128	if 'pId' in phasedict:
1129	DisAglData['pId'] = phasedict['pId']
1130	DisAglData['covData'] = self.OverallParms['Covariance']
1131	try:
1132	AtomLabels,DistArray,AngArray = G2stMn.RetDistAngle(
1133	generalData['DisAglCtls'],
1134	DisAglData)
1135	except KeyError: # inside DistAngle for missing atom types in DisAglCtls
1136	print(u'** ERROR computing distances & angles for phase {} **\nresetting to default values'.format(phasenam))
1137	data = generalData['DisAglCtls'] = {}
1138	data['Name'] = generalData['Name']
1139	data['Factors'] = [0.85,0.85]
1140	data['AtomTypes'] = generalData['AtomTypes']
1141	data['BondRadii'] = generalData['BondRadii'][:]
1142	data['AngleRadii'] = generalData['AngleRadii'][:]
1143	try:
1144	AtomLabels,DistArray,AngArray = G2stMn.RetDistAngle(
1145	generalData['DisAglCtls'],
1146	DisAglData)
1147	except:
1148	print('Reset failed. To fix this, use the Reset button in the "edit distance/angle menu" for this phase')
1149	return
1150
1151	# loop over interatomic distances for this phase
1152	WriteCIFitem(self.fp, '\n# MOLECULAR GEOMETRY')
1153	WriteCIFitem(self.fp, 'loop_' +
1154	'\n _geom_bond_atom_site_label_1' +
1155	'\n _geom_bond_atom_site_label_2' +
1156	'\n _geom_bond_distance' +
1157	'\n _geom_bond_site_symmetry_1' +
1158	'\n _geom_bond_site_symmetry_2' +
1159	'\n _geom_bond_publ_flag')
1160
1161	for i in sorted(AtomLabels.keys()):
1162	Dist = DistArray[i]
1163	for D in Dist:
1164	line = ' '+PutInCol(AtomLabels[i],6)+PutInCol(AtomLabels[D[0]],6)
1165	sig = D[4]
1166	if sig == 0: sig = -0.00009
1167	line += PutInCol(G2mth.ValEsd(D[3],sig,True),10)
1168	line += " 1_555 "
1169	line += " {:3d}_".format(G2opcodes.index(D[2])+1)
1170	for d in D[1]:
1171	line += "{:1d}".format(d+5)
1172	if DisAngSel.get((i,tuple(D[0:3]))):
1173	line += " no"
1174	else:
1175	line += " yes"
1176	WriteCIFitem(self.fp, line)
1177
1178	# loop over interatomic angles for this phase
1179	WriteCIFitem(self.fp, '\nloop_' +
1180	'\n _geom_angle_atom_site_label_1' +
1181	'\n _geom_angle_atom_site_label_2' +
1182	'\n _geom_angle_atom_site_label_3' +
1183	'\n _geom_angle' +
1184	'\n _geom_angle_site_symmetry_1' +
1185	'\n _geom_angle_site_symmetry_2' +
1186	'\n _geom_angle_site_symmetry_3' +
1187	'\n _geom_angle_publ_flag')
1188
1189	for i in sorted(AtomLabels.keys()):
1190	Dist = DistArray[i]
1191	for k,j,tup in AngArray[i]:
1192	Dj = Dist[j]
1193	Dk = Dist[k]
1194	line = ' '+PutInCol(AtomLabels[Dj[0]],6)+PutInCol(AtomLabels[i],6)+PutInCol(AtomLabels[Dk[0]],6)
1195	sig = tup[1]
1196	if sig == 0: sig = -0.009
1197	line += PutInCol(G2mth.ValEsd(tup[0],sig,True),10)
1198	line += " {:3d}_".format(G2opcodes.index(Dj[2])+1)
1199	for d in Dj[1]:
1200	line += "{:1d}".format(d+5)
1201	line += " 1_555 "
1202	line += " {:3d}_".format(G2opcodes.index(Dk[2])+1)
1203	for d in Dk[1]:
1204	line += "{:1d}".format(d+5)
1205	key = (tuple(Dk[0:3]),i,tuple(Dj[0:3]))
1206	if DisAngSel.get(key):
1207	line += " no"
1208	else:
1209	line += " yes"
1210	WriteCIFitem(self.fp, line)
1211
1212	def WritePhaseInfo(phasenam,hist=None):
1213	'Write out the phase information for the selected phase'
1214	WriteCIFitem(self.fp, '\n# phase info for '+str(phasenam) + ' follows')
1215	phasedict = self.Phases[phasenam] # pointer to current phase info
1216	WriteCIFitem(self.fp, '_pd_phase_name', phasenam)
1217	cellList,cellSig = self.GetCell(phasenam)
1218	defsigL = 3[-0.00001] + 3[-0.001] + [-0.01] # significance to use when no sigma
1219	names = ['length_a','length_b','length_c',
1220	'angle_alpha','angle_beta ','angle_gamma',
1221	'volume']
1222	prevsig = 0
1223	for lbl,defsig,val,sig in zip(names,defsigL,cellList,cellSig):
1224	if sig:
1225	txt = G2mth.ValEsd(val,sig)
1226	prevsig = -sig # use this as the significance for next value
1227	else:
1228	txt = G2mth.ValEsd(val,min(defsig,prevsig),True)
1229	WriteCIFitem(self.fp, '_cell_'+lbl,txt)
1230
1231	density = G2mth.getDensity(phasedict['General'])[0]
1232	WriteCIFitem(self.fp, '_exptl_crystal_density_diffrn',
1233	G2mth.ValEsd(density,-0.001))
1234
1235	WriteCIFitem(self.fp, '_symmetry_cell_setting',
1236	phasedict['General']['SGData']['SGSys'])
1237
1238	if phasedict['General']['Type'] in ['nuclear','macromolecular']:
1239	spacegroup = phasedict['General']['SGData']['SpGrp'].strip()
1240	# regularize capitalization and remove trailing H/R
1241	spacegroup = spacegroup[0].upper() + spacegroup[1:].lower().rstrip('rh ')
1242	WriteCIFitem(self.fp, '_symmetry_space_group_name_H-M',spacegroup)
1243
1244	# generate symmetry operations including centering and center of symmetry
1245	SymOpList,offsetList,symOpList,G2oprList,G2opcodes = G2spc.AllOps(
1246	phasedict['General']['SGData'])
1247	WriteCIFitem(self.fp, 'loop_\n _space_group_symop_id\n _space_group_symop_operation_xyz')
1248	for i,op in enumerate(SymOpList,start=1):
1249	WriteCIFitem(self.fp, ' {:3d} {:}'.format(i,op.lower()))
1250	elif phasedict['General']['Type'] == 'magnetic':
1251	parentSpGrp = phasedict['General']['SGData']['SpGrp'].strip()
1252	parentSpGrp = parentSpGrp[0].upper() + parentSpGrp[1:].lower().rstrip('rh ')
1253	WriteCIFitem(self.fp, '_parent_space_group.name_H-M_alt',parentSpGrp)
1254	# [Trans,Uvec,Vvec] = phasedict['General']['SGData']['fromParent'] #save these
1255	spacegroup = phasedict['General']['SGData']['MagSpGrp'].strip()
1256	spacegroup = spacegroup[0].upper() + spacegroup[1:].lower().rstrip('rh ')
1257	WriteCIFitem(self.fp, '_space_group_magn.name_BNS',spacegroup)
1258	WriteCIFitem(self.fp, '_space_group.magn_point_group',phasedict['General']['SGData']['MagPtGp'])
1259
1260	# generate symmetry operations including centering and center of symmetry
1261	SymOpList,offsetList,symOpList,G2oprList,G2opcodes = G2spc.AllOps(
1262	phasedict['General']['SGData'])
1263	SpnFlp = phasedict['General']['SGData']['SpnFlp']
1264	WriteCIFitem(self.fp, 'loop_\n _space_group_symop_magn_operation.id\n _space_group_symop_magn_operation.xyz')
1265	for i,op in enumerate(SymOpList,start=1):
1266	if SpnFlp[i-1] >0:
1267	opr = op.lower()+',+1'
1268	else:
1269	opr = op.lower()+',-1'
1270	WriteCIFitem(self.fp, ' {:3d} {:}'.format(i,opr))
1271
1272	# loop over histogram(s) used in this phase
1273	if not oneblock and not self.quickmode and not hist:
1274	# report pointers to the histograms used in this phase
1275	histlist = []
1276	for hist in self.Phases[phasenam]['Histograms']:
1277	if self.Phases[phasenam]['Histograms'][hist]['Use']:
1278	if phasebyhistDict.get(hist):
1279	phasebyhistDict[hist].append(phasenam)
1280	else:
1281	phasebyhistDict[hist] = [phasenam,]
1282	blockid = datablockidDict.get(hist)
1283	if not blockid:
1284	print("Internal error: no block for data. Phase "+str(
1285	phasenam)+" histogram "+str(hist))
1286	histlist = []
1287	break
1288	histlist.append(blockid)
1289
1290	if len(histlist) == 0:
1291	WriteCIFitem(self.fp, '# Note: phase has no associated data')
1292
1293	# report atom params
1294	if phasedict['General']['Type'] in ['nuclear','macromolecular']: #this needs macromolecular variant, etc!
1295	try:
1296	self.labellist
1297	except AttributeError:
1298	self.labellist = []
1299	WriteAtomsNuclear(self.fp, self.Phases[phasenam], phasenam,
1300	self.parmDict, self.sigDict, self.labellist)
1301	else:
1302	try:
1303	self.labellist
1304	except AttributeError:
1305	self.labellist = []
1306	WriteAtomsMagnetic(self.fp, self.Phases[phasenam], phasenam,
1307	self.parmDict, self.sigDict, self.labellist)
1308	# self.CloseFile()
1309	# raise Exception("no export for "+str(phasedict['General']['Type'])+" coordinates implemented")
1310	# report cell contents
1311	WriteComposition(self.fp, self.Phases[phasenam], phasenam, self.parmDict)
1312	if not self.quickmode and phasedict['General']['Type'] == 'nuclear': # report distances and angles
1313	WriteDistances(phasenam,SymOpList,offsetList,symOpList,G2oprList)
1314	if 'Map' in phasedict['General'] and 'minmax' in phasedict['General']['Map']:
1315	WriteCIFitem(self.fp, '\n# Difference density results')
1316	MinMax = phasedict['General']['Map']['minmax']
1317	WriteCIFitem(self.fp, '_refine_diff_density_max',G2mth.ValEsd(MinMax[0],-0.009))
1318	WriteCIFitem(self.fp, '_refine_diff_density_min',G2mth.ValEsd(MinMax[1],-0.009))
1319
1320	def Yfmt(ndec,val):
1321	'Format intensity values'
1322	out = ("{:."+str(ndec)+"f}").format(val)
1323	out = out.rstrip('0') # strip zeros to right of decimal
1324	return out.rstrip('.') # and decimal place when not needed
1325
1326	def WriteReflStat(refcount,hklmin,hklmax,dmin,dmax,nRefSets=1):
1327	'Write reflection statistics'
1328	WriteCIFitem(self.fp, '_reflns_number_total', str(refcount))
1329	if hklmin is not None and nRefSets == 1: # hkl range has no meaning with multiple phases
1330	WriteCIFitem(self.fp, '_reflns_limit_h_min', str(int(hklmin[0])))
1331	WriteCIFitem(self.fp, '_reflns_limit_h_max', str(int(hklmax[0])))
1332	WriteCIFitem(self.fp, '_reflns_limit_k_min', str(int(hklmin[1])))
1333	WriteCIFitem(self.fp, '_reflns_limit_k_max', str(int(hklmax[1])))
1334	WriteCIFitem(self.fp, '_reflns_limit_l_min', str(int(hklmin[2])))
1335	WriteCIFitem(self.fp, '_reflns_limit_l_max', str(int(hklmax[2])))
1336	if hklmin is not None:
1337	WriteCIFitem(self.fp, '_reflns_d_resolution_low ', G2mth.ValEsd(dmax,-0.009))
1338	WriteCIFitem(self.fp, '_reflns_d_resolution_high ', G2mth.ValEsd(dmin,-0.009))
1339
1340	def WritePowderData(histlbl):
1341	'Write out the selected powder diffraction histogram info'
1342	histblk = self.Histograms[histlbl]
1343	inst = histblk['Instrument Parameters'][0]
1344	hId = histblk['hId']
1345	pfx = ':' + str(hId) + ':'
1346
1347	if 'Lam1' in inst:
1348	ratio = self.parmDict.get('I(L2)/I(L1)',inst['I(L2)/I(L1)'][1])
1349	sratio = self.sigDict.get('I(L2)/I(L1)',-0.0009)
1350	lam1 = self.parmDict.get('Lam1',inst['Lam1'][1])
1351	slam1 = self.sigDict.get('Lam1',-0.00009)
1352	lam2 = self.parmDict.get('Lam2',inst['Lam2'][1])
1353	slam2 = self.sigDict.get('Lam2',-0.00009)
1354	# always assume Ka1 & Ka2 if two wavelengths are present
1355	WriteCIFitem(self.fp, '_diffrn_radiation_type','K\\a~1,2~')
1356	WriteCIFitem(self.fp, 'loop_' +
1357	'\n _diffrn_radiation_wavelength' +
1358	'\n _diffrn_radiation_wavelength_wt' +
1359	'\n _diffrn_radiation_wavelength_id')
1360	WriteCIFitem(self.fp, ' ' + PutInCol(G2mth.ValEsd(lam1,slam1),15)+
1361	PutInCol('1.0',15) +
1362	PutInCol('1',5))
1363	WriteCIFitem(self.fp, ' ' + PutInCol(G2mth.ValEsd(lam2,slam2),15)+
1364	PutInCol(G2mth.ValEsd(ratio,sratio),15)+
1365	PutInCol('2',5))
1366	elif 'Lam' in inst:
1367	lam1 = self.parmDict.get('Lam',inst['Lam'][1])
1368	slam1 = self.sigDict.get('Lam',-0.00009)
1369	WriteCIFitem(self.fp, '_diffrn_radiation_wavelength',G2mth.ValEsd(lam1,slam1))
1370
1371	if not oneblock:
1372	if not phasebyhistDict.get(histlbl):
1373	WriteCIFitem(self.fp, '\n# No phases associated with this data set')
1374	else:
1375	WriteCIFitem(self.fp, '\n# PHASE TABLE')
1376	WriteCIFitem(self.fp, 'loop_' +
1377	'\n _pd_phase_id' +
1378	'\n _pd_phase_block_id' +
1379	'\n _pd_phase_mass_%')
1380	wtFrSum = 0.
1381	for phasenam in phasebyhistDict.get(histlbl):
1382	hapData = self.Phases[phasenam]['Histograms'][histlbl]
1383	General = self.Phases[phasenam]['General']
1384	wtFrSum += hapData['Scale'][0]*General['Mass']
1385
1386	for phasenam in phasebyhistDict.get(histlbl):
1387	hapData = self.Phases[phasenam]['Histograms'][histlbl]
1388	General = self.Phases[phasenam]['General']
1389	wtFr = hapData['Scale'][0]*General['Mass']/wtFrSum
1390	pfx = str(self.Phases[phasenam]['pId'])+':'+str(hId)+':'
1391	if pfx+'Scale' in self.sigDict:
1392	sig = self.sigDict[pfx+'Scale']*wtFr/hapData['Scale'][0]
1393	else:
1394	sig = -0.0001
1395	WriteCIFitem(self.fp,
1396	' '+
1397	str(self.Phases[phasenam]['pId']) +
1398	' '+datablockidDict[phasenam]+
1399	' '+G2mth.ValEsd(wtFr,sig)
1400	)
1401	WriteCIFitem(self.fp, 'loop_' +
1402	'\n _gsas_proc_phase_R_F_factor' +
1403	'\n _gsas_proc_phase_R_Fsqd_factor' +
1404	'\n _gsas_proc_phase_id' +
1405	'\n _gsas_proc_phase_block_id')
1406	for phasenam in phasebyhistDict.get(histlbl):
1407	pfx = str(self.Phases[phasenam]['pId'])+':'+str(hId)+':'
1408	WriteCIFitem(self.fp,
1409	' '+
1410	' '+G2mth.ValEsd(histblk[pfx+'Rf']/100.,-.00009) +
1411	' '+G2mth.ValEsd(histblk[pfx+'Rf^2']/100.,-.00009)+
1412	' '+str(self.Phases[phasenam]['pId'])+
1413	' '+datablockidDict[phasenam]
1414	)
1415	else:
1416	# single phase in this histogram
1417	pfx = '0:'+str(hId)+':'
1418	WriteCIFitem(self.fp, '_refine_ls_R_F_factor ','%.5f'%(histblk[pfx+'Rf']/100.))
1419	WriteCIFitem(self.fp, '_refine_ls_R_Fsqd_factor ','%.5f'%(histblk[pfx+'Rf^2']/100.))
1420
1421	WriteCIFitem(self.fp, '_pd_proc_ls_prof_R_factor ','%.5f'%(histblk['R']/100.))
1422	WriteCIFitem(self.fp, '_pd_proc_ls_prof_wR_factor ','%.5f'%(histblk['wR']/100.))
1423	WriteCIFitem(self.fp, '_gsas_proc_ls_prof_R_B_factor ','%.5f'%(histblk['Rb']/100.))
1424	WriteCIFitem(self.fp, '_gsas_proc_ls_prof_wR_B_factor','%.5f'%(histblk['wRb']/100.))
1425	WriteCIFitem(self.fp, '_pd_proc_ls_prof_wR_expected','%.5f'%(histblk['wRmin']/100.))
1426
1427	if histblk['Instrument Parameters'][0]['Type'][1][1] == 'X':
1428	WriteCIFitem(self.fp, '_diffrn_radiation_probe','x-ray')
1429	pola = histblk['Instrument Parameters'][0].get('Polariz.')
1430	if pola:
1431	pfx = ':' + str(hId) + ':'
1432	sig = self.sigDict.get(pfx+'Polariz.',-0.0009)
1433	txt = G2mth.ValEsd(pola[1],sig)
1434	WriteCIFitem(self.fp, '_diffrn_radiation_polarisn_ratio',txt)
1435	elif histblk['Instrument Parameters'][0]['Type'][1][1] == 'N':
1436	WriteCIFitem(self.fp, '_diffrn_radiation_probe','neutron')
1437	if 'T' in inst['Type'][0]:
1438	txt = G2mth.ValEsd(inst['2-theta'][0],-0.009)
1439	WriteCIFitem(self.fp, '_pd_meas_2theta_fixed',txt)
1440
1441	# TODO: this will need help from Bob
1442	#if not oneblock:
1443	#WriteCIFitem(self.fp, '\n# SCATTERING FACTOR INFO')
1444	#WriteCIFitem(self.fp, 'loop_ _atom_type_symbol')
1445	#if histblk['Instrument Parameters'][0]['Type'][1][1] == 'X':
1446	# WriteCIFitem(self.fp, ' _atom_type_scat_dispersion_real')
1447	# WriteCIFitem(self.fp, ' _atom_type_scat_dispersion_imag')
1448	# for lbl in ('a1','a2','a3', 'a4', 'b1', 'b2', 'b3', 'b4', 'c'):
1449	# WriteCIFitem(self.fp, ' _atom_type_scat_Cromer_Mann_'+lbl)
1450	#elif histblk['Instrument Parameters'][0]['Type'][1][1] == 'N':
1451	# WriteCIFitem(self.fp, ' _atom_type_scat_length_neutron')
1452	#WriteCIFitem(self.fp, ' _atom_type_scat_source')
1453
1454	WriteCIFitem(self.fp, '_pd_proc_ls_background_function',FormatBackground(histblk['Background'],histblk['hId']))
1455
1456	# TODO: this will need help from Bob
1457	#WriteCIFitem(self.fp, '_exptl_absorpt_process_details','?')
1458	#WriteCIFitem(self.fp, '_exptl_absorpt_correction_T_min','?')
1459	#WriteCIFitem(self.fp, '_exptl_absorpt_correction_T_max','?')
1460	#C extinction
1461	#WRITE(IUCIF,'(A)') '# Extinction correction'
1462	#CALL WRVAL(IUCIF,'_gsas_exptl_extinct_corr_T_min',TEXT(1:10))
1463	#CALL WRVAL(IUCIF,'_gsas_exptl_extinct_corr_T_max',TEXT(11:20))
1464
1465	if not oneblock: # instrumental profile terms go here
1466	WriteCIFitem(self.fp, '_pd_proc_ls_profile_function',
1467	FormatInstProfile(histblk["Instrument Parameters"],histblk['hId']))
1468
1469	#refprx = '_refln.' # mm
1470	refprx = '_refln_' # normal
1471	# data collection parameters for the powder dataset
1472
1473	temperature = histblk['Sample Parameters'].get('Temperature') # G2 uses K
1474	if not temperature:
1475	T = '?'
1476	else:
1477	T = G2mth.ValEsd(temperature,-0.009,True) # CIF uses K
1478	WriteCIFitem(self.fp, '_diffrn_ambient_temperature',T)
1479
1480	pressure = histblk['Sample Parameters'].get('Pressure') #G2 uses mega-Pascal
1481	if not pressure:
1482	P = '?'
1483	else:
1484	P = G2mth.ValEsd(pressure*1000,-0.09,True) # CIF uses kilopascal
1485	WriteCIFitem(self.fp, '_diffrn_ambient_pressure',P)
1486
1487	WriteCIFitem(self.fp, '\n# STRUCTURE FACTOR TABLE')
1488	# compute maximum intensity reflection
1489	Imax = 0
1490	for phasenam in histblk['Reflection Lists']:
1491	scale = self.Phases[phasenam]['Histograms'][histlbl]['Scale'][0]
1492	refList = np.asarray(histblk['Reflection Lists'][phasenam]['RefList'])
1493	I100 = scalerefList.T[8]refList.T[11]
1494	#Icorr = np.array([refl[13] for refl in histblk['Reflection Lists'][phasenam]])[0]
1495	#FO2 = np.array([refl[8] for refl in histblk['Reflection Lists'][phasenam]])
1496	#I100 = scaleFO2Icorr
1497	Imax = max(Imax,max(I100))
1498
1499	WriteCIFitem(self.fp, 'loop_')
1500	if len(histblk['Reflection Lists'].keys()) > 1:
1501	WriteCIFitem(self.fp, ' _pd_refln_phase_id')
1502	WriteCIFitem(self.fp, ' ' + refprx + 'index_h' +
1503	'\n ' + refprx + 'index_k' +
1504	'\n ' + refprx + 'index_l' +
1505	'\n ' + refprx + 'F_squared_meas' +
1506	'\n ' + refprx + 'F_squared_calc' +
1507	'\n ' + refprx + 'phase_calc' +
1508	'\n _refln_d_spacing')
1509	if Imax > 0:
1510	WriteCIFitem(self.fp, ' _gsas_i100_meas')
1511
1512	refcount = 0
1513	hklmin = None
1514	hklmax = None
1515	dmax = None
1516	dmin = None
1517	for phasenam in histblk['Reflection Lists']:
1518	scale = self.Phases[phasenam]['Histograms'][histlbl]['Scale'][0]
1519	phaseid = self.Phases[phasenam]['pId']
1520	refcount += len(histblk['Reflection Lists'][phasenam]['RefList'])
1521	refList = np.asarray(histblk['Reflection Lists'][phasenam]['RefList'])
1522	I100 = scalerefList.T[8]refList.T[11]
1523	for j,ref in enumerate(histblk['Reflection Lists'][phasenam]['RefList']):
1524	if DEBUG:
1525	print('DEBUG: skipping reflection list')
1526	break
1527	if hklmin is None:
1528	hklmin = ref[0:3]
1529	hklmax = ref[0:3]
1530	dmax = dmin = ref[4]
1531	if len(histblk['Reflection Lists'].keys()) > 1:
1532	s = PutInCol(phaseid,2)
1533	else:
1534	s = ""
1535	for i,hkl in enumerate(ref[0:3]):
1536	hklmax[i] = max(hkl,hklmax[i])
1537	hklmin[i] = min(hkl,hklmin[i])
1538	s += PutInCol(int(hkl),4)
1539	for I in ref[8:10]:
1540	s += PutInCol(G2mth.ValEsd(I,-0.0009),10)
1541	s += PutInCol(G2mth.ValEsd(ref[10],-0.9),7)
1542	dmax = max(dmax,ref[4])
1543	dmin = min(dmin,ref[4])
1544	s += PutInCol(G2mth.ValEsd(ref[4],-0.00009),8)
1545	if Imax > 0:
1546	s += PutInCol(G2mth.ValEsd(100.*I100[j]/Imax,-0.09),6)
1547	WriteCIFitem(self.fp, " "+s)
1548
1549	WriteReflStat(refcount,hklmin,hklmax,dmin,dmax,len(histblk['Reflection Lists']))
1550	WriteCIFitem(self.fp, '\n# POWDER DATA TABLE')
1551	# is data fixed step? If the step varies by <0.01% treat as fixed step
1552	steps = histblk['Data'][0][1:] - histblk['Data'][0][:-1]
1553	if abs(max(steps)-min(steps)) > abs(max(steps))/10000.:
1554	fixedstep = False
1555	else:
1556	fixedstep = True
1557
1558	zero = None
1559	if fixedstep and 'T' not in inst['Type'][0]: # and not TOF
1560	WriteCIFitem(self.fp, '_pd_meas_2theta_range_min', G2mth.ValEsd(histblk['Data'][0][0],-0.00009))
1561	WriteCIFitem(self.fp, '_pd_meas_2theta_range_max', G2mth.ValEsd(histblk['Data'][0][-1],-0.00009))
1562	WriteCIFitem(self.fp, '_pd_meas_2theta_range_inc', G2mth.ValEsd(steps.sum()/len(steps),-0.00009))
1563	# zero correct, if defined
1564	zerolst = histblk['Instrument Parameters'][0].get('Zero')
1565	if zerolst: zero = zerolst[1]
1566	zero = self.parmDict.get('Zero',zero)
1567	if zero:
1568	WriteCIFitem(self.fp, '_pd_proc_2theta_range_min', G2mth.ValEsd(histblk['Data'][0][0]-zero,-0.00009))
1569	WriteCIFitem(self.fp, '_pd_proc_2theta_range_max', G2mth.ValEsd(histblk['Data'][0][-1]-zero,-0.00009))
1570	WriteCIFitem(self.fp, '_pd_proc_2theta_range_inc', G2mth.ValEsd(steps.sum()/len(steps),-0.00009))
1571
1572	if zero:
1573	WriteCIFitem(self.fp, '_pd_proc_number_of_points', str(len(histblk['Data'][0])))
1574	else:
1575	WriteCIFitem(self.fp, '_pd_meas_number_of_points', str(len(histblk['Data'][0])))
1576	WriteCIFitem(self.fp, '\nloop_')
1577	# WriteCIFitem(self.fp, ' _pd_proc_d_spacing') # need easy way to get this
1578	if not fixedstep:
1579	if zero:
1580	WriteCIFitem(self.fp, ' _pd_proc_2theta_corrected')
1581	elif 'T' in inst['Type'][0]: # and not TOF
1582	WriteCIFitem(self.fp, ' _pd_meas_time_of_flight')
1583	else:
1584	WriteCIFitem(self.fp, ' _pd_meas_2theta_scan')
1585	# at least for now, always report weights.
1586	#if countsdata:
1587	# WriteCIFitem(self.fp, ' _pd_meas_counts_total')
1588	#else:
1589	WriteCIFitem(self.fp, ' _pd_meas_intensity_total')
1590	WriteCIFitem(self.fp, ' _pd_calc_intensity_total')
1591	WriteCIFitem(self.fp, ' _pd_proc_intensity_bkg_calc')
1592	WriteCIFitem(self.fp, ' _pd_proc_ls_weight')
1593	maxY = max(histblk['Data'][1].max(),histblk['Data'][3].max())
1594	if maxY < 0: maxY *= -10 # this should never happen, but...
1595	ndec = max(0,10-int(np.log10(maxY))-1) # 10 sig figs should be enough
1596	maxSU = histblk['Data'][2].max()
1597	if maxSU < 0: maxSU *= -1 # this should never happen, but...
1598	ndecSU = max(0,8-int(np.log10(maxSU))-1) # 8 sig figs should be enough
1599	lowlim,highlim = histblk['Limits'][1]
1600
1601	if DEBUG:
1602	print('DEBUG: skipping profile list')
1603	else:
1604	for x,yobs,yw,ycalc,ybkg in zip(histblk['Data'][0],
1605	histblk['Data'][1],
1606	histblk['Data'][2],
1607	histblk['Data'][3],
1608	histblk['Data'][4]):
1609	if lowlim <= x <= highlim:
1610	pass
1611	else:
1612	yw = 0.0 # show the point is not in use
1613
1614	if fixedstep:
1615	s = ""
1616	elif zero:
1617	s = PutInCol(G2mth.ValEsd(x-zero,-0.00009),10)
1618	else:
1619	s = PutInCol(G2mth.ValEsd(x,-0.00009),10)
1620	s += PutInCol(Yfmt(ndec,yobs),12)
1621	s += PutInCol(Yfmt(ndec,ycalc),12)
1622	s += PutInCol(Yfmt(ndec,ybkg),11)
1623	s += PutInCol(Yfmt(ndecSU,yw),9)
1624	WriteCIFitem(self.fp, " "+s)
1625
1626	def WriteSingleXtalData(histlbl):
1627	'Write out the selected single crystal histogram info'
1628	histblk = self.Histograms[histlbl]
1629
1630	#refprx = '_refln.' # mm
1631	refprx = '_refln_' # normal
1632
1633	WriteCIFitem(self.fp, '\n# STRUCTURE FACTOR TABLE')
1634	WriteCIFitem(self.fp, 'loop_' +
1635	'\n ' + refprx + 'index_h' +
1636	'\n ' + refprx + 'index_k' +
1637	'\n ' + refprx + 'index_l' +
1638	'\n ' + refprx + 'F_squared_meas' +
1639	'\n ' + refprx + 'F_squared_sigma' +
1640	'\n ' + refprx + 'F_squared_calc' +
1641	'\n ' + refprx + 'phase_calc'
1642	)
1643
1644	hklmin = None
1645	hklmax = None
1646	dmax = None
1647	dmin = None
1648	refcount = len(histblk['Data']['RefList'])
1649	for ref in histblk['Data']['RefList']:
1650	if ref[3] <= 0: #skip user rejected reflections (mul <= 0)
1651	continue
1652	s = " "
1653	if hklmin is None:
1654	hklmin = ref[0:3]
1655	hklmax = ref[0:3]
1656	dmax = dmin = ref[4]
1657	for i,hkl in enumerate(ref[0:3]):
1658	hklmax[i] = max(hkl,hklmax[i])
1659	hklmin[i] = min(hkl,hklmin[i])
1660	s += PutInCol(int(hkl),4)
1661	if ref[5] == 0.0:
1662	s += PutInCol(G2mth.ValEsd(ref[8],0),12)
1663	s += PutInCol('.',10)
1664	s += PutInCol(G2mth.ValEsd(ref[9],0),12)
1665	s += PutInCol(G2mth.ValEsd(ref[10],-0.9),7)
1666	else:
1667	sig = ref[6] * ref[8] / ref[5]
1668	s += PutInCol(G2mth.ValEsd(ref[8],-abs(sig/10)),12)
1669	s += PutInCol(G2mth.ValEsd(sig,-abs(sig)/10.),10)
1670	s += PutInCol(G2mth.ValEsd(ref[9],-abs(sig/10)),12)
1671	s += PutInCol(G2mth.ValEsd(ref[10],-0.9),7)
1672	dmax = max(dmax,ref[4])
1673	dmin = min(dmin,ref[4])
1674	WriteCIFitem(self.fp, s)
1675	if not self.quickmode: # statistics only in a full CIF
1676	WriteReflStat(refcount,hklmin,hklmax,dmin,dmax)
1677	hId = histblk['hId']
1678	hfx = '0:'+str(hId)+':'
1679	phfx = '%d:%d:'%(0,hId)
1680	extType,extModel,extParms = self.Phases[phasenam]['Histograms'][histlbl]['Extinction']
1681	if extModel != 'None':
1682	WriteCIFitem(self.fp, '# Extinction scaled by 1.e5')
1683	WriteCIFitem(self.fp, '_refine_ls_extinction_method','Becker-Coppens %s %s'%(extModel,extType))
1684	sig = -1.e-3
1685	if extModel == 'Primary':
1686	parm = extParms['Ep'][0]*1.e5
1687	if extParms['Ep'][1]:
1688	sig = self.sigDict[phfx+'Ep']*1.e5
1689	text = G2mth.ValEsd(parm,sig)
1690	elif extModel == 'Secondary Type I':
1691	parm = extParms['Eg'][0]*1.e5
1692	if extParms['Eg'][1]:
1693	sig = self.sigDict[phfx+'Eg']*1.e5
1694	text = G2mth.ValEsd(parm,sig)
1695	elif extModel == 'Secondary Type II':
1696	parm = extParms['Es'][0]*1.e5
1697	if extParms['Es'][1]:
1698	sig = self.sigDict[phfx+'Es']*1.e5
1699	text = G2mth.ValEsd(parm,sig)
1700	elif extModel == 'Secondary Type I & II':
1701	parm = extParms['Eg'][0]*1.e5
1702	if extParms['Es'][1]:
1703	sig = self.sigDict[phfx+'Es']*1.e5
1704	text = G2mth.ValEsd(parm,sig)
1705	sig = -1.0e-3
1706	parm = extParms['Es'][0]*1.e5
1707	if extParms['Es'][1]:
1708	sig = self.sigDict[phfx+'Es']*1.e5
1709	text += G2mth.ValEsd(parm,sig)
1710	WriteCIFitem(self.fp, '_refine_ls_extinction_coef',text)
1711	WriteCIFitem(self.fp, '_refine_ls_extinction_expression','Becker & Coppens (1974). Acta Cryst. A30, 129-147')
1712
1713	WriteCIFitem(self.fp, '_refine_ls_wR_factor_gt ','%.4f'%(histblk['wR']/100.))
1714	WriteCIFitem(self.fp, '_refine_ls_R_factor_gt ','%.4f'%(histblk[hfx+'Rf']/100.))
1715	WriteCIFitem(self.fp, '_refine_ls_R_Fsqd_factor ','%.4f'%(histblk[hfx+'Rf^2']/100.))
1716	def EditAuthor(event=None):
1717	'dialog to edit the CIF author info'
1718	'Edit the CIF author name'
1719	dlg = G2G.SingleStringDialog(self.G2frame,
1720	'Get CIF Author',
1721	'Provide CIF Author name (Last, First)',
1722	value=self.author)
1723	if not dlg.Show():
1724	dlg.Destroy()
1725	return False # cancel was pressed
1726	self.author = dlg.GetValue()
1727	self.shortauthorname = self.author.replace(',','').replace(' ','')[:20]
1728	dlg.Destroy()
1729	try:
1730	self.OverallParms['Controls']["Author"] = self.author # save for future
1731	except KeyError:
1732	pass
1733	return True
1734
1735	def EditInstNames(event=None):
1736	'Provide a dialog for editing instrument names'
1737	dictlist = []
1738	keylist = []
1739	lbllist = []
1740	for hist in self.Histograms:
1741	if hist.startswith("PWDR"):
1742	key2 = "Sample Parameters"
1743	d = self.Histograms[hist][key2]
1744	elif hist.startswith("HKLF"):
1745	key2 = "Instrument Parameters"
1746	d = self.Histograms[hist][key2][0]
1747
1748	lbllist.append(hist)
1749	dictlist.append(d)
1750	keylist.append('InstrName')
1751	instrname = d.get('InstrName')
1752	if instrname is None:
1753	d['InstrName'] = ''
1754	return G2G.CallScrolledMultiEditor(
1755	self.G2frame,dictlist,keylist,
1756	prelbl=range(1,len(dictlist)+1),
1757	postlbl=lbllist,
1758	title='Instrument names',
1759	header="Edit instrument names. Note that a non-blank\nname is required for all histograms",
1760	CopyButton=True,ASCIIonly=True)
1761
1762	def EditRanges(event):
1763	'''Edit the bond distance/angle search range; phase is determined from
1764	a pointer placed in the button object (.phasedict) that references the
1765	phase dictionary
1766	'''
1767	but = event.GetEventObject()
1768	phasedict = but.phasedict
1769	dlg = G2G.DisAglDialog(
1770	self.G2frame,
1771	phasedict['General']['DisAglCtls'], # edited
1772	phasedict['General'], # defaults
1773	)
1774	if dlg.ShowModal() == wx.ID_OK:
1775	phasedict['General']['DisAglCtls'] = dlg.GetData()
1776	dlg.Destroy()
1777
1778	def EditCIFDefaults():
1779	'''Fills the CIF Defaults window with controls for editing various CIF export
1780	parameters (mostly related to templates).
1781	'''
1782	self.cifdefs.DestroyChildren()
1783	self.cifdefs.SetTitle('Edit CIF settings')
1784	vbox = wx.BoxSizer(wx.VERTICAL)
1785	vbox.Add(wx.StaticText(self.cifdefs, wx.ID_ANY,'Creating file '+self.filename))
1786	but = wx.Button(self.cifdefs, wx.ID_ANY,'Edit CIF Author')
1787	but.Bind(wx.EVT_BUTTON,EditAuthor)
1788	vbox.Add(but,0,wx.ALIGN_CENTER,3)
1789	but = wx.Button(self.cifdefs, wx.ID_ANY,'Edit Instrument Name(s)')
1790	but.Bind(wx.EVT_BUTTON,EditInstNames)
1791	vbox.Add(but,0,wx.ALIGN_CENTER,3)
1792	cpnl = wxscroll.ScrolledPanel(self.cifdefs,size=(300,300))
1793	cbox = wx.BoxSizer(wx.VERTICAL)
1794	G2G.HorizontalLine(cbox,cpnl)
1795	cbox.Add(
1796	CIFtemplateSelect(self.cifdefs,
1797	cpnl,'publ',self.OverallParms['Controls'],
1798	EditCIFDefaults,
1799	"Publication (overall) template",
1800	),
1801	0,wx.EXPAND\|wx.ALIGN_LEFT\|wx.ALL)
1802	for phasenam in sorted(self.Phases.keys()):
1803	G2G.HorizontalLine(cbox,cpnl)
1804	title = 'Phase '+phasenam
1805	phasedict = self.Phases[phasenam] # pointer to current phase info
1806	cbox.Add(
1807	CIFtemplateSelect(self.cifdefs,
1808	cpnl,'phase',phasedict['General'],
1809	EditCIFDefaults,
1810	title,
1811	phasenam),
1812	0,wx.EXPAND\|wx.ALIGN_LEFT\|wx.ALL)
1813	cpnl.SetSizer(cbox)
1814	if phasedict['General']['Type'] == 'nuclear':
1815	but = wx.Button(cpnl, wx.ID_ANY,'Edit distance/angle ranges')
1816	cbox.Add(but,0,wx.ALIGN_LEFT,0)
1817	cbox.Add((-1,2))
1818	but.phasedict = self.Phases[phasenam] # set a pointer to current phase info
1819	but.Bind(wx.EVT_BUTTON,EditRanges) # phase bond/angle ranges
1820	but = wx.Button(cpnl, wx.ID_ANY,'Set distance/angle publication flags')
1821	but.phase = phasenam # set a pointer to current phase info
1822	but.Bind(wx.EVT_BUTTON,SelectDisAglFlags) # phase bond/angle ranges
1823	cbox.Add(but,0,wx.ALIGN_LEFT,0)
1824	cbox.Add((-1,2))
1825	for i in sorted(self.powderDict.keys()):
1826	G2G.HorizontalLine(cbox,cpnl)
1827	hist = self.powderDict[i]
1828	histblk = self.Histograms[hist]
1829	title = 'Powder dataset '+hist[5:]
1830	cbox.Add(
1831	CIFtemplateSelect(self.cifdefs,
1832	cpnl,'powder',histblk["Sample Parameters"],
1833	EditCIFDefaults,
1834	title,
1835	histblk["Sample Parameters"]['InstrName']),
1836	0,wx.EXPAND\|wx.ALIGN_LEFT\|wx.ALL)
1837	for i in sorted(self.xtalDict.keys()):
1838	G2G.HorizontalLine(cbox,cpnl)
1839	hist = self.xtalDict[i]
1840	histblk = self.Histograms[hist]
1841	title = 'Single Xtal dataset '+hist[5:]
1842	cbox.Add(
1843	CIFtemplateSelect(self.cifdefs,
1844	cpnl,'single',histblk["Instrument Parameters"][0],
1845	EditCIFDefaults,
1846	title,
1847	histblk["Instrument Parameters"][0]['InstrName']),
1848	0,wx.EXPAND\|wx.ALIGN_LEFT\|wx.ALL)
1849	cpnl.SetSizer(cbox)
1850	cpnl.SetAutoLayout(1)
1851	cpnl.SetupScrolling()
1852	#cpnl.Bind(rw.EVT_RW_LAYOUT_NEEDED, self.OnLayoutNeeded) # needed if sizes change
1853	cpnl.Layout()
1854
1855	vbox.Add(cpnl, 1, wx.ALIGN_LEFT\|wx.ALL\|wx.EXPAND, 0)
1856	btnsizer = wx.StdDialogButtonSizer()
1857	btn = wx.Button(self.cifdefs, wx.ID_OK, "Create CIF")
1858	btn.SetDefault()
1859	btnsizer.AddButton(btn)
1860	btn = wx.Button(self.cifdefs, wx.ID_CANCEL)
1861	btnsizer.AddButton(btn)
1862	btnsizer.Realize()
1863	vbox.Add(btnsizer, 0, wx.ALIGN_CENTER\|wx.ALL, 5)
1864	self.cifdefs.SetSizer(vbox)
1865	vbox.Fit(self.cifdefs)
1866	self.cifdefs.Layout()
1867
1868	def OnToggleButton(event):
1869	'Respond to press of ToggleButton in SelectDisAglFlags'
1870	but = event.GetEventObject()
1871	if but.GetValue():
1872	but.DisAglSel[but.key] = True
1873	else:
1874	try:
1875	del but.DisAglSel[but.key]
1876	except KeyError:
1877	pass
1878	def keepTrue(event):
1879	event.GetEventObject().SetValue(True)
1880	def keepFalse(event):
1881	event.GetEventObject().SetValue(False)
1882
1883	def SelectDisAglFlags(event):
1884	'Select Distance/Angle use flags for the selected phase'
1885	phasenam = event.GetEventObject().phase
1886	phasedict = self.Phases[phasenam]
1887	SymOpList,offsetList,symOpList,G2oprList,G2opcodes = G2spc.AllOps(phasedict['General']['SGData'])
1888	generalData = phasedict['General']
1889	# create a dict for storing Pub flag for bonds/angles, if needed
1890	if phasedict['General'].get("DisAglHideFlag") is None:
1891	phasedict['General']["DisAglHideFlag"] = {}
1892	DisAngSel = phasedict['General']["DisAglHideFlag"]
1893
1894	cx,ct,cs,cia = phasedict['General']['AtomPtrs']
1895	cn = ct-1
1896	cfrac = cx+3
1897	DisAglData = {}
1898	# create a list of atoms, but skip atoms with zero occupancy
1899	xyz = []
1900	fpfx = str(phasedict['pId'])+'::Afrac:'
1901	for i,atom in enumerate(phasedict['Atoms']):
1902	if self.parmDict.get(fpfx+str(i),atom[cfrac]) == 0.0: continue
1903	xyz.append([i,]+atom[cn:cn+2]+atom[cx:cx+3])
1904	if 'DisAglCtls' not in generalData:
1905	# should not be used, since DisAglDialog should be called
1906	# for all phases before getting here
1907	dlg = G2G.DisAglDialog(
1908	self.cifdefs,
1909	{},
1910	generalData)
1911	if dlg.ShowModal() == wx.ID_OK:
1912	generalData['DisAglCtls'] = dlg.GetData()
1913	else:
1914	dlg.Destroy()
1915	return
1916	dlg.Destroy()
1917	dlg = wx.Dialog(
1918	self.G2frame,
1919	style=wx.DEFAULT_DIALOG_STYLE \| wx.RESIZE_BORDER)
1920	vbox = wx.BoxSizer(wx.VERTICAL)
1921	txt = wx.StaticText(dlg,wx.ID_ANY,'Searching distances for phase '+phasenam
1922	+'\nPlease wait...')
1923	vbox.Add(txt,0,wx.ALL\|wx.EXPAND)
1924	dlg.SetSizer(vbox)
1925	dlg.CenterOnParent()
1926	dlg.Show() # post "please wait"
1927	wx.BeginBusyCursor() # and change cursor
1928
1929	DisAglData['OrigAtoms'] = xyz
1930	DisAglData['TargAtoms'] = xyz
1931	SymOpList,offsetList,symOpList,G2oprList,G2opcodes = G2spc.AllOps(
1932	generalData['SGData'])
1933
1934	# xpandSGdata = generalData['SGData'].copy()
1935	# xpandSGdata.update({'SGOps':symOpList,
1936	# 'SGInv':False,
1937	# 'SGLatt':'P',
1938	# 'SGCen':np.array([[0, 0, 0]]),})
1939	# DisAglData['SGData'] = xpandSGdata
1940	DisAglData['SGData'] = generalData['SGData'].copy()
1941
1942	DisAglData['Cell'] = generalData['Cell'][1:] #+ volume
1943	if 'pId' in phasedict:
1944	DisAglData['pId'] = phasedict['pId']
1945	DisAglData['covData'] = self.OverallParms['Covariance']
1946	try:
1947	AtomLabels,DistArray,AngArray = G2stMn.RetDistAngle(
1948	generalData['DisAglCtls'],
1949	DisAglData)
1950	except KeyError: # inside DistAngle for missing atom types in DisAglCtls
1951	print('** ERROR - try again but do "Reset" to fill in missing atom types **')
1952	wx.EndBusyCursor()
1953	txt.SetLabel('Set publication flags for distances and angles in\nphase '+phasenam)
1954	vbox.Add((5,5))
1955	vbox.Add(wx.StaticText(dlg,wx.ID_ANY,
1956	'The default is to flag all distances and angles as to be'+
1957	'\npublished. Change this by pressing appropriate buttons.'),
1958	0,wx.ALL\|wx.EXPAND)
1959	hbox = wx.BoxSizer(wx.HORIZONTAL)
1960	vbox.Add(hbox)
1961	hbox.Add(wx.StaticText(dlg,wx.ID_ANY,'Button appearance: '))
1962	but = wx.ToggleButton(dlg,wx.ID_ANY,'Publish')
1963	but.Bind(wx.EVT_TOGGLEBUTTON,keepFalse)
1964	hbox.Add(but)
1965	but = wx.ToggleButton(dlg,wx.ID_ANY,"Don't publish")
1966	but.Bind(wx.EVT_TOGGLEBUTTON,keepTrue)
1967	hbox.Add(but)
1968	but.SetValue(True)
1969	G2G.HorizontalLine(vbox,dlg)
1970
1971	cpnl = wxscroll.ScrolledPanel(dlg,size=(400,300))
1972	cbox = wx.BoxSizer(wx.VERTICAL)
1973	for c in sorted(DistArray):
1974	karr = []
1975	UsedCols = {}
1976	cbox.Add(wx.StaticText(cpnl,wx.ID_ANY,
1977	'distances to/angles around atom '+AtomLabels[c]))
1978	#dbox = wx.GridBagSizer(hgap=5)
1979	dbox = wx.GridBagSizer()
1980	for i,D in enumerate(DistArray[c]):
1981	karr.append(tuple(D[0:3]))
1982	val = "{:.2f}".format(D[3])
1983	sym = " [{:d} {:d} {:d}]".format(*D[1]) + " #{:d}".format(D[2])
1984	dbox.Add(wx.StaticText(cpnl,wx.ID_ANY,AtomLabels[D[0]]),
1985	(i+1,0)
1986	)
1987	dbox.Add(wx.StaticText(cpnl,wx.ID_ANY,sym),
1988	(i+1,1)
1989	)
1990	but = wx.ToggleButton(cpnl,wx.ID_ANY,val)
1991	but.key = (c,karr[-1])
1992	but.DisAglSel = DisAngSel
1993	if DisAngSel.get(but.key): but.SetValue(True)
1994	but.Bind(wx.EVT_TOGGLEBUTTON,OnToggleButton)
1995	dbox.Add(but,(i+1,2),border=1)
1996	for i,D in enumerate(AngArray[c]):
1997	val = "{:.1f}".format(D[2][0])
1998	but = wx.ToggleButton(cpnl,wx.ID_ANY,val)
1999	but.key = (karr[D[0]],c,karr[D[1]])
2000	but.DisAglSel = DisAngSel
2001	if DisAngSel.get(but.key): but.SetValue(True)
2002	but.Bind(wx.EVT_TOGGLEBUTTON,OnToggleButton)
2003	dbox.Add(but,(D[0]+1,D[1]+3),border=1)
2004	UsedCols[D[1]+3] = True
2005	for i,D in enumerate(DistArray[c][:-1]): # label columns that are used
2006	if UsedCols.get(i+3):
2007	dbox.Add(wx.StaticText(cpnl,wx.ID_ANY,AtomLabels[D[0]]),
2008	(0,i+3),
2009	flag=wx.ALIGN_CENTER
2010	)
2011	dbox.Add(wx.StaticText(cpnl,wx.ID_ANY,'distance'),
2012	(0,2),
2013	flag=wx.ALIGN_CENTER
2014	)
2015	cbox.Add(dbox)
2016	G2G.HorizontalLine(cbox,cpnl)
2017	cpnl.SetSizer(cbox)
2018	cpnl.SetAutoLayout(1)
2019	cpnl.SetupScrolling()
2020	#cpnl.Bind(rw.EVT_RW_LAYOUT_NEEDED, self.OnLayoutNeeded) # needed if sizes change
2021	cpnl.Layout()
2022
2023	vbox.Add(cpnl, 1, wx.ALIGN_LEFT\|wx.ALL\|wx.EXPAND, 0)
2024
2025	btnsizer = wx.StdDialogButtonSizer()
2026	btn = wx.Button(dlg, wx.ID_OK, "Done")
2027	btn.SetDefault()
2028	btnsizer.AddButton(btn)
2029	btnsizer.Realize()
2030	vbox.Add(btnsizer, 0, wx.ALIGN_CENTER\|wx.ALL, 5)
2031	dlg.SetSizer(vbox)
2032	vbox.Fit(dlg)
2033	dlg.Layout()
2034
2035	dlg.CenterOnParent()
2036	dlg.ShowModal()
2037
2038	#=================================================================================
2039	#===== end of function definitions for _Exporter =================================
2040	#=================================================================================
2041	# make sure required information is present
2042	self.CIFdate = dt.datetime.strftime(dt.datetime.now(),"%Y-%m-%dT%H:%M")
2043	if not self.CIFname: # Get a name for the CIF. If not defined, use the GPX name (save, if that is needed).
2044	if not self.G2frame.GSASprojectfile:
2045	self.G2frame.OnFileSaveas(None)
2046	if not self.G2frame.GSASprojectfile: return
2047	self.CIFname = os.path.splitext(
2048	os.path.split(self.G2frame.GSASprojectfile)[1]
2049	)[0]
2050	self.CIFname = self.CIFname.replace(' ','')
2051	# replace non-ASCII characters in CIFname with dots
2052	s = ''
2053	for c in self.CIFname:
2054	if ord(c) < 128:
2055	s += c
2056	else:
2057	s += '.'
2058	self.CIFname = s
2059	# load saved CIF author name
2060	try:
2061	self.author = self.OverallParms['Controls'].get("Author",'').strip()
2062	except KeyError:
2063	pass
2064	#=================================================================
2065	# write quick CIFs
2066	#=================================================================
2067	if phaseOnly: #====Phase only CIF ================================
2068	print('Writing CIF output to file '+self.filename)
2069	#self.OpenFile()
2070	oneblock = True
2071	self.quickmode = True
2072	self.Write(' ')
2073	self.Write(70*'#')
2074	WriteCIFitem(self.fp, 'data_'+phaseOnly.replace(' ','_'))
2075	#phaseblk = self.Phases[phaseOnly] # pointer to current phase info
2076	# report the phase info
2077	WritePhaseInfo(phaseOnly)
2078	#self.CloseFile()
2079	return
2080	elif histOnly: #====Histogram only CIF ================================
2081	print('Writing CIF output to file '+self.filename)
2082	#self.OpenFile()
2083	hist = histOnly
2084	#histname = histOnly.replace(' ','')
2085	oneblock = True
2086	self.quickmode = True
2087	self.ifHKLF = False
2088	self.ifPWDR = True
2089	self.Write(' ')
2090	self.Write(70*'#')
2091	#phasenam = self.Phases.keys()[0]
2092	WriteCIFitem(self.fp, 'data_'+self.CIFname)
2093	#print 'phasenam',phasenam
2094	#phaseblk = self.Phases[phasenam] # pointer to current phase info
2095	#instnam = instnam.replace(' ','')
2096	#WriteCIFitem(self.fp, '_pd_block_id',
2097	# str(self.CIFdate) + "\|" + str(self.CIFname) + "\|" +
2098	# str(self.shortauthorname) + "\|" + instnam + '\|' + histname)
2099	#WriteAudit()
2100	#writeCIFtemplate(self.OverallParms['Controls'],'publ') # overall (publication) template
2101	#WriteOverall()
2102	#writeCIFtemplate(self.Phases[phasenam]['General'],'phase',phasenam) # write phase template
2103	# report the phase info
2104	#WritePhaseInfo(phasenam,hist)
2105	# preferred orientation
2106	#SH = FormatSH(phasenam)
2107	#MD = FormatHAPpo(phasenam)
2108	#if SH and MD:
2109	# WriteCIFitem(self.fp, '_pd_proc_ls_pref_orient_corr', SH + '\n' + MD)
2110	#elif SH or MD:
2111	# WriteCIFitem(self.fp, '_pd_proc_ls_pref_orient_corr', SH + MD)
2112	#else:
2113	# WriteCIFitem(self.fp, '_pd_proc_ls_pref_orient_corr', 'none')
2114	# report profile, since one-block: include both histogram and phase info
2115	#WriteCIFitem(self.fp, '_pd_proc_ls_profile_function',
2116	# FormatInstProfile(histblk["Instrument Parameters"],histblk['hId'])
2117	# +'\n'+FormatPhaseProfile(phasenam))
2118	if hist.startswith("PWDR"):
2119	WritePowderData(hist)
2120	elif hist.startswith("HKLF"):
2121	WriteSingleXtalData(hist)
2122	#writeCIFtemplate(histblk,'powder',histblk['InstrName']) # write powder template
2123	#self.CloseFile()
2124	return
2125	#elif IncludeOnlyHist is not None: # truncate histogram list to only selected (for sequential export)
2126	# self.Histograms = {IncludeOnlyHist:self.Histograms[IncludeOnlyHist]}
2127
2128	#===============================================================================
2129	# the export process for a full CIF starts here
2130	#===============================================================================
2131	self.InitExport(event)
2132	# load all of the tree into a set of dicts
2133	self.loadTree()
2134	# create a dict with refined values and their uncertainties
2135	self.loadParmDict()
2136	if self.ExportSelect('ask'): return
2137	if not self.filename:
2138	print('No name supplied')
2139	return
2140	self.OpenFile()
2141	#if self.ExportSelect('default'): return
2142	# Someday: get restraint & constraint info
2143	#restraintDict = self.OverallParms.get('Restraints',{})
2144	#for i in self.OverallParms['Constraints']:
2145	# print i
2146	# for j in self.OverallParms['Constraints'][i]:
2147	# print j
2148
2149	# is there anything to export?
2150	if len(self.Phases) == len(self.powderDict) == len(self.xtalDict) == 0:
2151	self.G2frame.ErrorDialog(
2152	'Empty project',
2153	'Project does not contain any data or phases. Are they interconnected?')
2154	return
2155	self.quickmode = False # full CIF
2156	phasenam = None # include all phases
2157	# Will this require a multiblock CIF?
2158	if len(self.Phases) > 1:
2159	oneblock = False
2160	elif len(self.powderDict) + len(self.xtalDict) > 1:
2161	oneblock = False
2162	else: # one phase, one dataset, Full CIF
2163	oneblock = True
2164
2165	# check there is an instrument name for every histogram
2166	self.ifPWDR = False
2167	self.ifHKLF = False
2168	invalid = 0
2169	key3 = 'InstrName'
2170	for hist in self.Histograms:
2171	if hist.startswith("PWDR"):
2172	self.ifPWDR = True
2173	key2 = "Sample Parameters"
2174	d = self.Histograms[hist][key2]
2175	elif hist.startswith("HKLF"):
2176	self.ifHKLF = True
2177	key2 = "Instrument Parameters"
2178	d = self.Histograms[hist][key2][0]
2179	instrname = d.get(key3)
2180	if instrname is None:
2181	d[key3] = ''
2182	invalid += 1
2183	elif instrname.strip() == '':
2184	invalid += 1
2185	if invalid:
2186	#msg = ""
2187	#if invalid > 3: msg = (
2188	# "\n\nNote: it may be faster to set the name for\n"
2189	# "one histogram for each instrument and use the\n"
2190	# "File/Copy option to duplicate the name"
2191	# )
2192	if not EditInstNames(): return
2193
2194	# check for a distance-angle range search range for each phase
2195	for phasenam in sorted(self.Phases.keys()):
2196	#i = self.Phases[phasenam]['pId']
2197	phasedict = self.Phases[phasenam] # pointer to current phase info
2198	if 'DisAglCtls' not in phasedict['General']:
2199	dlg = G2G.DisAglDialog(
2200	self.G2frame,
2201	{},
2202	phasedict['General'])
2203	if dlg.ShowModal() == wx.ID_OK:
2204	phasedict['General']['DisAglCtls'] = dlg.GetData()
2205	else:
2206	dlg.Destroy()
2207	return
2208	dlg.Destroy()
2209
2210	# check if temperature values & pressure are defaulted
2211	default = 0
2212	for hist in self.Histograms:
2213	if hist.startswith("PWDR"):
2214	key2 = "Sample Parameters"
2215	T = self.Histograms[hist][key2].get('Temperature')
2216	if not T:
2217	default += 1
2218	elif T == 300:
2219	default += 1
2220	P = self.Histograms[hist][key2].get('Pressure')
2221	if not P:
2222	default += 1
2223	elif P == 1:
2224	default += 1
2225	if default > 0:
2226	dlg = wx.MessageDialog(
2227	self.G2frame,
2228	'Temperature/Pressure values appear to be defaulted for some powder histograms (See Sample Parameters for each PWDR tree entry). Do you want to use those values?',
2229	'Check T and P values',
2230	wx.OK\|wx.CANCEL)
2231	ret = dlg.ShowModal()
2232	dlg.Destroy()
2233	if ret != wx.ID_OK: return
2234	if oneblock:
2235	# select a dataset to use (there should only be one set in one block,
2236	# but take whatever comes 1st)
2237	for hist in self.Histograms:
2238	histblk = self.Histograms[hist]
2239	if hist.startswith("PWDR"):
2240	instnam = histblk["Sample Parameters"]['InstrName']
2241	break # ignore all but 1st data histogram
2242	elif hist.startswith("HKLF"):
2243	instnam = histblk["Instrument Parameters"][0]['InstrName']
2244	break # ignore all but 1st data histogram
2245	# give the user a window to edit CIF contents
2246	if not self.author:
2247	if not EditAuthor(): return
2248	self.ValidateAscii([('Author name',self.author),]) # check for ASCII strings where needed, warn on problems
2249	self.cifdefs = wx.Dialog(
2250	self.G2frame,
2251	style=wx.DEFAULT_DIALOG_STYLE \| wx.RESIZE_BORDER)
2252	EditCIFDefaults()
2253	self.cifdefs.CenterOnParent()
2254	if self.cifdefs.ShowModal() != wx.ID_OK:
2255	self.cifdefs.Destroy()
2256	return
2257	while self.ValidateAscii([('Author name',self.author),
2258	]): # validate a few things as ASCII
2259	if self.cifdefs.ShowModal() != wx.ID_OK:
2260	self.cifdefs.Destroy()
2261	return
2262	self.cifdefs.Destroy()
2263	#======================================================================
2264	# Start writing the CIF - single block
2265	#======================================================================
2266	print('Writing CIF output to file '+self.filename+"...")
2267	#self.OpenFile()
2268	if self.currentExportType == 'single' or self.currentExportType == 'powder':
2269	#======Data only CIF (powder/xtal) ====================================
2270	hist = self.histnam[0]
2271	self.CIFname = hist[5:40].replace(' ','')
2272	WriteCIFitem(self.fp, 'data_'+self.CIFname)
2273	if hist.startswith("PWDR"):
2274	WritePowderData(hist)
2275	elif hist.startswith("HKLF"):
2276	WriteSingleXtalData(hist)
2277	else:
2278	print ("should not happen")
2279	elif oneblock:
2280	#====Single block, data & phase CIF ===================================
2281	WriteCIFitem(self.fp, 'data_'+self.CIFname)
2282	if phasenam is None: # if not already selected, select the first phase (should be one)
2283	phasenam = self.Phases.keys()[0]
2284	#print 'phasenam',phasenam
2285	#phaseblk = self.Phases[phasenam] # pointer to current phase info
2286	instnam = instnam.replace(' ','')
2287	WriteCIFitem(self.fp, '_pd_block_id',
2288	str(self.CIFdate) + "\|" + str(self.CIFname) + "\|" +
2289	str(self.shortauthorname) + "\|" + instnam)
2290	WriteAudit()
2291	writeCIFtemplate(self.OverallParms['Controls'],'publ') # overall (publication) template
2292	WriteOverall()
2293	writeCIFtemplate(self.Phases[phasenam]['General'],'phase',phasenam) # write phase template
2294	# report the phase info
2295	WritePhaseInfo(phasenam)
2296	if hist.startswith("PWDR"):
2297	# preferred orientation
2298	SH = FormatSH(phasenam)
2299	MD = FormatHAPpo(phasenam)
2300	if SH and MD:
2301	WriteCIFitem(self.fp, '_pd_proc_ls_pref_orient_corr', SH + '\n' + MD)
2302	elif SH or MD:
2303	WriteCIFitem(self.fp, '_pd_proc_ls_pref_orient_corr', SH + MD)
2304	else:
2305	WriteCIFitem(self.fp, '_pd_proc_ls_pref_orient_corr', 'none')
2306	# report profile, since one-block: include both histogram and phase info
2307	WriteCIFitem(self.fp, '_pd_proc_ls_profile_function',
2308	FormatInstProfile(histblk["Instrument Parameters"],histblk['hId'])
2309	+'\n'+FormatPhaseProfile(phasenam))
2310	histblk = self.Histograms[hist]["Sample Parameters"]
2311	writeCIFtemplate(histblk,'powder',histblk['InstrName']) # write powder template
2312	WritePowderData(hist)
2313	elif hist.startswith("HKLF"):
2314	histprm = self.Histograms[hist]["Instrument Parameters"][0]
2315	writeCIFtemplate(histprm,'single',histprm['InstrName']) # single crystal template
2316	WriteSingleXtalData(hist)
2317	else:
2318	#=== multiblock: multiple phases and/or histograms ====================
2319	nsteps = 1 + len(self.Phases) + len(self.powderDict) + len(self.xtalDict)
2320	dlg = wx.ProgressDialog('CIF progress','starting',nsteps,parent=self.G2frame)
2321	# Size = dlg.GetSize()
2322	# Size = (int(Size[0]*3),Size[1]) # increase size along x
2323	# dlg.SetSize(Size)
2324	dlg.CenterOnParent()
2325
2326	# publication info
2327	step = 1
2328	dlg.Update(step,"Exporting overall section")
2329	WriteCIFitem(self.fp, '\ndata_'+self.CIFname+'_publ')
2330	WriteAudit()
2331	WriteCIFitem(self.fp, '_pd_block_id',
2332	str(self.CIFdate) + "\|" + str(self.CIFname) + "\|" +
2333	str(self.shortauthorname) + "\|Overall")
2334	writeCIFtemplate(self.OverallParms['Controls'],'publ') #insert the publication template
2335	# ``template_publ.cif`` or a modified version
2336	# overall info
2337	WriteCIFitem(self.fp, 'data_'+str(self.CIFname)+'_overall')
2338	WriteOverall()
2339	#============================================================
2340	WriteCIFitem(self.fp, '# POINTERS TO PHASE AND HISTOGRAM BLOCKS')
2341	datablockidDict = {} # save block names here -- N.B. check for conflicts between phase & hist names (unlikely!)
2342	# loop over phase blocks
2343	if len(self.Phases) > 1:
2344	loopprefix = ''
2345	WriteCIFitem(self.fp, 'loop_ _pd_phase_block_id')
2346	else:
2347	loopprefix = '_pd_phase_block_id'
2348
2349	for phasenam in sorted(self.Phases.keys()):
2350	i = self.Phases[phasenam]['pId']
2351	datablockidDict[phasenam] = (str(self.CIFdate) + "\|" + str(self.CIFname) + "\|" +
2352	'phase_'+ str(i) + '\|' + str(self.shortauthorname))
2353	WriteCIFitem(self.fp, loopprefix,datablockidDict[phasenam])
2354	# loop over data blocks
2355	if len(self.powderDict) + len(self.xtalDict) > 1:
2356	loopprefix = ''
2357	WriteCIFitem(self.fp, 'loop_ _pd_block_diffractogram_id')
2358	else:
2359	loopprefix = '_pd_block_diffractogram_id'
2360	for i in sorted(self.powderDict.keys()):
2361	hist = self.powderDict[i]
2362	histblk = self.Histograms[hist]
2363	instnam = histblk["Sample Parameters"]['InstrName']
2364	instnam = instnam.replace(' ','')
2365	j = histblk['hId']
2366	datablockidDict[hist] = (str(self.CIFdate) + "\|" + str(self.CIFname) + "\|" +
2367	str(self.shortauthorname) + "\|" +
2368	instnam + "_hist_"+str(j))
2369	WriteCIFitem(self.fp, loopprefix,datablockidDict[hist])
2370	for i in sorted(self.xtalDict.keys()):
2371	hist = self.xtalDict[i]
2372	histblk = self.Histograms[hist]
2373	instnam = histblk["Instrument Parameters"][0]['InstrName']
2374	instnam = instnam.replace(' ','')
2375	i = histblk['hId']
2376	datablockidDict[hist] = (str(self.CIFdate) + "\|" + str(self.CIFname) + "\|" +
2377	str(self.shortauthorname) + "\|" +
2378	instnam + "_hist_"+str(i))
2379	WriteCIFitem(self.fp, loopprefix,datablockidDict[hist])
2380	#============================================================
2381	# loop over phases, exporting them
2382	phasebyhistDict = {} # create a cross-reference to phases by histogram
2383	for j,phasenam in enumerate(sorted(self.Phases.keys())):
2384	step += 1
2385	dlg.Update(step,"Exporting phase "+phasenam+' (#'+str(j+1)+')')
2386	i = self.Phases[phasenam]['pId']
2387	WriteCIFitem(self.fp, '\ndata_'+self.CIFname+"_phase_"+str(i))
2388	WriteCIFitem(self.fp, '# Information for phase '+str(i))
2389	WriteCIFitem(self.fp, '_pd_block_id',datablockidDict[phasenam])
2390	# report the phase
2391	writeCIFtemplate(self.Phases[phasenam]['General'],'phase',phasenam) # write phase template
2392	WritePhaseInfo(phasenam)
2393	# preferred orientation
2394	if self.ifPWDR:
2395	SH = FormatSH(phasenam)
2396	MD = FormatHAPpo(phasenam)
2397	if SH and MD:
2398	WriteCIFitem(self.fp, '_pd_proc_ls_pref_orient_corr', SH + '\n' + MD)
2399	elif SH or MD:
2400	WriteCIFitem(self.fp, '_pd_proc_ls_pref_orient_corr', SH + MD)
2401	else:
2402	WriteCIFitem(self.fp, '_pd_proc_ls_pref_orient_corr', 'none')
2403	# report sample profile terms
2404	PP = FormatPhaseProfile(phasenam)
2405	if PP:
2406	WriteCIFitem(self.fp, '_pd_proc_ls_profile_function',PP)
2407
2408	#============================================================
2409	# loop over histograms, exporting them
2410	for i in sorted(self.powderDict.keys()):
2411	hist = self.powderDict[i]
2412	histblk = self.Histograms[hist]
2413	if hist.startswith("PWDR"):
2414	step += 1
2415	dlg.Update(step,"Exporting "+hist.strip())
2416	WriteCIFitem(self.fp, '\ndata_'+self.CIFname+"_pwd_"+str(i))
2417	#instnam = histblk["Sample Parameters"]['InstrName']
2418	# report instrumental profile terms
2419	WriteCIFitem(self.fp, '_pd_proc_ls_profile_function',
2420	FormatInstProfile(histblk["Instrument Parameters"],histblk['hId']))
2421	WriteCIFitem(self.fp, '# Information for histogram '+str(i)+': '+hist)
2422	WriteCIFitem(self.fp, '_pd_block_id',datablockidDict[hist])
2423	histprm = self.Histograms[hist]["Sample Parameters"]
2424	writeCIFtemplate(histprm,'powder',histprm['InstrName']) # powder template
2425	WritePowderData(hist)
2426	for i in sorted(self.xtalDict.keys()):
2427	hist = self.xtalDict[i]
2428	histblk = self.Histograms[hist]
2429	if hist.startswith("HKLF"):
2430	step += 1
2431	dlg.Update(step,"Exporting "+hist.strip())
2432	WriteCIFitem(self.fp, '\ndata_'+self.CIFname+"_sx_"+str(i))
2433	#instnam = histblk["Instrument Parameters"][0]['InstrName']
2434	WriteCIFitem(self.fp, '# Information for histogram '+str(i)+': '+hist)
2435	WriteCIFitem(self.fp, '_pd_block_id',datablockidDict[hist])
2436	histprm = self.Histograms[hist]["Instrument Parameters"][0]
2437	writeCIFtemplate(histprm,'single',histprm['InstrName']) # single crystal template
2438	WriteSingleXtalData(hist)
2439
2440	dlg.Destroy()
2441
2442	WriteCIFitem(self.fp, '#--' + 15*'eof--' + '#')
2443	#self.CloseFile()
2444	print("...export completed")
2445	print('file '+self.fullpath)
2446	# end of CIF export
2447
2448	class ExportProjectCIF(ExportCIF):
2449	'''Used to create a CIF of an entire project
2450
2451	:param wx.Frame G2frame: reference to main GSAS-II frame
2452	'''
2453	def __init__(self,G2frame):
2454	ExportCIF.__init__(self,
2455	G2frame=G2frame,
2456	formatName = 'Full CIF',
2457	extension='.cif',
2458	longFormatName = 'Export project as CIF'
2459	)
2460	self.exporttype = ['project']
2461
2462	def Exporter(self,event=None):
2463	self._Exporter(event=event)
2464	self.CloseFile()
2465
2466	# def Writer(self,hist,mode='w'):
2467	# '''Used for full project CIF export of a sequential fit.
2468	# TODO: Needs extensive work
2469	# '''
2470	# # set the project file name
2471	# self.CIFname = os.path.splitext(
2472	# os.path.split(self.G2frame.GSASprojectfile)[1]
2473	# )[0]+'_'+hist
2474	# self.CIFname = self.CIFname.replace(' ','')
2475	# self.OpenFile(mode=mode)
2476	# self._Exporter(IncludeOnlyHist=hist)
2477	# if mode == 'w':
2478	# print('CIF written to file '+self.fullpath)
2479	# self.CloseFile()
2480
2481	class ExportPhaseCIF(ExportCIF):
2482	'''Used to create a simple CIF with one phase. Uses exact same code as
2483	:class:`ExportCIF` except that `phaseOnly` is set for the Exporter
2484	Shows up in menu as Quick CIF.
2485
2486	:param wx.Frame G2frame: reference to main GSAS-II frame
2487	'''
2488	def __init__(self,G2frame):
2489	ExportCIF.__init__(self,
2490	G2frame=G2frame,
2491	formatName = 'Quick CIF',
2492	extension='.cif',
2493	longFormatName = 'Export one phase in CIF'
2494	)
2495	self.exporttype = ['phase']
2496	# CIF-specific items
2497	self.author = ''
2498
2499	def Exporter(self,event=None):
2500	# get a phase and file name
2501	# the export process starts here
2502	self.InitExport(event)
2503	# load all of the tree into a set of dicts
2504	self.loadTree()
2505	# create a dict with refined values and their uncertainties
2506	self.loadParmDict()
2507	self.multiple = True
2508	self.currentExportType = 'phase'
2509	if self.ExportSelect('ask'): return
2510	self.OpenFile()
2511	for name in self.phasenam:
2512	self._Exporter(event=event,phaseOnly=name) #TODO: repeat for magnetic phase
2513	self.CloseFile()
2514
2515	def Writer(self,hist,phasenam,mode='w'):
2516	# set the project file name
2517	self.CIFname = os.path.splitext(
2518	os.path.split(self.G2frame.GSASprojectfile)[1]
2519	)[0]+'_'+phasenam+'_'+hist
2520	self.CIFname = self.CIFname.replace(' ','')
2521	self.OpenFile(mode=mode)
2522	self._Exporter(phaseOnly=phasenam)
2523	self.CloseFile()
2524
2525	class ExportPwdrCIF(ExportCIF):
2526	'''Used to create a simple CIF containing diffraction data only. Uses exact same code as
2527	:class:`ExportCIF` except that `histOnly` is set for the Exporter
2528	Shows up in menu as Quick CIF.
2529
2530	:param wx.Frame G2frame: reference to main GSAS-II frame
2531	'''
2532	def __init__(self,G2frame):
2533	ExportCIF.__init__(self,
2534	G2frame=G2frame,
2535	formatName = 'Data-only CIF',
2536	extension='.cif',
2537	longFormatName = 'Export data as CIF'
2538	)
2539	if G2frame is None: raise AttributeError('CIF export requires data tree') # prevent use from Scriptable
2540	self.exporttype = ['powder']
2541	# CIF-specific items
2542	self.author = ''
2543
2544	def Exporter(self,event=None):
2545	self.InitExport(event)
2546	# load all of the tree into a set of dicts
2547	self.currentExportType = None
2548	self.loadTree()
2549	self.currentExportType = 'powder'
2550	# create a dict with refined values and their uncertainties
2551	self.loadParmDict()
2552	self.multiple = False
2553	if self.ExportSelect( # set export parameters
2554	AskFile='ask' # get a file name/directory to save in
2555	): return
2556	self.OpenFile()
2557	self._Exporter(event=event,histOnly=self.histnam[0])
2558
2559	def Writer(self,hist,mode='w'):
2560	'''Used for histogram CIF export of a sequential fit.
2561	'''
2562	# set the project file name
2563	self.CIFname = os.path.splitext(
2564	os.path.split(self.G2frame.GSASprojectfile)[1]
2565	)[0]+'_'+hist
2566	self.CIFname = self.CIFname.replace(' ','')
2567	self.OpenFile(mode=mode)
2568	self._Exporter(histOnly=hist)
2569	if mode == 'w':
2570	print('CIF written to file '+self.fullpath)
2571	self.CloseFile()
2572
2573	class ExportHKLCIF(ExportCIF):
2574	'''Used to create a simple CIF containing diffraction data only. Uses exact same code as
2575	:class:`ExportCIF` except that `histOnly` is set for the Exporter
2576	Shows up in menu as Quick CIF.
2577
2578	:param wx.Frame G2frame: reference to main GSAS-II frame
2579	'''
2580	def __init__(self,G2frame):
2581	ExportCIF.__init__(self,
2582	G2frame=G2frame,
2583	formatName = 'Data-only CIF',
2584	extension='.cif',
2585	longFormatName = 'Export data as CIF'
2586	)
2587	self.exporttype = ['single']
2588	# CIF-specific items
2589	self.author = ''
2590
2591	def Exporter(self,event=None):
2592	self.InitExport(event)
2593	# load all of the tree into a set of dicts
2594	self.currentExportType = None
2595	self.loadTree()
2596	self.currentExportType = 'single'
2597	# create a dict with refined values and their uncertainties
2598	self.loadParmDict()
2599	self.multiple = False
2600	if self.ExportSelect( # set export parameters
2601	AskFile='ask' # get a file name/directory to save in
2602	): return
2603	self.OpenFile()
2604	self._Exporter(event=event,histOnly=self.histnam[0])
2605
2606	#===============================================================================
2607	# misc CIF utilities
2608	#===============================================================================
2609	def PickleCIFdict(fil):
2610	'''Loads a CIF dictionary, cherry picks out the items needed
2611	by local code and sticks them into a python dict and writes
2612	that dict out as a pickle file for later reuse.
2613	If the write fails a warning message is printed,
2614	but no exception occurs.
2615
2616	:param str fil: file name of CIF dictionary, will usually end
2617	in .dic
2618	:returns: the dict with the definitions
2619	'''
2620	import CifFile as cif # PyCifRW from James Hester
2621	cifdic = {}
2622	try:
2623	fp = open(fil,'r') # patch: open file to avoid windows bug
2624	dictobj = cif.CifDic(fp)
2625	fp.close()
2626	except IOError:
2627	dictobj = cif.CifDic(fil)
2628	if DEBUG: print('loaded '+fil)
2629	for item in dictobj.keys():
2630	cifdic[item] = {}
2631	for j in (
2632	'_definition','_type',
2633	'_enumeration',
2634	'_enumeration_detail',
2635	'_enumeration_range'):
2636	if dictobj[item].get(j):
2637	cifdic[item][j] = dictobj[item][j]
2638	try:
2639	fil = os.path.splitext(fil)[0]+'.cpickle'
2640	fp = open(fil,'w')
2641	pickle.dump(cifdic,fp)
2642	fp.close()
2643	if DEBUG: print('wrote '+fil)
2644	except:
2645	print ('Unable to write '+fil)
2646	return cifdic
2647
2648	def LoadCIFdic():
2649	'''Create a composite core+powder CIF lookup dict containing
2650	information about all items in the CIF dictionaries, loading
2651	pickled files if possible. The routine looks for files
2652	named cif_core.cpickle and cif_pd.cpickle in every
2653	directory in the path and if they are not found, files
2654	cif_core.dic and/or cif_pd.dic are read.
2655
2656	:returns: the dict with the definitions
2657	'''
2658	cifdic = {}
2659	for ftyp in "cif_core","cif_pd":
2660	for loc in sys.path:
2661	fil = os.path.join(loc,ftyp+".cpickle")
2662	if not os.path.exists(fil): continue
2663	fp = open(fil,'r')
2664	try:
2665	cifdic.update(pickle.load(fp))
2666	if DEBUG: print('reloaded '+fil)
2667	break
2668	finally:
2669	fp.close()
2670	else:
2671	for loc in sys.path:
2672	fil = os.path.join(loc,ftyp+".dic")
2673	if not os.path.exists(fil): continue
2674	#try:
2675	if True:
2676	cifdic.update(PickleCIFdict(fil))
2677	break
2678	#except:
2679	# pass
2680	else:
2681	print('Could not load '+ftyp+' dictionary')
2682	return cifdic
2683
2684	class CIFdefHelp(wx.Button):
2685	'''Create a help button that displays help information on
2686	the current data item
2687
2688	:param parent: the panel which will be the parent of the button
2689	:param str msg: the help text to be displayed
2690	:param wx.Dialog helpwin: Frame for CIF editing dialog
2691	:param wx.TextCtrl helptxt: TextCtrl where help text is placed
2692	'''
2693	def __init__(self,parent,msg,helpwin,helptxt):
2694	wx.Button.__init__(self,parent,wx.ID_HELP)
2695	self.Bind(wx.EVT_BUTTON,self._onPress)
2696	self.msg=msg
2697	self.parent = parent
2698	#self.helpwin = self.parent.helpwin
2699	self.helpwin = helpwin
2700	self.helptxt = helptxt
2701	def _onPress(self,event):
2702	'Respond to a button press by displaying the requested text'
2703	try:
2704	#helptxt = self.helptxt
2705	ow,oh = self.helptxt.GetSize()
2706	self.helptxt.SetLabel(self.msg)
2707	w,h = self.helptxt.GetSize()
2708	if h > oh:
2709	self.helpwin.GetSizer().Fit(self.helpwin)
2710	except: # error posting help, ignore
2711	return
2712
2713	def CIF2dict(cf):
2714	'''copy the contents of a CIF out from a PyCifRW block object
2715	into a dict
2716
2717	:returns: cifblk, loopstructure where cifblk is a dict with
2718	CIF items and loopstructure is a list of lists that defines
2719	which items are in which loops.
2720	'''
2721	blk = cf.keys()[0] # assume templates are a single CIF block, use the 1st
2722	loopstructure = cf[blk].loopnames()[:] # copy over the list of loop contents
2723	dblk = {}
2724	for item in cf[blk].keys(): # make a copy of all the items in the block
2725	dblk[item] = cf[blk][item]
2726	return dblk,loopstructure
2727
2728	def dict2CIF(dblk,loopstructure,blockname='Template'):
2729	'''Create a PyCifRW CIF object containing a single CIF
2730	block object from a dict and loop structure list.
2731
2732	:param dblk: a dict containing values for each CIF item
2733	:param list loopstructure: a list of lists containing the contents of
2734	each loop, as an example::
2735
2736	[ ["_a","_b"], ["_c"], ["_d_1","_d_2","_d_3"]]
2737
2738	this describes a CIF with this type of structure::
2739
2740	loop_ _a _b <a1> <b1> <a2> ...
2741	loop_ _c <c1> <c2>...
2742	loop _d_1 _d_2 _d_3 ...
2743
2744	Note that the values for each looped CIF item, such as _a,
2745	are contained in a list, for example as cifblk["_a"]
2746
2747	:param str blockname: an optional name for the CIF block.
2748	Defaults to 'Template'
2749
2750	:returns: the newly created PyCifRW CIF object
2751	'''
2752
2753	import CifFile as cif # PyCifRW from James Hester
2754	# compile a 'list' of items in loops
2755	loopnames = set()
2756	for i in loopstructure:
2757	loopnames \|= set(i)
2758	# create a new block
2759	newblk = cif.CifBlock()
2760	# add the looped items
2761	for keys in loopstructure:
2762	vals = []
2763	for key in keys:
2764	vals.append(dblk[key])
2765	newblk.AddCifItem(([keys],[vals]))
2766	# add the non-looped items
2767	for item in dblk:
2768	if item in loopnames: continue
2769	newblk[item] = dblk[item]
2770	# create a CIF and add the block
2771	newcf = cif.CifFile()
2772	newcf[blockname] = newblk
2773	return newcf
2774
2775
2776	class EditCIFtemplate(wx.Dialog):
2777	'''Create a dialog for editing a CIF template. The edited information is
2778	placed in cifblk. If the CIF is saved as a file, the name of that file
2779	is saved as ``self.newfile``.
2780
2781	:param wx.Frame parent: parent frame or None
2782	:param cifblk: dict or PyCifRW block containing values for each CIF item
2783	:param list loopstructure: a list of lists containing the contents of
2784	each loop, as an example::
2785
2786	[ ["_a","_b"], ["_c"], ["_d_1","_d_2","_d_3"]]
2787
2788	this describes a CIF with this type of structure::
2789
2790	loop_ _a _b <a1> <b1> <a2> ...
2791	loop_ _c <c1> <c2>...
2792	loop _d_1 _d_2 _d_3 ...
2793
2794	Note that the values for each looped CIF item, such as _a,
2795	are contained in a list, for example as cifblk["_a"]
2796
2797	:param str defaultname: specifies the default file name to be used for
2798	saving the CIF.
2799	'''
2800	def __init__(self,parent,cifblk,loopstructure,defaultname):
2801	OKbuttons = []
2802	self.cifblk = cifblk
2803	self.loopstructure = loopstructure
2804	self.newfile = None
2805	self.defaultname = defaultname
2806	global CIFdic # once this is loaded, keep it around
2807	if CIFdic is None:
2808	CIFdic = LoadCIFdic()
2809	wx.Dialog.__init__(self,parent,style=wx.DEFAULT_DIALOG_STYLE \| wx.RESIZE_BORDER)
2810
2811	# define widgets that will be needed during panel creation
2812	self.helptxt = wx.StaticText(self,wx.ID_ANY,"")
2813	savebtn = wx.Button(self, wx.ID_CLOSE, "Save as template")
2814	OKbuttons.append(savebtn)
2815	savebtn.Bind(wx.EVT_BUTTON,self._onSave)
2816	OKbtn = wx.Button(self, wx.ID_OK, "Use")
2817	OKbtn.SetDefault()
2818	OKbuttons.append(OKbtn)
2819
2820	self.SetTitle('Edit items in CIF template')
2821	vbox = wx.BoxSizer(wx.VERTICAL)
2822	cpnl = EditCIFpanel(self,cifblk,loopstructure,CIFdic,OKbuttons,size=(300,300))
2823	vbox.Add(cpnl, 1, wx.ALIGN_LEFT\|wx.ALL\|wx.EXPAND, 0)
2824	G2G.HorizontalLine(vbox,self)
2825	vbox.Add(self.helptxt, 0, wx.EXPAND\|wx.ALL, 5)
2826	G2G.HorizontalLine(vbox,self)
2827	btnsizer = wx.BoxSizer(wx.HORIZONTAL)
2828	btn = wx.Button(self, wx.ID_CANCEL)
2829	btnsizer.Add(btn,0,wx.ALIGN_CENTER\|wx.ALL)
2830	btnsizer.Add(savebtn,0,wx.ALIGN_CENTER\|wx.ALL)
2831	btnsizer.Add(OKbtn,0,wx.ALIGN_CENTER\|wx.ALL)
2832	vbox.Add(btnsizer, 0, wx.ALIGN_CENTER\|wx.ALL, 5)
2833	self.SetSizer(vbox)
2834	vbox.Fit(self)
2835	def Post(self):
2836	'''Display the dialog
2837
2838	:returns: True unless Cancel has been pressed.
2839	'''
2840	return (self.ShowModal() == wx.ID_OK)
2841	def _onSave(self,event):
2842	'Save CIF entries in a template file'
2843	pth = G2G.GetExportPath(self.G2frame)
2844	dlg = wx.FileDialog(
2845	self, message="Save as CIF template",
2846	defaultDir=pth,
2847	defaultFile=self.defaultname,
2848	wildcard="CIF (.cif)\|.cif",
2849	style=wx.SAVE)
2850	val = (dlg.ShowModal() == wx.ID_OK)
2851	fil = dlg.GetPath()
2852	dlg.Destroy()
2853	if val: # ignore a Cancel button
2854	fil = os.path.splitext(fil)[0]+'.cif' # force extension
2855	fp = open(fil,'w')
2856	newcf = dict2CIF(self.cifblk,self.loopstructure)
2857	fp.write(newcf.WriteOut())
2858	fp.close()
2859	self.newfile = fil
2860	self.EndModal(wx.ID_OK)
2861
2862	class EditCIFpanel(wxscroll.ScrolledPanel):
2863	'''Creates a scrolled panel for editing CIF template items
2864
2865	:param wx.Frame parent: parent frame where panel will be placed
2866	:param cifblk: dict or PyCifRW block containing values for each CIF item
2867	:param list loopstructure: a list of lists containing the contents of
2868	each loop, as an example::
2869
2870	[ ["_a","_b"], ["_c"], ["_d_1","_d_2","_d_3"]]
2871
2872	this describes a CIF with this type of structure::
2873
2874	loop_ _a _b <a1> <b1> <a2> ...
2875	loop_ _c <c1> <c2>...
2876	loop _d_1 _d_2 _d_3 ...
2877
2878	Note that the values for each looped CIF item, such as _a,
2879	are contained in a list, for example as cifblk["_a"]
2880
2881	:param dict cifdic: optional CIF dictionary definitions
2882	:param list OKbuttons: A list of wx.Button objects that should
2883	be disabled when information in the CIF is invalid
2884	:param (other): optional keyword parameters for wx.ScrolledPanel
2885	'''
2886	def __init__(self, parent, cifblk, loopstructure, cifdic={}, OKbuttons=[], **kw):
2887	self.parent = parent
2888	wxscroll.ScrolledPanel.__init__(self, parent, wx.ID_ANY, **kw)
2889	self.vbox = None
2890	self.AddDict = None
2891	self.cifdic = cifdic
2892	self.cifblk = cifblk
2893	self.loops = loopstructure
2894	self.parent = parent
2895	self.LayoutCalled = False
2896	self.parentOKbuttons = OKbuttons
2897	self.ValidatedControlsList = []
2898	self._fill()
2899	def _fill(self):
2900	'Fill the scrolled panel with widgets for each CIF item'
2901	wx.BeginBusyCursor()
2902	self.AddDict = {}
2903	self.ValidatedControlsList = []
2904	# delete any only contents
2905	if self.vbox:
2906	if 'phoenix' in wx.version():
2907	self.vbox.Clear(True)
2908	else:
2909	self.vbox.DeleteWindows()
2910	self.vbox = None
2911	self.Update()
2912	vbox = wx.BoxSizer(wx.VERTICAL)
2913	self.vbox = vbox
2914	# compile a 'list' of items in loops
2915	loopnames = set()
2916	for i in self.loops:
2917	loopnames \|= set(i)
2918	# post the looped CIF items
2919	for lnum,lp in enumerate(self.loops):
2920	hbox = wx.BoxSizer(wx.HORIZONTAL)
2921	hbox.Add(wx.StaticText(self,wx.ID_ANY,'Loop '+str(lnum+1)))
2922	vbox.Add(hbox)
2923	but = wx.Button(self,wx.ID_ANY,"Add row")
2924	self.AddDict[but]=lnum
2925
2926	hbox.Add(but)
2927	but.Bind(wx.EVT_BUTTON,self.OnAddRow)
2928	fbox = wx.GridBagSizer(0, 0)
2929	vbox.Add(fbox)
2930	rows = 0
2931	for i,item in enumerate(lp):
2932	txt = wx.StaticText(self,wx.ID_ANY,item+" ")
2933	fbox.Add(txt,(0,i+1))
2934	# if self.cifdic.get(item):
2935	# df = self.cifdic[item].get('_definition')
2936	# if df:
2937	# txt.SetToolTipString(G2IO.trim(df))
2938	# but = CIFdefHelp(self,
2939	# "Definition for "+item+":\n\n"+G2IO.trim(df),
2940	# self.parent,
2941	# self.parent.helptxt)
2942	# fbox.Add(but,(1,i+1),flag=wx.ALIGN_CENTER)
2943	for j,val in enumerate(self.cifblk[item]):
2944	ent = self.CIFEntryWidget(self.cifblk[item],j,item)
2945	#fbox.Add(ent,(j+2,i+1),flag=wx.EXPAND\|wx.ALL)
2946	fbox.Add(ent,(j+1,i+1),flag=wx.EXPAND\|wx.ALL)
2947	if self.cifdic.get(item):
2948	df = self.cifdic[item].get('_definition')
2949	if df:
2950	txt.SetToolTipString(G2IO.trim(df))
2951	but = CIFdefHelp(self,
2952	"Definition for "+item+":\n\n"+G2IO.trim(df),
2953	self.parent,
2954	self.parent.helptxt)
2955	fbox.Add(but,(j+2,i+1),flag=wx.ALIGN_CENTER)
2956	rows = max(rows,len(self.cifblk[item]))
2957	for i in range(rows):
2958	txt = wx.StaticText(self,wx.ID_ANY,str(i+1))
2959	fbox.Add(txt,(i+2,0))
2960	line = wx.StaticLine(self,wx.ID_ANY, size=(-1,3), style=wx.LI_HORIZONTAL)
2961	vbox.Add(line, 0, wx.EXPAND\|wx.ALIGN_CENTER\|wx.ALL, 10)
2962
2963	# post the non-looped CIF items
2964	for item in sorted(self.cifblk.keys()):
2965	if item not in loopnames:
2966	hbox = wx.BoxSizer(wx.HORIZONTAL)
2967	vbox.Add(hbox)
2968	txt = wx.StaticText(self,wx.ID_ANY,item)
2969	hbox.Add(txt)
2970	ent = self.CIFEntryWidget(self.cifblk,item,item)
2971	hbox.Add(ent)
2972	if self.cifdic.get(item):
2973	df = self.cifdic[item].get('_definition')
2974	if df:
2975	txt.SetToolTipString(G2IO.trim(df))
2976	but = CIFdefHelp(self,
2977	"Definition for "+item+":\n\n"+G2IO.trim(df),
2978	self.parent,
2979	self.parent.helptxt)
2980	hbox.Add(but,0,wx.ALL,2)
2981	self.SetSizer(vbox)
2982	#vbox.Fit(self.parent)
2983	self.SetAutoLayout(1)
2984	self.SetupScrolling()
2985	self.Bind(rw.EVT_RW_LAYOUT_NEEDED, self.OnLayoutNeeded)
2986	self.Layout()
2987	wx.EndBusyCursor()
2988	def OnLayoutNeeded(self,event):
2989	'''Called when an update of the panel layout is needed. Calls
2990	self.DoLayout after the current operations are complete using
2991	CallAfter. This is called only once, according to flag
2992	self.LayoutCalled, which is cleared in self.DoLayout.
2993	'''
2994	if self.LayoutCalled: return # call already queued
2995	wx.CallAfter(self.DoLayout) # queue a call
2996	self.LayoutCalled = True
2997	def DoLayout(self):
2998	'''Update the Layout and scroll bars for the Panel. Clears
2999	self.LayoutCalled so that next change to panel can
3000	request a new update
3001	'''
3002	wx.BeginBusyCursor()
3003	self.Layout()
3004	self.SetupScrolling()
3005	wx.EndBusyCursor()
3006	self.LayoutCalled = False
3007	def OnAddRow(self,event):
3008	'add a row to a loop'
3009	lnum = self.AddDict.get(event.GetEventObject())
3010	if lnum is None: return
3011	for item in self.loops[lnum]:
3012	self.cifblk[item].append('?')
3013	self._fill()
3014
3015	def ControlOKButton(self,setvalue):
3016	'''Enable or Disable the OK button(s) for the dialog. Note that this is
3017	passed into the ValidatedTxtCtrl for use by validators.
3018
3019	:param bool setvalue: if True, all entries in the dialog are
3020	checked for validity. The first invalid control triggers
3021	disabling of buttons.
3022	If False then the OK button(s) are disabled with no checking
3023	of the invalid flag for each control.
3024	'''
3025	if setvalue: # turn button on, do only if all controls show as valid
3026	for ctrl in self.ValidatedControlsList:
3027	if ctrl.invalid:
3028	for btn in self.parentOKbuttons:
3029	btn.Disable()
3030	return
3031	else:
3032	for btn in self.parentOKbuttons:
3033	btn.Enable()
3034	else:
3035	for btn in self.parentOKbuttons:
3036	btn.Disable()
3037
3038	def CIFEntryWidget(self,dct,item,dataname):
3039	'''Create an entry widget for a CIF item. Use a validated entry for numb values
3040	where int is required when limits are integers and floats otherwise.
3041	At present this does not allow entry of the special CIF values of "." and "?" for
3042	numerical values and highlights them as invalid.
3043	Use a selection widget when there are specific enumerated values for a string.
3044	'''
3045	if self.cifdic.get(dataname):
3046	if self.cifdic[dataname].get('_enumeration'):
3047	values = ['?']+self.cifdic[dataname]['_enumeration']
3048	choices = ['undefined']
3049	for i in self.cifdic[dataname].get('_enumeration_detail',values):
3050	choices.append(G2IO.trim(i))
3051	ent = G2G.EnumSelector(self, dct, item, choices, values, size=(200, -1))
3052	return ent
3053	if self.cifdic[dataname].get('_type') == 'numb':
3054	mn = None
3055	mx = None
3056	hint = int
3057	if self.cifdic[dataname].get('_enumeration_range'):
3058	rng = self.cifdic[dataname]['_enumeration_range'].split(':')
3059	if '.' in rng[0] or '.' in rng[1]: hint = float
3060	if rng[0]: mn = hint(rng[0])
3061	if rng[1]: mx = hint(rng[1])
3062	ent = G2G.ValidatedTxtCtrl(
3063	self,dct,item,typeHint=hint,min=mn,max=mx,
3064	CIFinput=True,ASCIIonly=True,
3065	OKcontrol=self.ControlOKButton)
3066	self.ValidatedControlsList.append(ent)
3067	return ent
3068	rw1 = rw.ResizeWidget(self)
3069	ent = G2G.ValidatedTxtCtrl(
3070	rw1,dct,item,size=(100, 20),
3071	style=wx.TE_MULTILINE\|wx.TE_PROCESS_ENTER,
3072	CIFinput=True,ASCIIonly=True,
3073	OKcontrol=self.ControlOKButton)
3074	self.ValidatedControlsList.append(ent)
3075	return rw1
3076
3077	class CIFtemplateSelect(wx.BoxSizer):
3078	'''Create a set of buttons to show, select and edit a CIF template
3079
3080	:param frame: wx.Frame object of parent
3081	:param panel: wx.Panel object where widgets should be placed
3082	:param str tmplate: one of 'publ', 'phase', or 'instrument' to determine
3083	the type of template
3084	:param dict G2dict: GSAS-II dict where CIF should be placed. The key
3085	"CIF_template" will be used to store either a list or a string.
3086	If a list, it will contain a dict and a list defining loops. If
3087	an str, it will contain a file name.
3088	:param function repaint: reference to a routine to be called to repaint
3089	the frame after a change has been made
3090	:param str title: A line of text to show at the top of the window
3091	:param str defaultname: specifies the default file name to be used for
3092	saving the CIF.
3093	'''
3094	def __init__(self,frame,panel,tmplate,G2dict, repaint, title, defaultname=''):
3095	wx.BoxSizer.__init__(self,wx.VERTICAL)
3096	self.cifdefs = frame
3097	self.dict = G2dict
3098	self.repaint = repaint
3099	templateDefName = 'template_'+tmplate+'.cif'
3100	self.CIF = G2dict.get("CIF_template")
3101	if defaultname:
3102	self.defaultname = G2obj.StripUnicode(defaultname)
3103	self.defaultname = re.sub(r'[^a-zA-Z0-9_-]','',self.defaultname)
3104	self.defaultname = tmplate + "_" + self.defaultname + ".cif"
3105	else:
3106	self.defaultname = ''
3107
3108	txt = wx.StaticText(panel,wx.ID_ANY,title)
3109	self.Add(txt,0,wx.ALIGN_CENTER)
3110	# change font on title
3111	txtfnt = txt.GetFont()
3112	txtfnt.SetWeight(wx.BOLD)
3113	txtfnt.SetPointSize(2+txtfnt.GetPointSize())
3114	txt.SetFont(txtfnt)
3115	self.Add((-1,3))
3116
3117	if not self.CIF: # empty or None
3118	for pth in [os.getcwd()]+sys.path:
3119	fil = os.path.join(pth,self.defaultname)
3120	if os.path.exists(fil) and self.defaultname:
3121	self.CIF = fil
3122	CIFtxt = "Template: "+self.defaultname
3123	break
3124	else:
3125	for pth in sys.path:
3126	fil = os.path.join(pth,templateDefName)
3127	if os.path.exists(fil):
3128	self.CIF = fil
3129	CIFtxt = "Template: "+templateDefName
3130	break
3131	else:
3132	print("Default CIF template "+self.defaultname+' not found in path!')
3133	self.CIF = None
3134	CIFtxt = "none! (No template found)"
3135	elif type(self.CIF) is not list and type(self.CIF) is not tuple:
3136	if not os.path.exists(self.CIF):
3137	print("Error: template file has disappeared: "+self.CIF)
3138	self.CIF = None
3139	CIFtxt = "none! (file not found)"
3140	else:
3141	if len(self.CIF) < 50:
3142	CIFtxt = "File: "+self.CIF
3143	else:
3144	CIFtxt = "File: ..."+self.CIF[-50:]
3145	else:
3146	CIFtxt = "Template is customized"
3147	# show template source
3148	self.Add(wx.StaticText(panel,wx.ID_ANY,CIFtxt))
3149	# show str, button to select file; button to edit (if CIF defined)
3150	but = wx.Button(panel,wx.ID_ANY,"Select Template File")
3151	but.Bind(wx.EVT_BUTTON,self._onGetTemplateFile)
3152	hbox = wx.BoxSizer(wx.HORIZONTAL)
3153	hbox.Add(but,0,0,2)
3154	but = wx.Button(panel,wx.ID_ANY,"Edit Template")
3155	but.Bind(wx.EVT_BUTTON,self._onEditTemplateContents)
3156	if self.CIF is None: but.Disable() # nothing to edit!
3157	hbox.Add(but,0,0,2)
3158	self.Add(hbox)
3159	def _onGetTemplateFile(self,event):
3160	'select a template file'
3161	pth = G2G.GetImportPath(self.G2frame)
3162	if not pth: pth = '.'
3163	dlg = wx.FileDialog(
3164	self.cifdefs, message="Read CIF template file",
3165	defaultDir=pth,
3166	defaultFile=self.defaultname,
3167	wildcard="CIF (.cif)\|.cif",
3168	style=wx.OPEN)
3169	ret = dlg.ShowModal()
3170	fil = dlg.GetPath()
3171	dlg.Destroy()
3172	if ret == wx.ID_OK:
3173	cf = G2IO.ReadCIF(fil)
3174	if len(cf.keys()) == 0:
3175	raise Exception("No CIF data_ blocks found")
3176	if len(cf.keys()) != 1:
3177	raise Exception('Error, CIF Template has more than one block: '+fil)
3178	self.dict["CIF_template"] = fil
3179	self.repaint() #EditCIFDefaults()
3180
3181	def _onEditTemplateContents(self,event):
3182	'Called to edit the contents of a CIF template'
3183	if type(self.CIF) is list or type(self.CIF) is tuple:
3184	dblk,loopstructure = copy.deepcopy(self.CIF) # don't modify original
3185	else:
3186	cf = G2IO.ReadCIF(self.CIF)
3187	dblk,loopstructure = CIF2dict(cf)
3188	dlg = EditCIFtemplate(self.cifdefs,dblk,loopstructure,self.defaultname)
3189	val = dlg.Post()
3190	if val:
3191	if dlg.newfile: # results saved in file
3192	self.dict["CIF_template"] = dlg.newfile
3193	else:
3194	self.dict["CIF_template"] = [dlg.cifblk,dlg.loopstructure]
3195	self.repaint() #EditCIFDefaults() # note that this does a dlg.Destroy()
3196	else:
3197	dlg.Destroy()
3198
3199	#===============================================================================
3200	# end of misc CIF utilities
3201	#===============================================================================

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

Download in other formats: