def __init__(self, parent, param, size=(80, -1), show_name=False, precision=4, **kws):
self.param = param
self.precision = precision
wx.Panel.__init__(self, parent, -1)
self.wids = Empty()
self.wids.val = FloatCtrl(self, value=param.value,
minval=param.min, maxval=param.max,
precision=precision, size=size)
self.wids.name = None
self.wids.edit = wx.Button(self, label='edit', size=(45, 25))
self.wids.edit.Bind(wx.EVT_BUTTON, self.onConfigure)
self.wids.edit.SetToolTip(wx.ToolTip("Configure Parameter"))
self.wids.vary = Choice(self, choices=VARY_CHOICES,
action=self.onVaryChoice, size=(80, -1))
vary_choice = 0
if param.vary:
vary_choice = 1
elif param.expr is not None:
vary_choice = 2
self.wids.vary.SetSelection(vary_choice)
sizer = wx.BoxSizer(wx.HORIZONTAL)
CLEFT = LEFT|wx.ALL|wx.ALIGN_CENTER_VERTICAL
if show_name:
self.wids.name = wx.StaticText(self,
label="%s: " % param.name,
size=(len(param.name)*8, -1))
sizer.Add(self.wids.name, 0, CLEFT)
sizer.Add(self.wids.val, 0, CLEFT)
sizer.Add(self.wids.vary, 0, CLEFT)
sizer.Add(self.wids.edit, 0, CLEFT)
pack(self, sizer)
class XYFitPanel(wx.Panel):
def __init__(self, parent=None, controller=None, **kws):
wx.Panel.__init__(self, parent, -1, size=(550, 500), **kws)
self.parent = parent
self.controller = controller
self.larch = controller.larch
self.fit_components = OrderedDict()
self.fit_model = None
self.fit_params = None
self.user_added_params = None
self.summary = None
self.sizer = wx.GridBagSizer(10, 6)
self.build_display()
self.pick2_timer = wx.Timer(self)
self.pick2_group = None
self.Bind(wx.EVT_TIMER, self.onPick2Timer, self.pick2_timer)
self.pick2_t0 = 0.
self.pick2_timeout = 15.
self.pick2erase_timer = wx.Timer(self)
self.pick2erase_panel = None
self.Bind(wx.EVT_TIMER, self.onPick2EraseTimer, self.pick2erase_timer)
def build_display(self):
self.mod_nb = flat_nb.FlatNotebook(self, -1, agwStyle=FNB_STYLE)
self.mod_nb.SetTabAreaColour(wx.Colour(250, 250, 250))
self.mod_nb.SetActiveTabColour(wx.Colour(254, 254, 195))
self.mod_nb.SetNonActiveTabTextColour(wx.Colour(10, 10, 128))
self.mod_nb.SetActiveTabTextColour(wx.Colour(128, 0, 0))
self.mod_nb.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, self.onNBChanged)
self.param_panel = AllParamsPanel(self, controller=self.controller)
# self.mod_nb.AddPage(self.param_panel, 'Parameters', True)
range_row = wx.Panel(self)
rsizer = wx.BoxSizer(wx.HORIZONTAL)
xmin_sel = BitmapButton(range_row,
get_icon('plus'),
action=partial(self.on_selpoint, opt='xmin'),
tooltip='use last point selected from plot')
xmax_sel = BitmapButton(range_row,
get_icon('plus'),
action=partial(self.on_selpoint, opt='xmax'),
tooltip='use last point selected from plot')
opts = {'size': (70, -1), 'gformat': True}
self.xmin = FloatCtrl(range_row, value=-np.inf, **opts)
self.xmax = FloatCtrl(range_row, value=np.inf, **opts)
rsizer.Add(SimpleText(range_row, 'Fit Range X=[ '), 0, LCEN, 3)
rsizer.Add(xmin_sel, 0, LCEN, 3)
rsizer.Add(self.xmin, 0, LCEN, 3)
rsizer.Add(SimpleText(range_row, ' : '), 0, LCEN, 3)
rsizer.Add(xmax_sel, 0, LCEN, 3)
rsizer.Add(self.xmax, 0, LCEN, 3)
rsizer.Add(SimpleText(range_row, ' ] '), 0, LCEN, 3)
rsizer.Add(
Button(range_row,
'Full Data Range',
size=(150, -1),
action=self.onResetRange), 0, LCEN, 3)
pack(range_row, rsizer)
action_row = wx.Panel(self)
rsizer = wx.BoxSizer(wx.HORIZONTAL)
self.plot_comps = Check(action_row,
label='Plot Components?',
default=True,
size=(150, -1))
rsizer.Add(
Button(action_row, 'Run Fit', size=(100, -1),
action=self.onRunFit), 0, RCEN, 3)
savebtn = Button(action_row,
'Save Fit',
size=(100, -1),
action=self.onSaveFit)
savebtn.Disable()
rsizer.Add(savebtn, 0, LCEN, 3)
rsizer.Add(
Button(action_row,
'Plot Current Model',
size=(150, -1),
action=self.onShowModel), 0, LCEN, 3)
rsizer.Add(self.plot_comps, 0, LCEN, 3)
pack(action_row, rsizer)
models_row = wx.Panel(self)
rsizer = wx.BoxSizer(wx.HORIZONTAL)
self.model_choice = Choice(models_row,
size=(200, -1),
choices=ModelChoices['peaks'],
action=self.addModel)
rsizer.Add(SimpleText(models_row, ' Add Model Type: '), 0, LCEN, 3)
rsizer.Add(
Choice(models_row,
size=(100, -1),
choices=ModelTypes,
action=self.onModelTypes), 0, LCEN, 3)
rsizer.Add(SimpleText(models_row, ' Model: '), 0, LCEN, 3)
rsizer.Add(self.model_choice, 0, LCEN, 3)
pack(models_row, rsizer)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.AddMany([(range_row, 0, LCEN, 4), ((9, 9), 0, LCEN, 4),
(models_row, 0, LCEN, 4), ((9, 9), 0, LCEN, 4),
(action_row, 0, LCEN, 4), ((9, 9), 0, LCEN, 4),
(HLine(self, size=(550, 3)), 0, LCEN, 4),
((10, 10), 0, LCEN, 2),
(self.mod_nb, 1, LCEN | wx.GROW, 10)])
pack(self, sizer)
def onNBChanged(self, event=None):
idx = self.mod_nb.GetSelection()
if self.mod_nb.GetPage(idx) is self.param_panel:
self.build_fitmodel()
self.param_panel.show_parameters(self.fit_params,
self.user_added_params)
def onModelTypes(self, event=None):
modtype = event.GetString().lower()
self.model_choice.SetChoices(ModelChoices[modtype])
def addModel(self, event=None, model=None):
if model is None and event is not None:
model = event.GetString()
if model is None or model.startswith('<'):
return
curmodels = [
"c%i_" % (i + 1) for i in range(1 + len(self.fit_components))
]
for comp in self.fit_components:
if comp in curmodels:
curmodels.remove(comp)
prefix = curmodels[0]
label = "%s(prefix='%s')" % (model, prefix)
title = "%s: %s" % (prefix[:-1], (model + ' ' * 8)[:8])
mclass_kws = {'prefix': prefix}
if 'step' in model.lower():
form = model.lower().replace('step', '').strip()
if form.startswith('err'): form = 'erf'
label = "Step(form='%s', prefix='%s')" % (form, prefix)
title = "%s: Step %s" % (prefix[:-1], form[:3])
mclass = lm_models.StepModel
mclass_kws['form'] = form
minst = mclass(form=form, prefix=prefix)
else:
mclass = getattr(lm_models, model + 'Model')
minst = mclass(prefix=prefix)
panel = GridPanel(self.mod_nb, ncols=1, nrows=1, pad=1, itemstyle=CEN)
def SLabel(label, size=(80, -1), **kws):
return SimpleText(panel,
label,
size=size,
style=wx.ALIGN_LEFT,
**kws)
usebox = Check(panel, default=True, label='Use?', size=(75, -1))
delbtn = Button(panel,
'Delete Model',
size=(120, -1),
action=partial(self.onDeleteComponent, prefix=prefix))
pick2msg = SimpleText(panel, " ", size=(75, -1))
pick2btn = Button(panel,
'Pick Data Range',
size=(135, -1),
action=partial(self.onPick2Points, prefix=prefix))
# SetTip(mname, 'Label for the model component')
SetTip(usebox, 'Use this component in fit?')
SetTip(delbtn, 'Delete this model component')
SetTip(pick2btn, 'Select X range on Plot to Guess Initial Values')
panel.Add(HLine(panel, size=(520, 3)), style=wx.ALIGN_CENTER, dcol=6)
panel.Add(SLabel(label, size=(200, -1), colour='#0000AA'),
dcol=3,
newrow=True)
panel.AddMany((usebox, pick2msg, pick2btn))
panel.Add(SLabel("Parameter"), newrow=True)
panel.AddMany((SLabel("Value"), SLabel("Type"), SLabel("Min"),
SLabel("Max"), SLabel("Expression")))
parwids = OrderedDict()
parnames = sorted(minst.param_names)
for a in minst._func_allargs:
pname = "%s%s" % (prefix, a)
if (pname not in parnames and a in minst.param_hints
and a not in minst.independent_vars):
parnames.append(pname)
for pname in parnames:
sname = pname[len(prefix):]
hints = minst.param_hints.get(sname, {})
par = Parameter(name=pname, value=0, vary=True)
if 'min' in hints:
par.min = hints['min']
if 'max' in hints:
par.max = hints['max']
if 'value' in hints:
par.value = hints['value']
if 'expr' in hints:
par.expr = hints['expr']
pwids = ParameterWidgets(panel,
par,
name_size=80,
expr_size=175,
float_size=80,
prefix=prefix,
widgets=('name', 'value', 'minval',
'maxval', 'vary', 'expr'))
parwids[par.name] = pwids
panel.Add(pwids.name, newrow=True)
panel.AddMany((pwids.value, pwids.vary, pwids.minval, pwids.maxval,
pwids.expr))
for sname, hint in minst.param_hints.items():
pname = "%s%s" % (prefix, sname)
if 'expr' in hint and pname not in parnames:
par = Parameter(name=pname, value=0, expr=hint['expr'])
pwids = ParameterWidgets(panel,
par,
name_size=80,
expr_size=275,
float_size=80,
prefix=prefix,
widgets=('name', 'value', 'vary',
'expr'))
parwids[par.name] = pwids
panel.Add(pwids.name, newrow=True)
panel.AddMany((pwids.value, pwids.vary))
panel.Add(pwids.expr, dcol=3, style=wx.ALIGN_RIGHT)
pwids.value.Disable()
pwids.vary.Disable()
panel.Add(HLine(panel, size=(90, 3)),
style=wx.ALIGN_CENTER,
newrow=True)
panel.Add(delbtn, dcol=2)
panel.Add(HLine(panel, size=(250, 3)), dcol=3, style=wx.ALIGN_CENTER)
fgroup = Group(prefix=prefix,
title=title,
mclass=mclass,
mclass_kws=mclass_kws,
usebox=usebox,
panel=panel,
parwids=parwids,
float_size=65,
expr_size=150,
pick2_msg=pick2msg)
self.fit_components[prefix] = fgroup
panel.pack()
self.mod_nb.AddPage(panel, title, True)
sx, sy = self.GetSize()
self.SetSize((sx, sy + 1))
self.SetSize((sx, sy))
def onDeleteComponent(self, evt=None, prefix=None):
fgroup = self.fit_components.get(prefix, None)
if fgroup is None:
return
for i in range(self.mod_nb.GetPageCount()):
if fgroup.title == self.mod_nb.GetPageText(i):
self.mod_nb.DeletePage(i)
for attr in dir(fgroup):
setattr(fgroup, attr, None)
self.fit_components.pop(prefix)
sx, sy = self.GetSize()
self.SetSize((sx, sy + 1))
self.SetSize((sx, sy))
def onPick2EraseTimer(self, evt=None):
"""erases line trace showing automated 'Pick 2' guess """
self.pick2erase_timer.Stop()
panel = self.pick2erase_panel
ntrace = panel.conf.ntrace - 1
trace = panel.conf.get_mpl_line(ntrace)
panel.conf.get_mpl_line(ntrace).set_data(np.array([]), np.array([]))
panel.conf.ntrace = ntrace
panel.draw()
def onPick2Timer(self, evt=None):
"""checks for 'Pick 2' events, and initiates 'Pick 2' guess
for a model from the selected data range
"""
try:
plotframe = self.controller.get_display(stacked=False)
curhist = plotframe.cursor_hist[:]
plotframe.Raise()
except:
return
if (time.time() - self.pick2_t0) > self.pick2_timeout:
msg = self.pick2_group.pick2_msg.SetLabel(" ")
plotframe.cursor_hist = []
self.pick2_timer.Stop()
return
if len(curhist) < 2:
self.pick2_group.pick2_msg.SetLabel("%i/2" % (len(curhist)))
return
self.pick2_group.pick2_msg.SetLabel("done.")
self.pick2_timer.Stop()
# guess param values
xcur = (curhist[0][0], curhist[1][0])
xmin, xmax = min(xcur), max(xcur)
dgroup = getattr(self.larch.symtable, self.controller.groupname)
x, y = dgroup.x, dgroup.y
i0 = index_of(dgroup.x, xmin)
i1 = index_of(dgroup.x, xmax)
x, y = dgroup.x[i0:i1 + 1], dgroup.y[i0:i1 + 1]
mod = self.pick2_group.mclass(prefix=self.pick2_group.prefix)
parwids = self.pick2_group.parwids
try:
guesses = mod.guess(y, x=x)
except:
return
for name, param in guesses.items():
if name in parwids:
parwids[name].value.SetValue(param.value)
dgroup._tmp = mod.eval(guesses, x=dgroup.x)
plotframe = self.controller.get_display(stacked=False)
plotframe.cursor_hist = []
plotframe.oplot(dgroup.x, dgroup._tmp)
self.pick2erase_panel = plotframe.panel
self.pick2erase_timer.Start(5000)
def onPick2Points(self, evt=None, prefix=None):
fgroup = self.fit_components.get(prefix, None)
if fgroup is None:
return
plotframe = self.controller.get_display(stacked=False)
plotframe.Raise()
plotframe.cursor_hist = []
fgroup.npts = 0
self.pick2_group = fgroup
if fgroup.pick2_msg is not None:
fgroup.pick2_msg.SetLabel("0/2")
self.pick2_t0 = time.time()
self.pick2_timer.Start(250)
def onSaveFit(self, event=None):
dgroup = self.get_datagroup()
deffile = dgroup.filename.replace('.', '_') + '.fitconf'
outfile = FileSave(self,
'Save Fit Configuration and Results',
default_file=deffile,
wildcard=FITCONF_WILDCARDS)
if outfile is None:
return
buff = ['#XYFit Config version 1']
buff.append(
json.dumps(encode4js(self.summary), encoding='UTF-8', default=str))
buff.append('')
try:
fout = open(outfile, 'w')
fout.write('\n'.join(buff))
fout.close()
except IOError:
print('could not write %s' % outfile)
def onResetRange(self, event=None):
dgroup = self.get_datagroup()
self.xmin.SetValue(min(dgroup.x))
self.xmax.SetValue(max(dgroup.x))
def on_selpoint(self, evt=None, opt='xmin'):
xval = None
try:
xval = self.larch.symtable._plotter.plot1_x
except:
xval = None
if xval is not None:
if opt == 'xmin':
self.xmin.SetValue(xval)
elif opt == 'xmax':
self.xmax.SetValue(xval)
def get_datagroup(self):
dgroup = None
if self.controller.groupname is not None:
try:
dgroup = getattr(self.larch.symtable,
self.controller.groupname)
except:
pass
return dgroup
def get_xranges(self, x):
xmin, xmax = min(x), max(x)
i1, i2 = 0, len(x)
_xmin = self.xmin.GetValue()
_xmax = self.xmax.GetValue()
if _xmin > min(x):
i1 = index_of(x, _xmin)
xmin = x[i1]
if _xmax < max(x):
i2 = index_of(x, _xmax) + 1
xmax = x[i2]
xv1 = max(min(x), xmin - (xmax - xmin) / 5.0)
xv2 = min(max(x), xmax + (xmax - xmin) / 5.0)
return i1, i2, xv1, xv2
def build_fitmodel(self):
""" use fit components to build model"""
dgroup = self.get_datagroup()
fullmodel = None
params = Parameters()
self.summary = {'components': [], 'options': {}}
for comp in self.fit_components.values():
if comp.usebox is not None and comp.usebox.IsChecked():
for parwids in comp.parwids.values():
params.add(parwids.param)
self.summary['components'].append(
(comp.mclass.__name__, comp.mclass_kws))
thismodel = comp.mclass(**comp.mclass_kws)
if fullmodel is None:
fullmodel = thismodel
else:
fullmodel += thismodel
self.fit_model = fullmodel
self.fit_params = params
if dgroup is not None:
i1, i2, xv1, xv2 = self.get_xranges(dgroup.x)
xsel = dgroup.x[slice(i1, i2)]
dgroup.xfit = xsel
dgroup.yfit = self.fit_model.eval(self.fit_params, x=xsel)
dgroup.ycomps = self.fit_model.eval_components(
params=self.fit_params, x=xsel)
return dgroup
def onShowModel(self, event=None):
dgroup = self.build_fitmodel()
if dgroup is not None:
with_components = (self.plot_comps.IsChecked()
and len(dgroup.ycomps) > 1)
self.plot_fitmodel(dgroup,
show_resid=False,
with_components=with_components)
def plot_fitmodel(self, dgroup, show_resid=False, with_components=None):
if dgroup is None:
return
i1, i2, xv1, xv2 = self.get_xranges(dgroup.x)
ysel = dgroup.y[slice(i1, i2)]
plotframe = self.controller.get_display(stacked=True)
plotframe.plot(dgroup.xfit,
ysel,
new=True,
panel='top',
xmin=xv1,
xmax=xv2,
label='data',
xlabel=dgroup.plot_xlabel,
ylabel=dgroup.plot_ylabel,
title='Larch XYFit: %s' % dgroup.filename)
plotframe.oplot(dgroup.xfit, dgroup.yfit, label='fit')
plotframe.plot(dgroup.xfit,
ysel - dgroup.yfit,
grid=False,
marker='o',
markersize=4,
linewidth=1,
panel='bot')
if with_components is None:
with_components = (self.plot_comps.IsChecked()
and len(dgroup.ycomps) > 1)
if with_components:
for label, _y in dgroup.ycomps.items():
plotframe.oplot(dgroup.xfit,
_y,
label=label,
style='short dashed')
line_opts = dict(color='#AAAAAA',
label='_nolegend_',
linewidth=1,
zorder=-5)
plotframe.panel_bot.axes.axhline(0, **line_opts)
axvline = plotframe.panel.axes.axvline
if i1 > 0:
axvline(dgroup.x[i1], **line_opts)
if i2 < len(dgroup.x):
axvline(dgroup.x[i2 - 1], **line_opts)
plotframe.panel.canvas.draw()
def onRunFit(self, event=None):
dgroup = self.build_fitmodel()
if dgroup is None:
return
i1, i2, xv1, xv2 = self.get_xranges(dgroup.x)
dgroup.xfit = dgroup.x[slice(i1, i2)]
ysel = dgroup.y[slice(i1, i2)]
weights = np.ones(len(ysel))
if hasattr(dgroup, 'yerr'):
yerr = dgroup.yerr
if not isinstance(yerr, np.ndarray):
yerr = yerr * np.ones(len(ysel))
else:
yerr = yerr[slice(i1, i2)]
yerr_min = 1.e-9 * ysel.mean()
yerr[np.where(yerr < yerr_min)] = yerr_min
weights = 1.0 / yerr
result = self.fit_model.fit(ysel,
params=self.fit_params,
x=dgroup.xfit,
weights=weights,
method='leastsq')
self.summary['xmin'] = xv1
self.summary['xmax'] = xv2
for attr in ('aic', 'bic', 'chisqr', 'redchi', 'ci_out', 'covar',
'flatchain', 'success', 'nan_policy', 'nfev', 'ndata',
'nfree', 'nvarys', 'init_values'):
self.summary[attr] = getattr(result, attr)
self.summary['params'] = result.params
dgroup.fit_history = []
dgroup.fit_history.append(self.summary)
dgroup.yfit = result.best_fit
dgroup.ycomps = self.fit_model.eval_components(params=result.params,
x=dgroup.xfit)
with_components = (self.plot_comps.IsChecked()
and len(dgroup.ycomps) > 1)
self.plot_fitmodel(dgroup,
show_resid=True,
with_components=with_components)
# print(" == fit model == ", self.fit_model)
# print(" == fit result == ", result)
model_repr = self.fit_model._reprstring(long=True)
report = fit_report(result,
show_correl=True,
min_correl=0.25,
sort_pars=True)
report = '[[Model]]\n %s\n%s\n' % (model_repr, report)
self.summary['report'] = report
self.controller.show_report(report)
# fill parameters with best fit values
allparwids = {}
for comp in self.fit_components.values():
if comp.usebox is not None and comp.usebox.IsChecked():
for name, parwids in comp.parwids.items():
allparwids[name] = parwids
for pname, par in result.params.items():
if pname in allparwids:
allparwids[pname].value.SetValue(par.value)
def build_display(self):
self.mod_nb = flat_nb.FlatNotebook(self, -1, agwStyle=FNB_STYLE)
self.mod_nb.SetTabAreaColour(wx.Colour(250, 250, 250))
self.mod_nb.SetActiveTabColour(wx.Colour(254, 254, 195))
self.mod_nb.SetNonActiveTabTextColour(wx.Colour(10, 10, 128))
self.mod_nb.SetActiveTabTextColour(wx.Colour(128, 0, 0))
self.mod_nb.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, self.onNBChanged)
self.param_panel = AllParamsPanel(self, controller=self.controller)
# self.mod_nb.AddPage(self.param_panel, 'Parameters', True)
range_row = wx.Panel(self)
rsizer = wx.BoxSizer(wx.HORIZONTAL)
xmin_sel = BitmapButton(range_row,
get_icon('plus'),
action=partial(self.on_selpoint, opt='xmin'),
tooltip='use last point selected from plot')
xmax_sel = BitmapButton(range_row,
get_icon('plus'),
action=partial(self.on_selpoint, opt='xmax'),
tooltip='use last point selected from plot')
opts = {'size': (70, -1), 'gformat': True}
self.xmin = FloatCtrl(range_row, value=-np.inf, **opts)
self.xmax = FloatCtrl(range_row, value=np.inf, **opts)
rsizer.Add(SimpleText(range_row, 'Fit Range X=[ '), 0, LCEN, 3)
rsizer.Add(xmin_sel, 0, LCEN, 3)
rsizer.Add(self.xmin, 0, LCEN, 3)
rsizer.Add(SimpleText(range_row, ' : '), 0, LCEN, 3)
rsizer.Add(xmax_sel, 0, LCEN, 3)
rsizer.Add(self.xmax, 0, LCEN, 3)
rsizer.Add(SimpleText(range_row, ' ] '), 0, LCEN, 3)
rsizer.Add(
Button(range_row,
'Full Data Range',
size=(150, -1),
action=self.onResetRange), 0, LCEN, 3)
pack(range_row, rsizer)
action_row = wx.Panel(self)
rsizer = wx.BoxSizer(wx.HORIZONTAL)
self.plot_comps = Check(action_row,
label='Plot Components?',
default=True,
size=(150, -1))
rsizer.Add(
Button(action_row, 'Run Fit', size=(100, -1),
action=self.onRunFit), 0, RCEN, 3)
savebtn = Button(action_row,
'Save Fit',
size=(100, -1),
action=self.onSaveFit)
savebtn.Disable()
rsizer.Add(savebtn, 0, LCEN, 3)
rsizer.Add(
Button(action_row,
'Plot Current Model',
size=(150, -1),
action=self.onShowModel), 0, LCEN, 3)
rsizer.Add(self.plot_comps, 0, LCEN, 3)
pack(action_row, rsizer)
models_row = wx.Panel(self)
rsizer = wx.BoxSizer(wx.HORIZONTAL)
self.model_choice = Choice(models_row,
size=(200, -1),
choices=ModelChoices['peaks'],
action=self.addModel)
rsizer.Add(SimpleText(models_row, ' Add Model Type: '), 0, LCEN, 3)
rsizer.Add(
Choice(models_row,
size=(100, -1),
choices=ModelTypes,
action=self.onModelTypes), 0, LCEN, 3)
rsizer.Add(SimpleText(models_row, ' Model: '), 0, LCEN, 3)
rsizer.Add(self.model_choice, 0, LCEN, 3)
pack(models_row, rsizer)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.AddMany([(range_row, 0, LCEN, 4), ((9, 9), 0, LCEN, 4),
(models_row, 0, LCEN, 4), ((9, 9), 0, LCEN, 4),
(action_row, 0, LCEN, 4), ((9, 9), 0, LCEN, 4),
(HLine(self, size=(550, 3)), 0, LCEN, 4),
((10, 10), 0, LCEN, 2),
(self.mod_nb, 1, LCEN | wx.GROW, 10)])
pack(self, sizer)
def __init__(self, parent, controller, **kws):
self.parent = parent
self.controller = controller
self.dgroup = self.controller.get_group()
groupnames = list(self.controller.file_groups.keys())
self.data = [self.dgroup.energy[:], self.dgroup.norm[:]]
title = "Correct Over-absorption"
wx.Dialog.__init__(self, parent, wx.ID_ANY, size=(550, 275), title=title)
panel = GridPanel(self, ncols=3, nrows=4, pad=2, itemstyle=LCEN)
self.grouplist = Choice(panel, choices=groupnames, size=(250, -1),
action=self.on_groupchoice)
self.grouplist.SetStringSelection(self.dgroup.filename)
self.wids = wids = {}
opts = dict(size=(90, -1), precision=1, act_on_losefocus=True,
minval=-90, maxval=180)
wids['phi_in'] = FloatCtrl(panel, value=45, **opts)
wids['phi_out'] = FloatCtrl(panel, value=45, **opts)
opts = dict(size=(75, -1), action=self.on_correct)
wids['elem'] = Choice(panel, choices=ELEM_LIST, **opts)
wids['edge'] = Choice(panel, choices=EDGE_LIST, **opts)
wids['formula'] = wx.TextCtrl(panel, -1, '', size=(350, -1))
wids['formula'].Bind(wx.EVT_TEXT_ENTER, self.on_correct)
wids['formula'].Bind(wx.EVT_KILL_FOCUS, self.on_correct)
self.set_default_elem_edge(self.dgroup)
for wname in ('phi_in', 'phi_out'):
wids[wname].SetAction(self.on_correct)
apply_one = Button(panel, 'Save Arrays for this Group', size=(175, -1),
action=self.on_apply_one)
apply_one.SetToolTip('Save corrected data, overwrite current arrays')
# apply_sel = Button(panel, 'Apply to Selected Groups', size=(175, -1),
# action=self.on_apply_sel)
#apply_sel.SetToolTip('''Apply SA Correction to the Selected Groups
# in XAS GUI, overwriting current arrays''')
done = Button(panel, 'Done', size=(125, -1), action=self.on_done)
panel.Add(SimpleText(panel, ' Correction for Group: '), dcol=1)
panel.Add(self.grouplist, dcol=5)
panel.Add(SimpleText(panel, ' Absorbing Element: '), newrow=True)
panel.Add(wids['elem'])
panel.Add(SimpleText(panel, ' Edge: '))
panel.Add(wids['edge'])
panel.Add(SimpleText(panel, ' Material Formula: '), newrow=True)
panel.Add(wids['formula'], dcol=3)
panel.Add(SimpleText(panel, ' Incident Angle: '), newrow=True)
panel.Add(wids['phi_in'])
panel.Add(SimpleText(panel, 'degrees'))
panel.Add(SimpleText(panel, ' Exit Angle: '), newrow=True)
panel.Add(wids['phi_out'])
panel.Add(SimpleText(panel, 'degrees'))
panel.Add(apply_one, dcol=4, newrow=True)
panel.Add(HLine(panel, size=(550, 3)), dcol=7, newrow=True)
panel.Add(done, dcol=4, newrow=True)
panel.pack()
class ProcessPanel(wx.Panel):
def __init__(self, parent, controller=None, reporter=None, **kws):
wx.Panel.__init__(self, parent, -1, **kws)
self.controller = controller
self.reporter = reporter
self.needs_update = False
self.proc_timer = wx.Timer(self)
self.Bind(wx.EVT_TIMER, self.onProcessTimer, self.proc_timer)
self.proc_timer.Start(100)
self.build_display()
def edit_config(self, event=None):
pass
def fill(self, dgroup):
opts = self.controller.get_proc_opts(dgroup)
self.xshift.SetValue(opts['xshift'])
self.yshift.SetValue(opts['yshift'])
self.xscale.SetValue(opts['xscale'])
self.yscale.SetValue(opts['yscale'])
self.smooth_op.SetStringSelection(opts['smooth_op'])
self.smooth_conv.SetStringSelection(opts['smooth_conv'])
self.smooth_c0.SetValue(opts['smooth_c0'])
self.smooth_c1.SetValue(opts['smooth_c1'])
self.smooth_sig.SetValue(opts['smooth_sig'])
if dgroup.datatype == 'xas':
self.xas_op.SetStringSelection(opts['xas_op'])
self.xas_e0.SetValue(opts['e0'])
self.xas_step.SetValue(opts['edge_step'])
self.xas_pre1.SetValue(opts['pre1'])
self.xas_pre2.SetValue(opts['pre2'])
self.xas_nor1.SetValue(opts['norm1'])
self.xas_nor2.SetValue(opts['norm2'])
self.xas_vict.SetSelection(opts['nvict'])
self.xas_nnor.SetSelection(opts['nnorm'])
self.xas_showe0.SetValue(opts['show_e0'])
self.xas_autoe0.SetValue(opts['auto_e0'])
self.xas_autostep.SetValue(opts['auto_step'])
def build_display(self):
self.SetFont(Font(10))
titleopts = dict(font=Font(11), colour='#AA0000')
gopts = dict(ncols=4, nrows=4, pad=2, itemstyle=LCEN)
xas = self.xaspanel = GridPanel(self, **gopts)
gen = self.genpanel = GridPanel(self, **gopts)
self.btns = {}
#gen
opts = dict(action=self.UpdatePlot, size=(65, -1), gformat=True)
self.xshift = FloatCtrl(gen, value=0.0, **opts)
self.xscale = FloatCtrl(gen, value=1.0, **opts)
self.yshift = FloatCtrl(gen, value=0.0, **opts)
self.yscale = FloatCtrl(gen, value=1.0, **opts)
self.btns['xshift'] = BitmapButton(gen, get_icon('plus'),
action=partial(self.on_selpoint, opt='xshift'),
tooltip='use last point selected from plot')
self.btns['yshift'] = BitmapButton(gen, get_icon('plus'),
action=partial(self.on_selpoint, opt='yshift'),
tooltip='use last point selected from plot')
opts = dict(action=self.onSmoothChoice, size=(30, -1))
sm_row1 = wx.Panel(gen)
sm_row2 = wx.Panel(gen)
sm_siz1= wx.BoxSizer(wx.HORIZONTAL)
sm_siz2= wx.BoxSizer(wx.HORIZONTAL)
self.smooth_c0 = FloatCtrl(sm_row1, value=2, precision=0, minval=1, **opts)
self.smooth_c1 = FloatCtrl(sm_row1, value=1, precision=0, minval=1, **opts)
self.smooth_msg = SimpleText(sm_row1, label=' ', size=(205, -1))
opts['size'] = (65, -1)
self.smooth_sig = FloatCtrl(sm_row2, value=1, gformat=True, **opts)
opts['size'] = (120, -1)
self.smooth_op = Choice(sm_row1, choices=SMOOTH_OPS, **opts)
self.smooth_op.SetSelection(0)
self.smooth_conv = Choice(sm_row2, choices=CONV_OPS, **opts)
self.smooth_c0.Disable()
self.smooth_c1.Disable()
self.smooth_sig.Disable()
self.smooth_conv.SetSelection(0)
self.smooth_conv.Disable()
sm_siz1.Add(self.smooth_op, 0, LCEN, 1)
sm_siz1.Add(SimpleText(sm_row1, ' n= '), 0, LCEN, 1)
sm_siz1.Add(self.smooth_c0, 0, LCEN, 1)
sm_siz1.Add(SimpleText(sm_row1, ' order= '), 0, LCEN, 1)
sm_siz1.Add(self.smooth_c1, 0, LCEN, 1)
sm_siz1.Add(self.smooth_msg, 0, LCEN, 1)
sm_siz2.Add(SimpleText(sm_row2, ' form= '), 0, LCEN, 1)
sm_siz2.Add(self.smooth_conv, 0, LCEN, 1)
sm_siz2.Add(SimpleText(sm_row2, ' sigma= '), 0, LCEN, 1)
sm_siz2.Add(self.smooth_sig, 0, LCEN, 1)
pack(sm_row1, sm_siz1)
pack(sm_row2, sm_siz2)
gen.Add(SimpleText(gen, ' General Data Processing', **titleopts), dcol=8)
gen.Add(SimpleText(gen, ' X shift:'), newrow=True)
gen.Add(self.btns['xshift'])
gen.Add(self.xshift, dcol=2)
gen.Add(SimpleText(gen, ' X scale:'))
gen.Add(self.xscale, dcol=2)
gen.Add(SimpleText(gen, ' Y shift:'), newrow=True)
gen.Add(self.btns['yshift'])
gen.Add(self.yshift, dcol=2)
gen.Add(SimpleText(gen, ' Y scale:'))
gen.Add(self.yscale, dcol=2)
gen.Add(SimpleText(gen, ' Smoothing:'), newrow=True)
gen.Add(sm_row1, dcol=8)
gen.Add(sm_row2, icol=1, dcol=7, newrow=True)
gen.pack()
#xas
opts = {'action': self.UpdatePlot}
e0opts_panel = wx.Panel(xas)
self.xas_autoe0 = Check(e0opts_panel, default=True, label='auto?', **opts)
self.xas_showe0 = Check(e0opts_panel, default=True, label='show?', **opts)
sx = wx.BoxSizer(wx.HORIZONTAL)
sx.Add(self.xas_autoe0, 0, LCEN, 4)
sx.Add(self.xas_showe0, 0, LCEN, 4)
pack(e0opts_panel, sx)
self.xas_autostep = Check(xas, default=True, label='auto?', **opts)
opts['size'] = (250, -1)
self.xas_op = Choice(xas, choices=XASOPChoices, **opts)
self.xas_op.SetStringSelection('Normalized')
for name in ('e0', 'pre1', 'pre2', 'nor1', 'nor2'):
bb = BitmapButton(xas, get_icon('plus'),
action=partial(self.on_selpoint, opt=name),
tooltip='use last point selected from plot')
self.btns[name] = bb
opts = {'size': (65, -1), 'gformat': True}
self.xas_e0 = FloatCtrl(xas, value=0, action=self.onSet_XASE0, **opts)
self.xas_step = FloatCtrl(xas, value=0, action=self.onSet_XASStep, **opts)
opts['precision'] = 1
opts['action'] = self.UpdatePlot
self.xas_pre1 = FloatCtrl(xas, value=-200, **opts)
self.xas_pre2 = FloatCtrl(xas, value= -30, **opts)
self.xas_nor1 = FloatCtrl(xas, value= 50, **opts)
self.xas_nor2 = FloatCtrl(xas, value= -50, **opts)
opts = {'size': (50, -1),
'choices': ('0', '1', '2', '3'),
'action': self.UpdatePlot}
self.xas_vict = Choice(xas, **opts)
self.xas_nnor = Choice(xas, **opts)
self.xas_vict.SetSelection(1)
self.xas_nnor.SetSelection(1)
def CopyBtn(name):
return Button(xas, 'Copy', size=(50, 30),
action=partial(self.onCopyParam, name))
xas.Add(SimpleText(xas, ' XAS Data Processing', **titleopts), dcol=6)
xas.Add(SimpleText(xas, ' Copy to Selected Groups?'), style=RCEN, dcol=3)
xas.Add(SimpleText(xas, 'Arrays to Plot: '), newrow=True)
xas.Add(self.xas_op, dcol=6)
xas.Add((10, 10))
xas.Add(CopyBtn('xas_op'), style=RCEN)
xas.Add(SimpleText(xas, 'E0 : '), newrow=True)
xas.Add(self.btns['e0'])
xas.Add(self.xas_e0)
xas.Add(e0opts_panel, dcol=4)
xas.Add((10, 1))
xas.Add(CopyBtn('xas_e0'), style=RCEN)
xas.Add(SimpleText(xas, 'Edge Step: '), newrow=True)
xas.Add((10, 1))
xas.Add(self.xas_step)
xas.Add(self.xas_autostep, dcol=3)
xas.Add((10, 1))
xas.Add((10, 1))
xas.Add(CopyBtn('xas_step'), style=RCEN)
xas.Add(SimpleText(xas, 'Pre-edge range: '), newrow=True)
xas.Add(self.btns['pre1'])
xas.Add(self.xas_pre1)
xas.Add(SimpleText(xas, ':'))
xas.Add(self.btns['pre2'])
xas.Add(self.xas_pre2)
xas.Add(SimpleText(xas, 'Victoreen:'))
xas.Add(self.xas_vict)
xas.Add(CopyBtn('xas_pre'), style=RCEN)
xas.Add(SimpleText(xas, 'Normalization range: '), newrow=True)
xas.Add(self.btns['nor1'])
xas.Add(self.xas_nor1)
xas.Add(SimpleText(xas, ':'))
xas.Add(self.btns['nor2'])
xas.Add(self.xas_nor2)
xas.Add(SimpleText(xas, 'PolyOrder:'))
xas.Add(self.xas_nnor)
xas.Add(CopyBtn('xas_norm'), style=RCEN)
xas.pack()
saveconf = Button(self, 'Save as Default Settings',
size=(175, 30),
action=self.onSaveConfigBtn)
hxline = HLine(self, size=(550, 2))
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.AddMany([((10, 10), 0, LCEN, 10), (gen, 0, LCEN, 10),
((10, 10), 0, LCEN, 10), (hxline, 0, LCEN, 10),
((10, 10), 0, LCEN, 10), (xas, 0, LCEN, 10),
((10, 10), 0, LCEN, 10), (saveconf, 0, LCEN, 10),
])
xas.Disable()
pack(self, sizer)
def onSaveConfigBtn(self, evt=None):
conf = self.controller.larch.symtable._sys.xyfit
data_proc = {}
data_proc.update(getattr(conf, 'data_proc', {}))
data_proc['xshift'] = self.xshift.GetValue()
data_proc['yshift'] = self.yshift.GetValue()
data_proc['xscale'] = self.xscale.GetValue()
data_proc['yscale'] = self.yscale.GetValue()
data_proc['smooth_op'] = str(self.smooth_op.GetStringSelection())
data_proc['smooth_c0'] = int(self.smooth_c0.GetValue())
data_proc['smooth_c1'] = int(self.smooth_c1.GetValue())
data_proc['smooth_sig'] = float(self.smooth_sig.GetValue())
data_proc['smooth_conv'] = str(self.smooth_conv.GetStringSelection())
conf.data_proc = data_proc
if self.xaspanel.Enabled:
xas_proc = {}
xas_proc.update(getattr(conf, 'xas_proc', {}))
xas_proc['auto_e0'] = True
xas_proc['auto_step'] = True
xas_proc['pre1'] = self.xas_pre1.GetValue()
xas_proc['pre2'] = self.xas_pre2.GetValue()
xas_proc['norm1'] = self.xas_nor1.GetValue()
xas_proc['norm2'] = self.xas_nor2.GetValue()
xas_proc['nvict'] = self.xas_vict.GetSelection()
xas_proc['nnorm'] = self.xas_nnor.GetSelection()
xas_proc['show_e0'] = self.xas_showe0.IsChecked()
xas_proc['nnorm'] = int(self.xas_nnor.GetSelection())
xas_proc['nvict'] = int(self.xas_vict.GetSelection())
xas_proc['xas_op'] = str(self.xas_op.GetStringSelection())
conf.xas_proc = xas_proc
def onCopyParam(self, name=None, event=None):
proc_opts = self.controller.group.proc_opts
opts = {}
name = str(name)
if name == 'xas_op':
opts['xas_op'] = proc_opts['xas_op']
elif name == 'xas_e0':
opts['e0'] = proc_opts['e0']
opts['show_e0'] = proc_opts['show_e0']
opts['auto_e0'] = False
elif name == 'xas_step':
opts['edge_step'] = proc_opts['edge_step']
opts['auto_step'] = False
elif name == 'xas_pre':
opts['nvict'] = proc_opts['nvict']
opts['pre1'] = proc_opts['pre1']
opts['pre2'] = proc_opts['pre2']
elif name == 'xas_norm':
opts['nnorm'] = proc_opts['nnorm']
opts['norm1'] = proc_opts['norm1']
opts['norm2'] = proc_opts['norm2']
for checked in self.controller.filelist.GetCheckedStrings():
groupname = self.controller.file_groups[str(checked)]
grp = self.controller.get_group(groupname)
if grp != self.controller.group:
grp.proc_opts.update(opts)
self.fill(grp)
self.process(grp.groupname)
def onSmoothChoice(self, evt=None, value=1):
try:
choice = self.smooth_op.GetStringSelection().lower()
conv = self.smooth_conv.GetStringSelection()
self.smooth_c0.Disable()
self.smooth_c1.Disable()
self.smooth_conv.Disable()
self.smooth_sig.Disable()
self.smooth_msg.SetLabel('')
self.smooth_c0.SetMin(1)
self.smooth_c0.odd_only = False
if choice.startswith('box'):
self.smooth_c0.Enable()
elif choice.startswith('savi'):
self.smooth_c0.Enable()
self.smooth_c1.Enable()
self.smooth_c0.Enable()
self.smooth_c0.odd_only = True
c0 = int(self.smooth_c0.GetValue())
c1 = int(self.smooth_c1.GetValue())
x0 = max(c1+1, c0)
if x0 % 2 == 0:
x0 += 1
self.smooth_c0.SetMin(c1+1)
if c0 != x0:
self.smooth_c0.SetValue(x0)
self.smooth_msg.SetLabel('n must odd and > order+1')
elif choice.startswith('conv'):
self.smooth_conv.Enable()
self.smooth_sig.Enable()
self.needs_update = True
except AttributeError:
pass
def onSet_XASE0(self, evt=None, **kws):
self.xas_autoe0.SetValue(0)
self.needs_update = True
def onSet_XASStep(self, evt=None, **kws):
self.xas_autostep.SetValue(0)
self.needs_update = True
def onProcessTimer(self, evt=None):
if self.needs_update and self.controller.groupname is not None:
self.process(self.controller.groupname)
self.controller.plot_group(groupname=self.controller.groupname, new=True)
self.needs_update = False
def UpdatePlot(self, evt=None, **kws):
self.needs_update = True
def on_selpoint(self, evt=None, opt='e0'):
xval, yval = self.controller.get_cursor()
if xval is None:
return
e0 = self.xas_e0.GetValue()
if opt == 'e0':
self.xas_e0.SetValue(xval)
self.xas_autoe0.SetValue(0)
elif opt == 'pre1':
self.xas_pre1.SetValue(xval-e0)
elif opt == 'pre2':
self.xas_pre2.SetValue(xval-e0)
elif opt == 'nor1':
self.xas_nor1.SetValue(xval-e0)
elif opt == 'nor2':
self.xas_nor2.SetValue(xval-e0)
elif opt == 'xshift':
self.xshift.SetValue(xval)
elif opt == 'yshift':
self.yshift.SetValue(yval)
def process(self, gname, **kws):
""" handle process (pre-edge/normalize) XAS data from XAS form, overwriting
larch group 'x' and 'y' attributes to be plotted
"""
dgroup = self.controller.get_group(gname)
proc_opts = {}
proc_opts['xshift'] = self.xshift.GetValue()
proc_opts['yshift'] = self.yshift.GetValue()
proc_opts['xscale'] = self.xscale.GetValue()
proc_opts['yscale'] = self.yscale.GetValue()
proc_opts['smooth_op'] = self.smooth_op.GetStringSelection()
proc_opts['smooth_c0'] = int(self.smooth_c0.GetValue())
proc_opts['smooth_c1'] = int(self.smooth_c1.GetValue())
proc_opts['smooth_sig'] = float(self.smooth_sig.GetValue())
proc_opts['smooth_conv'] = self.smooth_conv.GetStringSelection()
self.xaspanel.Enable(dgroup.datatype.startswith('xas'))
if dgroup.datatype.startswith('xas'):
proc_opts['datatype'] = 'xas'
proc_opts['e0'] = self.xas_e0.GetValue()
proc_opts['edge_step'] = self.xas_step.GetValue()
proc_opts['pre1'] = self.xas_pre1.GetValue()
proc_opts['pre2'] = self.xas_pre2.GetValue()
proc_opts['norm1'] = self.xas_nor1.GetValue()
proc_opts['norm2'] = self.xas_nor2.GetValue()
proc_opts['nvict'] = self.xas_vict.GetSelection()
proc_opts['nnorm'] = self.xas_nnor.GetSelection()
proc_opts['auto_e0'] = self.xas_autoe0.IsChecked()
proc_opts['show_e0'] = self.xas_showe0.IsChecked()
proc_opts['auto_step'] = self.xas_autostep.IsChecked()
proc_opts['nnorm'] = int(self.xas_nnor.GetSelection())
proc_opts['nvict'] = int(self.xas_vict.GetSelection())
proc_opts['xas_op'] = self.xas_op.GetStringSelection()
self.controller.process(dgroup, proc_opts=proc_opts)
if dgroup.datatype.startswith('xas'):
if self.xas_autoe0.IsChecked():
self.xas_e0.SetValue(dgroup.proc_opts['e0'], act=False)
if self.xas_autostep.IsChecked():
self.xas_step.SetValue(dgroup.proc_opts['edge_step'], act=False)
self.xas_pre1.SetValue(dgroup.proc_opts['pre1'])
self.xas_pre2.SetValue(dgroup.proc_opts['pre2'])
self.xas_nor1.SetValue(dgroup.proc_opts['norm1'])
self.xas_nor2.SetValue(dgroup.proc_opts['norm2'])
dgroup.orig_ylabel = dgroup.plot_ylabel
dgroup.plot_ylabel = '$\mu$'
dgroup.plot_y2label = None
dgroup.plot_xlabel = '$E \,\mathrm{(eV)}$'
dgroup.plot_yarrays = [(dgroup.mu, PLOTOPTS_1, dgroup.plot_ylabel)]
y4e0 = dgroup.mu
out = self.xas_op.GetStringSelection().lower() # raw, pre, norm, flat
if out.startswith('raw data + pre'):
dgroup.plot_yarrays = [(dgroup.mu, PLOTOPTS_1, '$\mu$'),
(dgroup.pre_edge, PLOTOPTS_2, 'pre edge'),
(dgroup.post_edge, PLOTOPTS_2, 'post edge')]
elif out.startswith('pre'):
dgroup.pre_edge_sub = dgroup.norm * dgroup.edge_step
dgroup.plot_yarrays = [(dgroup.pre_edge_sub, PLOTOPTS_1,
'pre-edge subtracted $\mu$')]
y4e0 = dgroup.pre_edge_sub
dgroup.plot_ylabel = 'pre-edge subtracted $\mu$'
elif 'norm' in out and 'deriv' in out:
dgroup.plot_yarrays = [(dgroup.norm, PLOTOPTS_1, 'normalized $\mu$'),
(dgroup.dmude, PLOTOPTS_D, '$d\mu/dE$')]
y4e0 = dgroup.norm
dgroup.plot_ylabel = 'normalized $\mu$'
dgroup.plot_y2label = '$d\mu/dE$'
dgroup.y = dgroup.norm
elif out.startswith('norm'):
dgroup.plot_yarrays = [(dgroup.norm, PLOTOPTS_1, 'normalized $\mu$')]
y4e0 = dgroup.norm
dgroup.plot_ylabel = 'normalized $\mu$'
dgroup.y = dgroup.norm
elif out.startswith('deriv'):
dgroup.plot_yarrays = [(dgroup.dmude, PLOTOPTS_1, '$d\mu/dE$')]
y4e0 = dgroup.dmude
dgroup.plot_ylabel = '$d\mu/dE$'
dgroup.y = dgroup.dmude
dgroup.plot_ymarkers = []
if self.xas_showe0.IsChecked():
ie0 = index_of(dgroup.xdat, dgroup.e0)
dgroup.plot_ymarkers = [(dgroup.e0, y4e0[ie0], {'label': '_nolegend_'})]
def build_display(self):
self.SetFont(Font(10))
titleopts = dict(font=Font(11), colour='#AA0000')
gopts = dict(ncols=4, nrows=4, pad=2, itemstyle=LCEN)
xas = self.xaspanel = GridPanel(self, **gopts)
gen = self.genpanel = GridPanel(self, **gopts)
self.btns = {}
#gen
opts = dict(action=self.UpdatePlot, size=(65, -1), gformat=True)
self.xshift = FloatCtrl(gen, value=0.0, **opts)
self.xscale = FloatCtrl(gen, value=1.0, **opts)
self.yshift = FloatCtrl(gen, value=0.0, **opts)
self.yscale = FloatCtrl(gen, value=1.0, **opts)
self.btns['xshift'] = BitmapButton(gen, get_icon('plus'),
action=partial(self.on_selpoint, opt='xshift'),
tooltip='use last point selected from plot')
self.btns['yshift'] = BitmapButton(gen, get_icon('plus'),
action=partial(self.on_selpoint, opt='yshift'),
tooltip='use last point selected from plot')
opts = dict(action=self.onSmoothChoice, size=(30, -1))
sm_row1 = wx.Panel(gen)
sm_row2 = wx.Panel(gen)
sm_siz1= wx.BoxSizer(wx.HORIZONTAL)
sm_siz2= wx.BoxSizer(wx.HORIZONTAL)
self.smooth_c0 = FloatCtrl(sm_row1, value=2, precision=0, minval=1, **opts)
self.smooth_c1 = FloatCtrl(sm_row1, value=1, precision=0, minval=1, **opts)
self.smooth_msg = SimpleText(sm_row1, label=' ', size=(205, -1))
opts['size'] = (65, -1)
self.smooth_sig = FloatCtrl(sm_row2, value=1, gformat=True, **opts)
opts['size'] = (120, -1)
self.smooth_op = Choice(sm_row1, choices=SMOOTH_OPS, **opts)
self.smooth_op.SetSelection(0)
self.smooth_conv = Choice(sm_row2, choices=CONV_OPS, **opts)
self.smooth_c0.Disable()
self.smooth_c1.Disable()
self.smooth_sig.Disable()
self.smooth_conv.SetSelection(0)
self.smooth_conv.Disable()
sm_siz1.Add(self.smooth_op, 0, LCEN, 1)
sm_siz1.Add(SimpleText(sm_row1, ' n= '), 0, LCEN, 1)
sm_siz1.Add(self.smooth_c0, 0, LCEN, 1)
sm_siz1.Add(SimpleText(sm_row1, ' order= '), 0, LCEN, 1)
sm_siz1.Add(self.smooth_c1, 0, LCEN, 1)
sm_siz1.Add(self.smooth_msg, 0, LCEN, 1)
sm_siz2.Add(SimpleText(sm_row2, ' form= '), 0, LCEN, 1)
sm_siz2.Add(self.smooth_conv, 0, LCEN, 1)
sm_siz2.Add(SimpleText(sm_row2, ' sigma= '), 0, LCEN, 1)
sm_siz2.Add(self.smooth_sig, 0, LCEN, 1)
pack(sm_row1, sm_siz1)
pack(sm_row2, sm_siz2)
gen.Add(SimpleText(gen, ' General Data Processing', **titleopts), dcol=8)
gen.Add(SimpleText(gen, ' X shift:'), newrow=True)
gen.Add(self.btns['xshift'])
gen.Add(self.xshift, dcol=2)
gen.Add(SimpleText(gen, ' X scale:'))
gen.Add(self.xscale, dcol=2)
gen.Add(SimpleText(gen, ' Y shift:'), newrow=True)
gen.Add(self.btns['yshift'])
gen.Add(self.yshift, dcol=2)
gen.Add(SimpleText(gen, ' Y scale:'))
gen.Add(self.yscale, dcol=2)
gen.Add(SimpleText(gen, ' Smoothing:'), newrow=True)
gen.Add(sm_row1, dcol=8)
gen.Add(sm_row2, icol=1, dcol=7, newrow=True)
gen.pack()
#xas
opts = {'action': self.UpdatePlot}
e0opts_panel = wx.Panel(xas)
self.xas_autoe0 = Check(e0opts_panel, default=True, label='auto?', **opts)
self.xas_showe0 = Check(e0opts_panel, default=True, label='show?', **opts)
sx = wx.BoxSizer(wx.HORIZONTAL)
sx.Add(self.xas_autoe0, 0, LCEN, 4)
sx.Add(self.xas_showe0, 0, LCEN, 4)
pack(e0opts_panel, sx)
self.xas_autostep = Check(xas, default=True, label='auto?', **opts)
opts['size'] = (250, -1)
self.xas_op = Choice(xas, choices=XASOPChoices, **opts)
self.xas_op.SetStringSelection('Normalized')
for name in ('e0', 'pre1', 'pre2', 'nor1', 'nor2'):
bb = BitmapButton(xas, get_icon('plus'),
action=partial(self.on_selpoint, opt=name),
tooltip='use last point selected from plot')
self.btns[name] = bb
opts = {'size': (65, -1), 'gformat': True}
self.xas_e0 = FloatCtrl(xas, value=0, action=self.onSet_XASE0, **opts)
self.xas_step = FloatCtrl(xas, value=0, action=self.onSet_XASStep, **opts)
opts['precision'] = 1
opts['action'] = self.UpdatePlot
self.xas_pre1 = FloatCtrl(xas, value=-200, **opts)
self.xas_pre2 = FloatCtrl(xas, value= -30, **opts)
self.xas_nor1 = FloatCtrl(xas, value= 50, **opts)
self.xas_nor2 = FloatCtrl(xas, value= -50, **opts)
opts = {'size': (50, -1),
'choices': ('0', '1', '2', '3'),
'action': self.UpdatePlot}
self.xas_vict = Choice(xas, **opts)
self.xas_nnor = Choice(xas, **opts)
self.xas_vict.SetSelection(1)
self.xas_nnor.SetSelection(1)
def CopyBtn(name):
return Button(xas, 'Copy', size=(50, 30),
action=partial(self.onCopyParam, name))
xas.Add(SimpleText(xas, ' XAS Data Processing', **titleopts), dcol=6)
xas.Add(SimpleText(xas, ' Copy to Selected Groups?'), style=RCEN, dcol=3)
xas.Add(SimpleText(xas, 'Arrays to Plot: '), newrow=True)
xas.Add(self.xas_op, dcol=6)
xas.Add((10, 10))
xas.Add(CopyBtn('xas_op'), style=RCEN)
xas.Add(SimpleText(xas, 'E0 : '), newrow=True)
xas.Add(self.btns['e0'])
xas.Add(self.xas_e0)
xas.Add(e0opts_panel, dcol=4)
xas.Add((10, 1))
xas.Add(CopyBtn('xas_e0'), style=RCEN)
xas.Add(SimpleText(xas, 'Edge Step: '), newrow=True)
xas.Add((10, 1))
xas.Add(self.xas_step)
xas.Add(self.xas_autostep, dcol=3)
xas.Add((10, 1))
xas.Add((10, 1))
xas.Add(CopyBtn('xas_step'), style=RCEN)
xas.Add(SimpleText(xas, 'Pre-edge range: '), newrow=True)
xas.Add(self.btns['pre1'])
xas.Add(self.xas_pre1)
xas.Add(SimpleText(xas, ':'))
xas.Add(self.btns['pre2'])
xas.Add(self.xas_pre2)
xas.Add(SimpleText(xas, 'Victoreen:'))
xas.Add(self.xas_vict)
xas.Add(CopyBtn('xas_pre'), style=RCEN)
xas.Add(SimpleText(xas, 'Normalization range: '), newrow=True)
xas.Add(self.btns['nor1'])
xas.Add(self.xas_nor1)
xas.Add(SimpleText(xas, ':'))
xas.Add(self.btns['nor2'])
xas.Add(self.xas_nor2)
xas.Add(SimpleText(xas, 'PolyOrder:'))
xas.Add(self.xas_nnor)
xas.Add(CopyBtn('xas_norm'), style=RCEN)
xas.pack()
saveconf = Button(self, 'Save as Default Settings',
size=(175, 30),
action=self.onSaveConfigBtn)
hxline = HLine(self, size=(550, 2))
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.AddMany([((10, 10), 0, LCEN, 10), (gen, 0, LCEN, 10),
((10, 10), 0, LCEN, 10), (hxline, 0, LCEN, 10),
((10, 10), 0, LCEN, 10), (xas, 0, LCEN, 10),
((10, 10), 0, LCEN, 10), (saveconf, 0, LCEN, 10),
])
xas.Disable()
pack(self, sizer)
class XASNormPanel(wx.Panel):
"""XAS normalization Panel"""
def __init__(self, parent, controller=None, reporter=None, **kws):
wx.Panel.__init__(self, parent, -1, **kws)
self.parent = parent
self.controller = controller
self.reporter = reporter
self.skip_process = False
self.build_display()
def onPanelExposed(self, **kws):
# called when notebook is selected
try:
fname = self.controller.filelist.GetStringSelection()
gname = self.controller.file_groups[fname]
dgroup = self.controller.get_group(gname)
self.fill_form(dgroup)
except:
pass
def larch_eval(self, cmd):
"""eval"""
self.controller.larch.eval(cmd)
def build_display(self):
self.SetFont(Font(10))
titleopts = dict(font=Font(11), colour='#AA0000')
xas = self.xaspanel = GridPanel(self,
ncols=4,
nrows=4,
pad=2,
itemstyle=LCEN)
self.plotone_op = Choice(xas,
choices=list(PlotOne_Choices.keys()),
action=self.onPlotOne,
size=(200, -1))
self.plotsel_op = Choice(xas,
choices=list(PlotSel_Choices.keys()),
action=self.onPlotSel,
size=(200, -1))
self.plotone_op.SetStringSelection('Normalized')
self.plotsel_op.SetStringSelection('Normalized')
plot_one = Button(xas,
'Plot This Group',
size=(150, -1),
action=self.onPlotOne)
plot_sel = Button(xas,
'Plot Selected Groups',
size=(150, -1),
action=self.onPlotSel)
self.btns = {}
opts = dict(action=self.onReprocess)
self.deconv_ewid = FloatCtrl(xas,
value=0.5,
precision=2,
minval=0,
size=(50, -1),
**opts)
self.deconv_form = Choice(xas,
choices=DECONV_OPS,
size=(100, -1),
**opts)
e0opts_panel = wx.Panel(xas)
self.xas_autoe0 = Check(e0opts_panel,
default=True,
label='auto?',
**opts)
self.xas_showe0 = Check(e0opts_panel,
default=True,
label='show?',
**opts)
sx = wx.BoxSizer(wx.HORIZONTAL)
sx.Add(self.xas_autoe0, 0, LCEN, 4)
sx.Add(self.xas_showe0, 0, LCEN, 4)
pack(e0opts_panel, sx)
self.xas_autostep = Check(xas, default=True, label='auto?', **opts)
for name in ('e0', 'pre1', 'pre2', 'nor1', 'nor2'):
bb = BitmapButton(xas,
get_icon('plus'),
action=partial(self.on_selpoint, opt=name),
tooltip='use last point selected from plot')
self.btns[name] = bb
opts['size'] = (50, -1)
self.xas_vict = Choice(xas, choices=('0', '1', '2', '3'), **opts)
self.xas_nnor = Choice(xas, choices=('0', '1', '2', '3'), **opts)
self.xas_vict.SetSelection(1)
self.xas_nnor.SetSelection(1)
opts.update({'size': (75, -1), 'precision': 1})
self.xas_pre1 = FloatCtrl(xas, value=-np.inf, **opts)
self.xas_pre2 = FloatCtrl(xas, value=-30, **opts)
self.xas_nor1 = FloatCtrl(xas, value=50, **opts)
self.xas_nor2 = FloatCtrl(xas, value=np.inf, **opts)
opts = {'size': (75, -1), 'gformat': True}
self.xas_e0 = FloatCtrl(xas, value=0, action=self.onSet_XASE0, **opts)
self.xas_step = FloatCtrl(xas,
value=0,
action=self.onSet_XASStep,
**opts)
saveconf = Button(xas,
'Save as Default Settings',
size=(200, -1),
action=self.onSaveConfigBtn)
def CopyBtn(name):
return Button(xas,
'Copy',
size=(50, -1),
action=partial(self.onCopyParam, name))
xas.Add(SimpleText(xas, ' XAS Pre-edge subtraction and Normalization',
**titleopts),
dcol=6)
xas.Add(SimpleText(xas, ' Copy to Selected Groups?'),
style=RCEN,
dcol=3)
xas.Add(plot_sel, newrow=True)
xas.Add(self.plotsel_op, dcol=6)
xas.Add(plot_one, newrow=True)
xas.Add(self.plotone_op, dcol=6)
xas.Add((10, 10))
xas.Add(CopyBtn('plotone_op'), style=RCEN)
xas.Add(SimpleText(xas, 'E0 : '), newrow=True)
xas.Add(self.btns['e0'])
xas.Add(self.xas_e0)
xas.Add(e0opts_panel, dcol=4)
xas.Add((10, 1))
xas.Add(CopyBtn('xas_e0'), style=RCEN)
xas.Add(SimpleText(xas, 'Edge Step: '), newrow=True)
xas.Add((10, 1))
xas.Add(self.xas_step)
xas.Add(self.xas_autostep, dcol=3)
xas.Add((10, 1))
xas.Add((10, 1))
xas.Add(CopyBtn('xas_step'), style=RCEN)
xas.Add(SimpleText(xas, 'Pre-edge range: '), newrow=True)
xas.Add(self.btns['pre1'])
xas.Add(self.xas_pre1)
xas.Add(SimpleText(xas, ':'))
xas.Add(self.btns['pre2'])
xas.Add(self.xas_pre2)
xas.Add(SimpleText(xas, 'Victoreen:'))
xas.Add(self.xas_vict)
xas.Add(CopyBtn('xas_pre'), style=RCEN)
xas.Add(SimpleText(xas, 'Normalization range: '), newrow=True)
xas.Add(self.btns['nor1'])
xas.Add(self.xas_nor1)
xas.Add(SimpleText(xas, ':'))
xas.Add(self.btns['nor2'])
xas.Add(self.xas_nor2)
xas.Add(SimpleText(xas, 'Poly Order:'))
xas.Add(self.xas_nnor)
xas.Add(CopyBtn('xas_norm'), style=RCEN)
xas.Add(SimpleText(xas, ' Deconvolution:'), newrow=True)
xas.Add(self.deconv_form, dcol=5)
xas.Add(SimpleText(xas, 'Energy width:'))
xas.Add(self.deconv_ewid)
xas.Add(CopyBtn('deconv'), style=RCEN)
xas.Add(saveconf, dcol=6, newrow=True)
xas.pack()
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add((5, 5), 0, LCEN, 3)
sizer.Add(HLine(self, size=(550, 2)), 0, LCEN, 3)
sizer.Add(xas, 0, LCEN, 3)
sizer.Add((5, 5), 0, LCEN, 3)
sizer.Add(HLine(self, size=(550, 2)), 0, LCEN, 3)
pack(self, sizer)
def get_config(self, dgroup=None):
"""get processing configuration for a group"""
if dgroup is None:
dgroup = self.controller.get_group()
conf = getattr(dgroup, 'xasnorm_config', {})
if 'e0' not in conf:
conf = default_xasnorm_config()
dgroup.xasnorm_config = conf
return conf
def fill_form(self, dgroup):
"""fill in form from a data group"""
opts = self.get_config(dgroup)
self.skip_process = True
widlist = (self.xas_e0, self.xas_step, self.xas_pre1, self.xas_pre2,
self.xas_nor1, self.xas_nor2, self.xas_vict, self.xas_nnor,
self.xas_showe0, self.xas_autoe0, self.xas_autostep,
self.deconv_form, self.deconv_ewid)
if dgroup.datatype == 'xas':
for k in widlist:
k.Enable()
self.plotone_op.SetChoices(list(PlotOne_Choices.keys()))
self.plotsel_op.SetChoices(list(PlotSel_Choices.keys()))
self.plotone_op.SetStringSelection(opts['plotone_op'])
self.plotsel_op.SetStringSelection(opts['plotsel_op'])
self.xas_e0.SetValue(opts['e0'])
self.xas_step.SetValue(opts['edge_step'])
self.xas_pre1.SetValue(opts['pre1'])
self.xas_pre2.SetValue(opts['pre2'])
self.xas_nor1.SetValue(opts['norm1'])
self.xas_nor2.SetValue(opts['norm2'])
self.xas_vict.SetSelection(opts['nvict'])
self.xas_nnor.SetSelection(opts['nnorm'])
self.xas_showe0.SetValue(opts['show_e0'])
self.xas_autoe0.SetValue(opts['auto_e0'])
self.xas_autostep.SetValue(opts['auto_step'])
self.deconv_form.SetStringSelection(opts['deconv_form'])
self.deconv_ewid.SetValue(opts['deconv_ewid'])
else:
self.plotone_op.SetChoices(list(PlotOne_Choices_nonxas.keys()))
self.plotsel_op.SetChoices(list(PlotSel_Choices_nonxas.keys()))
self.plotone_op.SetStringSelection('Raw Data')
self.plotsel_op.SetStringSelection('Raw Data')
for k in widlist:
k.Disable()
self.skip_process = False
self.process(dgroup)
def read_form(self):
"read for, returning dict of values"
form_opts = {}
form_opts['e0'] = self.xas_e0.GetValue()
form_opts['edge_step'] = self.xas_step.GetValue()
form_opts['pre1'] = self.xas_pre1.GetValue()
form_opts['pre2'] = self.xas_pre2.GetValue()
form_opts['norm1'] = self.xas_nor1.GetValue()
form_opts['norm2'] = self.xas_nor2.GetValue()
form_opts['nnorm'] = int(self.xas_nnor.GetSelection())
form_opts['nvict'] = int(self.xas_vict.GetSelection())
form_opts['plotone_op'] = self.plotone_op.GetStringSelection()
form_opts['plotsel_op'] = self.plotsel_op.GetStringSelection()
form_opts['show_e0'] = self.xas_showe0.IsChecked()
form_opts['auto_e0'] = self.xas_autoe0.IsChecked()
form_opts['auto_step'] = self.xas_autostep.IsChecked()
form_opts['deconv_form'] = self.deconv_form.GetStringSelection()
form_opts['deconv_ewid'] = self.deconv_ewid.GetValue()
return form_opts
def onPlotOne(self, evt=None):
self.plot(self.controller.get_group())
def onPlotSel(self, evt=None):
newplot = True
group_ids = self.controller.filelist.GetCheckedStrings()
if len(group_ids) < 1:
return
last_id = group_ids[-1]
yarray_name = PlotSel_Choices[self.plotsel_op.GetStringSelection()]
ylabel = getattr(plotlabels, yarray_name)
# print("Plot Sel:: ", group_ids)
for checked in group_ids:
groupname = self.controller.file_groups[str(checked)]
dgroup = self.controller.get_group(groupname)
plot_yarrays = [(yarray_name, PLOTOPTS_1, dgroup.filename)]
dgroup.plot_ylabel = ylabel
if dgroup is not None:
dgroup.plot_extras = []
# print(" PlotSel -> plot ", checked, (last_id!=checked) )
self.plot(dgroup,
title='',
new=newplot,
plot_yarrays=plot_yarrays,
show_legend=True,
with_extras=False,
delay_draw=(last_id != checked))
newplot = False
self.controller.get_display(stacked=False).panel.canvas.draw()
def onSaveConfigBtn(self, evt=None):
conf = self.controller.larch.symtable._sys.xas_viewer
opts = {}
opts.update(getattr(conf, 'xas_norm', {}))
opts.update(self.read_form())
conf.xas_norm = opts
def onCopyParam(self, name=None, evt=None):
conf = self.get_config()
conf.update(self.read_form())
opts = {}
name = str(name)
def copy_attrs(*args):
for a in args:
opts[a] = conf[a]
if name == 'plotone_op':
copy_attrs('plotone_op')
elif name == 'xas_e0':
copy_attrs('e0', 'show_e0')
opts['auto_e0'] = False
elif name == 'xas_step':
copy_attrs('edge_step')
opts['auto_step'] = False
elif name == 'xas_pre':
copy_attrs('pre1', 'pre2', 'nvict')
elif name == 'xas_norm':
copy_attrs('nnorm', 'norm1', 'norm2')
elif name == 'deconv':
copy_attrs('deconv_form', 'deconv_ewid')
for checked in self.controller.filelist.GetCheckedStrings():
groupname = self.controller.file_groups[str(checked)]
grp = self.controller.get_group(groupname)
if grp != self.controller.group:
grp.xasnorm_config.update(opts)
self.fill_form(grp)
self.process(grp)
def onSet_XASE0(self, evt=None, value=None):
self.xas_autoe0.SetValue(0)
self.onReprocess()
def onSet_XASStep(self, evt=None, value=None):
self.xas_autostep.SetValue(0)
self.onReprocess()
def onReprocess(self, evt=None, value=None, **kws):
if self.skip_process:
return
try:
dgroup = self.controller.get_group()
except TypeError:
return
self.process(dgroup)
self.plot(dgroup)
def on_selpoint(self, evt=None, opt='e0'):
xval, yval = self.controller.get_cursor()
if xval is None:
return
e0 = self.xas_e0.GetValue()
if opt == 'e0':
self.xas_e0.SetValue(xval)
self.xas_autoe0.SetValue(0)
elif opt == 'pre1':
self.xas_pre1.SetValue(xval - e0)
elif opt == 'pre2':
self.xas_pre2.SetValue(xval - e0)
elif opt == 'nor1':
self.xas_nor1.SetValue(xval - e0)
elif opt == 'nor2':
self.xas_nor2.SetValue(xval - e0)
else:
print(" unknown selection point ", opt)
def process(self, dgroup, **kws):
""" handle process (pre-edge/normalize, deconvolve) of XAS data from XAS form
"""
if self.skip_process:
return
self.skip_process = True
dgroup.custom_plotopts = {}
# print("XAS norm process ", dgroup.datatype)
if dgroup.datatype != 'xas':
self.skip_process = False
dgroup.mu = dgroup.ydat * 1.0
return
en_units = getattr(dgroup, 'energy_units', None)
if en_units is None:
en_units = 'eV'
units = guess_energy_units(dgroup.energy)
if units != 'eV':
dlg = EnergyUnitsDialog(self.parent, units, dgroup.energy)
res = dlg.GetResponse()
dlg.Destroy()
if res.ok:
en_units = res.units
dgroup.xdat = dgroup.energy = res.energy
dgroup.energy_units = en_units
form = self.read_form()
e0 = form['e0']
edge_step = form['edge_step']
form['group'] = dgroup.groupname
copts = [dgroup.groupname]
if not form['auto_e0']:
if e0 < max(dgroup.energy) and e0 > min(dgroup.energy):
copts.append("e0=%.4f" % float(e0))
if not form['auto_step']:
copts.append("step=%.4f" % float(edge_step))
for attr in ('pre1', 'pre2', 'nvict', 'nnorm', 'norm1', 'norm2'):
copts.append("%s=%.2f" % (attr, form[attr]))
self.larch_eval("pre_edge(%s)" % (', '.join(copts)))
if form['auto_e0']:
self.xas_e0.SetValue(dgroup.e0, act=False)
if form['auto_step']:
self.xas_step.SetValue(dgroup.edge_step, act=False)
self.xas_pre1.SetValue(dgroup.pre_edge_details.pre1)
self.xas_pre2.SetValue(dgroup.pre_edge_details.pre2)
self.xas_nor1.SetValue(dgroup.pre_edge_details.norm1)
self.xas_nor2.SetValue(dgroup.pre_edge_details.norm2)
# deconvolution
deconv_form = form['deconv_form'].lower()
deconv_ewid = float(form['deconv_ewid'])
if not deconv_form.startswith('none') and deconv_ewid > 1.e-3:
dopts = [
dgroup.groupname,
"form='%s'" % (deconv_form),
"esigma=%.4f" % (deconv_ewid)
]
self.larch_eval("xas_deconvolve(%s)" % (', '.join(dopts)))
for attr in ('e0', 'edge_step'):
dgroup.xasnorm_config[attr] = getattr(dgroup, attr)
for attr in ('pre1', 'pre2', 'nnorm', 'norm1', 'norm2'):
dgroup.xasnorm_config[attr] = getattr(dgroup.pre_edge_details,
attr)
self.skip_process = False
def get_plot_arrays(self, dgroup):
form = self.read_form()
lab = plotlabels.norm
dgroup.plot_y2label = None
dgroup.plot_xlabel = plotlabels.energy
dgroup.plot_yarrays = [('norm', PLOTOPTS_1, lab)]
if dgroup.datatype != 'xas':
pchoice = PlotOne_Choices_nonxas[
self.plotone_op.GetStringSelection()]
dgroup.plot_xlabel = 'x'
dgroup.plot_ylabel = 'y'
dgroup.plot_yarrays = [('ydat', PLOTOPTS_1, 'ydat')]
dgroup.dmude = np.gradient(dgroup.ydat) / np.gradient(dgroup.xdat)
if pchoice == 'dmude':
dgroup.plot_ylabel = 'dy/dx'
dgroup.plot_yarrays = [('dmude', PLOTOPTS_1, 'dy/dx')]
elif pchoice == 'norm+deriv':
lab = plotlabels.norm
dgroup.plot_y2label = 'dy/dx'
dgroup.plot_yarrays = [('ydat', PLOTOPTS_1, 'y'),
('dmude', PLOTOPTS_D, 'dy/dx')]
return
pchoice = PlotOne_Choices[self.plotone_op.GetStringSelection()]
if pchoice in ('mu', 'norm', 'flat', 'dmude'):
lab = getattr(plotlabels, pchoice)
dgroup.plot_yarrays = [(pchoice, PLOTOPTS_1, lab)]
elif pchoice == 'prelines':
dgroup.plot_yarrays = [('mu', PLOTOPTS_1, lab),
('pre_edge', PLOTOPTS_2, 'pre edge'),
('post_edge', PLOTOPTS_2, 'post edge')]
elif pchoice == 'preedge':
dgroup.pre_edge_sub = dgroup.norm * dgroup.edge_step
dgroup.plot_yarrays = [('pre_edge_sub', PLOTOPTS_1,
r'pre-edge subtracted $\mu$')]
lab = r'pre-edge subtracted $\mu$'
elif pchoice == 'norm+deriv':
lab = plotlabels.norm
lab2 = plotlabels.dmude
dgroup.plot_yarrays = [('norm', PLOTOPTS_1, lab),
('dmude', PLOTOPTS_D, lab2)]
dgroup.plot_y2label = lab2
elif pchoice == 'deconv' and hasattr(dgroup, 'deconv'):
lab = plotlabels.deconv
dgroup.plot_yarrays = [('deconv', PLOTOPTS_1, lab)]
elif pchoice == 'deconv+norm' and hasattr(dgroup, 'deconv'):
lab1 = plotlabels.norm
lab2 = plotlabels.deconv
dgroup.plot_yarrays = [('deconv', PLOTOPTS_1, lab2),
('norm', PLOTOPTS_1, lab1)]
lab = lab1 + ' + ' + lab2
dgroup.plot_ylabel = lab
y4e0 = dgroup.ydat = getattr(dgroup, dgroup.plot_yarrays[0][0],
dgroup.mu)
dgroup.plot_extras = []
if form['show_e0']:
ie0 = index_of(dgroup.energy, dgroup.e0)
dgroup.plot_extras.append(('marker', dgroup.e0, y4e0[ie0], {}))
def plot(self,
dgroup,
title=None,
plot_yarrays=None,
delay_draw=False,
new=True,
zoom_out=True,
with_extras=True,
**kws):
self.get_plot_arrays(dgroup)
ppanel = self.controller.get_display(stacked=False).panel
viewlims = ppanel.get_viewlimits()
plotcmd = ppanel.oplot
if new:
plotcmd = ppanel.plot
groupname = dgroup.groupname
if not hasattr(dgroup, 'xdat'):
print("Cannot plot group ", groupname)
if ((getattr(dgroup, 'plot_yarrays', None) is None
or getattr(dgroup, 'energy', None) is None
or getattr(dgroup, 'mu', None) is None)):
self.process(dgroup)
if plot_yarrays is None and hasattr(dgroup, 'plot_yarrays'):
plot_yarrays = dgroup.plot_yarrays
popts = kws
path, fname = os.path.split(dgroup.filename)
if not 'label' in popts:
popts['label'] = dgroup.plot_ylabel
zoom_out = (zoom_out or min(dgroup.xdat) >= viewlims[1]
or max(dgroup.xdat) <= viewlims[0]
or min(dgroup.ydat) >= viewlims[3]
or max(dgroup.ydat) <= viewlims[2])
if not zoom_out:
popts['xmin'] = viewlims[0]
popts['xmax'] = viewlims[1]
popts['ymin'] = viewlims[2]
popts['ymax'] = viewlims[3]
popts['xlabel'] = dgroup.plot_xlabel
popts['ylabel'] = dgroup.plot_ylabel
if getattr(dgroup, 'plot_y2label', None) is not None:
popts['y2label'] = dgroup.plot_y2label
plot_extras = None
if new:
if title is None:
title = fname
plot_extras = getattr(dgroup, 'plot_extras', None)
popts['title'] = title
popts['delay_draw'] = delay_draw
if hasattr(dgroup, 'custom_plotopts'):
popts.update(dgroup.custom_plotopts)
narr = len(plot_yarrays) - 1
for i, pydat in enumerate(plot_yarrays):
yaname, yopts, yalabel = pydat
popts.update(yopts)
if yalabel is not None:
popts['label'] = yalabel
popts['delay_draw'] = delay_draw or (i != narr)
# print("plot:: ", i, popts['delay_draw'], plotcmd)
# print(popts)
plotcmd(dgroup.xdat, getattr(dgroup, yaname), **popts)
plotcmd = ppanel.oplot
if with_extras and plot_extras is not None:
axes = ppanel.axes
for etype, x, y, opts in plot_extras:
if etype == 'marker':
xpopts = {
'marker': 'o',
'markersize': 4,
'label': '_nolegend_',
'markerfacecolor': 'red',
'markeredgecolor': '#884444'
}
xpopts.update(opts)
axes.plot([x], [y], **xpopts)
elif etype == 'vline':
xpopts = {
'ymin': 0,
'ymax': 1.0,
'label': '_nolegend_',
'color': '#888888'
}
xpopts.update(opts)
axes.axvline(x, **xpopts)
if not popts['delay_draw']:
ppanel.canvas.draw()
def build_display(self):
self.SetFont(Font(10))
titleopts = dict(font=Font(11), colour='#AA0000')
xas = self.xaspanel = GridPanel(self,
ncols=4,
nrows=4,
pad=2,
itemstyle=LCEN)
self.plotone_op = Choice(xas,
choices=list(PlotOne_Choices.keys()),
action=self.onPlotOne,
size=(200, -1))
self.plotsel_op = Choice(xas,
choices=list(PlotSel_Choices.keys()),
action=self.onPlotSel,
size=(200, -1))
self.plotone_op.SetStringSelection('Normalized')
self.plotsel_op.SetStringSelection('Normalized')
plot_one = Button(xas,
'Plot This Group',
size=(150, -1),
action=self.onPlotOne)
plot_sel = Button(xas,
'Plot Selected Groups',
size=(150, -1),
action=self.onPlotSel)
self.btns = {}
opts = dict(action=self.onReprocess)
self.deconv_ewid = FloatCtrl(xas,
value=0.5,
precision=2,
minval=0,
size=(50, -1),
**opts)
self.deconv_form = Choice(xas,
choices=DECONV_OPS,
size=(100, -1),
**opts)
e0opts_panel = wx.Panel(xas)
self.xas_autoe0 = Check(e0opts_panel,
default=True,
label='auto?',
**opts)
self.xas_showe0 = Check(e0opts_panel,
default=True,
label='show?',
**opts)
sx = wx.BoxSizer(wx.HORIZONTAL)
sx.Add(self.xas_autoe0, 0, LCEN, 4)
sx.Add(self.xas_showe0, 0, LCEN, 4)
pack(e0opts_panel, sx)
self.xas_autostep = Check(xas, default=True, label='auto?', **opts)
for name in ('e0', 'pre1', 'pre2', 'nor1', 'nor2'):
bb = BitmapButton(xas,
get_icon('plus'),
action=partial(self.on_selpoint, opt=name),
tooltip='use last point selected from plot')
self.btns[name] = bb
opts['size'] = (50, -1)
self.xas_vict = Choice(xas, choices=('0', '1', '2', '3'), **opts)
self.xas_nnor = Choice(xas, choices=('0', '1', '2', '3'), **opts)
self.xas_vict.SetSelection(1)
self.xas_nnor.SetSelection(1)
opts.update({'size': (75, -1), 'precision': 1})
self.xas_pre1 = FloatCtrl(xas, value=-np.inf, **opts)
self.xas_pre2 = FloatCtrl(xas, value=-30, **opts)
self.xas_nor1 = FloatCtrl(xas, value=50, **opts)
self.xas_nor2 = FloatCtrl(xas, value=np.inf, **opts)
opts = {'size': (75, -1), 'gformat': True}
self.xas_e0 = FloatCtrl(xas, value=0, action=self.onSet_XASE0, **opts)
self.xas_step = FloatCtrl(xas,
value=0,
action=self.onSet_XASStep,
**opts)
saveconf = Button(xas,
'Save as Default Settings',
size=(200, -1),
action=self.onSaveConfigBtn)
def CopyBtn(name):
return Button(xas,
'Copy',
size=(50, -1),
action=partial(self.onCopyParam, name))
xas.Add(SimpleText(xas, ' XAS Pre-edge subtraction and Normalization',
**titleopts),
dcol=6)
xas.Add(SimpleText(xas, ' Copy to Selected Groups?'),
style=RCEN,
dcol=3)
xas.Add(plot_sel, newrow=True)
xas.Add(self.plotsel_op, dcol=6)
xas.Add(plot_one, newrow=True)
xas.Add(self.plotone_op, dcol=6)
xas.Add((10, 10))
xas.Add(CopyBtn('plotone_op'), style=RCEN)
xas.Add(SimpleText(xas, 'E0 : '), newrow=True)
xas.Add(self.btns['e0'])
xas.Add(self.xas_e0)
xas.Add(e0opts_panel, dcol=4)
xas.Add((10, 1))
xas.Add(CopyBtn('xas_e0'), style=RCEN)
xas.Add(SimpleText(xas, 'Edge Step: '), newrow=True)
xas.Add((10, 1))
xas.Add(self.xas_step)
xas.Add(self.xas_autostep, dcol=3)
xas.Add((10, 1))
xas.Add((10, 1))
xas.Add(CopyBtn('xas_step'), style=RCEN)
xas.Add(SimpleText(xas, 'Pre-edge range: '), newrow=True)
xas.Add(self.btns['pre1'])
xas.Add(self.xas_pre1)
xas.Add(SimpleText(xas, ':'))
xas.Add(self.btns['pre2'])
xas.Add(self.xas_pre2)
xas.Add(SimpleText(xas, 'Victoreen:'))
xas.Add(self.xas_vict)
xas.Add(CopyBtn('xas_pre'), style=RCEN)
xas.Add(SimpleText(xas, 'Normalization range: '), newrow=True)
xas.Add(self.btns['nor1'])
xas.Add(self.xas_nor1)
xas.Add(SimpleText(xas, ':'))
xas.Add(self.btns['nor2'])
xas.Add(self.xas_nor2)
xas.Add(SimpleText(xas, 'Poly Order:'))
xas.Add(self.xas_nnor)
xas.Add(CopyBtn('xas_norm'), style=RCEN)
xas.Add(SimpleText(xas, ' Deconvolution:'), newrow=True)
xas.Add(self.deconv_form, dcol=5)
xas.Add(SimpleText(xas, 'Energy width:'))
xas.Add(self.deconv_ewid)
xas.Add(CopyBtn('deconv'), style=RCEN)
xas.Add(saveconf, dcol=6, newrow=True)
xas.pack()
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add((5, 5), 0, LCEN, 3)
sizer.Add(HLine(self, size=(550, 2)), 0, LCEN, 3)
sizer.Add(xas, 0, LCEN, 3)
sizer.Add((5, 5), 0, LCEN, 3)
sizer.Add(HLine(self, size=(550, 2)), 0, LCEN, 3)
pack(self, sizer)
def build_display(self):
titleopts = dict(font=Font(12), colour='#AA0000')
panel = self.panel
wids = self.wids
self.skip_process = True
wids['fitspace'] = Choice(panel,
choices=FitSpace_Choices,
size=(175, -1))
wids['fitspace'].SetStringSelection(norm)
wids['plotchoice'] = Choice(panel,
choices=Plot_Choices,
size=(175, -1),
action=self.onPlot)
wids['plotchoice'].SetSelection(1)
add_text = self.add_text
opts = dict(digits=2, increment=1.0, relative_e0=True)
e0_wids = self.add_floatspin('e0', value=0, **opts)
elo_wids = self.add_floatspin('elo', value=-20, **opts)
ehi_wids = self.add_floatspin('ehi', value=30, **opts)
wids['fit_group'] = Button(panel,
'Fit this Group',
size=(150, -1),
action=self.onFitOne)
wids['fit_selected'] = Button(panel,
'Fit Selected Groups',
size=(150, -1),
action=self.onFitAll)
wids['add_selected'] = Button(panel,
'Use Selected Groups as Components',
size=(250, -1),
action=self.onUseSelected)
wids['saveconf'] = Button(panel,
'Save as Default Settings',
size=(200, -1),
action=self.onSaveConfigBtn)
opts = dict(default=True, size=(75, -1), action=self.onPlotOne)
wids['show_e0'] = Check(panel, label='show?', **opts)
wids['show_fitrange'] = Check(panel, label='show?', **opts)
wids['sum_to_one'] = Check(panel,
label='Weights Must Sum to 1?',
default=True)
wids['all_combos'] = Check(panel,
label='Fit All Combinations?',
default=True)
panel.Add(SimpleText(panel, ' Linear Combination Analysis',
**titleopts),
dcol=5)
add_text('Run Fit', newrow=False)
add_text('Array to Fit: ', newrow=True)
panel.Add(wids['fitspace'], dcol=4)
panel.Add(wids['fit_group'])
add_text('Plot : ', newrow=True)
panel.Add(wids['plotchoice'], dcol=4)
panel.Add(wids['fit_selected'])
add_text('E0: ')
panel.Add(e0_wids, dcol=3)
panel.Add(wids['show_e0'])
add_text('Fit Energy Range: ')
panel.Add(elo_wids)
add_text(' : ', newrow=False)
panel.Add(ehi_wids)
panel.Add(wids['show_fitrange'])
panel.Add(wids['sum_to_one'], dcol=2, newrow=True)
panel.Add(wids['all_combos'], dcol=3)
panel.Add(HLine(panel, size=(400, 2)), dcol=5, newrow=True)
add_text('Components: ')
panel.Add(wids['add_selected'], dcol=4)
groupnames = [noname] + list(self.controller.file_groups.keys())
sgrid = GridPanel(panel, nrows=6)
sgrid.Add(SimpleText(sgrid, "#"))
sgrid.Add(SimpleText(sgrid, "Group"))
sgrid.Add(SimpleText(sgrid, "Weight"))
sgrid.Add(SimpleText(sgrid, "Min Weight"))
sgrid.Add(SimpleText(sgrid, "Max Weight"))
fopts = dict(minval=-10, maxval=20, precision=4, size=(60, -1))
for i in range(1, 1 + MAX_COMPONENTS):
si = ("comp", "_%2.2d" % i)
sgrid.Add(SimpleText(sgrid, "%2i" % i), newrow=True)
wids['%schoice%s' % si] = Choice(sgrid,
choices=groupnames,
size=(200, -1),
action=partial(self.onComponent,
comp=i))
wids['%sval%s' % si] = FloatCtrl(sgrid, value=0, **fopts)
wids['%smin%s' % si] = FloatCtrl(sgrid, value=0, **fopts)
wids['%smax%s' % si] = FloatCtrl(sgrid, value=1, **fopts)
for cname in ('choice', 'val', 'min', 'max'):
sgrid.Add(wids[("%%s%s%%s" % cname) % si])
sgrid.pack()
panel.Add(sgrid, dcol=5, newrow=True)
panel.Add(HLine(panel, size=(400, 2)), dcol=5, newrow=True)
panel.Add(wids['saveconf'], dcol=4, newrow=True)
panel.pack()
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(panel, 1, LCEN, 3)
pack(self, sizer)
self.skip_process = False
def __init__(self, parent, param, precision=4, vary=None, **kws):
self.param = param
title = " Parameter: %s " % (param.name)
wx.Dialog.__init__(self, parent, wx.ID_ANY, title=title)
panel = GridPanel(self)
self.SetFont(parent.GetFont())
if vary is None:
vary = 0
if param.vary:
vary = 1
elif param.expr is not None:
vary = 2
minval, maxval = param.min, param.max
stderr, expr = param.stderr, param.expr
sminval = "%s" % minval
smaxval = "%s" % maxval
if minval in (None, 'None', -np.inf): minval = -np.inf
if maxval in (None, 'None', np.inf): maxval = np.inf
if stderr is None: stderr = ''
if expr is None: expr = ''
self.wids = Empty()
self.wids.vary = Choice(panel, choices=VARY_CHOICES,
action=self.onVaryChoice, size=(110, -1))
self.wids.vary.SetSelection(vary)
self.wids.val = FloatCtrl(panel, value=param.value, size=(100, -1),
precision=precision,
minval=minval, maxval=maxval)
self.wids.min = FloatCtrl(panel, value=minval, size=(100, -1))
self.wids.max = FloatCtrl(panel, value=maxval, size=(100, -1))
self.wids.expr = wx.TextCtrl(panel, value=expr, size=(300, -1))
self.wids.err = wx.StaticText(panel, label="%s" % stderr)
SetTip(self.wids.expr, "Mathematical expression to calcutate value")
btnsizer = wx.StdDialogButtonSizer()
ok_btn = wx.Button(panel, wx.ID_OK)
ok_btn.SetDefault()
btnsizer.AddButton(ok_btn)
btnsizer.AddButton(wx.Button(panel, wx.ID_CANCEL))
btnsizer.Realize()
panel.AddText(' Name:', style=LEFT)
panel.AddText(param.name, style=LEFT)
panel.AddText(' Type:', style=LEFT)
panel.Add(self.wids.vary, style=LEFT)
panel.AddText(' Value:', style=LEFT, newrow=True)
panel.Add(self.wids.val, style=LEFT)
panel.AddText(' Std Error:', style=LEFT)
panel.Add(self.wids.err, style=LEFT)
panel.AddText(' Min Value:', style=LEFT, newrow=True)
panel.Add(self.wids.min, style=LEFT)
panel.AddText(' Max Value:', style=LEFT)
panel.Add(self.wids.max, style=LEFT)
panel.AddText(' Constraint:', style=LEFT, newrow=True)
panel.Add(self.wids.expr, style=LEFT, dcol=3)
panel.Add(HLine(panel, size=(375, 2)), dcol=4, newrow=True)
panel.Add(btnsizer, dcol=4, newrow=True, style=LEFT)
panel.pack()
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(panel, 0, 0, 25)
self.onVaryChoice()
pack(self, sizer)
bsize = self.GetBestSize()
self.SetSize((bsize[0]+10, bsize[1]+10))
def build_display(self):
self.mod_nb = flat_nb.FlatNotebook(self, -1, agwStyle=FNB_STYLE)
self.mod_nb.SetTabAreaColour(wx.Colour(250,250,250))
self.mod_nb.SetActiveTabColour(wx.Colour(254,254,195))
self.mod_nb.SetNonActiveTabTextColour(wx.Colour(10,10,128))
self.mod_nb.SetActiveTabTextColour(wx.Colour(128,0,0))
self.mod_nb.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, self.onNBChanged)
pan = self.panel = GridPanel(self, ncols=4, nrows=4, pad=2, itemstyle=LCEN)
self.btns = {}
for name in ('ppeak_e0', 'ppeak_elo', 'ppeak_emin', 'ppeak_emax', 'ppeak_ehi'):
bb = BitmapButton(pan, get_icon('plus'),
action=partial(self.on_selpoint, opt=name),
tooltip='use last point selected from plot')
self.btns[name] = bb
opts = dict(size=(75, -1), gformat=True, precision=1)
self.ppeak_e0 = FloatCtrl(pan, value=0, **opts)
self.ppeak_emin = FloatCtrl(pan, value=-30, **opts)
self.ppeak_emax = FloatCtrl(pan, value=0, **opts)
self.ppeak_elo = FloatCtrl(pan, value=-15, **opts)
self.ppeak_ehi = FloatCtrl(pan, value=-5, **opts)
self.fitbline_btn = Button(pan,'Fit Baseline', action=self.onFitBaseline,
size=(150, 25))
self.fitmodel_btn = Button(pan, 'Fit Model',
action=self.onFitModel, size=(150, 25))
self.fitsel_btn = Button(pan, 'Fit Selected Groups',
action=self.onFitSelected, size=(150, 25))
self.fitmodel_btn.Disable()
self.fitsel_btn.Disable()
self.array_choice = Choice(pan, size=(125, -1),
choices=list(Array_Choices.keys()))
self.array_choice.SetSelection(1)
models_peaks = Choice(pan, size=(125, -1),
choices=ModelChoices['peaks'],
action=self.addModel)
models_other = Choice(pan, size=(125, -1),
choices=ModelChoices['other'],
action=self.addModel)
self.plot_choice = Choice(pan, size=(125, -1),
choices=PlotChoices,
action=self.onPlot)
self.message = SimpleText(pan,
'first fit baseline, then add peaks to fit model.')
self.msg_centroid = SimpleText(pan, '----')
opts = dict(default=True, size=(75, -1), action=self.onPlot)
self.show_centroid = Check(pan, label='show?', **opts)
self.show_peakrange = Check(pan, label='show?', **opts)
self.show_fitrange = Check(pan, label='show?', **opts)
self.show_e0 = Check(pan, label='show?', **opts)
opts = dict(default=False, size=(200, -1), action=self.onPlot)
self.plot_sub_bline = Check(pan, label='Subtract Baseline?', **opts)
titleopts = dict(font=Font(11), colour='#AA0000')
pan.Add(SimpleText(pan, ' Pre-edge Peak Fitting', **titleopts), dcol=7)
pan.Add(SimpleText(pan, ' Run Fit:'), style=LCEN)
pan.Add(SimpleText(pan, 'Array to fit: '), newrow=True)
pan.Add(self.array_choice, dcol=4)
pan.Add((10, 10), dcol=2)
pan.Add(self.fitbline_btn)
pan.Add(SimpleText(pan, 'E0: '), newrow=True)
pan.Add(self.btns['ppeak_e0'])
pan.Add(self.ppeak_e0)
pan.Add((10, 10), dcol=3)
pan.Add(self.show_e0)
pan.Add(self.fitmodel_btn)
pan.Add(SimpleText(pan, 'Fit Energy Range: '), newrow=True)
pan.Add(self.btns['ppeak_emin'])
pan.Add(self.ppeak_emin)
pan.Add(SimpleText(pan, ':'))
pan.Add(self.btns['ppeak_emax'])
pan.Add(self.ppeak_emax)
pan.Add(self.show_fitrange, dcol=1)
pan.Add(self.fitsel_btn)
t = SimpleText(pan, 'Pre-edge Peak Range: ')
t.SetToolTip('Range used as mask for background')
pan.Add(t, newrow=True)
pan.Add(self.btns['ppeak_elo'])
pan.Add(self.ppeak_elo)
pan.Add(SimpleText(pan, ':'))
pan.Add(self.btns['ppeak_ehi'])
pan.Add(self.ppeak_ehi)
pan.Add(self.show_peakrange, dcol=1)
pan.Add(SimpleText(pan, 'Peak Centroid: '), newrow=True)
pan.Add(self.msg_centroid, dcol=5)
pan.Add(self.show_centroid, dcol=1)
# plot buttons
ts = wx.BoxSizer(wx.HORIZONTAL)
ts.Add(self.plot_choice)
ts.Add(self.plot_sub_bline)
pan.Add(SimpleText(pan, 'Plot: '), newrow=True)
pan.Add(ts, dcol=7)
# add model
ts = wx.BoxSizer(wx.HORIZONTAL)
ts.Add(models_peaks)
ts.Add(models_other)
pan.Add(SimpleText(pan, 'Add Component: '), newrow=True)
pan.Add(ts, dcol=7)
pan.Add(SimpleText(pan, 'Messages: '), newrow=True)
pan.Add(self.message, dcol=7)
pan.pack()
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add((5,5), 0, LCEN, 3)
sizer.Add(HLine(self, size=(550, 2)), 0, LCEN, 3)
sizer.Add(pan, 0, LCEN, 3)
sizer.Add((5,5), 0, LCEN, 3)
sizer.Add(HLine(self, size=(550, 2)), 0, LCEN, 3)
sizer.Add((5,5), 0, LCEN, 3)
sizer.Add(self.mod_nb, 1, LCEN|wx.GROW, 10)
pack(self, sizer)
class PrePeakPanel(wx.Panel):
def __init__(self, parent=None, controller=None, **kws):
wx.Panel.__init__(self, parent, -1, size=(550, 625), **kws)
self.parent = parent
self.controller = controller
self.larch = controller.larch
self.fit_components = OrderedDict()
self.fit_model = None
self.fit_params = None
self.user_added_params = None
self.summary = None
self.sizer = wx.GridBagSizer(10, 6)
self.build_display()
self.pick2_timer = wx.Timer(self)
self.pick2_group = None
self.Bind(wx.EVT_TIMER, self.onPick2Timer, self.pick2_timer)
self.pick2_t0 = 0.
self.pick2_timeout = 15.
self.pick2erase_timer = wx.Timer(self)
self.pick2erase_panel = None
self.Bind(wx.EVT_TIMER, self.onPick2EraseTimer, self.pick2erase_timer)
def onPanelExposed(self, **kws):
# called when notebook is selected
try:
fname = self.controller.filelist.GetStringSelection()
gname = self.controller.file_groups[fname]
dgroup = self.controller.get_group(gname)
# print(" Fill prepeak panel from group ", fname, gname, dgroup)
self.fill_form_from_group(dgroup)
except:
pass # print(" Cannot Fill prepeak panel from group ")
def larch_eval(self, cmd):
"""eval"""
self.controller.larch.eval(cmd)
def build_display(self):
self.mod_nb = flat_nb.FlatNotebook(self, -1, agwStyle=FNB_STYLE)
self.mod_nb.SetTabAreaColour(wx.Colour(250,250,250))
self.mod_nb.SetActiveTabColour(wx.Colour(254,254,195))
self.mod_nb.SetNonActiveTabTextColour(wx.Colour(10,10,128))
self.mod_nb.SetActiveTabTextColour(wx.Colour(128,0,0))
self.mod_nb.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, self.onNBChanged)
pan = self.panel = GridPanel(self, ncols=4, nrows=4, pad=2, itemstyle=LCEN)
self.btns = {}
for name in ('ppeak_e0', 'ppeak_elo', 'ppeak_emin', 'ppeak_emax', 'ppeak_ehi'):
bb = BitmapButton(pan, get_icon('plus'),
action=partial(self.on_selpoint, opt=name),
tooltip='use last point selected from plot')
self.btns[name] = bb
opts = dict(size=(75, -1), gformat=True, precision=1)
self.ppeak_e0 = FloatCtrl(pan, value=0, **opts)
self.ppeak_emin = FloatCtrl(pan, value=-30, **opts)
self.ppeak_emax = FloatCtrl(pan, value=0, **opts)
self.ppeak_elo = FloatCtrl(pan, value=-15, **opts)
self.ppeak_ehi = FloatCtrl(pan, value=-5, **opts)
self.fitbline_btn = Button(pan,'Fit Baseline', action=self.onFitBaseline,
size=(150, 25))
self.fitmodel_btn = Button(pan, 'Fit Model',
action=self.onFitModel, size=(150, 25))
self.fitsel_btn = Button(pan, 'Fit Selected Groups',
action=self.onFitSelected, size=(150, 25))
self.fitmodel_btn.Disable()
self.fitsel_btn.Disable()
self.array_choice = Choice(pan, size=(125, -1),
choices=list(Array_Choices.keys()))
self.array_choice.SetSelection(1)
models_peaks = Choice(pan, size=(125, -1),
choices=ModelChoices['peaks'],
action=self.addModel)
models_other = Choice(pan, size=(125, -1),
choices=ModelChoices['other'],
action=self.addModel)
self.plot_choice = Choice(pan, size=(125, -1),
choices=PlotChoices,
action=self.onPlot)
self.message = SimpleText(pan,
'first fit baseline, then add peaks to fit model.')
self.msg_centroid = SimpleText(pan, '----')
opts = dict(default=True, size=(75, -1), action=self.onPlot)
self.show_centroid = Check(pan, label='show?', **opts)
self.show_peakrange = Check(pan, label='show?', **opts)
self.show_fitrange = Check(pan, label='show?', **opts)
self.show_e0 = Check(pan, label='show?', **opts)
opts = dict(default=False, size=(200, -1), action=self.onPlot)
self.plot_sub_bline = Check(pan, label='Subtract Baseline?', **opts)
titleopts = dict(font=Font(11), colour='#AA0000')
pan.Add(SimpleText(pan, ' Pre-edge Peak Fitting', **titleopts), dcol=7)
pan.Add(SimpleText(pan, ' Run Fit:'), style=LCEN)
pan.Add(SimpleText(pan, 'Array to fit: '), newrow=True)
pan.Add(self.array_choice, dcol=4)
pan.Add((10, 10), dcol=2)
pan.Add(self.fitbline_btn)
pan.Add(SimpleText(pan, 'E0: '), newrow=True)
pan.Add(self.btns['ppeak_e0'])
pan.Add(self.ppeak_e0)
pan.Add((10, 10), dcol=3)
pan.Add(self.show_e0)
pan.Add(self.fitmodel_btn)
pan.Add(SimpleText(pan, 'Fit Energy Range: '), newrow=True)
pan.Add(self.btns['ppeak_emin'])
pan.Add(self.ppeak_emin)
pan.Add(SimpleText(pan, ':'))
pan.Add(self.btns['ppeak_emax'])
pan.Add(self.ppeak_emax)
pan.Add(self.show_fitrange, dcol=1)
pan.Add(self.fitsel_btn)
t = SimpleText(pan, 'Pre-edge Peak Range: ')
t.SetToolTip('Range used as mask for background')
pan.Add(t, newrow=True)
pan.Add(self.btns['ppeak_elo'])
pan.Add(self.ppeak_elo)
pan.Add(SimpleText(pan, ':'))
pan.Add(self.btns['ppeak_ehi'])
pan.Add(self.ppeak_ehi)
pan.Add(self.show_peakrange, dcol=1)
pan.Add(SimpleText(pan, 'Peak Centroid: '), newrow=True)
pan.Add(self.msg_centroid, dcol=5)
pan.Add(self.show_centroid, dcol=1)
# plot buttons
ts = wx.BoxSizer(wx.HORIZONTAL)
ts.Add(self.plot_choice)
ts.Add(self.plot_sub_bline)
pan.Add(SimpleText(pan, 'Plot: '), newrow=True)
pan.Add(ts, dcol=7)
# add model
ts = wx.BoxSizer(wx.HORIZONTAL)
ts.Add(models_peaks)
ts.Add(models_other)
pan.Add(SimpleText(pan, 'Add Component: '), newrow=True)
pan.Add(ts, dcol=7)
pan.Add(SimpleText(pan, 'Messages: '), newrow=True)
pan.Add(self.message, dcol=7)
pan.pack()
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add((5,5), 0, LCEN, 3)
sizer.Add(HLine(self, size=(550, 2)), 0, LCEN, 3)
sizer.Add(pan, 0, LCEN, 3)
sizer.Add((5,5), 0, LCEN, 3)
sizer.Add(HLine(self, size=(550, 2)), 0, LCEN, 3)
sizer.Add((5,5), 0, LCEN, 3)
sizer.Add(self.mod_nb, 1, LCEN|wx.GROW, 10)
pack(self, sizer)
def get_config(self, dgroup=None):
"""get processing configuration for a group"""
if dgroup is None:
dgroup = self.controller.get_group()
conf = getattr(dgroup, 'prepeak_config', {})
if 'e0' not in conf:
conf = default_prepeak_config()
if not hasattr(dgroup, 'prepeaks'):
dgroup.prepeaks = Group()
dgroup.prepeaks.config = conf
return conf
def fill_form_from_group(self, dgroup):
self.ppeak_e0.SetValue(dgroup.e0)
if hasattr(dgroup, 'prepeaks'):
self.ppeak_emin.SetValue(dgroup.prepeaks.emin)
self.ppeak_emax.SetValue(dgroup.prepeaks.emax)
self.ppeak_elo.SetValue(dgroup.prepeaks.elo)
self.ppeak_ehi.SetValue(dgroup.prepeaks.ehi)
def fill_form_from_dict(self, data):
self.ppeak_e0.SetValue(data['e0'])
self.ppeak_emin.SetValue(data['emin'])
self.ppeak_emax.SetValue(data['emax'])
self.ppeak_elo.SetValue(data['elo'])
self.ppeak_ehi.SetValue(data['ehi'])
self.array_choice.SetStringSelection(data['array_desc'])
self.show_e0.Enable(data['show_e0'])
self.show_centroid.Enable(data['show_centroid'])
self.show_fitrange.Enable(data['show_fitrange'])
self.show_peakrange.Enable(data['show_peakrange'])
self.plot_sub_bline.Enable(data['plot_sub_bline'])
def read_form(self):
"read for, returning dict of values"
dgroup = self.controller.get_group()
array_desc = self.array_choice.GetStringSelection()
form_opts = {'gname': dgroup.groupname,
'array_desc': array_desc.lower(),
'array_name': Array_Choices[array_desc],
'baseline_form': 'lorentzian'}
form_opts['e0'] = self.ppeak_e0.GetValue()
form_opts['emin'] = self.ppeak_emin.GetValue()
form_opts['emax'] = self.ppeak_emax.GetValue()
form_opts['elo'] = self.ppeak_elo.GetValue()
form_opts['ehi'] = self.ppeak_ehi.GetValue()
form_opts['plot_sub_bline'] = self.plot_sub_bline.IsChecked()
form_opts['show_centroid'] = self.show_centroid.IsChecked()
form_opts['show_peakrange'] = self.show_peakrange.IsChecked()
form_opts['show_fitrange'] = self.show_fitrange.IsChecked()
form_opts['show_e0'] = self.show_e0.IsChecked()
return form_opts
def onFitBaseline(self, evt=None):
opts = self.read_form()
cmd = """{gname:s}.ydat = 1.0*{gname:s}.{array_name:s}
pre_edge_baseline(energy={gname:s}.energy, norm={gname:s}.ydat, group={gname:s},
form='{baseline_form:s}', with_line=True,
elo={elo:.3f}, ehi={ehi:.3f}, emin={emin:.3f}, emax={emax:.3f})
"""
self.larch_eval(cmd.format(**opts))
dgroup = self.controller.get_group()
ppeaks = dgroup.prepeaks
dgroup.centroid_msg = "%.4f +/- %.4f eV" % (ppeaks.centroid,
ppeaks.delta_centroid)
self.msg_centroid.SetLabel(dgroup.centroid_msg)
if 'loren_' not in self.fit_components:
self.addModel(model='Lorentzian', prefix='loren_', isbkg=True)
if 'line_' not in self.fit_components:
self.addModel(model='Linear', prefix='line_', isbkg=True)
for prefix in ('loren_', 'line_'):
cmp = self.fit_components[prefix]
# cmp.bkgbox.SetValue(1)
self.fill_model_params(prefix, dgroup.prepeaks.fit_details.params)
self.fill_form_from_group(dgroup)
self.fitmodel_btn.Enable()
# self.fitallmodel_btn.Enable()
i1, i2 = self.get_xranges(dgroup.energy)
dgroup.yfit = dgroup.xfit = 0.0*dgroup.energy[i1:i2]
self.plot_choice.SetStringSelection(PLOT_BASELINE)
self.onPlot()
def fill_model_params(self, prefix, params):
comp = self.fit_components[prefix]
parwids = comp.parwids
for pname, par in params.items():
pname = prefix + pname
if pname in parwids:
wids = parwids[pname]
if wids.minval is not None:
wids.minval.SetValue(par.min)
if wids.maxval is not None:
wids.maxval.SetValue(par.max)
wids.value.SetValue(par.value)
varstr = 'vary' if par.vary else 'fix'
if par.expr is not None:
varstr = 'constrain'
if wids.vary is not None:
wids.vary.SetStringSelection(varstr)
def onPlot(self, evt=None):
plot_choice = self.plot_choice.GetStringSelection()
opts = self.read_form()
dgroup = self.controller.get_group()
ppeaks = getattr(dgroup, 'prepeaks', None)
if ppeaks is None:
return
i1, i2 = self.get_xranges(dgroup.xdat)
# i2 = len(ppeaks.baseline) + i1
if len(dgroup.yfit) > len(ppeaks.baseline):
i2 = i1 + len(ppeaks.baseline)
# print(" Indexes: ", i1, i2, i2-i1, len(dgroup.yfit), len(ppeaks.baseline))
xdat = 1.0*dgroup.energy
ydat = 1.0*dgroup.ydat
yfit = 1.0*dgroup.ydat
baseline = 1.0*dgroup.ydat
yfit[i1:i2] = dgroup.yfit[:i2-i1]
baseline[i1:i2] = ppeaks.baseline[:i2-i1]
if opts['plot_sub_bline']:
ydat = ydat - baseline
if plot_choice in (PLOT_FIT, PLOT_RESID):
yfit = yfit - baseline
if plot_choice == PLOT_RESID:
resid = ydat - yfit
_xs = dgroup.energy[i1:i2]
xrange = max(_xs) - min(_xs)
pxmin = min(_xs) - 0.05 * xrange
pxmax = max(_xs) + 0.05 * xrange
jmin = index_of(dgroup.energy, pxmin)
jmax = index_of(dgroup.energy, pxmax) + 1
_ys = ydat[jmin:jmax]
yrange = max(_ys) - min(_ys)
pymin = min(_ys) - 0.05 * yrange
pymax = max(_ys) + 0.05 * yrange
title = ' pre-edge fit'
if plot_choice == PLOT_BASELINE:
title = ' pre-edge baseline'
if opts['plot_sub_bline']:
title = ' pre-edge peaks'
array_desc = self.array_choice.GetStringSelection()
plotopts = {'xmin': pxmin, 'xmax': pxmax,
'ymin': pymin, 'ymax': pymax,
'title': '%s: %s' % (opts['gname'], title),
'xlabel': 'Energy (eV)',
'ylabel': '%s $\mu$' % opts['array_desc'],
'label': '%s $\mu$' % opts['array_desc'],
'delay_draw': True,
'show_legend': True}
plot_extras = []
if opts['show_fitrange']:
popts = {'color': '#DDDDCC'}
emin = opts['emin']
emax = opts['emax']
imin = index_of(dgroup.energy, emin)
imax = index_of(dgroup.energy, emax)
plot_extras.append(('vline', emin, None, popts))
plot_extras.append(('vline', emax, None, popts))
if opts['show_peakrange']:
popts = {'marker': '+', 'markersize': 6}
elo = opts['elo']
ehi = opts['ehi']
ilo = index_of(dgroup.xdat, elo)
ihi = index_of(dgroup.xdat, ehi)
plot_extras.append(('marker', elo, ydat[ilo], popts))
plot_extras.append(('marker', ehi, ydat[ihi], popts))
if opts['show_centroid']:
popts = {'color': '#EECCCC'}
ecen = getattr(dgroup.prepeaks, 'centroid', -1)
if ecen > min(dgroup.energy):
plot_extras.append(('vline', ecen, None, popts))
pframe = self.controller.get_display(stacked=(plot_choice==PLOT_RESID))
ppanel = pframe.panel
axes = ppanel.axes
plotopts.update(PLOTOPTS_1)
ppanel.plot(xdat, ydat, **plotopts)
if plot_choice == PLOT_BASELINE:
if not opts['plot_sub_bline']:
ppanel.oplot(dgroup.prepeaks.energy,
dgroup.prepeaks.baseline,
label='baseline', **PLOTOPTS_2)
elif plot_choice in (PLOT_FIT, PLOT_RESID):
ppanel.oplot(dgroup.energy, yfit,
label='fit', **PLOTOPTS_1)
if hasattr(dgroup, 'ycomps'):
ncomp = len(dgroup.ycomps)
icomp = 0
for label, ycomp in dgroup.ycomps.items():
icomp +=1
fcomp = self.fit_components[label]
# print("ycomp: ", plot_choice, label, len(ycomp), len(dgroup.xfit),
# fcomp.bkgbox.IsChecked(), opts['plot_sub_bline'], icomp, ncomp)
if not (fcomp.bkgbox.IsChecked() and opts['plot_sub_bline']):
ppanel.oplot(dgroup.xfit, ycomp, label=label,
delay_draw=(icomp!=ncomp), style='short dashed')
if plot_choice == PLOT_RESID:
_ys = resid
yrange = max(_ys) - min(_ys)
plotopts['ymin'] = min(_ys) - 0.05 * yrange
plotopts['ymax'] = max(_ys) + 0.05 * yrange
plotopts['delay_draw'] = False
plotopts['ylabel'] = 'data-fit'
plotopts['label'] = '_nolegend_'
pframe.plot(dgroup.energy, resid, panel='bot', **plotopts)
pframe.Show()
# print(" RESIDUAL PLOT margins: ")
# print(" top : ", pframe.panel.conf.margins)
# print(" bot : ", pframe.panel_bot.conf.margins)
for etype, x, y, opts in plot_extras:
if etype == 'marker':
popts = {'marker': 'o', 'markersize': 4,
'label': '_nolegend_',
'markerfacecolor': 'red',
'markeredgecolor': '#884444'}
popts.update(opts)
axes.plot([x], [y], **popts)
elif etype == 'vline':
popts = {'ymin': 0, 'ymax': 1.0, 'color': '#888888',
'label': '_nolegend_'}
popts.update(opts)
axes.axvline(x, **popts)
ppanel.canvas.draw()
def onNBChanged(self, event=None):
idx = self.mod_nb.GetSelection()
def addModel(self, event=None, model=None, prefix=None, isbkg=False):
if model is None and event is not None:
model = event.GetString()
if model is None or model.startswith('<'):
return
if prefix is None:
p = model[:5].lower()
curmodels = ["%s%i_" % (p, i+1) for i in range(1+len(self.fit_components))]
for comp in self.fit_components:
if comp in curmodels:
curmodels.remove(comp)
prefix = curmodels[0]
label = "%s(prefix='%s')" % (model, prefix)
title = "%s: %s " % (prefix[:-1], model)
title = prefix[:-1]
mclass_kws = {'prefix': prefix}
if 'step' in model.lower():
form = model.lower().replace('step', '').strip()
if form.startswith('err'): form = 'erf'
label = "Step(form='%s', prefix='%s')" % (form, prefix)
title = "%s: Step %s" % (prefix[:-1], form[:3])
mclass = lm_models.StepModel
mclass_kws['form'] = form
minst = mclass(form=form, prefix=prefix)
else:
if model in ModelFuncs:
mclass = getattr(lm_models, ModelFuncs[model])
else:
mclass = getattr(lm_models, model+'Model')
minst = mclass(prefix=prefix)
panel = GridPanel(self.mod_nb, ncols=1, nrows=1, pad=1, itemstyle=CEN)
def SLabel(label, size=(80, -1), **kws):
return SimpleText(panel, label,
size=size, style=wx.ALIGN_LEFT, **kws)
usebox = Check(panel, default=True, label='Use in Fit?', size=(100, -1))
bkgbox = Check(panel, default=False, label='Is Baseline?', size=(125, -1))
if isbkg:
bkgbox.SetValue(1)
delbtn = Button(panel, 'Delete Component', size=(125, -1),
action=partial(self.onDeleteComponent, prefix=prefix))
pick2msg = SimpleText(panel, " ", size=(125, -1))
pick2btn = Button(panel, 'Pick Values from Data', size=(150, -1),
action=partial(self.onPick2Points, prefix=prefix))
# SetTip(mname, 'Label for the model component')
SetTip(usebox, 'Use this component in fit?')
SetTip(bkgbox, 'Label this component as "background" when plotting?')
SetTip(delbtn, 'Delete this model component')
SetTip(pick2btn, 'Select X range on Plot to Guess Initial Values')
panel.Add(SLabel(label, size=(275, -1), colour='#0000AA'),
dcol=3, style=wx.ALIGN_LEFT, newrow=True)
panel.Add(usebox, dcol=1)
panel.Add(bkgbox, dcol=2, style=LCEN)
panel.Add(delbtn, dcol=1, style=wx.ALIGN_LEFT)
panel.Add(pick2btn, dcol=2, style=wx.ALIGN_LEFT, newrow=True)
panel.Add(pick2msg, dcol=2, style=wx.ALIGN_RIGHT)
# panel.Add((10, 10), newrow=True)
# panel.Add(HLine(panel, size=(150, 3)), dcol=4, style=wx.ALIGN_CENTER)
panel.Add(SLabel("Parameter "), style=wx.ALIGN_LEFT, newrow=True)
panel.AddMany((SLabel(" Value"), SLabel(" Type"), SLabel(' Bounds'),
SLabel(" Min", size=(60, -1)),
SLabel(" Max", size=(60, -1)), SLabel(" Expression")))
parwids = OrderedDict()
parnames = sorted(minst.param_names)
for a in minst._func_allargs:
pname = "%s%s" % (prefix, a)
if (pname not in parnames and
a in minst.param_hints and
a not in minst.independent_vars):
parnames.append(pname)
for pname in parnames:
sname = pname[len(prefix):]
hints = minst.param_hints.get(sname, {})
par = Parameter(name=pname, value=0, vary=True)
if 'min' in hints:
par.min = hints['min']
if 'max' in hints:
par.max = hints['max']
if 'value' in hints:
par.value = hints['value']
if 'expr' in hints:
par.expr = hints['expr']
pwids = ParameterWidgets(panel, par, name_size=100, expr_size=125,
float_size=80, prefix=prefix,
widgets=('name', 'value', 'minval',
'maxval', 'vary', 'expr'))
parwids[par.name] = pwids
panel.Add(pwids.name, newrow=True)
panel.AddMany((pwids.value, pwids.vary, pwids.bounds,
pwids.minval, pwids.maxval, pwids.expr))
for sname, hint in minst.param_hints.items():
pname = "%s%s" % (prefix, sname)
if 'expr' in hint and pname not in parnames:
par = Parameter(name=pname, value=0, expr=hint['expr'])
pwids = ParameterWidgets(panel, par, name_size=100, expr_size=225,
float_size=80, prefix=prefix,
widgets=('name', 'value', 'expr'))
parwids[par.name] = pwids
panel.Add(pwids.name, newrow=True)
panel.Add(pwids.value)
panel.Add(pwids.expr, dcol=4, style=wx.ALIGN_RIGHT)
pwids.value.Disable()
fgroup = Group(prefix=prefix, title=title, mclass=mclass,
mclass_kws=mclass_kws, usebox=usebox, panel=panel,
parwids=parwids, float_size=65, expr_size=150,
pick2_msg=pick2msg, bkgbox=bkgbox)
self.fit_components[prefix] = fgroup
panel.pack()
self.mod_nb.AddPage(panel, title, True)
sx,sy = self.GetSize()
self.SetSize((sx, sy+1))
self.SetSize((sx, sy))
def onDeleteComponent(self, evt=None, prefix=None):
fgroup = self.fit_components.get(prefix, None)
if fgroup is None:
return
for i in range(self.mod_nb.GetPageCount()):
if fgroup.title == self.mod_nb.GetPageText(i):
self.mod_nb.DeletePage(i)
for attr in dir(fgroup):
setattr(fgroup, attr, None)
self.fit_components.pop(prefix)
# sx,sy = self.GetSize()
# self.SetSize((sx, sy+1))
# self.SetSize((sx, sy))
def onPick2EraseTimer(self, evt=None):
"""erases line trace showing automated 'Pick 2' guess """
self.pick2erase_timer.Stop()
panel = self.pick2erase_panel
ntrace = panel.conf.ntrace - 1
trace = panel.conf.get_mpl_line(ntrace)
panel.conf.get_mpl_line(ntrace).set_data(np.array([]), np.array([]))
panel.conf.ntrace = ntrace
panel.draw()
def onPick2Timer(self, evt=None):
"""checks for 'Pick 2' events, and initiates 'Pick 2' guess
for a model from the selected data range
"""
try:
plotframe = self.controller.get_display(stacked=False)
curhist = plotframe.cursor_hist[:]
plotframe.Raise()
except:
return
if (time.time() - self.pick2_t0) > self.pick2_timeout:
msg = self.pick2_group.pick2_msg.SetLabel(" ")
plotframe.cursor_hist = []
self.pick2_timer.Stop()
return
if len(curhist) < 2:
self.pick2_group.pick2_msg.SetLabel("%i/2" % (len(curhist)))
return
self.pick2_group.pick2_msg.SetLabel("done.")
self.pick2_timer.Stop()
# guess param values
xcur = (curhist[0][0], curhist[1][0])
xmin, xmax = min(xcur), max(xcur)
dgroup = getattr(self.larch.symtable, self.controller.groupname)
x, y = dgroup.xdat, dgroup.ydat
i0 = index_of(dgroup.xdat, xmin)
i1 = index_of(dgroup.xdat, xmax)
x, y = dgroup.xdat[i0:i1+1], dgroup.ydat[i0:i1+1]
mod = self.pick2_group.mclass(prefix=self.pick2_group.prefix)
parwids = self.pick2_group.parwids
try:
guesses = mod.guess(y, x=x)
except:
return
for name, param in guesses.items():
if name in parwids:
parwids[name].value.SetValue(param.value)
dgroup._tmp = mod.eval(guesses, x=dgroup.xdat)
plotframe = self.controller.get_display(stacked=False)
plotframe.cursor_hist = []
plotframe.oplot(dgroup.xdat, dgroup._tmp)
self.pick2erase_panel = plotframe.panel
self.pick2erase_timer.Start(5000)
def onPick2Points(self, evt=None, prefix=None):
fgroup = self.fit_components.get(prefix, None)
if fgroup is None:
return
plotframe = self.controller.get_display(stacked=False)
plotframe.Raise()
plotframe.cursor_hist = []
fgroup.npts = 0
self.pick2_group = fgroup
if fgroup.pick2_msg is not None:
fgroup.pick2_msg.SetLabel("0/2")
self.pick2_t0 = time.time()
self.pick2_timer.Start(250)
def onSaveFitResult(self, event=None):
dgroup = self.controller.get_group()
deffile = dgroup.filename.replace('.', '_') + '.modl'
outfile = FileSave(self, 'Save Fit Result',
default_file=deffile,
wildcard=ModelWcards)
if outfile is not None:
try:
self.save_fit_result(dgroup.fit_history[-1], outfile)
except IOError:
print('could not write %s' % outfile)
def onLoadFitResult(self, event=None):
mfile = FileOpen(self, 'Load Fit Result',
default_file='', wildcard=ModelWcards)
if mfile is not None:
self.load_modelresult(mfile)
def save_fit_result(self, fitresult, outfile):
"""saves a customized ModelResult"""
save_modelresult(fitresult, outfile)
def load_modelresult(self, inpfile):
"""read a customized ModelResult"""
result = load_modelresult(inpfile)
for prefix in list(self.fit_components.keys()):
self.onDeleteComponent(self, prefix=prefix)
for comp in result.model.components:
isbkg = comp.prefix in result.user_options['bkg_components']
self.addModel(model=comp.func.__name__,
prefix=comp.prefix, isbkg=isbkg)
for comp in result.model.components:
parwids = self.fit_components[comp.prefix].parwids
for pname, par in result.params.items():
if pname in parwids:
wids = parwids[pname]
if wids.minval is not None:
wids.minval.SetValue(par.min)
if wids.maxval is not None:
wids.maxval.SetValue(par.max)
val = result.init_values.get(pname, par.value)
wids.value.SetValue(val)
self.fill_form_from_dict(result.user_options)
return result
def onExportFitResult(self, event=None):
dgroup = self.controller.get_group()
deffile = dgroup.filename.replace('.', '_') + '_result.xdi'
wcards = 'All files (*.*)|*.*'
outfile = FileSave(self, 'Export Fit Result',
default_file=deffile, wildcard=wcards)
if outfile is not None:
i1, i2 = self.get_xranges(dgroup.xdat)
x = dgroup.xdat[i1:i2]
y = dgroup.ydat[i1:i2]
yerr = None
if hasattr(dgroup, 'yerr'):
yerr = 1.0*dgroup.yerr
if not isinstance(yerr, np.ndarray):
yerr = yerr * np.ones(len(y))
else:
yerr = yerr[i1:i2]
export_modelresult(dgroup.fit_history[-1],
filename=outfile,
datafile=dgroup.filename,
ydata=y, yerr=yerr, x=x)
def on_selpoint(self, evt=None, opt='xmin'):
xval = None
try:
xval = self.larch.symtable._plotter.plot1_x
except:
return
wid = getattr(self, opt, None)
if wid is not None:
wid.SetValue(xval)
def get_xranges(self, x):
opts = self.read_form()
dgroup = self.controller.get_group()
en_eps = min(np.diff(dgroup.energy)) / 5.
i1 = index_of(x, opts['emin'] + en_eps)
i2 = index_of(x, opts['emax'] + en_eps) + 1
return i1, i2
def build_fitmodel(self):
""" use fit components to build model"""
dgroup = self.controller.get_group()
fullmodel = None
params = Parameters()
self.summary = {'components': [], 'options': {}}
peaks = []
for comp in self.fit_components.values():
_cen, _amp = None, None
if comp.usebox is not None and comp.usebox.IsChecked():
for parwids in comp.parwids.values():
params.add(parwids.param)
#print(" add param ", parwids.param)
if parwids.param.name.endswith('_center'):
_cen = parwids.param.name
elif parwids.param.name.endswith('_amplitude'):
_amp = parwids.param.name
self.summary['components'].append((comp.mclass.__name__, comp.mclass_kws))
thismodel = comp.mclass(**comp.mclass_kws)
if fullmodel is None:
fullmodel = thismodel
else:
fullmodel += thismodel
if not comp.bkgbox.IsChecked() and _cen is not None and _amp is not None:
peaks.append((_amp, _cen))
if len(peaks) > 0:
denom = '+'.join([p[0] for p in peaks])
numer = '+'.join(["%s*%s "% p for p in peaks])
params.add('fit_centroid', expr="(%s)/(%s)" %(numer, denom))
self.fit_model = fullmodel
self.fit_params = params
if dgroup is not None:
i1, i2 = self.get_xranges(dgroup.xdat)
xsel = dgroup.xdat[i1:i2]
dgroup.xfit = xsel
dgroup.yfit = self.fit_model.eval(self.fit_params, x=xsel)
dgroup.ycomps = self.fit_model.eval_components(params=self.fit_params,
x=xsel)
return dgroup
def onFitSelected(self, event=None):
dgroup = self.build_fitmodel()
opts = self.read_form()
print("fitting selected groups in progress")
def onFitModel(self, event=None):
dgroup = self.build_fitmodel()
opts = self.read_form()
i1, i2 = self.get_xranges(dgroup.xdat)
dgroup.xfit = dgroup.xdat[i1:i2]
ysel = dgroup.ydat[i1:i2]
# print('onFit Model : xrange ', i1, i2, len(dgroup.xfit), len(dgroup.yfit))
weights = np.ones(len(ysel))
if hasattr(dgroup, 'yerr'):
yerr = 1.0*dgroup.yerr
if not isinstance(yerr, np.ndarray):
yerr = yerr * np.ones(len(ysel))
else:
yerr = yerr[i1:i2]
yerr_min = 1.e-9*ysel.mean()
yerr[np.where(yerr < yerr_min)] = yerr_min
weights = 1.0/yerr
result = self.fit_model.fit(ysel, params=self.fit_params,
x=dgroup.xfit, weights=weights,
method='leastsq')
self.summary['xmin'] = dgroup.xdat[i1]
self.summary['xmax'] = dgroup.xdat[i2]
for attr in ('aic', 'bic', 'chisqr', 'redchi', 'ci_out', 'covar',
'flatchain', 'success', 'nan_policy', 'nfev', 'ndata',
'nfree', 'nvarys', 'init_values'):
self.summary[attr] = getattr(result, attr)
self.summary['params'] = result.params
dgroup.yfit = result.best_fit
dgroup.ycomps = self.fit_model.eval_components(params=result.params,
x=dgroup.xfit)
result.model_repr = self.fit_model._reprstring(long=True)
## hacks to save user options
result.user_options = opts
bkg_comps = []
for label, comp in self.fit_components.items():
if comp.bkgbox.IsChecked():
bkg_comps.append(label)
result.user_options['bkg_components'] = bkg_comps
self.autosave_modelresult(result)
if not hasattr(dgroup, 'fit_history'):
dgroup.fit_history = []
dgroup.fit_history.append(result)
self.plot_choice.SetStringSelection(PLOT_FIT)
self.onPlot()
self.parent.show_subframe('result_frame', FitResultFrame,
datagroup=dgroup, peakframe=self)
self.parent.subframes['result_frame'].show_fitresult()
[m.Enable(True) for m in self.parent.afterfit_menus]
def update_start_values(self, params):
"""fill parameters with best fit values"""
allparwids = {}
for comp in self.fit_components.values():
if comp.usebox is not None and comp.usebox.IsChecked():
for name, parwids in comp.parwids.items():
allparwids[name] = parwids
for pname, par in params.items():
if pname in allparwids:
allparwids[pname].value.SetValue(par.value)
def autosave_modelresult(self, result, fname=None):
"""autosave model result to user larch folder"""
xasguidir = os.path.join(site_config.usr_larchdir, 'xasgui')
if not os.path.exists(xasguidir):
try:
os.makedirs(xasguidir)
except OSError:
print("Warning: cannot create XAS GUI user folder")
return
if not HAS_MODELSAVE:
print("Warning: cannot save model results: upgrade lmfit")
return
if fname is None:
fname = 'autosave.fitresult'
fname = os.path.join(xasguidir, fname)
self.save_fit_result(result, fname)
def build(self):
sizer = wx.GridBagSizer(10, 5)
sizer.SetVGap(2)
sizer.SetHGap(2)
panel = scrolled.ScrolledPanel(self)
self.SetMinSize((600, 450))
self.colors = GUIColors()
# title row
self.wids = wids = {}
title = SimpleText(panel, 'Fit Results', font=Font(12),
colour=self.colors.title, style=LCEN)
wids['data_title'] = SimpleText(panel, '< > ', font=Font(12),
colour=self.colors.title, style=LCEN)
wids['hist_info'] = SimpleText(panel, ' ___ ', font=Font(12),
colour=self.colors.title, style=LCEN)
sizer.Add(title, (0, 0), (1, 2), LCEN)
sizer.Add(wids['data_title'], (0, 2), (1, 2), LCEN)
sizer.Add(wids['hist_info'], (0, 4), (1, 2), LCEN)
irow = 1
wids['model_desc'] = SimpleText(panel, '<Model>', font=Font(12),
size=(550, 75), style=LCEN)
sizer.Add(wids['model_desc'], (irow, 0), (1, 6), LCEN)
irow += 1
sizer.Add(HLine(panel, size=(400, 3)), (irow, 0), (1, 5), LCEN)
irow += 1
title = SimpleText(panel, '[[Fit Statistics]]', font=Font(12),
colour=self.colors.title, style=LCEN)
sizer.Add(title, (irow, 0), (1, 4), LCEN)
for label, attr in (('Fit method', 'method'),
('# Fit Evaluations', 'nfev'),
('# Data Points', 'ndata'),
('# Fit Variables', 'nvarys'),
('# Free Points', 'nfree'),
('Chi-square', 'chisqr'),
('Reduced Chi-square', 'redchi'),
('Akaike Info Criteria', 'aic'),
('Bayesian Info Criteria', 'bic')):
irow += 1
wids[attr] = SimpleText(panel, '?')
sizer.Add(SimpleText(panel, " %s = " % label), (irow, 0), (1, 1), LCEN)
sizer.Add(wids[attr], (irow, 1), (1, 1), LCEN)
irow += 1
sizer.Add(HLine(panel, size=(400, 3)), (irow, 0), (1, 5), LCEN)
irow += 1
title = SimpleText(panel, '[[Variables]]', font=Font(12),
colour=self.colors.title, style=LCEN)
sizer.Add(title, (irow, 0), (1, 1), LCEN)
self.wids['copy_params'] = Button(panel, 'Update Model with Best Fit Values',
size=(250, -1), action=self.onCopyParams)
sizer.Add(self.wids['copy_params'], (irow, 1), (1, 3), LCEN)
dvstyle = dv.DV_SINGLE|dv.DV_VERT_RULES|dv.DV_ROW_LINES
pview = self.wids['params'] = dv.DataViewListCtrl(panel, style=dvstyle)
self.wids['paramsdata'] = []
pview.AppendTextColumn('Parameter', width=150)
pview.AppendTextColumn('Best-Fit Value', width=100)
pview.AppendTextColumn('Standard Error', width=100)
pview.AppendTextColumn('Info ', width=275)
for col in (0, 1, 2, 3):
this = pview.Columns[col]
isort, align = True, wx.ALIGN_LEFT
if col in (1, 2):
isort, align = False, wx.ALIGN_RIGHT
this.Sortable = isort
this.Alignment = this.Renderer.Alignment = align
pview.SetMinSize((650, 200))
pview.Bind(dv.EVT_DATAVIEW_SELECTION_CHANGED, self.onSelectParameter)
irow += 1
sizer.Add(pview, (irow, 0), (1, 5), LCEN)
irow += 1
sizer.Add(HLine(panel, size=(400, 3)), (irow, 0), (1, 5), LCEN)
irow += 1
title = SimpleText(panel, '[[Correlations]]', font=Font(12),
colour=self.colors.title, style=LCEN)
self.wids['all_correl'] = Button(panel, 'Show All',
size=(100, -1), action=self.onAllCorrel)
self.wids['min_correl'] = FloatCtrl(panel, value=MIN_CORREL,
minval=0, size=(60, -1), gformat=True)
ctitle = SimpleText(panel, 'minimum correlation: ')
sizer.Add(title, (irow, 0), (1, 1), LCEN)
sizer.Add(ctitle, (irow, 1), (1, 1), LCEN)
sizer.Add(self.wids['min_correl'], (irow, 2), (1, 1), LCEN)
sizer.Add(self.wids['all_correl'], (irow, 3), (1, 1), LCEN)
irow += 1
cview = self.wids['correl'] = dv.DataViewListCtrl(panel, style=dvstyle)
cview.AppendTextColumn('Parameter 1', width=150)
cview.AppendTextColumn('Parameter 2', width=150)
cview.AppendTextColumn('Correlation', width=100)
for col in (0, 1, 2):
this = cview.Columns[col]
isort, align = True, wx.ALIGN_LEFT
if col == 1:
isort = False
if col == 2:
align = wx.ALIGN_RIGHT
this.Sortable = isort
this.Alignment = this.Renderer.Alignment = align
cview.SetMinSize((450, 200))
irow += 1
sizer.Add(cview, (irow, 0), (1, 5), LCEN)
irow += 1
sizer.Add(HLine(panel, size=(400, 3)), (irow, 0), (1, 5), LCEN)
pack(panel, sizer)
panel.SetupScrolling()
mainsizer = wx.BoxSizer(wx.VERTICAL)
mainsizer.Add(panel, 1, wx.GROW|wx.ALL, 1)
pack(self, mainsizer)
self.Show()
self.Raise()