def _initialise_GSAS(self):
"""
Initialise a GSAS project object with a spectrum and an instrument parameter file
:return: GSAS project object
"""
gsas_path = self.getPropertyValue(self.PROP_PATH_TO_GSASII)
sys.path.append(gsas_path)
try:
global GSASII
global GSASIIlattice
global GSASIIspc
global GSASIImath
import GSASIIscriptable as GSASII
import GSASIIlattice
import GSASIIspc
import GSASIImath
except ImportError:
error_msg = "Could not import GSAS-II. Are you sure it's installed at {}?".format(
gsas_path)
logger.error(error_msg)
raise ImportError(error_msg)
gsas_proj_path = self.getPropertyValue(self.PROP_GSAS_PROJ_PATH)
gsas_proj = GSASII.G2Project(filename=gsas_proj_path)
spectrum = self._extract_spectrum_from_workspace()
spectrum_path = self._save_temporary_fxye(spectrum=spectrum)
inst_param_path = self.getPropertyValue(self.PROP_PATH_TO_INST_PARAMS)
gsas_proj.add_powder_histogram(datafile=spectrum_path,
iparams=inst_param_path,
fmthint="xye")
self._remove_temporary_fxye(spectrum_path=spectrum_path)
return gsas_proj
def ProcessImage(newImage, imgprms, mskprms, xydata, PDFdict, InterpVals,
calcModes, outputModes):
'''Process one image that is read from file newImage and is integrated into
one or more diffraction patterns and optionally each diffraction pattern can
be transformed into a pair distribution function.
:param str newImage: file name (full path) for input image
:param dict imgprms: dict with some nested lists & dicts describing the image
settings and integration parameters
:param dict mskprms: dict with areas of image to be masked
:param dict xydata: contains histogram information with about background
contributions, used for PDF computation (used if ComputePDF is True)
:param PDFdict: contains PDF parameters (used if ComputePDF is True)
:param InterpVals: contains interpolation table (used if TableMode is True)
:param tuple calcModes: set of values for which computations are
performed and how
:param tuple outputModes: determines which files are written and where
'''
(TableMode, ComputePDF, SeparateDir, optPDF) = calcModes
(outputSelect, PDFformats, fmtlist, outdir,
multipleFmtChoices) = outputModes
if SeparateDir:
savedir = os.path.join(outdir, 'gpx')
if not os.path.exists(savedir): os.makedirs(savedir)
else:
savedir = outdir
outgpx = os.path.join(
savedir,
os.path.split(os.path.splitext(newImage)[0] + '.gpx')[1])
gpxout = G2sc.G2Project(filename=outgpx)
print('creating', gpxout.filename)
# looped because a file can contain multiple images
if TableMode: # look up parameter values from table
imgprms, mskprms = LookupFromTable(
im.data['Image Controls'].get('setdist'), InterpVals)
for im in gpxout.add_image(newImage):
# apply image parameters
im.setControls(imgprms)
setdist = '{:.2f}'.format(
im.getControls()
['setdist']) # ignore differences in position less than 0.01 mm
if setdist not in MapCache['distanceList']:
if mskprms:
im.setMasks(mskprms)
else:
im.initMasks()
MapCache['distanceList'].append(setdist)
MapCache['maskMap'][setdist] = G2sc.calcMaskMap(
im.getControls(), im.getMasks())
MapCache['ThetaAzimMap'][setdist] = G2sc.calcThetaAzimMap(
im.getControls())
# else: # debug
# print('*** reusing',setdist)
#if mskprms:
# im.setMasks(mskprms)
#else:
# im.initMasks()
hists = im.Integrate(MaskMap=MapCache['maskMap'][setdist],
ThetaAzimMap=MapCache['ThetaAzimMap'][setdist])
# write requested files
for dfmt in fmtlist:
fmt = dfmt[1:]
if not outputSelect[fmt]: continue
if fmtlist[dfmt] is None: continue
hint = ''
if fmt in multipleFmtChoices:
hint = multipleFmtChoices[fmt]
if SeparateDir:
savedir = os.path.join(outdir, fmt)
else:
savedir = outdir
if not os.path.exists(savedir): os.makedirs(savedir)
# loop over created histgrams (multiple if caked), writing them as requested
for i, h in enumerate(hists):
fname = h.name[5:].replace(' ', '_')
#if len(hists) > 1:
#GSASIIpath.IPyBreak_base()
try:
fil = os.path.join(savedir, fname)
print('Wrote', h.Export(fil, dfmt, hint))
except Exception as msg:
print('Failed to write {} as {}. Error msg\n{}'.format(
fname, dfmt, msg))
if ComputePDF: # compute PDF
for h in hists:
pdf = gpxout.copy_PDF(PDFdict, h)
pdf.data['PDF Controls']['Sample']['Name'] = h.name
xydata['Sample'] = h.data['data']
fname = h.name[5:].replace(' ', '_')
limits = h.data['Limits'][1]
inst = h.data['Instrument Parameters'][0]
pdf.calculate(copy.deepcopy(xydata), limits, inst)
if optPDF:
for i in range(5):
if pdf.optimize(True, 5, copy.deepcopy(xydata), limits,
inst):
break
pdf.calculate(copy.deepcopy(xydata), limits, inst)
for fmt in PDFformats:
if not outputSelect[fmt]: continue
if SeparateDir:
savedir = os.path.join(
outdir,
fmt.replace("(", "_").replace(")", ""))
else:
savedir = outdir
pdf.export(os.path.join(savedir, fname), fmt)
if outputSelect.get('gpx'):
gpxout.save()
else:
del gpxout
def OnTimerLoop(self, event):
'''A method that is called every :meth:`PollTime` seconds that is
used to check for new files and process them. Integrates new images.
Also optionally sets up and computes PDF.
This is called only after the "Start" button is pressed (then its label reads "Pause").
'''
if GSASIIpath.GetConfigValue('debug'):
import datetime
print("DBG_Timer tick at {:%d %b %Y %H:%M:%S}\n".format(
datetime.datetime.now()))
if self.PreventTimerReEntry: return
self.PreventTimerReEntry = True
self.ShowMatchingFiles(None)
if not self.currImageList:
self.PreventTimerReEntry = False
return
updateList = False
# get input for integration
imgprms = mskprms = None
if not self.params['TableMode']:
# read in image controls/masks, used below in loop. In Table mode
# we will get this image-by image.
gpxinp = G2sc.G2Project(self.gpxin[3])
print('reading template project', gpxinp.filename)
img = gpxinp.image(self.imprm[1].GetStringSelection())
imgprms = img.getControls(True)
if self.maskfl[1].GetStringSelection().strip():
img = gpxinp.image(self.maskfl[1].GetStringSelection())
mskprms = img.getMasks()
# setup shared input for PDF computation (for now will not be table mode)
xydata = {}
if self.params['ComputePDF']:
pdfEntry = self.pdfSel.GetStringSelection()
try:
PDFobj = gpxinp.pdf(pdfEntry)
except KeyError:
print("PDF entry not found: {}".format(pdfEntry))
# update with GUI input
for i, lbl in enumerate(
('Sample Bkg.', 'Container', 'Container Bkg.')):
name = self.pbkg[i][1].GetStringSelection()
try:
xydata[lbl] = gpxinp.histogram(name).data['data']
except AttributeError:
pass
PDFobj.data['PDF Controls'][lbl]['Mult'] = self.pbkg[i][6]
PDFobj.data['PDF Controls'][lbl]['Name'] = name
else:
PDFobj = None
if self.MPpool:
self.MPpool.imap_unordered(
ProcessImageMP, self.ArgGen(PDFobj, imgprms, mskprms, xydata))
else:
for intArgs in self.ArgGen(PDFobj, imgprms, mskprms, xydata):
newImage = intArgs[0]
print('processing ', newImage)
ProcessImage(*intArgs)
updateList = True
for newImage in self.currImageList:
self.ProcessedList.append(newImage)
if updateList: self.ShowMatchingFiles(None)
self.PreventTimerReEntry = False
self.Raise()
def __init__(self, G2frame, PollTime=30.0):
def OnStart(event):
'''Called when the start button is pressed. Changes button label
to Pause. When Pause is pressed the label changes to Resume.
When either Start or Resume is pressed, the processing loop
is started. When Pause is pressed, the loop is stopped.
'''
self.Pause = False
# change button label
if self.btnstart.GetLabel() != 'Pause':
self.btnstart.SetLabel('Pause')
self.Status.SetStatusText(
'Press Pause to delay integration or Reset to prepare to reintegrate all images'
)
if self.timer.IsRunning(): self.timer.Stop()
self.PreventTimerReEntry = False
if self.StartLoop():
G2G.G2MessageBox(
self, 'Error in setting up integration. See console')
return
# delete pool of slaved interpreters in case input has changed
if self.MPpool:
self.MPpool.terminate()
self.MPpool = None
# if self.ncores >= 1: # debug
if self.ncores > 1:
# print('Creating pool of ',self.ncores,'cores') # debug
self.MPpool = mp.Pool(self.ncores)
self.OnTimerLoop(None) # run once immediately
if not self.Pause:
# no pause, so start timer to check for new files
self.timer.Start(int(1000 * PollTime), oneShot=False)
return
# we will get to this point if Paused
self.OnPause()
def OnReset(event):
'''Called when Reset button is pressed. This stops the
processing loop and resets the list of integrated files so
all images can be reintegrated.
'''
self.btnstart.SetLabel('Restart')
self.Status.SetStatusText(
'Press Restart to reload and re-integrate images matching filter'
)
if self.timer.IsRunning(): self.timer.Stop()
self.Reset = True
self.Pause = True
self.ProcessedList = []
self.ShowMatchingFiles(None)
def OnQuit(event):
'''Stop the processing loop and close the Frame
'''
if self.timer.IsRunning():
self.timer.Stop() # make sure we stop first
wx.CallAfter(self.Destroy)
def OnBrowse(event):
'''Responds when the Browse button is pressed to load a file.
The routine determines which button was pressed and gets the
appropriate file type and loads it into the appropriate place
in the dict.
'''
if btn3 == event.GetEventObject():
dlg = wx.DirDialog(self, 'Select directory for output files',
self.params['outdir'], wx.DD_DEFAULT_STYLE)
dlg.CenterOnParent()
try:
if dlg.ShowModal() == wx.ID_OK:
self.params['outdir'] = dlg.GetPath()
fInp3.SetValue(self.params['outdir'])
finally:
dlg.Destroy()
return
def showPDFctrls(event):
'''Called to show or hide AutoPDF widgets. Note that TextCtrl's
must be included in the sizer layout with .Show(True) before
.Show(False) will work properly.
'''
TestInput()
if len(self.pdfList) == 0 or self.params['TableMode']:
lbl4b.SetValue(False)
self.params['ComputePDF'] = False
lbl4b.Enable(False)
else:
lbl4b.Enable(True)
for w in [self.pbkg[i][4] for i in (0, 1, 2)]:
w.Enable(self.params['ComputePDF'])
w.Show(self.params['ComputePDF'])
#for o in pdfwidgets+[self.pbkg[i][2] for i in (0,1,2)]:
for o in pdfwidgets + [self.pdfSel
] + [self.pbkg[i][1] for i in range(3)]:
o.Enable(self.params['ComputePDF'])
if self.params['ComputePDF']:
c = "black"
else:
c = "gray"
for l in ([lbl4, lbl4a, lbl5, lbl5a, lbl5b] +
[self.pbkg[i][0] for i in (0, 1, 2)] +
[self.pbkg[i][5] for i in (0, 1, 2)]):
l.SetForegroundColour(c)
checkPDFselection()
self.SendSizeEvent()
def GetGPXInputFile(event):
'Get and read input from input GPX file'
pth = self.params['readdir']
lbl = 'Select a project input file'
filtyp = 'project file (.gpx)|*.gpx'
if event is not None:
dlg = wx.FileDialog(self,
lbl,
pth,
style=wx.FD_OPEN,
wildcard=filtyp)
dlg.CenterOnParent()
if dlg.ShowModal() == wx.ID_OK:
self.gpxin[3] = dlg.GetPath()
dlg.Destroy()
if not os.path.exists(self.gpxin[3]):
G2G.G2MessageBox(
self, 'Error: file {} not found.'.format(self.gpxin[3]))
return
SetGPXInputFile()
def SetGPXInputFile():
gpx = G2sc.G2Project(self.gpxin[3])
self.imgList = gpx.images()
self.histList = gpx.histograms()
self.pdfList = gpx.pdfs()
if not self.imgList:
G2G.G2MessageBox(
self, 'Error: no images in {}.'.format(self.gpxin[3]))
return
self.gpxin[1].SetValue(self.gpxin[3])
self.imprm[1].Clear()
self.imprm[1].AppendItems([i.name for i in self.imgList])
if len(self.imgList) == 1:
self.imprm[1].SetSelection(0)
self.maskfl[1].Clear()
self.maskfl[1].AppendItems([''] + [i.name for i in self.imgList])
for i in range(3):
self.pbkg[i][1].Clear()
self.pbkg[i][1].AppendItems([''] +
[i.name for i in self.histList])
self.pdfSel.Clear()
self.pdfSel.AppendItems([i.name for i in self.pdfList])
showPDFctrls(None)
def TestInput(*args, **kwargs):
'''Determine if the start button should be enabled and
ask for the exporter type with ambiguous extensions
'''
for dfmt, obj in self.fmtlist.items():
fmt = dfmt[1:]
if not self.params['outsel'][fmt]: continue
if fmt in self.multipleFmtChoices: continue
if type(obj) is not list:
continue # only one exporter for this
choices = []
for e in obj:
choices.append(e.formatName)
if len(choices) == 0:
print('Error: why 0 choices in TestInput?')
continue
if len(choices) == 1:
print('Error: why 1 choice in TestInput?')
self.multipleFmtChoices[fmt] = obj[0].formatName
continue
# select the format here
dlg = G2G.G2SingleChoiceDialog(
self, 'There is more than one format with a ' +
'.{} output. Choose the one to use'.format(fmt),
'Choose output format', choices)
dlg.CenterOnParent()
dlg.clb.SetSelection(0) # force a selection
if dlg.ShowModal() == wx.ID_OK and dlg.GetSelection() >= 0:
self.multipleFmtChoices[fmt] = choices[dlg.GetSelection()]
dlg.Destroy()
writingSomething = False
writingPDF = False
# is at least one output file selected?
for dfmt in self.fmtlist:
fmt = dfmt[1:]
if self.params['outsel'][fmt]:
writingSomething = True
break
if self.params['ComputePDF']:
for fmt in self.PDFformats:
if self.params['outsel'][fmt]:
writingPDF = writingSomething = True
break
if not writingSomething:
self.EnableIntButtons(False)
return
# do we have integration input?
if not self.params['TableMode']:
if not self.gpxin[3]:
self.EnableIntButtons(False)
return
elif not os.path.exists(self.gpxin[3]):
self.EnableIntButtons(False)
return
elif len(self.imgList) == 0:
self.EnableIntButtons(False)
return
else:
self.EnableIntButtons(True)
else:
if self.ImgTblParms:
self.EnableIntButtons(True)
else:
self.EnableIntButtons(False)
return
# do we have PDF input, if requested
if self.params['ComputePDF']:
if len(self.pdfList) == 0 or not writingPDF:
self.EnableIntButtons(False)
elif 'Error' in self.formula:
self.EnableIntButtons(False)
def checkPDFselection():
'Read PDF entry from input GPX file & show in GUI'
pdfEntry = self.pdfSel.GetStringSelection()
if not self.pdfList:
self.params['ComputePDF'] = False
lbl4b.Enable(False)
return
else:
lbl4b.Enable(True)
if pdfEntry not in [i.name for i in self.pdfList]:
# strange something -- not selected
self.pdfSel.SetSelection(0)
pdfEntry = self.pdfSel.GetStringSelection()
if self.gpxInp is None or self.gpxInp.filename != self.gpxin[3]:
self.gpxInp = G2sc.G2Project(self.gpxin[3])
try:
PDFobj = self.gpxInp.pdf(pdfEntry)
except KeyError:
print("PDF entry not found: {}".format(pdfEntry))
return
histNames = [i.name for i in self.histList]
for i, lbl in enumerate(
('Sample Bkg.', 'Container', 'Container Bkg.')):
self.pbkg[i][4].SetValue(
str(PDFobj.data['PDF Controls'][lbl]['Mult']))
self.pbkg[i][6] = PDFobj.data['PDF Controls'][lbl]['Mult']
try:
i = 1 + histNames.index(
PDFobj.data['PDF Controls'][lbl]['Name'])
self.pbkg[i][1].SetSelection(i)
except ValueError:
i = 0
self.pbkg[i][1].SetSelection(0)
if PDFobj.data['PDF Controls'][lbl]['Name']:
print('PDF {} hist entry {} not found'.format(
lbl, PDFobj.data['PDF Controls'][lbl]['Name']))
PDFobj.data['PDF Controls'][lbl]['Name'] = ''
self.formula = ''
for el in PDFobj.data['PDF Controls']['ElList']:
i = PDFobj.data['PDF Controls']['ElList'][el]['FormulaNo']
if i <= 0:
continue
elif i == 1:
if self.formula: self.formula += ' '
self.formula += '{}'.format(el)
else:
if self.formula: self.formula += ' '
self.formula += '{}({:.1f})'.format(el, i)
if not self.formula:
self.formula = 'Error: no chemical formula'
lbl5b.SetLabel(self.formula)
TestInput()
def ShowbyMode():
'create table or non-table integration section of GUI'
intPrmSizer.Clear(True)
if not self.params['TableMode']:
sizer = wx.BoxSizer(wx.HORIZONTAL)
self.gpxin[0] = wx.StaticText(mnpnl, wx.ID_ANY,
'Project (gpx) file:')
sizer.Add(self.gpxin[0])
self.gpxin[1] = G2G.ValidatedTxtCtrl(mnpnl,
self.gpxin,
3,
OKcontrol=TestInput,
OnLeave=TestInput)
sizer.Add(self.gpxin[1], 1, wx.EXPAND, 1)
self.gpxin[2] = wx.Button(mnpnl, wx.ID_ANY, "Browse")
self.gpxin[2].Bind(wx.EVT_BUTTON, GetGPXInputFile)
sizer.Add(self.gpxin[2], 0,
wx.ALIGN_RIGHT | wx.ALIGN_CENTER_VERTICAL)
intPrmSizer.Add(sizer, 0, wx.EXPAND, 0)
sizer = wx.BoxSizer(wx.HORIZONTAL)
self.imprm[0] = wx.StaticText(mnpnl, wx.ID_ANY,
'Image parms from:')
sizer.Add(self.imprm[0])
self.imprm[3] = 0
self.imprm[1] = G2G.G2ChoiceButton(mnpnl, [''],
self.imprm,
3,
onChoice=TestInput)
sizer.Add(self.imprm[1], 1, wx.EXPAND, 1)
intPrmSizer.Add(sizer, 0, wx.EXPAND, 0)
sizer = wx.BoxSizer(wx.HORIZONTAL)
self.maskfl[0] = wx.StaticText(mnpnl, wx.ID_ANY,
'Mask parms from:')
sizer.Add(self.maskfl[0])
self.maskfl[3] = 0
self.maskfl[1] = G2G.G2ChoiceButton(mnpnl, [''],
self.maskfl,
3,
onChoice=TestInput)
sizer.Add(self.maskfl[1], 1, wx.EXPAND, 1)
intPrmSizer.Add(sizer, 0, wx.EXPAND, 0)
else:
sizer = wx.BoxSizer(wx.HORIZONTAL)
self.table = [None, None, None, None]
self.table[0] = wx.Button(mnpnl, wx.ID_ANY, "Create table")
sizer.Add(self.table[0], 0, wx.ALIGN_LEFT | wx.ALL, 5)
self.table[0].Bind(wx.EVT_BUTTON, OnTableButton)
self.table[1] = wx.Button(mnpnl, wx.ID_ANY, "Read table")
sizer.Add(self.table[1], 0, wx.ALIGN_LEFT | wx.ALL, 5)
self.table[1].Bind(wx.EVT_BUTTON, OnTableButton)
self.table[2] = wx.Button(mnpnl, wx.ID_ANY, "Edit table")
sizer.Add(self.table[2], 0, wx.ALIGN_LEFT | wx.ALL, 5)
self.table[2].Bind(wx.EVT_BUTTON, OnTableButton)
#self.table[3] = wx.Button(mnpnl, wx.ID_ANY, "Save table")
#sizer.Add(self.table[3],0,wx.ALIGN_LEFT|wx.ALL,5)
#self.table[3].Bind(wx.EVT_BUTTON, OnTableButton)
intPrmSizer.Add(sizer, 0, wx.EXPAND, 0)
# enable/disable based on status of files/table
TestInput()
mnsizer.Fit(self)
def OnTableButton(event):
'''Called to edit/create the distance-dependent parameter look-up table.
'''
pth = self.params['readdir']
readFileList = []
parms, fileList = [], []
if event.GetEventObject() == self.table[0]:
dlg = wx.FileDialog(
self,
'Build new table by selecting image control files',
pth,
style=wx.FD_OPEN | wx.FD_MULTIPLE,
wildcard='Image control files (.imctrl)|*.imctrl')
dlg.CenterOnParent()
if dlg.ShowModal() == wx.ID_OK:
readFileList = dlg.GetPaths()
dlg.Destroy()
if len(readFileList) <= 0: return
elif event.GetEventObject() == self.table[1]:
dlg = wx.FileDialog(
self,
'Reload table by selecting saved file',
pth,
style=wx.FD_OPEN,
wildcard='Integration table (*.imtbl)|*.imtbl')
dlg.CenterOnParent()
if dlg.ShowModal() == wx.ID_OK:
readFileList = [dlg.GetPath()]
dlg.Destroy()
if len(readFileList) <= 0: return
elif event.GetEventObject() == self.table[2]:
parms = copy.deepcopy(self.ImgTblParms)
fileList = copy.copy(self.IMfileList)
if not parms:
G2G.G2MessageBox(self, 'Create or Read table first')
return
dlg = None
try:
dlg = G2imG.IntegParmTable(self, parms, fileList, readFileList)
dlg.CenterOnParent()
if dlg.ShowModal() == wx.ID_OK:
self.params['InterVals'] = SetupInterpolation(dlg)
self.ImgTblParms = dlg.ReadImageParmTable()
self.IMfileList = dlg.IMfileList
self.params['TableMode'] = True
self.params['ControlsTable'] = {}
self.params['MaskTable'] = {}
for f, m in zip(self.IMfileList, self.ImgTblParms[-1]):
n = os.path.split(f)[1]
if n in self.params['ControlsTable']:
print('Warning overwriting entry {}'.format(n))
self.params['ControlsTable'][n] = G2imG.ReadControls(f)
if m and os.path.exists(m):
self.params['MaskTable'][n] = G2imG.ReadMask(m)
elif m != "(none)":
print("Error: Mask file {} not found".format(m))
else:
self.params['TableMode'] = False
self.params['ControlsTable'] = {}
self.params['MaskTable'] = {}
self.imageBase = G2frame.Image
finally:
if dlg: dlg.Destroy()
TestInput()
##################################################
# beginning of __init__ processing
##################################################
self.G2frame = G2frame
self.ImgTblParms = None
self.IMfileList = None
self.params = {}
self.Reset = False
self.Pause = False
self.PreventReEntryShowMatch = False
self.PreventTimerReEntry = False
self.params['ControlsTable'] = {}
self.params['MaskTable'] = {}
G2sc.LoadG2fil()
self.fmtlist = G2sc.exportersByExtension.get('powder', {})
self.fmtlist['.gpx'] = None
self.timer = wx.Timer()
self.timer.Bind(wx.EVT_TIMER, self.OnTimerLoop)
self.imageBase = G2frame.Image
self.params['ComputePDF'] = False
self.params['pdfDmax'] = 0.0
self.params['pdfprm'] = ''
self.params['optPDF'] = True
self.params['TableMode'] = False
self.params['outsel'] = {}
self.formula = 'Error'
self.pdfControls = {}
self.imgList = []
self.histList = []
self.pdfList = []
self.Scale = [
1.0,
]
self.ProcessedList = [] # files that have been integrated
self.currImageList = [] # files that will be integrated
self.gpxInp = None
self.gpxin = [None, None, None, '']
self.imprm = [None, None, None, '']
self.maskfl = [None, None, None, '']
self.ncores = mp.cpu_count() // 2
self.MPpool = None
self.params['readdir'] = os.getcwd()
self.params['filter'] = '*.tif'
self.params['outdir'] = os.getcwd()
self.PDFformats = ('I(Q)', 'S(Q)', 'F(Q)', 'G(r)', 'PDFgui')
self.multipleFmtChoices = {}
#GSASIIpath.IPyBreak_base()
wx.Frame.__init__(self,
None,
title='Automatic Integration',
style=wxMainFrameStyle)
self.Status = self.CreateStatusBar()
self.Status.SetStatusText(
'Press Start to load and integrate images matching filter')
mnpnl = wx.Panel(self)
mnsizer = wx.BoxSizer(wx.VERTICAL)
# box for integration controls & masks input
intSizer = wx.BoxSizer(wx.VERTICAL)
sizer = wx.BoxSizer(wx.HORIZONTAL)
sizer.Add((-1, -1), 1, wx.EXPAND, 1)
sizer.Add(
wx.StaticText(mnpnl, wx.ID_ANY,
'Calibration/Integration parameters'))
sizer.Add((-1, -1), 1, wx.EXPAND, 1)
intSizer.Add(sizer, 1, wx.EXPAND, 1)
def ontblModeBtn(event):
if tblModeBtn.GetValue():
self.params['TableMode'] = True
else:
self.params['TableMode'] = False
ShowbyMode()
tblModeBtn = wx.CheckBox(mnpnl, label='Use distance lookup table')
tblModeBtn.SetValue(False)
tblModeBtn.Bind(wx.EVT_CHECKBOX, ontblModeBtn)
intSizer.Add(tblModeBtn)
mnsizer.Add(intSizer, 0, wx.EXPAND, 0)
intPrmSizer = wx.BoxSizer(wx.VERTICAL)
mnsizer.Add(intPrmSizer, 0, wx.EXPAND, 0)
# file filter stuff
mnsizer.Add((-1, 15))
sizer = wx.BoxSizer(wx.HORIZONTAL)
sizer.Add(wx.StaticText(mnpnl, wx.ID_ANY, 'Read images from '))
self.readDir = G2G.ValidatedTxtCtrl(mnpnl,
self.params,
'readdir',
OnLeave=self.ShowMatchingFiles,
size=(200, -1))
sizer.Add(self.readDir, 1, wx.EXPAND, 1)
btn3 = wx.Button(mnpnl, wx.ID_ANY, "Browse")
btn3.Bind(wx.EVT_BUTTON, self.SetSourceDir)
sizer.Add(btn3, 0, wx.ALIGN_RIGHT | wx.ALIGN_CENTER_VERTICAL)
mnsizer.Add(sizer, 0, wx.EXPAND, 0)
sizer = wx.BoxSizer(wx.HORIZONTAL)
sizer.Add((-1, -1), 1, wx.EXPAND, 1)
sizer.Add(wx.StaticText(mnpnl, wx.ID_ANY, ' Image filter'))
flterInp = G2G.ValidatedTxtCtrl(mnpnl,
self.params,
'filter',
OnLeave=self.ShowMatchingFiles)
sizer.Add(flterInp)
mnsizer.Add(sizer, 0, wx.EXPAND, 0)
self.ListBox = wx.ListBox(mnpnl, size=(-1, 100))
mnsizer.Add(self.ListBox, 1, wx.EXPAND, 1)
self.ShowMatchingFiles(None)
# box for output selections
mnsizer.Add((-1, 15))
lbl = wx.StaticBox(mnpnl, wx.ID_ANY, "Integration output")
lblsizr = wx.StaticBoxSizer(lbl, wx.VERTICAL)
sizer = wx.BoxSizer(wx.HORIZONTAL)
sizer.Add(wx.StaticText(mnpnl, wx.ID_ANY, 'Write to: '), 0,
wx.ALIGN_CENTER_VERTICAL)
fInp3 = G2G.ValidatedTxtCtrl(mnpnl,
self.params,
'outdir',
notBlank=False,
size=(300, -1))
sizer.Add(fInp3, 1, wx.ALIGN_CENTER_VERTICAL | wx.EXPAND)
btn3 = wx.Button(mnpnl, wx.ID_ANY, "Browse")
btn3.Bind(wx.EVT_BUTTON, OnBrowse)
sizer.Add(btn3, 0, wx.ALIGN_RIGHT | wx.ALIGN_CENTER_VERTICAL)
lblsizr.Add(sizer, 0, wx.EXPAND)
sizer = wx.BoxSizer(wx.HORIZONTAL)
sizer.Add(wx.StaticText(mnpnl, wx.ID_ANY, 'Select format(s):'))
for dfmt in sorted(self.fmtlist):
sizer.Add((6, 2)) # add a bit of extra space
fmt = dfmt[1:]
if fmt not in self.params['outsel']:
self.params['outsel'][fmt] = False
btn = G2G.G2CheckBox(mnpnl,
dfmt,
self.params['outsel'],
fmt,
OnChange=TestInput)
sizer.Add(btn)
lblsizr.Add(sizer)
sizer = wx.BoxSizer(wx.HORIZONTAL)
sizer.Add(
wx.StaticText(mnpnl, wx.ID_ANY, 'Separate dir for each format: '))
self.params['SeparateDir'] = False
sizer.Add(G2G.G2CheckBox(mnpnl, '', self.params, 'SeparateDir'))
lblsizr.Add(sizer)
mnsizer.Add(lblsizr, 0, wx.ALIGN_CENTER | wx.EXPAND, 1)
mnsizer.Add((-1, 15))
lbl = wx.StaticBox(mnpnl, wx.ID_ANY, "PDF settings")
pdfwidgets = []
lblsizr = wx.StaticBoxSizer(lbl, wx.VERTICAL)
sizer = wx.BoxSizer(wx.HORIZONTAL)
sizer.Add(wx.StaticText(mnpnl, wx.ID_ANY, 'Autocompute PDF:'), 0,
wx.ALIGN_CENTER_VERTICAL)
lbl4b = G2G.G2CheckBox(mnpnl,
'',
self.params,
'ComputePDF',
OnChange=showPDFctrls)
sizer.Add(lbl4b)
lbl4a = wx.StaticText(mnpnl, wx.ID_ANY, 'Max detector distance: ')
sizer.Add(lbl4a, 0, wx.ALIGN_CENTER_VERTICAL)
fInp4a = G2G.ValidatedTxtCtrl(mnpnl, self.params, 'pdfDmax', xmin=0.0)
pdfwidgets.append(fInp4a)
sizer.Add(fInp4a, 0, wx.ALIGN_CENTER_VERTICAL)
cOpt = G2G.G2CheckBox(mnpnl, 'Optimize', self.params, 'optPDF')
pdfwidgets.append(cOpt)
sizer.Add(cOpt)
lblsizr.Add(sizer, 0)
sizer = wx.BoxSizer(wx.HORIZONTAL)
lbl4 = wx.StaticText(mnpnl, wx.ID_ANY, 'PDF control: ')
sizer.Add(lbl4, 0, wx.ALIGN_CENTER_VERTICAL)
self.pdfSel = G2G.G2ChoiceButton(mnpnl, [''],
self.params,
'pdfprm',
onChoice=checkPDFselection)
sizer.Add(self.pdfSel, 1, wx.ALIGN_CENTER_VERTICAL | wx.EXPAND, 1)
lblsizr.Add(sizer, 0, wx.EXPAND)
sizer = wx.BoxSizer(wx.HORIZONTAL)
lbl5a = wx.StaticText(mnpnl, wx.ID_ANY, 'Chemical formula: ')
sizer.Add(lbl5a)
lbl5b = wx.StaticText(mnpnl, wx.ID_ANY, '(formula)')
sizer.Add(lbl5b)
lblsizr.Add(sizer, 0, wx.EXPAND)
sizer = wx.BoxSizer(wx.HORIZONTAL)
lbl5 = wx.StaticText(mnpnl, wx.ID_ANY, 'Select format(s):')
sizer.Add(lbl5)
for fmt in self.PDFformats:
sizer.Add((6, 2)) # add a bit of extra space
if fmt not in self.params['outsel']:
self.params['outsel'][fmt] = False
btn = G2G.G2CheckBox(mnpnl,
fmt,
self.params['outsel'],
fmt,
OnChange=TestInput)
sizer.Add(btn)
pdfwidgets.append(btn)
lblsizr.Add(sizer, 0, wx.EXPAND)
self.pbkg = 3 * [None]
for i, lbl in enumerate(
(' Sample bkg:', ' Container:', 'Container bkg:')):
self.pbkg[i] = [None, None, None, '', None, None, -1.0]
sizer = wx.BoxSizer(wx.HORIZONTAL)
self.pbkg[i][0] = wx.StaticText(mnpnl, wx.ID_ANY, lbl)
sizer.Add(self.pbkg[i][0])
self.pbkg[i][1] = G2G.G2ChoiceButton(mnpnl, [''], self.pbkg[i], 3)
sizer.Add(self.pbkg[i][1], 1, wx.EXPAND, 1)
self.pbkg[i][5] = wx.StaticText(mnpnl, wx.ID_ANY, ' mult:')
sizer.Add(self.pbkg[i][5])
self.pbkg[i][4] = G2G.ValidatedTxtCtrl(mnpnl,
self.pbkg[i],
6, (6, 3),
typeHint=float,
size=(50, -1),
OnLeave=TestInput,
notBlank=False)
sizer.Add(self.pbkg[i][4])
lblsizr.Add(sizer, 0, wx.EXPAND, 0)
mnsizer.Add(lblsizr, 0, wx.ALIGN_CENTER | wx.EXPAND, 1)
# buttons on bottom
sizer = wx.BoxSizer(wx.HORIZONTAL)
sizer.Add((20, -1))
self.btnstart = wx.Button(mnpnl, wx.ID_ANY, "Start")
self.btnstart.Bind(wx.EVT_BUTTON, OnStart)
sizer.Add(self.btnstart)
self.btnreset = wx.Button(mnpnl, wx.ID_ANY, "Reset")
self.btnreset.Bind(wx.EVT_BUTTON, OnReset)
sizer.Add(self.btnreset)
sizer.Add((20, -1), wx.EXPAND, 1)
sizer.Add(wx.StaticText(mnpnl, wx.ID_ANY, ' cores:'))
spin = wx.SpinCtrl(mnpnl, wx.ID_ANY, size=(50, -1))
spin.SetRange(1, mp.cpu_count())
# spin.SetRange(0, mp.cpu_count()) # debug
spin.SetValue(self.ncores)
def _onSpin(event):
if event: event.Skip()
self.ncores = spin.GetValue()
spin.Bind(wx.EVT_SPINCTRL, _onSpin)
spin.Bind(wx.EVT_KILL_FOCUS, _onSpin)
sizer.Add(spin)
sizer.Add((20, -1), wx.EXPAND, 1)
self.btnclose = wx.Button(mnpnl, wx.ID_ANY, "Exit")
self.btnclose.Bind(wx.EVT_BUTTON, OnQuit)
self.EnableIntButtons(False)
sizer.Add(self.btnclose)
sizer.Add((20, -1))
mnsizer.Add(sizer, 0, wx.EXPAND | wx.BOTTOM | wx.TOP, 5)
# finish up window
mnpnl.SetSizer(mnsizer)
#OnRadioSelect(None) # disable widgets
mnsizer.Fit(self)
ShowbyMode()
if len(sys.argv) > 1:
fil = os.path.splitext(sys.argv[1])[0] + '.gpx'
if os.path.exists(fil):
self.gpxin[3] = fil
SetGPXInputFile()
showPDFctrls(None)
def generate_sulfur_pdf(inputs=[]):
import sys
sys.path.append(inputs[1])
def generate_charts(data, prefix, dest, xlabel, ylabel, volume):
import plotly.graph_objects as go
import plotly
import numpy as np
x, y = np.loadtxt(data, unpack=True)
layout = go.Layout(
title=prefix,
xaxis=dict(
title=xlabel
),
yaxis=dict(
title=ylabel
))
fig = go.Figure(layout=layout, layout_xaxis_range=[0, 20], layout_yaxis_range=[-20, 20])
rho = 1.0
if ylabel == 'S(Q)':
fig.add_shape(type='line',
x0=min(x),
y0=1,
x1=max(x),
y1=1,
line_dash="dash",
line=dict(color='Red'))
if ylabel == 'G(R)':
fig.add_shape(type='line',
x0=min(x),
y0=0,
x1=max(x),
y1=0,
line_dash="dash",
line=dict(color='Blue'))
noa = 1 # Get from gpx PDF controls sample information->element
#volume = 13.306 # Get from Sample information->formula volume
fig.add_trace(go.Scatter(x=x[:250], y=-4*3.142*x*noa/volume,
name="Atomic Density Line",line=dict(color='Green')))
line = dict(color="#ffe476")
scatter = go.Scatter(x=x, y=y,
mode='lines',
line=dict(color="#003865"),
name='Sulfur')
fig.add_trace(scatter)
data = [scatter]
div = plotly.offline.plot(data, include_plotlyjs=False, output_type='div')
fig.write_html(dest + "/" + prefix + ".html")
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.pyplot import axhline
from matplotlib.axis import Axis
import GSASIIscriptable as G2sc
data = inputs[0]
config = inputs[2]
# Create workflow GSAS2 project
gpx = G2sc.G2Project(data['filename'])
sulfurImageFile = os.path.abspath(data['images']['Sulfur'])
print(sulfurImageFile)
# Get project images
ceo2Image = gpx.images()[0]
capillaryImage = gpx.images()[1]
sulfurImage = gpx.images()[2]
# Export sulfur image control settings so we can apply it to newly added images
sulfurControlFile = os.path.abspath(data['export']['prefix']+'.imctrl')
sulfurImage.saveControls(sulfurControlFile)
# Apply sulfur image control settings to newly loaded sulfur image
imageList = gpx.add_image(sulfurImageFile)
newSulfurImage = imageList[0]
newSulfurImage.loadControls(sulfurControlFile)
sulfurPWDRList = newSulfurImage.Integrate()
capillaryPWDRList = capillaryImage.Integrate()
print("PDFs",gpx.pdfs())
pdf = gpx.pdfs()[0]
if config is not None:
pdf.data['PDF Controls'].update(config)
pdf.data['PDF Controls']['Container']['Name'] = capillaryPWDRList[0].name
for i in range(5):
if pdf.optimize():
break
pdf.calculate()
pdf.export(data['export']['prefix'], 'I(Q), S(Q), F(Q), G(r)')
gpx.save()
x, y = np.loadtxt(data['export']['prefix'] + '.gr', unpack=True)
plt.plot(x, y, label='Sulfur')
fig = plt.figure(1)
plt.title('Sulfur G(R)')
plt.xlabel('x')
plt.ylabel('y')
axes = plt.gca()
plt.xlim(data['limits']['xlim'])
plt.ylim(data['limits']['ylim'])
plt.savefig(data['outputfig'])
os.makedirs(data['datadir'] + "/charts", exist_ok=True)
volume = pdf.data['PDF Controls']['Form Vol']
generate_charts(data['export']['prefix'] + '.gr', os.path.basename(data['export']['prefix']) + "-gr", data['datadir'] + "/charts", "Angstroms", "G(R)", volume)
x, y = np.loadtxt(data['export']['prefix'] + '.sq', unpack=True)
plt.plot(x, y, label='Sulfur')
fig = plt.figure(1)
plt.title('Sulfur S(Q)')
plt.xlabel('x')
plt.ylabel('y')
axes = plt.gca()
plt.xlim(data['limits']['xlim'])
plt.ylim(data['limits']['ylim'])
plt.savefig(data['outputfig'])
os.makedirs(data['datadir'] + "/charts", exist_ok=True)
generate_charts(data['export']['prefix'] + '.sq', os.path.basename(data['export']['prefix']) + "-sq", data['datadir'] + "/charts", "Inverse Angstroms", "S(Q)", volume)
return True
def import_refinements_gsas2(refinement_gpx,
hdf_groupname,
hdf_filename=DEFAULT_HDF_FILENAME,
gsas_path=DEFAULT_GSAS_PATH):
# Try and import
try:
gsas
except NameError:
sys.path.append(str(Path(gsas_path).expanduser()))
import GSASIIscriptable as gsas
# Open the GPX project file
project = gsas.G2Project(refinement_gpx)
seq = project.seqref()
enums = ['x', 'yobs', 'yweight', 'ycalc', 'background', 'residual']
results = {k: [] for k in enums}
param_rows = []
filename_re = re.compile('(?:PWDR )?(.*)')
phases = project.phases()
histograms = project.histograms()
for pattern in tqdm(histograms, desc="Importing"):
# Extract the data
data_list = pattern.data['data'][1]
for key in enums:
results[key].append(data_list[enums.index(key)])
# Extract the refined parameters
histname = pattern.data['data'][-1]
sample_params = pattern.data['Sample Parameters']
residuals = pattern.data['data'][0].get('Residuals', {})
params = {
'name': filename_re.match(pattern.data['data'][-1]).group(1),
'displacement': sample_params['DisplaceX'][0],
'pattern_scale': sample_params['Scale'][0],
'absorption': sample_params['Absorption'][0],
'wR': residuals.get('wR', np.nan),
}
# Get phase-histogram parameters
for phase in phases:
pid = phase['pId']
params.update(_extract_cell_params(seq, pid, pattern.name))
params.update(_extract_atom_params(seq, pid, pattern.name))
try:
hap_values = phase.getHAPvalues(pattern)
except KeyError:
continue
params.update(_extract_hap_sizes(hap_values, pid))
params.update(_extract_hap_strains(hap_values, pid))
params.update(_extract_phase_weight(hap_values, phase, pid))
params[f"{pid}:*:Scale"] = hap_values['Scale'][0]
# Add overall weight fractions for the phases
total_weight = np.nansum(
[v for k, v in params.items() if k[-3:] == 'Wgt'])
fracs = {
f"{k}Frac": v / total_weight
for k, v in params.items() if k[-3:] == 'Wgt'
}
params.update(fracs)
# Add to the list of imported histograms
param_rows.append(params)
# Convert the data to numpy arrays
for key in enums:
results[key] = np.asarray(results[key])
# Convert the refined parameters to a pandas dataframe
metadata = pd.DataFrame.from_dict(param_rows, orient='columns')
# Save to disk
metadata.to_hdf(hdf_filename,
key=os.path.join(hdf_groupname, 'refinements',
'parameters'))
with h5py.File(hdf_filename, mode='a') as h5fp:
base_grp = h5fp[hdf_groupname]
for key in enums:
ds_name = os.path.join('refinements', key)
if ds_name in base_grp:
del base_grp[ds_name]
base_grp.create_dataset(ds_name, data=results[key])
def generate_sulfur_pdf(inputs=[]):
def generate_charts(data, prefix, dest, xlabel, ylabel):
import plotly.graph_objects as go
import plotly
import numpy as np
x, y = np.loadtxt(data, unpack=True)
layout = go.Layout(
title=prefix,
xaxis=dict(
title=xlabel
),
yaxis=dict(
title=ylabel
))
# Create traces
fig = go.Figure(layout=layout, layout_xaxis_range=[0, 20])
line = dict(color="#ffe476")
scatter = go.Scatter(x=x, y=y,
mode='lines',
line=dict(color="#003865"),
name='lines')
fig.add_trace(scatter)
data = [scatter]
div = plotly.offline.plot(data, include_plotlyjs=False, output_type='div')
fig.write_html(dest + "/" + prefix + ".html")
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.axis import Axis
import GSASIIscriptable as G2sc
data = inputs[0]
filename = data['filename']
ceo2ImageFile = data['images']['CeO2']
ceo2ControlFile = data['controls']['CeO2']
capillaryImageFile = data['images']['Capillary']
capillaryControlFile = data['controls']['Capillary']
sulfurImageFile = data['images']['Sulfur']
sulfurControlFile = data['controls']['Sulfur']
# Create workflow GSAS2 project
gpx = G2sc.G2Project(filename=filename)
# Load tif images
gpx.add_image(ceo2ImageFile)
gpx.add_image(capillaryImageFile)
gpx.add_image(sulfurImageFile)
ceo2Image = gpx.images()[0]
capillaryImage = gpx.images()[1]
sulfurImage = gpx.images()[2]
ceo2Image.loadControls(ceo2ControlFile)
capillaryImage.loadControls(capillaryControlFile)
sulfurImage.loadControls(sulfurControlFile)
sulfurPWDRList = sulfurImage.Integrate()
capillaryPWDRList = capillaryImage.Integrate()
sulfurPWDRList[0].SaveProfile('pwdr_Sulfur')
capillaryPWDRList[0].SaveProfile('pwdr_Capillary')
sulfurPowerFile = data['powders']['Sulfur']
print(sulfurPWDRList)
pdf = gpx.add_PDF(sulfurPowerFile, 0)
pdf.set_formula(['S', 1])
pdf.data['PDF Controls']['Container']['Name'] = capillaryPWDRList[0].name
pdf.data['PDF Controls']['Container']['Mult'] = -0.988
pdf.data['PDF Controls']['Form Vol'] = 13.306
pdf.data['PDF Controls']['Geometry'] = 'Cylinder'
pdf.data['PDF Controls']['DetType'] = 'Area Detector'
pdf.data['PDF Controls']['ObliqCoeff'] = 0.2
pdf.data['PDF Controls']['Flat Bkg'] = 5081
pdf.data['PDF Controls']['BackRatio'] = 1.0
pdf.data['PDF Controls']['Ruland'] = 0.1
pdf.data['PDF Controls']['Lorch'] = True
pdf.data['PDF Controls']['QScaleLim'] = [23.4, 26.0]
pdf.data['PDF Controls']['Pack'] = 1.0
pdf.data['PDF Controls']['Diam'] = 1.5
pdf.data['PDF Controls']['Trans'] = 0.2
pdf.data['PDF Controls']['Ruland'] = 0.1
pdf.data['PDF Controls']['BackRatio'] = 0.184
pdf.data['PDF Controls']['Rmax'] = 20.0
for i in range(5):
if pdf.optimize():
break
pdf.calculate()
pdf.export(data['export']['prefix'], 'I(Q), S(Q), F(Q), G(r)')
gpx.save()
x, y = np.loadtxt(data['export']['prefix'] + '.gr', unpack=True)
plt.plot(x, y, label='Sulfur')
fig = plt.figure(1)
plt.title('Sulfur G(R)')
plt.xlabel('x')
plt.ylabel('y')
axes = plt.gca()
plt.xlim(data['limits']['xlim'])
plt.ylim(data['limits']['ylim'])
plt.savefig(data['outputfig'])
os.makedirs(data['datadir'] + "/charts", exist_ok=True)
generate_charts(data['export']['prefix'] + '.gr', os.path.basename(data['export']['prefix']) + "-gr", data['datadir'] + "/charts", "heat", "G(R)")
x, y = np.loadtxt(data['export']['prefix'] + '.sq', unpack=True)
plt.plot(x, y, label='Sulfur')
fig = plt.figure(1)
plt.title('Sulfur S(Q)')
plt.xlabel('x')
plt.ylabel('y')
axes = plt.gca()
plt.xlim(data['limits']['xlim'])
plt.ylim(data['limits']['ylim'])
plt.savefig(data['outputfig'])
os.makedirs(data['datadir'] + "/charts", exist_ok=True)
generate_charts(data['export']['prefix'] + '.sq', os.path.basename(data['export']['prefix']) + "-sq", data['datadir'] + "/charts", "heat", "S(Q)")
return True
Python script for running multiple refinements in GSAS II
Main script
@author: Joel Eugênio Cordeiro Junior
last updated on: 3/1/2020
"""
import os, sys
import shutil
from config import *
sys.path.insert(0, GSPATH)
import GSASIIscriptable as G2sc
# set verbosity level
G2sc.SetPrintLevel('warn')
# ----------------------------------------------
# Create projects
# ----------------------------------------------
# select powder data files
powders = []
for file in os.listdir(INDIR):
if file.lower().endswith(PWDEXT):
powders.append(file)
# sort list of powder files by name
powders.sort()
# select phase files
gsasii_temp_dir = tempfile.gettempdir()
sys.path.insert(0, gsasii_dirname)
project_file = os.path.join(gsasii_temp_dir, "temp.gpx")
from PyQt5.QtCore import Qt, QSettings
GSASII_MODE_ONLINE = 0
GSASII_MODE_EXTERNAL = 1
try:
import GSASIIscriptable as G2sc
G2sc.SetPrintLevel("none")
print("GSAS-II found in ", gsasii_dirname)
except Exception as e:
print("GSAS-II not available")
class GSASIIReflectionData:
def __init__(self, h, k, l, pos, multiplicity, F2):
self.h = int(h)
self.k = int(k)
self.l = int(l)
self.pos = pos
self.multiplicity = int(multiplicity)
self.F2 = F2
"""
print(u"*** profile Rwp, " + os.path.split(gpx.filename)[1])
for hist in gpx.histograms():
print("\t{:20s}: {:.2f}".format(hist.name,hist.get_wR()))
print("")
# where files will be written
work_dir = "tmp_gsasii"
if not os.path.exists(work_dir):
os.mkdir(work_dir)
# where data files are stored
data_dir = os.getcwd()
# create a GSAS-II project
gpx = gsasii.G2Project(newgpx=os.path.join(work_dir, "PbSO4.gpx"))
# add histograms
hist1 = gpx.add_powder_histogram(
os.path.join(data_dir,"PBSO4.xra"),
os.path.join(data_dir,"INST_XRY.prm"))
hist2 = gpx.add_powder_histogram(
os.path.join(data_dir,"PBSO4.cwn"),
os.path.join(data_dir,"inst_d1a.prm"))
# add phase
phase1 = gpx.add_phase(os.path.join(data_dir, "PbSO4-Wyckoff.cif"),
phasename="PbSO4",
histograms=[hist1, hist2])
# increase number of cycles to improve convergence
def compute(self):
# create a GSAS-II project
self.gpx = gsasii.G2Project("step_1.gpx")
self.gpx.save("step_2.gpx")
# change lattice parameters
for phase in self.gpx["Phases"].keys():
# ignore data key
if phase == "data":
continue
# handle PBSO4 phase
elif phase == "PBSO4":
cell = self.gpx["Phases"][phase]["General"]["Cell"]
a, b, c = self.get("PBSO4_A"), self.get("PBSO4_B"), self.get(
"PBSO4_C")
t11, t22, t33 = cell[1] / a, cell[2] / b, cell[3] / c
self.gpx["Phases"][phase]["General"][
"Cell"][1:] = lattice.TransformCell(
cell[1:7],
[[t11, 0.0, 0.0], [0.0, t22, 0.0], [0.0, 0.0, t33]])
# otherwise raise error because refinement plan does not support this phase
else:
raise NotImplementedError(
"Refinement plan cannot handle phase {}".format(phase))
# turn on unit cell refinement
args = {
"set": {
"Cell": True,
}
}
# refine
self.gpx.set_refinement(args)
self.gpx.do_refinements([{}])
# get histograms and phases
hist1, hist2 = self.gpx.histograms()
phase1 = self.gpx.phases()[0]
# turn on Dij terms (HAP) for phase 1 only
args6 = {
"set": {
"HStrain": True
},
"histograms": [hist1],
"phases": [phase1],
}
# turn on size and strain broadening (HAP) for histogram 1 only
args7 = {
"set": {
"Mustrain": {
"type": "isotropic",
"refine": True,
},
"Size": {
"type": "isotropic",
"refine": True
},
},
"histograms": [hist1],
}
# turn on sample parameters and radius (Hist)
# turn on atom parameters (phase)
args8a = {
"set": {
"Sample Parameters": ["Shift"]
},
"histograms": [hist1],
"skip": True,
}
args8b = {
"set": {
"Atoms": {
"all": "XU",
},
"Sample Parameters": ["DisplaceX", "DisplaceY"],
},
"histograms": [hist2],
}
# change data limits and instrument parmeter refinements (Hist)
args9a = {
"set": {
"Limits": [16.0, 158.4],
},
"histograms": [hist1],
"skip": True,
}
args9b = {
"set": {
"Limits": [19.0, 153.0],
},
"histograms": [hist2],
"skip": True,
}
args9c = {
"set": {
"Instrument Parameters": ["U", "V", "W"],
},
}
# change number of cycles and radius
self.gpx.data["Controls"]["data"]["max cyc"] = 8
hist2.data["Sample Parameters"]["Gonio. radius"] = 650.0
# refine
args_list = [args6, args7, args8a, args8b, args9a, args9b, args9c]
self.gpx.do_refinements(args_list)
# get minimization statistic
stat = self.gpx["Covariance"]["data"]["Rvals"]["Rwp"]
return stat