def createMainPanel(self):
panel = wx.Panel(self)
sizer = wx.GridBagSizer(5, 4)
lab_roi = SimpleText(panel, ' Element / ROI Name')
lab_out = SimpleText(panel, ' Output Folder:')
lab_bad = SimpleText(panel, ' Bad Channels:')
lab_sel = SimpleText(panel, ' Select Files:')
self.roi_wid = wx.TextCtrl(panel, -1, '', size=(200, -1))
self.dir_wid = wx.TextCtrl(panel, -1, 'DT_Corrected', size=(200, -1))
self.badchans_wid = wx.TextCtrl(panel, -1, ' ', size=(200, -1))
self.sel_wid = Button(panel,
'Browse',
size=(100, -1),
action=self.onBrowse)
ir = 0
sizer.Add(lab_roi, (ir, 0), (1, 1), LCEN, 2)
sizer.Add(self.roi_wid, (ir, 1), (1, 1), LCEN, 2)
ir += 1
sizer.Add(lab_out, (ir, 0), (1, 1), LCEN, 2)
sizer.Add(self.dir_wid, (ir, 1), (1, 1), LCEN, 2)
ir += 1
sizer.Add(lab_bad, (ir, 0), (1, 1), LCEN, 2)
sizer.Add(self.badchans_wid, (ir, 1), (1, 1), LCEN, 2)
ir += 1
sizer.Add(lab_sel, (ir, 0), (1, 1), LCEN, 2)
sizer.Add(self.sel_wid, (ir, 1), (1, 1), LCEN, 2)
pack(panel, sizer)
wx.CallAfter(self.init_larch)
return
def CustomConfig(self, panel, sizer=None, irow=0):
"""config panel for left-hand-side of frame"""
labstyle = wx.ALIGN_LEFT|wx.LEFT|wx.TOP|wx.EXPAND
if self.lasso_callback is None:
zoom_opts = ('Zoom to Rectangle',)
else:
zoom_opts = ('Zoom to Rectangle',
'Pick Area for XRF Spectrum')
cpanel = wx.Panel(panel)
if sizer is None:
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(SimpleText(cpanel, label='Cursor Modes', style=labstyle),
0, labstyle, 3)
self.zoom_mode = wx.RadioBox(cpanel, -1, "",
wx.DefaultPosition, wx.DefaultSize,
zoom_opts, 1, wx.RA_SPECIFY_COLS)
self.zoom_mode.Bind(wx.EVT_RADIOBOX, self.onCursorMode)
sizer.Add(self.zoom_mode, 1, labstyle, 4)
if self.save_callback is not None:
sizer.Add(SimpleText(cpanel, label='Save Position:', style=labstyle),
0, labstyle, 3)
self.pos_name = wx.TextCtrl(cpanel, -1, '', size=(155, -1),
style=wx.TE_PROCESS_ENTER)
self.pos_name.Bind(wx.EVT_TEXT_ENTER, self.onSavePixel)
sizer.Add(self.pos_name, 0, labstyle, 3)
pack(cpanel, sizer)
return cpanel
def CustomConfig(self, panel, sizer=None, irow=0):
"""config panel for left-hand-side of frame"""
labstyle = wx.ALIGN_LEFT | wx.LEFT | wx.TOP | wx.EXPAND
if self.lasso_callback is None:
zoom_opts = ('Zoom to Rectangle', 'Show Line Profile')
else:
zoom_opts = ('Zoom to Rectangle', 'Pick Area for XRF Spectrum',
'Show Line Profile')
if self.wxmplot_version > 0.921:
cpanel = wx.Panel(panel)
if sizer is None:
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(SimpleText(cpanel, label='Cursor Modes', style=labstyle),
0, labstyle, 3)
self.zoom_mode = wx.RadioBox(cpanel, -1, "", wx.DefaultPosition,
wx.DefaultSize, zoom_opts, 1,
wx.RA_SPECIFY_COLS)
self.zoom_mode.Bind(wx.EVT_RADIOBOX, self.onCursorMode)
sizer.Add(self.zoom_mode, 1, labstyle, 4)
if self.save_callback is not None:
sizer.Add(
SimpleText(cpanel, label='Save Position:', style=labstyle),
0, labstyle, 3)
self.pos_name = wx.TextCtrl(cpanel,
-1,
'',
size=(155, -1),
style=wx.TE_PROCESS_ENTER)
self.pos_name.Bind(wx.EVT_TEXT_ENTER, self.onSavePixel)
sizer.Add(self.pos_name, 0, labstyle, 3)
pack(cpanel, sizer)
return cpanel
else: # support older versions of wxmplot, will be able to deprecate
conf = self.panel.conf
lpanel = panel
lsizer = sizer
self.zoom_mode = wx.RadioBox(panel, -1, "Cursor Mode:",
wx.DefaultPosition, wx.DefaultSize,
zoom_opts, 1, wx.RA_SPECIFY_COLS)
self.zoom_mode.Bind(wx.EVT_RADIOBOX, self.onCursorMode)
sizer.Add(self.zoom_mode, (irow, 0), (1, 4), labstyle, 3)
if self.save_callback is not None:
self.pos_name = wx.TextCtrl(panel,
-1,
'',
size=(175, -1),
style=wx.TE_PROCESS_ENTER)
self.pos_name.Bind(wx.EVT_TEXT_ENTER, self.onSavePixel)
label = SimpleText(panel,
label='Save Position:',
size=(-1, -1))
sizer.Add(label, (irow + 1, 0), (1, 2), labstyle, 3)
sizer.Add(self.pos_name, (irow + 1, 2), (1, 2), labstyle, 3)
def __init__(self, parent, calfile, **kws):
self.parent = parent
self.scandb = parent.scandb
self.calfile = calfile
poni = read_poni(calfile)
wx.Dialog.__init__(self,
parent,
wx.ID_ANY,
size=(600, 525),
title="Read Calibration File")
panel = GridPanel(self, ncols=3, nrows=4, pad=2, itemstyle=LCEN)
self.wids = wids = {}
wids['filename'] = SimpleText(panel, calfile)
_p, fname = os.path.split(calfile)
wids['calname'] = wx.TextCtrl(panel, value=fname, size=(350, -1))
wids['ok'] = Button(panel, 'OK', size=(150, -1), action=self.on_apply)
def add_text(text, dcol=1, newrow=True):
panel.Add(SimpleText(panel, text), dcol=dcol, newrow=newrow)
add_text(' Calibration file: ', newrow=False)
panel.Add(wids['filename'], dcol=3)
add_text(' Save as : ')
panel.Add(wids['calname'], dcol=3)
opts = dict(size=(90, -1), digits=5)
for wname in ('wavelength', 'dist', 'pixel1', 'pixel2', 'poni1',
'poni2', 'rot1', 'rot2', 'rot3'):
scale, units = self.conv[wname]
val = scale * float(poni[wname])
if wname == 'wavelength':
energy = 12398.4193 / val
units = '%s, Energy=%.2f' % (units, energy)
wids[wname] = FloatCtrl(panel,
value=val,
size=(100, -1),
precision=4)
wids[wname + '_units'] = SimpleText(panel, units)
add_text(' %s:' % wname.title())
panel.Add(wids[wname])
panel.Add(wids[wname + '_units'])
panel.Add((5, 5))
panel.Add(wids['ok'], dcol=2, newrow=True)
panel.pack()
def CustomConfig(self, panel, sizer, irow):
"""config panel for left-hand-side of frame"""
conf = self.panel.conf
lpanel = panel
lsizer = sizer
labstyle = wx.ALIGN_LEFT|wx.LEFT|wx.TOP|wx.EXPAND
self.zoom_mode = wx.RadioBox(panel, -1, "Cursor Mode:",
wx.DefaultPosition, wx.DefaultSize,
('Zoom to Rectangle',
'Pick Area for XRF Spectrum',
'Show Line Profile'),
1, wx.RA_SPECIFY_COLS)
self.zoom_mode.Bind(wx.EVT_RADIOBOX, self.onCursorMode)
sizer.Add(self.zoom_mode, (irow, 0), (1, 4), labstyle, 3)
if self.save_callback is not None:
self.pos_name = wx.TextCtrl(panel, -1, '', size=(175, -1),
style=wx.TE_PROCESS_ENTER)
self.pos_name.Bind(wx.EVT_TEXT_ENTER, self.onSavePixel)
label = SimpleText(panel, label='Save Position:',
size=(-1, -1))
# sbutton = Button(panel, 'Save Position', size=(100, -1),
# action=self.onSavePixel)
sizer.Add(label, (irow+1, 0), (1, 2), labstyle, 3)
sizer.Add(self.pos_name, (irow+1, 2), (1, 2), labstyle, 3)
# sizer.Add(sbutton, (irow+2, 0), (1, 2), labstyle, 3)
if self.move_callback is not None:
mbutton = Button(panel, 'Move to Position', size=(100, -1),
action=self.onMoveToPixel)
irow = irow + 2
sizer.Add(mbutton, (irow+1, 0), (1, 2), labstyle, 3)
def add_subtitle(panel, text, colour='#222288'):
p = wx.Panel(panel)
s = wx.BoxSizer(wx.HORIZONTAL)
s.Add(wx.StaticLine(p, size=(50, 5), style=wx.LI_HORIZONTAL), 0, LCEN, 5)
s.Add(SimpleText(p, text, colour=colour), 0, LCEN, 5)
pack(p, s)
return p
def createMainPanel(self):
panel = wx.Panel(self)
sizer = wx.GridBagSizer(5, 4)
lab_roi = SimpleText(panel, ' Element / ROI Name:')
lab_dir = SimpleText(panel, ' Output Folder:')
lab_ath = SimpleText(panel, ' Athena Project File:')
lab_bad = SimpleText(panel, ' Bad Channels:')
lab_sel = SimpleText(panel, ' Select Files:')
self.wid_roi = wx.TextCtrl(panel, -1, '', size=(200, -1))
self.wid_dir = wx.TextCtrl(panel, -1, 'DT_Corrected', size=(200, -1))
self.wid_ath = wx.TextCtrl(panel, -1, 'Athena_001.prj', size=(200, -1))
self.wid_bad = wx.TextCtrl(panel, -1, ' ', size=(200, -1))
self.wid_autoname = Check(panel,
default=True,
size=(150, -1),
label='auto-increment?')
self.sel_wid = Button(panel,
'Browse',
size=(100, -1),
action=self.onBrowse)
ir = 0
sizer.Add(lab_roi, (ir, 0), (1, 1), LCEN, 2)
sizer.Add(self.wid_roi, (ir, 1), (1, 1), LCEN, 2)
ir += 1
sizer.Add(lab_dir, (ir, 0), (1, 1), LCEN, 2)
sizer.Add(self.wid_dir, (ir, 1), (1, 1), LCEN, 2)
ir += 1
sizer.Add(lab_ath, (ir, 0), (1, 1), LCEN, 2)
sizer.Add(self.wid_ath, (ir, 1), (1, 1), LCEN, 2)
sizer.Add(self.wid_autoname, (ir, 2), (1, 1), LCEN, 2)
ir += 1
sizer.Add(lab_bad, (ir, 0), (1, 1), LCEN, 2)
sizer.Add(self.wid_bad, (ir, 1), (1, 1), LCEN, 2)
ir += 1
sizer.Add(lab_sel, (ir, 0), (1, 1), LCEN, 2)
sizer.Add(self.sel_wid, (ir, 1), (1, 1), LCEN, 2)
pack(panel, sizer)
wx.CallAfter(self.init_larch)
return
def txt(panel, label, size=75, colour=None, font=None, style=None):
if style is None:
style = wx.ALIGN_LEFT|wx.ALL|wx.GROW
if colour is None:
colour = wx.Colour(0, 0, 50)
this = SimpleText(panel, label, size=(size, -1),
colour=colour, style=style)
if font is not None: this.SetFont(font)
return this
def CreateFitPanel(self, parent):
panel = wx.Panel(parent)
tpan = wx.Panel(panel)
self.fit_model = Choice(tpan,
size=(100, -1),
choices=('Gaussian', 'Lorentzian', 'Voigt',
'Linear', 'Quadratic', 'Step',
'Rectangle', 'Exponential'))
self.fit_bkg = Choice(tpan,
size=(100, -1),
choices=('None', 'constant', 'linear',
'quadratic'))
self.fit_step = Choice(tpan,
size=(100, -1),
choices=('linear', 'error function', 'arctan'))
tsizer = wx.GridBagSizer(10, 4)
tsizer.Add(SimpleText(tpan, 'Fit Model: '), (0, 0), (1, 1), LCEN)
tsizer.Add(self.fit_model, (0, 1), (1, 1), LCEN)
tsizer.Add(SimpleText(tpan, 'Background: '), (0, 2), (1, 1), LCEN)
tsizer.Add(self.fit_bkg, (0, 3), (1, 1), LCEN)
tsizer.Add(
Button(tpan, 'Show Fit', size=(100, -1), action=self.onFitPeak),
(1, 1), (1, 1), LCEN)
tsizer.Add(SimpleText(tpan, 'Step Form: '), (1, 2), (1, 1), LCEN)
tsizer.Add(self.fit_step, (1, 3), (1, 1), LCEN)
pack(tpan, tsizer)
self.fit_report = RichTextCtrl(panel,
size=(525, 250),
style=wx.VSCROLL | wx.NO_BORDER)
self.fit_report.SetEditable(False)
self.fit_report.SetFont(Font(9))
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(tpan, 0, wx.GROW | wx.ALL, 2)
sizer.Add(self.fit_report, 1, LCEN | wx.GROW, 2)
pack(panel, sizer)
return panel
def CustomConfig(self, panel, sizer=None, irow=0):
'''
override to add custom config panel items
to bottom of config panel
'''
labstyle = wx.ALIGN_LEFT|wx.LEFT|wx.TOP|wx.EXPAND
if self.lasso_callback is None:
zoom_opts = ('Zoom to Rectangle',
'Show Line Profile')
else:
zoom_opts = ('Zoom to Rectangle',
'Pick Area for XRM Spectra',
'Show Line Profile')
if self.wxmplot_version > 0.921:
cpanel = wx.Panel(panel)
if sizer is None:
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(SimpleText(cpanel, label='Cursor Modes', style=labstyle), 0, labstyle, 3)
self.zoom_mode = wx.RadioBox(cpanel, -1, '',
wx.DefaultPosition, wx.DefaultSize,
zoom_opts, 1, wx.RA_SPECIFY_COLS)
self.zoom_mode.Bind(wx.EVT_RADIOBOX, self.onCursorMode)
sizer.Add(self.zoom_mode, 1, labstyle, 4)
pack(cpanel, sizer)
return cpanel
else: # support older versions of wxmplot, will be able to deprecate
conf = self.tomo_frame[0].panel.conf # self.panel.conf
lpanel = panel
lsizer = sizer
self.zoom_mode = wx.RadioBox(panel, -1, 'Cursor Mode:',
wx.DefaultPosition, wx.DefaultSize,
zoom_opts, 1, wx.RA_SPECIFY_COLS)
self.zoom_mode.Bind(wx.EVT_RADIOBOX, self.onCursorMode)
sizer.Add(self.zoom_mode, (irow, 0), (1, 4), labstyle, 3)
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, group, on_ok=None):
self.group = group
self.on_ok = on_ok
wx.Frame.__init__(self,
None,
-1,
'Edit Array Names',
style=wx.DEFAULT_FRAME_STYLE | wx.TAB_TRAVERSAL)
self.SetFont(Font(10))
sizer = wx.GridBagSizer(4, 4)
self.SetMinSize((600, 600))
self.wids = {}
cind = SimpleText(self, label='Column')
cold = SimpleText(self, label='Current Name')
cnew = SimpleText(self, label='Enter New Name')
cret = SimpleText(self, label=' Result ', size=(150, -1))
cinfo = SimpleText(self, label=' Data Range')
ir = 0
sizer.Add(cind, (ir, 0), (1, 1), LCEN, 3)
sizer.Add(cold, (ir, 1), (1, 1), LCEN, 3)
sizer.Add(cnew, (ir, 2), (1, 1), LCEN, 3)
sizer.Add(cret, (ir, 3), (1, 1), LCEN, 3)
sizer.Add(cinfo, (ir, 4), (1, 1), LCEN, 3)
for i, name in enumerate(group.array_labels):
ir += 1
cind = SimpleText(self, label=' %i ' % (i + 1))
cold = SimpleText(self, label=' %s ' % name)
cret = SimpleText(self, label=fix_varname(name), size=(150, -1))
cnew = wx.TextCtrl(self, value=name, size=(150, -1))
cnew.Bind(wx.EVT_KILL_FOCUS, partial(self.update, index=i))
cnew.Bind(wx.EVT_CHAR, partial(self.update_char, index=i))
cnew.Bind(wx.EVT_TEXT_ENTER, partial(self.update, index=i))
arr = group.data[i, :]
info_str = " [ %8g : %8g ] " % (arr.min(), arr.max())
cinfo = SimpleText(self, label=info_str)
self.wids[i] = cnew
self.wids["ret_%i" % i] = cret
sizer.Add(cind, (ir, 0), (1, 1), LCEN, 3)
sizer.Add(cold, (ir, 1), (1, 1), LCEN, 3)
sizer.Add(cnew, (ir, 2), (1, 1), LCEN, 3)
sizer.Add(cret, (ir, 3), (1, 1), LCEN, 3)
sizer.Add(cinfo, (ir, 4), (1, 1), LCEN, 3)
sizer.Add(Button(self, 'OK', action=self.onOK), (ir + 1, 1), (1, 2),
LCEN, 3)
pack(self, sizer)
self.Show()
self.Raise()
def __init__(self,
parent,
filename=None,
groupname=None,
last_array_sel=None,
read_ok_cb=None,
edit_groupname=True,
_larch=None):
self.parent = parent
self._larch = _larch
self.path = filename
group = self.initgroup = self.read_column_file(self.path)
self.subframes = {}
self.workgroup = Group(raw=group)
for attr in ('path', 'filename', 'groupname', 'datatype',
'array_labels'):
setattr(self.workgroup, attr, getattr(group, attr, None))
arr_labels = [l.lower() for l in self.initgroup.array_labels]
if self.workgroup.datatype is None:
self.workgroup.datatype = 'raw'
if ('energ' in arr_labels[0] or 'energ' in arr_labels[1]):
self.workgroup.datatype = 'xas'
self.read_ok_cb = read_ok_cb
self.array_sel = {
'xpop': '',
'xarr': None,
'ypop': '',
'yop': '/',
'yarr1': None,
'yarr2': None,
'use_deriv': False
}
if last_array_sel is not None:
self.array_sel.update(last_array_sel)
if self.array_sel['yarr2'] is None and 'i0' in arr_labels:
self.array_sel['yarr2'] = 'i0'
if self.array_sel['yarr1'] is None:
if 'itrans' in arr_labels:
self.array_sel['yarr1'] = 'itrans'
elif 'i1' in arr_labels:
self.array_sel['yarr1'] = 'i1'
message = "Data Columns for %s" % group.filename
wx.Frame.__init__(self,
None,
-1,
'Build Arrays from Data Columns for %s' %
group.filename,
style=FRAMESTYLE)
self.SetFont(Font(10))
panel = wx.Panel(self)
self.SetMinSize((600, 600))
self.colors = GUIColors()
# title row
title = SimpleText(panel,
message,
font=Font(13),
colour=self.colors.title,
style=LCEN)
opts = dict(action=self.onUpdate, size=(120, -1))
yarr_labels = self.yarr_labels = arr_labels + ['1.0', '0.0', '']
xarr_labels = self.xarr_labels = arr_labels + ['_index']
self.xarr = Choice(panel, choices=xarr_labels, **opts)
self.yarr1 = Choice(panel, choices=arr_labels, **opts)
self.yarr2 = Choice(panel, choices=yarr_labels, **opts)
self.yerr_arr = Choice(panel, choices=yarr_labels, **opts)
self.yerr_arr.Disable()
self.datatype = Choice(panel, choices=DATATYPES, **opts)
self.datatype.SetStringSelection(self.workgroup.datatype)
opts['size'] = (50, -1)
self.yop = Choice(panel, choices=ARR_OPS, **opts)
opts['size'] = (120, -1)
self.use_deriv = Check(panel,
label='use derivative',
default=self.array_sel['use_deriv'],
**opts)
self.xpop = Choice(panel, choices=XPRE_OPS, **opts)
self.ypop = Choice(panel, choices=YPRE_OPS, **opts)
opts['action'] = self.onYerrChoice
self.yerr_op = Choice(panel, choices=YERR_OPS, **opts)
self.yerr_op.SetSelection(0)
self.yerr_const = FloatCtrl(panel, value=1, precision=4, size=(90, -1))
ylab = SimpleText(panel, 'Y = ')
xlab = SimpleText(panel, 'X = ')
yerr_lab = SimpleText(panel, 'Yerror = ')
self.xsuf = SimpleText(panel, '')
self.ysuf = SimpleText(panel, '')
self.xpop.SetStringSelection(self.array_sel['xpop'])
self.ypop.SetStringSelection(self.array_sel['ypop'])
self.yop.SetStringSelection(self.array_sel['yop'])
if '(' in self.array_sel['ypop']:
self.ysuf.SetLabel(')')
ixsel, iysel, iy2sel = 0, 1, len(yarr_labels) - 1
if self.array_sel['xarr'] in xarr_labels:
ixsel = xarr_labels.index(self.array_sel['xarr'])
if self.array_sel['yarr1'] in arr_labels:
iysel = arr_labels.index(self.array_sel['yarr1'])
if self.array_sel['yarr2'] in yarr_labels:
iy2sel = yarr_labels.index(self.array_sel['yarr2'])
self.xarr.SetSelection(ixsel)
self.yarr1.SetSelection(iysel)
self.yarr2.SetSelection(iy2sel)
bpanel = wx.Panel(panel)
bsizer = wx.BoxSizer(wx.HORIZONTAL)
_ok = Button(bpanel, 'OK', action=self.onOK)
_cancel = Button(bpanel, 'Cancel', action=self.onCancel)
_edit = Button(bpanel, 'Edit Array Names', action=self.onEditNames)
bsizer.Add(_ok)
bsizer.Add(_cancel)
bsizer.Add(_edit)
_ok.SetDefault()
pack(bpanel, bsizer)
sizer = wx.GridBagSizer(4, 8)
sizer.Add(title, (0, 0), (1, 7), LCEN, 5)
ir = 1
sizer.Add(xlab, (ir, 0), (1, 1), LCEN, 0)
sizer.Add(self.xpop, (ir, 1), (1, 1), CEN, 0)
sizer.Add(self.xarr, (ir, 2), (1, 1), CEN, 0)
sizer.Add(self.xsuf, (ir, 3), (1, 1), CEN, 0)
ir += 1
sizer.Add(ylab, (ir, 0), (1, 1), LCEN, 0)
sizer.Add(self.ypop, (ir, 1), (1, 1), CEN, 0)
sizer.Add(self.yarr1, (ir, 2), (1, 1), CEN, 0)
sizer.Add(self.yop, (ir, 3), (1, 1), CEN, 0)
sizer.Add(self.yarr2, (ir, 4), (1, 1), CEN, 0)
sizer.Add(self.ysuf, (ir, 5), (1, 1), CEN, 0)
sizer.Add(self.use_deriv, (ir, 6), (1, 1), LCEN, 0)
ir += 1
sizer.Add(yerr_lab, (ir, 0), (1, 1), LCEN, 0)
sizer.Add(self.yerr_op, (ir, 1), (1, 1), CEN, 0)
sizer.Add(self.yerr_arr, (ir, 2), (1, 1), CEN, 0)
sizer.Add(SimpleText(panel, 'Value:'), (ir, 3), (1, 1), CEN, 0)
sizer.Add(self.yerr_const, (ir, 4), (1, 2), CEN, 0)
ir += 1
sizer.Add(SimpleText(panel, 'Data Type:'), (ir, 0), (1, 1), LCEN, 0)
sizer.Add(self.datatype, (ir, 1), (1, 2), LCEN, 0)
ir += 1
self.wid_groupname = wx.TextCtrl(panel,
value=group.groupname,
size=(240, -1))
if not edit_groupname:
self.wid_groupname.Disable()
sizer.Add(SimpleText(panel, 'Group Name:'), (ir, 0), (1, 1), LCEN, 0)
sizer.Add(self.wid_groupname, (ir, 1), (1, 2), LCEN, 0)
ir += 1
sizer.Add(bpanel, (ir, 0), (1, 5), LCEN, 3)
pack(panel, sizer)
self.nb = fnb.FlatNotebook(self, -1, agwStyle=FNB_STYLE)
self.nb.SetTabAreaColour(wx.Colour(248, 248, 240))
self.nb.SetActiveTabColour(wx.Colour(254, 254, 195))
self.nb.SetNonActiveTabTextColour(wx.Colour(40, 40, 180))
self.nb.SetActiveTabTextColour(wx.Colour(80, 0, 0))
self.plotpanel = PlotPanel(self, messenger=self.plot_messages)
textpanel = wx.Panel(self)
ftext = wx.TextCtrl(textpanel,
style=wx.TE_MULTILINE | wx.TE_READONLY,
size=(400, 250))
ftext.SetValue(group.text)
ftext.SetFont(Font(10))
textsizer = wx.BoxSizer(wx.VERTICAL)
textsizer.Add(ftext, 1, LCEN | wx.GROW, 1)
pack(textpanel, textsizer)
self.nb.AddPage(textpanel, ' Text of Data File ', True)
self.nb.AddPage(self.plotpanel, ' Plot of Selected Arrays ', True)
mainsizer = wx.BoxSizer(wx.VERTICAL)
mainsizer.Add(panel, 0, wx.GROW | wx.ALL, 2)
mainsizer.Add(self.nb, 1, LCEN | wx.GROW, 2)
pack(self, mainsizer)
self.statusbar = self.CreateStatusBar(2, 0)
self.statusbar.SetStatusWidths([-1, -1])
statusbar_fields = [group.filename, ""]
for i in range(len(statusbar_fields)):
self.statusbar.SetStatusText(statusbar_fields[i], i)
self.Show()
self.Raise()
self.onUpdate(self)
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()
def __init__(self,
parent,
filename=None,
read_ok_cb=None,
size=(725, 450),
_larch=None):
self.parent = parent
self.filename = filename
self.larch = _larch
self.read_ok_cb = read_ok_cb
self.colors = GUIColors()
wx.Frame.__init__(self, parent, -1, size=size, style=FRAMESTYLE)
splitter = wx.SplitterWindow(self, style=wx.SP_LIVE_UPDATE)
splitter.SetMinimumPaneSize(200)
leftpanel = wx.Panel(splitter)
ltop = wx.Panel(leftpanel)
sel_none = Button(ltop,
'Select None',
size=(100, 30),
action=self.onSelNone)
sel_all = Button(ltop,
'Select All',
size=(100, 30),
action=self.onSelAll)
sel_imp = Button(ltop,
'Import Selected Groups',
size=(200, 30),
action=self.onOK)
self.select_imported = sel_imp
self.select_imported.Disable()
self.grouplist = FileCheckList(leftpanel,
select_action=self.onShowGroup)
self.grouplist.SetBackgroundColour(wx.Colour(255, 255, 255))
tsizer = wx.GridBagSizer(2, 2)
tsizer.Add(sel_all, (0, 0), (1, 1), LCEN, 0)
tsizer.Add(sel_none, (0, 1), (1, 1), LCEN, 0)
tsizer.Add(sel_imp, (1, 0), (1, 2), LCEN, 0)
pack(ltop, tsizer)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(ltop, 0, LCEN | wx.GROW, 1)
sizer.Add(self.grouplist, 1, LCEN | wx.GROW | wx.ALL, 1)
pack(leftpanel, sizer)
# right hand side
rightpanel = wx.Panel(splitter)
self.SetTitle("Reading Athena Project '%s'" % self.filename)
self.title = SimpleText(rightpanel,
self.filename,
font=Font(13),
colour=self.colors.title,
style=LCEN)
self.plotpanel = PlotPanel(rightpanel, messenger=self.plot_messages)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(self.title, 0, LCEN, 2)
sizer.Add(self.plotpanel, 0, LCEN, 2)
pack(rightpanel, sizer)
splitter.SplitVertically(leftpanel, rightpanel, 1)
self.statusbar = self.CreateStatusBar(2, 0)
self.statusbar.SetStatusWidths([-3, -1])
statusbar_fields = [self.filename, ""]
for i in range(len(statusbar_fields)):
self.statusbar.SetStatusText(statusbar_fields[i], i)
self.all = read_athena(self.filename,
do_bkg=False,
do_fft=False,
with_journal=False,
_larch=_larch)
for item in dir(self.all):
self.grouplist.Append(item)
self.Show()
self.Raise()
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)
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 XYFitFrame(wx.Frame):
_about = """Larch XYFit: XY Data Viewing & Curve Fitting
Matt Newville <newville @ cars.uchicago.edu>
"""
def __init__(self, parent=None, size=(875, 550), _larch=None, **kws):
wx.Frame.__init__(self, parent, -1, size=size, style=FRAMESTYLE)
self.last_array_sel = {}
self.paths2read = []
title = "Larch XYFit: XY Data Viewing & Curve Fitting"
self.larch_buffer = parent
if not isinstance(parent, LarchFrame):
self.larch_buffer = LarchFrame(_larch=_larch)
self.larch_buffer.Show()
self.larch_buffer.Raise()
self.larch=self.larch_buffer.larchshell
self.controller = XYFitController(wxparent=self, _larch=self.larch)
self.subframes = {}
self.plotframe = None
self.SetTitle(title)
self.SetSize(size)
self.SetFont(Font(10))
self.larch_buffer.Hide()
self.createMainPanel()
self.createMenus()
self.statusbar = self.CreateStatusBar(2, 0)
self.statusbar.SetStatusWidths([-3, -1])
statusbar_fields = ["Initializing....", " "]
for i in range(len(statusbar_fields)):
self.statusbar.SetStatusText(statusbar_fields[i], i)
def createMainPanel(self):
splitter = wx.SplitterWindow(self, style=wx.SP_LIVE_UPDATE)
splitter.SetMinimumPaneSize(250)
leftpanel = wx.Panel(splitter)
ltop = wx.Panel(leftpanel)
def Btn(msg, x, act):
b = Button(ltop, msg, size=(x, 30), action=act)
b.SetFont(Font(10))
return b
plot_one = Btn('Plot One', 120, self.onPlotOne)
plot_sel = Btn('Plot Selected', 120, self.onPlotSel)
sel_none = Btn('Select None', 120, self.onSelNone)
sel_all = Btn('Select All', 120, self.onSelAll)
self.controller.filelist = FileCheckList(leftpanel, main=self,
select_action=self.ShowFile,
remove_action=self.RemoveFile)
self.controller.filelist.SetBackgroundColour(wx.Colour(255, 255, 255))
tsizer = wx.GridBagSizer(1, 1)
tsizer.Add(plot_one, (0, 0), (1, 1), LCEN, 2)
tsizer.Add(plot_sel, (0, 1), (1, 1), LCEN, 2)
tsizer.Add(sel_all, (1, 0), (1, 1), LCEN, 2)
tsizer.Add(sel_none, (1, 1), (1, 1), LCEN, 2)
pack(ltop, tsizer)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(ltop, 0, LCEN|wx.GROW, 1)
sizer.Add(self.controller.filelist, 1, LCEN|wx.GROW|wx.ALL, 1)
pack(leftpanel, sizer)
# right hand side
panel = wx.Panel(splitter)
sizer = wx.BoxSizer(wx.VERTICAL)
self.title = SimpleText(panel, 'initializing...', size=(300, -1))
self.title.SetFont(Font(10))
ir = 0
sizer.Add(self.title, 0, LCEN|wx.GROW|wx.ALL, 1)
self.nb = flat_nb.FlatNotebook(panel, -1, agwStyle=FNB_STYLE)
self.nb.SetTabAreaColour(wx.Colour(250,250,250))
self.nb.SetActiveTabColour(wx.Colour(254,254,195))
self.nb.SetNonActiveTabTextColour(wx.Colour(10,10,128))
self.nb.SetActiveTabTextColour(wx.Colour(128,0,0))
panel_opts = dict(parent=self.nb, controller=self.controller)
self.proc_panel = ProcessPanel(**panel_opts)
self.fit_panel = XYFitPanel(**panel_opts)
self.nb.AddPage(self.proc_panel, ' Data Processing ', True)
self.nb.AddPage(self.fit_panel, ' Curve Fitting ', True)
sizer.Add(self.nb, 1, LCEN|wx.EXPAND, 2)
self.nb.SetSelection(0)
pack(panel, sizer)
splitter.SplitVertically(leftpanel, panel, 1)
wx.CallAfter(self.init_larch)
def onSelAll(self, event=None):
self.controller.filelist.SetCheckedStrings(self.controller.file_groups.keys())
def onSelNone(self, event=None):
self.controller.filelist.SetCheckedStrings([])
def init_larch(self):
self.SetStatusText('initializing Larch')
self.title.SetLabel('')
self.fit_panel.larch = self.controller.larch
self.controller.init_larch()
plotframe = self.controller.get_display(stacked=False)
xpos, ypos = self.GetPosition()
xsiz, ysiz = self.GetSize()
plotframe.SetPosition((xpos+xsiz, ypos))
self.SetStatusText('ready')
self.Raise()
def write_message(self, s, panel=0):
"""write a message to the Status Bar"""
self.SetStatusText(s, panel)
def onPlotOne(self, evt=None, groupname=None):
if groupname is None:
groupname = self.controller.groupname
dgroup = self.controller.get_group(groupname)
if dgroup is not None:
self.controller.plot_group(groupname=groupname, new=True)
def onPlotSel(self, evt=None):
newplot = True
group_ids = self.controller.filelist.GetCheckedStrings()
for checked in group_ids:
groupname = self.controller.file_groups[str(checked)]
dgroup = self.controller.get_group(groupname)
if dgroup is not None:
self.controller.plot_group(groupname=groupname, title='',
new=newplot, label=dgroup.filename)
newplot=False
def plot_group(self, groupname=None, title=None, new=True, **kws):
self.controller.plot_group(groupname=groupname, title=title, new=new, **kws)
self.Raise()
def RemoveFile(self, fname=None, **kws):
if fname is not None:
s = str(fname)
if s in self.controller.file_groups:
group = self.controller.file_groups.pop(s)
def ShowFile(self, evt=None, groupname=None, **kws):
filename = None
if evt is not None:
filename = str(evt.GetString())
if groupname is None and filename is not None:
groupname = self.controller.file_groups[filename]
if not hasattr(self.larch.symtable, groupname):
return
dgroup = self.controller.get_group(groupname)
self.controller.group = dgroup
self.controller.groupname = groupname
self.nb.SetSelection(0)
self.proc_panel.fill(dgroup)
if filename is None:
filename = dgroup.filename
self.title.SetLabel(filename)
def createMenus(self):
# ppnl = self.plotpanel
self.menubar = wx.MenuBar()
#
fmenu = wx.Menu()
MenuItem(self, fmenu, "&Open Data File\tCtrl+O",
"Open Data File", self.onReadDialog)
fmenu.AppendSeparator()
MenuItem(self, fmenu, 'Show Larch Buffer\tCtrl+L',
'Show Larch Programming Buffer',
self.onShowLarchBuffer)
MenuItem(self, fmenu, "debug wx\tCtrl+I", "", self.showInspectionTool)
MenuItem(self, fmenu, "&Quit\tCtrl+Q", "Quit program", self.onCloseNicely)
self.menubar.Append(fmenu, "&File")
omenu = wx.Menu()
self.menubar.Append(omenu, "Options")
MenuItem(self, omenu, "Configure Data Processing",
"Configure Data Processing", self.onConfigDataProcessing)
MenuItem(self, omenu, "Configure Data Fitting",
"Configure Data Fitting", self.onConfigDataFitting)
self.SetMenuBar(self.menubar)
self.Bind(wx.EVT_CLOSE, self.onExit)
def onShowLarchBuffer(self, evt=None):
if self.larch_buffer is None:
self.larch_buffer = LarchFrame(_larch=self.larch)
self.larch_buffer.Show()
self.larch_buffer.Raise()
def onConfigDataProcessing(self, event=None):
pass
def onConfigDataFitting(self, event=None):
pass
def showInspectionTool(self, event=None):
app = wx.GetApp()
app.ShowInspectionTool()
def onAbout(self,evt):
dlg = wx.MessageDialog(self, self._about,
"About Larch XYFit",
wx.OK | wx.ICON_INFORMATION)
dlg.ShowModal()
dlg.Destroy()
def onExit(self, evt):
for nam in dir(self.larch.symtable._plotter):
obj = getattr(self.larch.symtable._plotter, nam)
time.sleep(0.05)
try:
obj.Destroy()
except:
pass
for nam in dir(self.larch.symtable._sys.wx):
obj = getattr(self.larch.symtable._sys.wx, nam)
time.sleep(0.05)
del obj
if self.larch_buffer is not None:
try:
self.larch_buffer.Destroy()
except:
pass
self.Destroy()
def onCloseNicely(self, evt):
dlg = wx.MessageDialog(None, 'Really Quit?', 'Question',
wx.YES_NO | wx.NO_DEFAULT | wx.ICON_QUESTION)
if wx.ID_YES != dlg.ShowModal():
return
self.controller.save_config()
self.proc_panel.proc_timer.Stop()
time.sleep(0.05)
self.onExit(evt)
def show_subframe(self, name, frameclass, **opts):
shown = False
if name in self.subframes:
try:
self.subframes[name].Raise()
shown = True
except:
del self.subframes[name]
if not shown:
self.subframes[name] = frameclass(self, **opts)
def onSelectColumns(self, evt=None):
dgroup = self.controller.get_group(self.controller.groupname)
self.show_subframe('readfile', ColumnDataFileFrame,
group=dgroup.raw,
last_array_sel=self.last_array_sel,
_larch=self.larch,
read_ok_cb=partial(self.onRead_OK,
overwrite=True))
def onReadDialog(self, evt=None):
dlg = wx.FileDialog(self, message="Read Data File",
defaultDir=os.getcwd(),
wildcard=FILE_WILDCARDS,
style=wx.FD_OPEN|wx.FD_MULTIPLE)
self.paths2read = []
if dlg.ShowModal() == wx.ID_OK:
self.paths2read = dlg.GetPaths()
dlg.Destroy()
if len(self.paths2read) < 1:
return
path = self.paths2read.pop(0)
path = path.replace('\\', '/')
do_read = True
if path in self.controller.file_groups:
do_read = (wx.ID_YES == popup(self,
"Re-read file '%s'?" % path,
'Re-read file?'))
if do_read:
self.onRead(path)
def onRead(self, path):
filedir, filename = os.path.split(path)
if self.controller.get_config('chdir_on_fileopen'):
os.chdir(filedir)
self.controller.set_workdir()
# check for athena projects
if is_athena_project(path):
kwargs = dict(filename=path,
_larch = self.controller.larch,
read_ok_cb=self.onReadAthenaProject_OK)
self.show_subframe('athena_import', AthenaImporter, **kwargs)
else:
kwargs = dict(filename=path,
_larch=self.larch_buffer.larchshell,
last_array_sel = self.last_array_sel,
read_ok_cb=self.onRead_OK)
self.show_subframe('readfile', ColumnDataFileFrame, **kwargs)
def onReadAthenaProject_OK(self, path, namelist):
"""read groups from a list of groups from an athena project file"""
self.larch.eval("_prj = read_athena('{path:s}', do_fft=False, do_bkg=False)".format(path=path))
s = """{group:s} = _prj.{group:s}
{group:s}.datatype = 'xas'
{group:s}.x = {group:s}.xdat = {group:s}.energy
{group:s}.y = {group:s}.ydat = {group:s}.mu
{group:s}.yerr = 1.0
{group:s}.plot_ylabel = 'mu'
{group:s}.plot_xlabel = 'energy'
"""
for gname in namelist:
self.larch.eval(s.format(group=gname))
self.install_group(gname, gname)
self.larch.eval("del _prj")
def onRead_OK(self, script, path, groupname=None, array_sel=None,
overwrite=False):
""" called when column data has been selected and is ready to be used
overwrite: whether to overwrite the current datagroup, as when
editing a datagroup
"""
abort_read = False
filedir, filename = os.path.split(path)
if not overwrite and hasattr(self.larch.symtable, groupname):
newname = file2groupname(filename, symtable=self.larch.symtable)
msg = """Warning: groupname '%s' already used.
Will use groupname '%s' instead """ % (groupname, newname)
dlg = wx.MessageDialog(self, msg, 'Warning',
wx.OK | wx.CANCEL )
abort_read = (wx.ID_OK != dlg.ShowModal())
dlg.Destroy()
groupname = newname
if abort_read:
return
self.larch.eval(script.format(group=groupname, path=path))
if array_sel is not None:
self.last_array_sel = array_sel
self.install_group(groupname, filename)
if len(self.paths2read) > 0 :
path = self.paths2read.pop(0)
path = path.replace('\\', '/')
filedir, filename = os.path.split(path)
gname = file2groupname(filename, symtable=self.larch.symtable)
self.onRead_OK(script, path, groupname=gname)
def install_group(self, groupname, filename):
"""add groupname / filename to list of available data groups"""
thisgroup = getattr(self.larch.symtable, groupname)
thisgroup.groupname = groupname
thisgroup.filename = filename
datatype = getattr(thisgroup, 'datatype', 'raw')
# file /group may already exist in list
if filename in self.controller.file_groups and not overwrite:
for i in range(1, 101):
ftest = "%s (%i)" % (filename, i)
if ftest not in self.controller.file_groups:
filename = ftest
break
if filename not in self.controller.file_groups:
self.controller.filelist.Append(filename)
self.controller.file_groups[filename] = groupname
self.nb.SetSelection(0)
self.ShowFile(groupname=groupname)
def __init__(self, parent, mca, size=(-1, -1), callback=None):
self.mca = mca
self.callback = callback
wx.Frame.__init__(self,
parent,
-1,
'Calibrate MCA',
size=size,
style=wx.DEFAULT_FRAME_STYLE)
opanel = scrolled.ScrolledPanel(self)
osizer = wx.BoxSizer(wx.VERTICAL)
panel = GridPanel(opanel)
self.calib_updated = False
panel.AddText("Calibrate MCA Energy (Energies in eV)",
colour='#880000',
dcol=7)
panel.AddText("ROI", newrow=True, style=CEN)
panel.AddText("Predicted", style=CEN)
panel.AddText("Peaks with Current Calibration", dcol=3, style=CEN)
panel.AddText("Peaks with Refined Calibration", dcol=3, style=CEN)
panel.AddText("Name", newrow=True, style=CEN)
panel.AddText("Energy", style=CEN)
panel.AddText("Center", style=CEN)
panel.AddText("Difference", style=CEN)
panel.AddText("FWHM", style=CEN)
panel.AddText("Center", style=CEN)
panel.AddText("Difference", style=CEN)
panel.AddText("FWHM", style=CEN)
panel.AddText("Use? ", style=CEN)
panel.Add(HLine(panel, size=(700, 3)), dcol=9, newrow=True)
self.wids = []
# find ROI peak positions
self.init_wids = {}
for roi in self.mca.rois:
eknown, ecen, fwhm = 1, 1, 1
words = roi.name.split()
elem = words[0].title()
family = 'ka'
if len(words) > 1:
family = words[1]
try:
eknown = xray_line(elem, family).energy / 1000.0
except (AttributeError, ValueError):
eknown = 0.0001
mid = (roi.right + roi.left) / 2
wid = (roi.right - roi.left) / 2
ecen = mid * mca.slope + mca.offset
fwhm = 2.354820 * wid * mca.slope
diff = ecen - eknown
name = (' ' + roi.name + ' ' * 10)[:10]
opts = {'style': CEN, 'size': (75, -1)}
w_name = SimpleText(panel, name, **opts)
w_pred = SimpleText(panel, "% .1f" % (1000 * eknown), **opts)
w_ccen = SimpleText(panel, "% .1f" % (1000 * ecen), **opts)
w_cdif = SimpleText(panel, "% .1f" % (1000 * diff), **opts)
w_cwid = SimpleText(panel, "% .1f" % (1000 * fwhm), **opts)
w_ncen = SimpleText(panel, "-----", **opts)
w_ndif = SimpleText(panel, "-----", **opts)
w_nwid = SimpleText(panel, "-----", **opts)
w_use = Check(panel, label='', size=(40, -1), default=0)
panel.Add(w_name, style=LEFT, newrow=True)
panel.AddMany((w_pred, w_ccen, w_cdif, w_cwid, w_ncen, w_ndif,
w_nwid, w_use))
self.init_wids[roi.name] = [
False, w_pred, w_ccen, w_cdif, w_cwid, w_use
]
self.wids.append(
(roi.name, eknown, ecen, w_ncen, w_ndif, w_nwid, w_use))
panel.Add(HLine(panel, size=(700, 3)), dcol=9, newrow=True)
offset = 1000.0 * self.mca.offset
slope = 1000.0 * self.mca.slope
panel.AddText("Current Calibration:", dcol=2, newrow=True)
panel.AddText("offset(eV):")
panel.AddText("%.3f" % (offset), dcol=1, style=RIGHT)
panel.AddText("slope(eV/chan):")
panel.AddText("%.3f" % (slope), dcol=1, style=RIGHT)
panel.AddText("Refined Calibration:", dcol=2, newrow=True)
self.new_offset = FloatCtrl(panel,
value=offset,
precision=3,
size=(80, -1))
self.new_slope = FloatCtrl(panel,
value=slope,
precision=3,
size=(80, -1))
panel.AddText("offset(eV):")
panel.Add(self.new_offset, dcol=1, style=RIGHT)
panel.AddText("slope(eV/chan):")
panel.Add(self.new_slope, dcol=1, style=RIGHT)
self.calib_btn = Button(panel,
'Compute Calibration',
size=(175, -1),
action=self.onCalibrate)
self.calib_btn.Disable()
panel.Add(self.calib_btn, dcol=3, newrow=True)
panel.Add(Button(panel,
'Use New Calibration',
size=(175, -1),
action=self.onUseCalib),
dcol=3,
style=RIGHT)
panel.Add(Button(panel, 'Done', size=(125, -1), action=self.onClose),
dcol=2,
style=RIGHT)
panel.pack()
a = panel.GetBestSize()
self.SetSize((a[0] + 25, a[1] + 50))
osizer.Add(panel)
pack(opanel, osizer)
opanel.SetupScrolling()
self.Show()
self.Raise()
self.init_proc = False
self.init_t0 = time.time()
self.init_timer = wx.Timer(self)
self.Bind(wx.EVT_TIMER, self.onInitTimer, self.init_timer)
self.init_timer.Start(2)
def __init__(self, parent, pos=(-1, -1)):
self.parent = parent
self.larch = parent.larch
self.lgroup = parent.lgroup
message = "Edit Column Labels for %s" % self.lgroup.filename
wx.Frame.__init__(self,
None,
-1,
'Edit Column Labels',
style=FRAMESTYLE)
FWID = 600
self.SetFont(Font(10))
sizer = wx.GridBagSizer(10, 5)
panel = scrolled.ScrolledPanel(self)
self.SetMinSize((600, 600))
self.colors = GUIColors()
# title row
title = SimpleText(panel,
message,
font=Font(13),
colour=self.colors.title,
style=LCEN)
sizer.Add(title, (0, 0), (1, 3), LCEN, 5)
ir = 1
sizer.Add(SimpleText(panel, label='Column #', size=(55, -1)), (ir, 0),
(1, 1), LCEN, 2)
sizer.Add(SimpleText(panel, label='Current Label', size=(200, -1)),
(ir, 1), (1, 1), RCEN, 2)
sizer.Add(SimpleText(panel, label='New Label'), (ir, 2), (1, 1), LCEN,
2)
ir += 1
sizer.Add(wx.StaticLine(panel, size=(FWID, 3), style=wx.LI_HORIZONTAL),
(ir, 0), (1, 4), LCEN | wx.GROW | wx.ALL, 3)
self.twids = []
for icol, clab in enumerate(self.lgroup.array_labels):
ix = SimpleText(panel, label='%i' % icol, size=(55, -1))
old = SimpleText(panel, label=clab, size=(200, -1))
new = wx.TextCtrl(panel, -1, value=clab, size=(200, -1))
self.twids.append((clab, new))
ir += 1
sizer.Add(ix, (ir, 0), (1, 1), RCEN, 2)
sizer.Add(old, (ir, 1), (1, 1), LCEN, 2)
sizer.Add(new, (ir, 2), (1, 1), LCEN, 2)
ir += 1
sizer.Add(okcancel(panel, self.onOK, self.onClose), (ir, 0), (1, 2),
LCEN, 3)
ir += 1
sizer.Add(wx.StaticLine(panel, size=(FWID, 3), style=wx.LI_HORIZONTAL),
(ir, 0), (1, 4), LCEN | wx.GROW | wx.ALL, 3)
#
pack(panel, sizer)
ftext = wx.TextCtrl(self,
style=wx.TE_MULTILINE | wx.TE_READONLY,
size=(-1, 275))
try:
m = open(self.lgroup.filename, 'r')
text = m.read()
m.close()
except:
text = "The file '%s'\n was not found" % self.lgroup.filename
ftext.SetValue(text)
ftext.SetFont(Font(9))
mainsizer = wx.BoxSizer(wx.VERTICAL)
mainsizer.Add(panel, 0, wx.GROW | wx.ALL, 2)
mainsizer.Add(ftext, 1, LCEN | wx.GROW, 2)
pack(self, mainsizer)
self.Show()
self.Raise()
def txt(label):
return SimpleText(self, label, size=(120, -1), style=LEFT)
def createDetailsPanel(self, parent):
mainpanel = wx.Panel(parent)
mainsizer = wx.BoxSizer(wx.VERTICAL)
panel = wx.Panel(mainpanel)
sizer = wx.GridBagSizer(8, 7)
self.title = SimpleText(panel, 'initializing...')
ir = 0
sizer.Add(self.title, (ir, 0), (1, 6), LCEN, 2)
# x-axis
self.xarr = Choice(panel,
choices=[],
action=self.onColumnChoices,
size=(120, -1))
self.xop = Choice(panel,
choices=('', 'log'),
action=self.onColumnChoices,
size=(90, -1))
ir += 1
sizer.Add(SimpleText(panel, 'X = '), (ir, 0), (1, 1), CEN, 0)
sizer.Add(self.xop, (ir, 1), (1, 1), CEN, 0)
sizer.Add(SimpleText(panel, '('), (ir, 2), (1, 1), CEN, 0)
sizer.Add(self.xarr, (ir, 3), (1, 1), RCEN, 0)
sizer.Add(SimpleText(panel, ')'), (ir, 4), (1, 1), CEN, 0)
self.yops = []
self.yarr = []
opts = {
'choices': [],
'size': (120, -1),
'action': self.onColumnChoices
}
for i in range(3):
self.yarr.append(Choice(panel, **opts))
for opts, sel, siz in ((PRE_OPS, 0, 90), (ARR_OPS, 3, 50), (ARR_OPS, 3,
50)):
w1 = Choice(panel,
choices=opts,
action=self.onColumnChoices,
size=(siz, -1))
w1.SetSelection(sel)
self.yops.append(w1)
ir += 1
label = 'Y = '
sizer.Add(SimpleText(panel, label), (ir, 0), (1, 1), CEN, 0)
sizer.Add(self.yops[0], (ir, 1), (1, 1), CEN, 0)
sizer.Add(SimpleText(panel, '[('), (ir, 2), (1, 1), CEN, 0)
sizer.Add(self.yarr[0], (ir, 3), (1, 1), CEN, 0)
sizer.Add(self.yops[1], (ir, 4), (1, 1), CEN, 0)
sizer.Add(self.yarr[1], (ir, 5), (1, 1), CEN, 0)
sizer.Add(SimpleText(panel, ')'), (ir, 6), (1, 1), LCEN, 0)
ir += 1
sizer.Add(self.yops[2], (ir, 4), (1, 1), CEN, 0)
sizer.Add(self.yarr[2], (ir, 5), (1, 1), CEN, 0)
sizer.Add(SimpleText(panel, ']'), (ir, 6), (1, 1), LCEN, 0)
self.use_deriv = Check(panel,
default=False,
label='Use Derivative?',
action=self.onColumnChoices)
self.dtcorr = Check(panel,
default=True,
label='correct deadtime?',
action=self.onColumnChoices)
ir += 1
sizer.Add(self.use_deriv, (ir, 0), (1, 3), LCEN, 0)
sizer.Add(self.dtcorr, (ir, 3), (1, 3), LCEN, 0)
pack(panel, sizer)
self.nb = flat_nb.FlatNotebook(mainpanel, -1, agwStyle=FNB_STYLE)
self.nb.SetTabAreaColour(wx.Colour(248, 248, 240))
self.nb.SetActiveTabColour(wx.Colour(254, 254, 195))
self.nb.SetNonActiveTabTextColour(wx.Colour(40, 40, 180))
self.nb.SetActiveTabTextColour(wx.Colour(80, 0, 0))
self.xas_panel = self.CreateXASPanel(self.nb) # mainpanel)
self.fit_panel = self.CreateFitPanel(self.nb) # mainpanel)
self.nb.AddPage(self.fit_panel, ' General Analysis ', True)
self.nb.AddPage(self.xas_panel, ' XAS Processing ', True)
mainsizer.Add(panel, 0, LCEN | wx.EXPAND, 2)
btnbox = wx.Panel(mainpanel)
btnsizer = wx.BoxSizer(wx.HORIZONTAL)
for ttl, opt in (('New Plot', 'new'), ('Over Plot (left)', 'left'),
('Over Plot (right)', 'right')):
btnsizer.Add(
Button(btnbox,
ttl,
size=(135, -1),
action=partial(self.onPlot, opt=opt)), LCEN, 1)
pack(btnbox, btnsizer)
mainsizer.Add(btnbox, 0, LCEN, 2)
mainsizer.Add(self.nb, 1, LCEN | wx.EXPAND, 2)
pack(mainpanel, mainsizer)
return mainpanel
class ScanViewerFrame(wx.Frame):
_about = """Scan 2D Plotter
Matt Newville <newville @ cars.uchicago.edu>
"""
def __init__(self, _larch=None, **kws):
wx.Frame.__init__(self, None, -1, style=FRAMESTYLE)
self.file_groups = {}
self.file_paths = []
title = "Column Data File Viewer"
self.larch = _larch
self.larch_buffer = None
self.subframes = {}
self.plotframe = None
self.groupname = None
self.SetTitle(title)
self.SetSize((850, 650))
self.SetFont(Font(10))
self.config = {'chdir_on_fileopen': True}
self.createMainPanel()
self.createMenus()
self.statusbar = self.CreateStatusBar(2, 0)
self.statusbar.SetStatusWidths([-3, -1])
statusbar_fields = ["Initializing....", " "]
for i in range(len(statusbar_fields)):
self.statusbar.SetStatusText(statusbar_fields[i], i)
read_workdir('scanviewer.dat')
def createMainPanel(self):
splitter = wx.SplitterWindow(self, style=wx.SP_LIVE_UPDATE)
splitter.SetMinimumPaneSize(225)
self.filelist = wx.ListBox(splitter)
self.filelist.SetBackgroundColour(wx.Colour(255, 255, 255))
self.filelist.Bind(wx.EVT_LISTBOX, self.ShowFile)
self.detailspanel = self.createDetailsPanel(splitter)
splitter.SplitVertically(self.filelist, self.detailspanel, 1)
wx.CallAfter(self.init_larch)
def createDetailsPanel(self, parent):
mainpanel = wx.Panel(parent)
mainsizer = wx.BoxSizer(wx.VERTICAL)
panel = wx.Panel(mainpanel)
sizer = wx.GridBagSizer(8, 7)
self.title = SimpleText(panel, 'initializing...')
ir = 0
sizer.Add(self.title, (ir, 0), (1, 6), LCEN, 2)
# x-axis
self.xarr = Choice(panel,
choices=[],
action=self.onColumnChoices,
size=(120, -1))
self.xop = Choice(panel,
choices=('', 'log'),
action=self.onColumnChoices,
size=(90, -1))
ir += 1
sizer.Add(SimpleText(panel, 'X = '), (ir, 0), (1, 1), CEN, 0)
sizer.Add(self.xop, (ir, 1), (1, 1), CEN, 0)
sizer.Add(SimpleText(panel, '('), (ir, 2), (1, 1), CEN, 0)
sizer.Add(self.xarr, (ir, 3), (1, 1), RCEN, 0)
sizer.Add(SimpleText(panel, ')'), (ir, 4), (1, 1), CEN, 0)
self.yops = []
self.yarr = []
opts = {
'choices': [],
'size': (120, -1),
'action': self.onColumnChoices
}
for i in range(3):
self.yarr.append(Choice(panel, **opts))
for opts, sel, siz in ((PRE_OPS, 0, 90), (ARR_OPS, 3, 50), (ARR_OPS, 3,
50)):
w1 = Choice(panel,
choices=opts,
action=self.onColumnChoices,
size=(siz, -1))
w1.SetSelection(sel)
self.yops.append(w1)
ir += 1
label = 'Y = '
sizer.Add(SimpleText(panel, label), (ir, 0), (1, 1), CEN, 0)
sizer.Add(self.yops[0], (ir, 1), (1, 1), CEN, 0)
sizer.Add(SimpleText(panel, '[('), (ir, 2), (1, 1), CEN, 0)
sizer.Add(self.yarr[0], (ir, 3), (1, 1), CEN, 0)
sizer.Add(self.yops[1], (ir, 4), (1, 1), CEN, 0)
sizer.Add(self.yarr[1], (ir, 5), (1, 1), CEN, 0)
sizer.Add(SimpleText(panel, ')'), (ir, 6), (1, 1), LCEN, 0)
ir += 1
sizer.Add(self.yops[2], (ir, 4), (1, 1), CEN, 0)
sizer.Add(self.yarr[2], (ir, 5), (1, 1), CEN, 0)
sizer.Add(SimpleText(panel, ']'), (ir, 6), (1, 1), LCEN, 0)
self.use_deriv = Check(panel,
default=False,
label='Use Derivative?',
action=self.onColumnChoices)
self.dtcorr = Check(panel,
default=True,
label='correct deadtime?',
action=self.onColumnChoices)
ir += 1
sizer.Add(self.use_deriv, (ir, 0), (1, 3), LCEN, 0)
sizer.Add(self.dtcorr, (ir, 3), (1, 3), LCEN, 0)
pack(panel, sizer)
self.nb = flat_nb.FlatNotebook(mainpanel, -1, agwStyle=FNB_STYLE)
self.nb.SetTabAreaColour(wx.Colour(248, 248, 240))
self.nb.SetActiveTabColour(wx.Colour(254, 254, 195))
self.nb.SetNonActiveTabTextColour(wx.Colour(40, 40, 180))
self.nb.SetActiveTabTextColour(wx.Colour(80, 0, 0))
self.xas_panel = self.CreateXASPanel(self.nb) # mainpanel)
self.fit_panel = self.CreateFitPanel(self.nb) # mainpanel)
self.nb.AddPage(self.fit_panel, ' General Analysis ', True)
self.nb.AddPage(self.xas_panel, ' XAS Processing ', True)
mainsizer.Add(panel, 0, LCEN | wx.EXPAND, 2)
btnbox = wx.Panel(mainpanel)
btnsizer = wx.BoxSizer(wx.HORIZONTAL)
for ttl, opt in (('New Plot', 'new'), ('Over Plot (left)', 'left'),
('Over Plot (right)', 'right')):
btnsizer.Add(
Button(btnbox,
ttl,
size=(135, -1),
action=partial(self.onPlot, opt=opt)), LCEN, 1)
pack(btnbox, btnsizer)
mainsizer.Add(btnbox, 0, LCEN, 2)
mainsizer.Add(self.nb, 1, LCEN | wx.EXPAND, 2)
pack(mainpanel, mainsizer)
return mainpanel
def CreateFitPanel(self, parent):
panel = wx.Panel(parent)
tpan = wx.Panel(panel)
self.fit_model = Choice(tpan,
size=(100, -1),
choices=('Gaussian', 'Lorentzian', 'Voigt',
'Linear', 'Quadratic', 'Step',
'Rectangle', 'Exponential'))
self.fit_bkg = Choice(tpan,
size=(100, -1),
choices=('None', 'constant', 'linear',
'quadratic'))
self.fit_step = Choice(tpan,
size=(100, -1),
choices=('linear', 'error function', 'arctan'))
tsizer = wx.GridBagSizer(10, 4)
tsizer.Add(SimpleText(tpan, 'Fit Model: '), (0, 0), (1, 1), LCEN)
tsizer.Add(self.fit_model, (0, 1), (1, 1), LCEN)
tsizer.Add(SimpleText(tpan, 'Background: '), (0, 2), (1, 1), LCEN)
tsizer.Add(self.fit_bkg, (0, 3), (1, 1), LCEN)
tsizer.Add(
Button(tpan, 'Show Fit', size=(100, -1), action=self.onFitPeak),
(1, 1), (1, 1), LCEN)
tsizer.Add(SimpleText(tpan, 'Step Form: '), (1, 2), (1, 1), LCEN)
tsizer.Add(self.fit_step, (1, 3), (1, 1), LCEN)
pack(tpan, tsizer)
self.fit_report = RichTextCtrl(panel,
size=(525, 250),
style=wx.VSCROLL | wx.NO_BORDER)
self.fit_report.SetEditable(False)
self.fit_report.SetFont(Font(9))
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(tpan, 0, wx.GROW | wx.ALL, 2)
sizer.Add(self.fit_report, 1, LCEN | wx.GROW, 2)
pack(panel, sizer)
return panel
def InitializeXASPanel(self):
if self.groupname is None:
lgroup = None
lgroup = getattr(self.larch.symtable, self.groupname)
self.xas_e0.SetValue(getattr(lgroup, 'e0', 0))
self.xas_step.SetValue(getattr(lgroup, 'edge_step', 0))
self.xas_pre1.SetValue(getattr(lgroup, 'pre1', -200))
self.xas_pre2.SetValue(getattr(lgroup, 'pre2', -30))
self.xas_nor1.SetValue(getattr(lgroup, 'norm1', 50))
self.xas_nor2.SetValue(getattr(lgroup, 'norm2', -10))
self.xas_vict.SetSelection(getattr(lgroup, 'nvict', 1))
self.xas_nnor.SetSelection(getattr(lgroup, 'nnorm', 2))
def CreateXASPanel(self, parent):
p = panel = wx.Panel(parent)
self.xas_autoe0 = Check(panel, default=True, label='auto?')
self.xas_showe0 = Check(panel, default=True, label='show?')
self.xas_autostep = Check(panel, default=True, label='auto?')
self.xas_op = Choice(
panel,
size=(225, -1),
choices=('Raw Data', 'Normalized', 'Derivative',
'Normalized + Derivative', 'Pre-edge subtracted',
'Raw Data With Pre-edge/Post-edge Curves'),
action=self.onXASChoice)
opts = {
'size': (95, -1),
'precision': 3
} # , 'action': self.onXASChoice}
self.xas_e0 = FloatCtrl(panel, value=0, **opts)
self.xas_step = FloatCtrl(panel, value=0, **opts)
opts['precision'] = 1
self.xas_pre1 = FloatCtrl(panel, value=-200, **opts)
self.xas_pre2 = FloatCtrl(panel, value=-30, **opts)
self.xas_nor1 = FloatCtrl(panel, value=50, **opts)
self.xas_nor2 = FloatCtrl(panel, value=-50, **opts)
opts = {
'size': (50, -1),
'choices': ('0', '1', '2', '3'),
'action': self.onXASChoice
}
self.xas_vict = Choice(panel, **opts)
self.xas_nnor = Choice(panel, **opts)
self.xas_vict.SetSelection(1)
self.xas_nnor.SetSelection(2)
sizer = wx.GridBagSizer(10, 4)
sizer.Add(SimpleText(p, 'Plot XAS as: '), (0, 0), (1, 1), LCEN)
sizer.Add(SimpleText(p, 'E0 : '), (1, 0), (1, 1), LCEN)
sizer.Add(SimpleText(p, 'Edge Step: '), (2, 0), (1, 1), LCEN)
sizer.Add(SimpleText(p, 'Pre-edge range: '), (3, 0), (1, 1), LCEN)
sizer.Add(SimpleText(p, 'Normalization range: '), (4, 0), (1, 1), LCEN)
sizer.Add(self.xas_op, (0, 1), (1, 3), LCEN)
sizer.Add(self.xas_e0, (1, 1), (1, 1), LCEN)
sizer.Add(self.xas_step, (2, 1), (1, 1), LCEN)
sizer.Add(self.xas_pre1, (3, 1), (1, 1), LCEN)
sizer.Add(SimpleText(p, ':'), (3, 2), (1, 1), LCEN)
sizer.Add(self.xas_pre2, (3, 3), (1, 1), LCEN)
sizer.Add(self.xas_nor1, (4, 1), (1, 1), LCEN)
sizer.Add(SimpleText(p, ':'), (4, 2), (1, 1), LCEN)
sizer.Add(self.xas_nor2, (4, 3), (1, 1), LCEN)
sizer.Add(self.xas_autoe0, (1, 2), (1, 2), LCEN)
sizer.Add(self.xas_showe0, (1, 4), (1, 2), LCEN)
sizer.Add(self.xas_autostep, (2, 2), (1, 2), LCEN)
sizer.Add(SimpleText(p, 'Victoreen:'), (3, 4), (1, 1), LCEN)
sizer.Add(self.xas_vict, (3, 5), (1, 1), LCEN)
sizer.Add(SimpleText(p, 'PolyOrder:'), (4, 4), (1, 1), LCEN)
sizer.Add(self.xas_nnor, (4, 5), (1, 1), LCEN)
pack(panel, sizer)
return panel
def onFitPeak(self, evt=None):
gname = self.groupname
dtext = []
model = self.fit_model.GetStringSelection().lower()
dtext.append('Fit Model: %s' % model)
bkg = self.fit_bkg.GetStringSelection()
if bkg == 'None':
bkg = None
if bkg is None:
dtext.append('No Background')
else:
dtext.append('Background: %s' % bkg)
step = self.fit_step.GetStringSelection().lower()
if model in ('step', 'rectangle'):
dtext.append('Step form: %s' % step)
try:
lgroup = getattr(self.larch.symtable, gname)
x = lgroup._xdat_
y = lgroup._ydat_
except AttributeError:
self.write_message('need data to fit!')
return
if step.startswith('error'):
step = 'erf'
elif step.startswith('arctan'):
step = 'atan'
pgroup = fit_peak(x,
y,
model,
background=bkg,
step=step,
_larch=self.larch)
dtext = '\n'.join(dtext)
dtext = '%s\n%s\n' % (
dtext, fit_report(
pgroup.params, min_correl=0.25, _larch=self.larch))
self.fit_report.SetEditable(True)
self.fit_report.SetValue(dtext)
self.fit_report.SetEditable(False)
popts1 = dict(style='solid', linewidth=3, marker='None', markersize=4)
popts2 = dict(style='short dashed',
linewidth=2,
marker='None',
markersize=4)
lgroup.plot_yarrays = [(lgroup._ydat_, popts1, lgroup.plot_ylabel)]
if bkg is None:
lgroup._fit = pgroup.fit[:]
lgroup.plot_yarrays.append((lgroup._fit, popts2, 'fit'))
else:
lgroup._fit = pgroup.fit[:]
lgroup._fit_bgr = pgroup.bkg[:]
lgroup.plot_yarrays.append((lgroup._fit, popts2, 'fit'))
lgroup.plot_yarrays.append((lgroup._fit_bgr, popts2, 'background'))
self.onPlot()
def xas_process(self, gname, new_mu=False, **kws):
""" process (pre-edge/normalize) XAS data from XAS form, overwriting
larch group '_y1_' attribute to be plotted
"""
out = self.xas_op.GetStringSelection().lower() # raw, pre, norm, flat
preopts = {'group': gname, 'e0': None}
lgroup = getattr(self.larch.symtable, gname)
dtcorr = self.dtcorr.IsChecked()
if new_mu:
try:
del lgroup.e0, lgroup.edge_step
except:
pass
if not self.xas_autoe0.IsChecked():
e0 = self.xas_e0.GetValue()
if e0 < max(lgroup._xdat_) and e0 > min(lgroup._xdat_):
preopts['e0'] = e0
if not self.xas_autostep.IsChecked():
preopts['step'] = self.xas_step.GetValue()
dt = debugtime()
preopts['pre1'] = self.xas_pre1.GetValue()
preopts['pre2'] = self.xas_pre2.GetValue()
preopts['norm1'] = self.xas_nor1.GetValue()
preopts['norm2'] = self.xas_nor2.GetValue()
preopts['nvict'] = self.xas_vict.GetSelection()
preopts['nvict'] = self.xas_vict.GetSelection()
preopts['nnorm'] = self.xas_nnor.GetSelection()
preopts['make_flat'] = 'False'
preopts['group'] = gname
preopts = ", ".join(["%s=%s" % (k, v) for k, v in preopts.items()])
preedge_cmd = "pre_edge(%s._xdat_, %s._ydat_, %s)"
self.larch(preedge_cmd % (gname, gname, preopts))
if self.xas_autoe0.IsChecked():
self.xas_e0.SetValue(lgroup.e0)
if self.xas_autostep.IsChecked():
self.xas_step.SetValue(lgroup.edge_step)
details_group = lgroup
try:
details_group = lgroup.pre_edge_details
except:
pass
self.xas_pre1.SetValue(details_group.pre1)
self.xas_pre2.SetValue(details_group.pre2)
self.xas_nor1.SetValue(details_group.norm1)
self.xas_nor2.SetValue(details_group.norm2)
popts1 = dict(style='solid', linewidth=3, marker='None', markersize=4)
popts2 = dict(style='short dashed',
linewidth=2,
zorder=-5,
marker='None',
markersize=4)
poptsd = dict(style='solid',
linewidth=2,
zorder=-5,
side='right',
y2label='derivative',
marker='None',
markersize=4)
lgroup.plot_yarrays = [(lgroup._ydat_, popts1, lgroup.plot_ylabel)]
y4e0 = lgroup._ydat_
if out.startswith('raw data with'):
lgroup.plot_yarrays = [(lgroup._ydat_, popts1, lgroup.plot_ylabel),
(lgroup.pre_edge, popts2, 'pre edge'),
(lgroup.post_edge, popts2, 'post edge')]
elif out.startswith('pre'):
self.larch('%s.pre_edge_sub = %s.norm * %s.edge_step' %
(gname, gname, gname))
lgroup.plot_yarrays = [(lgroup.pre_edge_sub, popts1,
'pre edge subtracted XAFS')]
y4e0 = lgroup.pre_edge_sub
elif 'norm' in out and 'deriv' in out:
lgroup.plot_yarrays = [(lgroup.norm, popts1, 'normalized XAFS'),
(lgroup.dmude, poptsd, 'derivative')]
y4e0 = lgroup.norm
elif out.startswith('norm'):
lgroup.plot_yarrays = [(lgroup.norm, popts1, 'normalized XAFS')]
y4e0 = lgroup.norm
elif out.startswith('deriv'):
lgroup.plot_yarrays = [(lgroup.dmude, popts1, 'derivative')]
y4e0 = lgroup.dmude
lgroup.plot_ymarkers = []
if self.xas_showe0.IsChecked():
ie0 = index_of(lgroup._xdat_, lgroup.e0)
lgroup.plot_ymarkers = [(lgroup.e0, y4e0[ie0], {'label': 'e0'})]
return
def init_larch(self):
t0 = time.time()
if self.larch is None:
self.larch = Interpreter()
self.larch.symtable.set_symbol('_sys.wx.wxapp', wx.GetApp())
self.larch.symtable.set_symbol('_sys.wx.parent', self)
self.SetStatusText('ready')
self.datagroups = self.larch.symtable
self.title.SetLabel('')
def write_message(self, s, panel=0):
"""write a message to the Status Bar"""
self.SetStatusText(s, panel)
def get_data(self, group, arrayname, correct=False):
if hasattr(group, 'get_data'):
return group.get_data(arrayname, correct=correct)
return getattr(group, arrayname, None)
def onXASChoice(self, evt=None, **kws):
if self.groupname is None:
return
self.xas_process(self.groupname, **kws)
self.onPlot()
def onColumnChoices(self, evt=None):
"""column selections changed ..
recalculate _xdat_ and _ydat_
arrays for this larch group"""
dtcorr = self.dtcorr.IsChecked()
use_deriv = self.use_deriv.IsChecked()
ix = self.xarr.GetSelection()
x = self.xarr.GetStringSelection()
xop = self.xop.GetStringSelection()
op1 = self.yops[0].GetStringSelection()
op2 = self.yops[1].GetStringSelection()
op3 = self.yops[2].GetStringSelection()
y1 = self.yarr[0].GetStringSelection()
y2 = self.yarr[1].GetStringSelection()
y3 = self.yarr[2].GetStringSelection()
array_sel = {
'xop': xop,
'xarr': x,
'op1': op1,
'op2': op2,
'op3': op3,
'y1': y1,
'y2': y2,
'y3': y3,
'dtcorr': dtcorr,
'use_deriv': use_deriv
}
try:
gname = self.groupname
lgroup = getattr(self.larch.symtable, gname)
except:
gname = SCANGROUP
lgroup = getattr(self.larch.symtable, gname)
xlabel = x
try:
xunits = lgroup.array_units[ix]
except:
xunits = ''
if xop != '':
xlabel = "%s(%s)" % (xop, xlabel)
if xunits != '':
xlabel = '%s (%s)' % (xlabel, xunits)
ylabel = y1
if y2 == '':
y2, op2 = '1.0', '*'
else:
ylabel = "%s%s%s" % (ylabel, op2, y2)
if y3 == '':
y3, op3 = '1.0', '*'
else:
ylabel = "(%s)%s%s" % (ylabel, op3, y3)
if op1 != '':
ylabel = "%s(%s)" % (op1, ylabel)
if y1 in ('0.0', '1.0'):
y1 = float(yl1)
else:
y1 = self.get_data(lgroup, y1, correct=dtcorr)
if y2 in ('0.0', '1.0'):
y2 = float(y2)
if op2 == '/': y2 = 1.0
else:
y2 = self.get_data(lgroup, y2, correct=dtcorr)
if y3 in ('0.0', '1.0'):
y3 = float(y3)
if op3 == '/': y3 = 1.0
else:
y3 = self.get_data(lgroup, y3, correct=dtcorr)
if x not in ('0', '1'):
x = self.get_data(lgroup, x)
lgroup._x = x
lgroup._y1 = y1
lgroup._y2 = y2
lgroup._y3 = y3
self.larch("%s._xdat_ = %s(%s._x)" % (gname, xop, gname))
try:
yexpr = "%s._ydat_ = %s((%s._y1 %s %s._y2) %s %s._y3)" % (
gname, op1, gname, op2, gname, op3, gname)
self.larch(yexpr)
except RuntimeWarning:
self.larch("%s._ydat_ = %s._y1")
try:
if use_deriv:
d_calc = "%s._ydat_ = gradient(%s._ydat_)/gradient(%s._xdat_)"
self.larch(d_calc % (gname, gname, gname))
except:
pass
try:
npts = min(len(lgroup._xdat_), len(lgroup._ydat_))
except AttributeError:
print('Error calculating arrays (npts not correct)')
return
del lgroup._x, lgroup._y1, lgroup._y2, lgroup._y3
lgroup.array_sel = array_sel
lgroup.plot_xlabel = xlabel
lgroup.plot_ylabel = ylabel
lgroup._xdat_ = np.array(lgroup._xdat_[:npts])
lgroup._ydat_ = np.array(lgroup._ydat_[:npts])
if (self.nb.GetCurrentPage() == self.xas_panel):
self.xas_process(self.groupname, new_mu=True)
else:
lgroup.plot_yarrays = [(lgroup._ydat_, {}, None)]
def onPlot(self, evt=None, opt='new', npts=None, reprocess=False):
try:
self.plotframe.Show()
except: # wx.PyDeadObjectError
self.plotframe = PlotFrame(None, size=(650, 400))
self.plotframe.Show()
self.plotpanel = self.plotframe.panel
if reprocess:
if (self.nb.GetCurrentPage() == self.xas_panel):
self.xas_process(self.groupname, new_mu=True)
side = 'left'
update = False
plotcmd = self.plotpanel.plot
if opt in ('left', 'right'):
side = opt
plotcmd = self.plotpanel.oplot
elif opt == 'update' and npts > 4:
plotcmd = self.plotpanel.update_line
update = True
if 'new' in opt:
self.plotpanel.clear()
popts = {'side': side}
try:
gname = self.groupname
lgroup = getattr(self.larch.symtable, gname)
except:
gname = SCANGROUP
lgroup = getattr(self.larch.symtable, gname)
return
if not hasattr(lgroup, '_xdat_'):
self.onColumnChoices()
lgroup._xdat_ = np.array(lgroup._xdat_[:npts])
plot_yarrays = [(lgroup._ydat_, {}, None)]
if hasattr(lgroup, 'plot_yarrays'):
plot_yarrays = lgroup.plot_yarrays
#for yarr in plot_yarrays:
# yarr = np.array(yarr[:npts])
path, fname = os.path.split(lgroup.filename)
popts['label'] = "%s: %s" % (fname, lgroup.plot_ylabel)
if side == 'right':
popts['y2label'] = lgroup.plot_ylabel
else:
popts['ylabel'] = lgroup.plot_ylabel
if plotcmd == self.plotpanel.plot:
popts['title'] = fname
if update:
self.plotpanel.set_xlabel(lgroup.plot_xlabel)
self.plotpanel.set_ylabel(lgroup.plot_ylabel)
for itrace, yarr, label in enumerate(plot_yarrays):
plotcmd(itrace,
lgroup._xdat_,
yarr[0],
draw=True,
update_limits=((npts < 5) or (npts % 5 == 0)),
**yarr[1])
self.plotpanel.set_xylims(
(min(lgroup._xdat_), max(lgroup._xdat_), min(yarr),
max(yarr)))
else:
for yarr in plot_yarrays:
popts.update(yarr[1])
if yarr[2] is not None:
popts['label'] = yarr[2]
plotcmd(lgroup._xdat_, yarr[0], **popts)
plotcmd = self.plotpanel.oplot
if hasattr(lgroup, 'plot_ymarkers'):
for x, y, opts in lgroup.plot_ymarkers:
popts = {'marker': 'o', 'markersize': 4}
popts.update(opts)
self.plotpanel.oplot([x], [y], **popts)
self.plotpanel.canvas.draw()
def onShowLarchBuffer(self, evt=None):
if self.larch_buffer is None:
self.larch_buffer = larchframe.LarchFrame(_larch=self.larch)
self.larch_buffer.Show()
self.larch_buffer.Raise()
def ShowFile(self, evt=None, groupname=None, **kws):
if groupname is None and evt is not None:
fpath = self.file_paths[evt.GetInt()]
groupname = self.file_groups[fpath]
if not hasattr(self.datagroups, groupname):
print('Error reading file ', groupname)
return
self.groupname = groupname
self.lgroup = getattr(self.datagroups, groupname, None)
if groupname == SCANGROUP:
self.lgroup.filename = filename
elif self.lgroup is not None:
if hasattr(self.lgroup, 'array_labels'):
array_labels = self.lgroup.array_labels[:]
elif hasattr(self.lgroup, 'column_labels'):
array_labels = self.lgroup.column_labels[:]
else:
array_labels = []
for attr in dir(self.lgroup):
if isinstance(getattr(self.lgroup, attr), np.ndarray):
array_labels.append(attr)
self.lgroup.array_labels = array_labels
self.set_array_labels()
if hasattr(self.lgroup, 'array_sel'):
sel = self.lgroup.array_sel
try:
self.xarr.SetStringSelection(sel['xarr'])
self.xop.SetStringSelection(sel['xop'])
self.yops[0].SetStringSelection(sel['op1'])
self.yops[1].SetStringSelection(sel['op2'])
self.yops[2].SetStringSelection(sel['op3'])
self.yarr[0].SetStringSelection(sel['y1'])
self.yarr[1].SetStringSelection(sel['y2'])
self.yarr[2].SetStringSelection(sel['y3'])
self.dtcorr.SetValue({True: 1, False: 0}[sel['dtcorr']])
self.use_deriv.SetValue({
True: 1,
False: 0
}[sel['use_deriv']])
except:
pass
def set_array_labels(self, labels=None):
"""set choices for array dropdowns from array labels"""
array_labels = self.lgroup.array_labels
xcols = array_labels[:]
ycols = array_labels[:]
y2cols = array_labels[:] + ['1.0', '0.0', '']
ncols = len(xcols)
self.title.SetLabel(self.lgroup.filename)
_xarr = self.xarr.GetStringSelection()
if len(_xarr) < 1 or _xarr not in xcols:
_xarr = xcols[0]
_yarr = [[], [], []]
for j in range(3):
_yarr[j] = self.yarr[j].GetStringSelection()
if _yarr[j] not in ycols:
_yarr[j] = ''
self.xarr.SetItems(xcols)
self.xarr.SetStringSelection(_xarr)
for j in range(3):
if j == 0:
self.yarr[j].SetItems(ycols)
if _yarr[j] in ycols and len(_yarr[j]) > 0:
self.yarr[j].SetStringSelection(_yarr[j])
elif ycols[0] == _xarr and len(ycols) > 1:
self.yarr[j].SetStringSelection(ycols[1])
else:
self.yarr[j].SetItems(y2cols)
self.yarr[j].SetStringSelection(_yarr[j])
inb = 0
for colname in xcols:
if 'energ' in colname.lower():
inb = 1
self.nb.SetSelection(inb)
if inb == 1:
self.InitializeXASPanel()
def createMenus(self):
# ppnl = self.plotpanel
self.menubar = wx.MenuBar()
#
fmenu = wx.Menu()
MenuItem(self, fmenu, "&Open Data File\tCtrl+O", "Read Scan File",
self.onReadScan)
MenuItem(self, fmenu, "Show Larch Buffer",
"Show Larch Programming Buffer", self.onShowLarchBuffer)
fmenu.AppendSeparator()
MenuItem(self, fmenu, "&Quit\tCtrl+Q", "Quit program", self.onClose)
self.menubar.Append(fmenu, "&File")
omenu = wx.Menu()
MenuItem(self, omenu, "Edit Column Labels\tCtrl+E",
"Edit Column Labels", self.onEditColumnLabels)
self.menubar.Append(omenu, "Options")
# fmenu.AppendSeparator()
# MenuItem(self, fmenu, "&Copy\tCtrl+C",
# "Copy Figure to Clipboard", self.onClipboard)
# MenuItem(self, fmenu, "&Save\tCtrl+S", "Save Figure", self.onSaveFig)
# MenuItem(self, fmenu, "&Print\tCtrl+P", "Print Figure", self.onPrint)
# MenuItem(self, fmenu, "Page Setup", "Print Page Setup", self.onPrintSetup)
# MenuItem(self, fmenu, "Preview", "Print Preview", self.onPrintPreview)
#
#MenuItem(self, pmenu, "Unzoom\tCtrl+Z", "Unzoom Plot", self.onUnzoom)
##pmenu.AppendSeparator()
#MenuItem(self, pmenu, "Toggle Legend\tCtrl+L",
# "Toggle Legend on Plot", self.onToggleLegend)
#MenuItem(self, pmenu, "Toggle Grid\tCtrl+G",
# "Toggle Grid on Plot", self.onToggleGrid)
# self.menubar.Append(pmenu, "Plot Options")
self.SetMenuBar(self.menubar)
self.Bind(wx.EVT_CLOSE, self.onClose)
def onAbout(self, evt):
dlg = wx.MessageDialog(self, self._about, "About Epics StepScan",
wx.OK | wx.ICON_INFORMATION)
dlg.ShowModal()
dlg.Destroy()
def onClose(self, evt):
save_workdir('scanviewer.dat')
try:
self.plotframe.Destroy()
except:
pass
if self.larch_buffer is not None:
try:
self.larch_buffer.onClose()
except:
pass
for nam in dir(self.larch.symtable._sys.wx):
obj = getattr(self.larch.symtable._sys.wx, nam)
del obj
self.Destroy()
def show_subframe(self, name, frameclass):
shown = False
if name in self.subframes:
try:
self.subframes[name].Raise()
shown = True
except:
del self.subframes[name]
if not shown:
self.subframes[name] = frameclass(self)
def onEditColumnLabels(self, evt=None):
self.show_subframe('coledit', EditColumnFrame)
def onReadScan(self, evt=None):
dlg = wx.FileDialog(self,
message="Load Column Data File",
defaultDir=os.getcwd(),
wildcard=FILE_WILDCARDS,
style=wx.FD_OPEN)
if dlg.ShowModal() == wx.ID_OK:
path = dlg.GetPath()
path = path.replace('\\', '/')
if path in self.file_groups:
if wx.ID_YES != popup(self, "Re-read file '%s'?" % path,
'Re-read file?'):
return
gname = '_sview0001'
count, maxcount = 1, 9999
while hasattr(self.datagroups, gname) and count < maxcount:
count += 1
gname = '_sview%4.4i' % count
if hasattr(self.datagroups, gname):
gname = randname()
parent, fname = os.path.split(path)
if self.config['chdir_on_fileopen']:
os.chdir(parent)
fh = open(path, 'r')
line1 = fh.readline().lower()
fh.close()
reader = 'read_ascii'
if 'epics scan' in line1:
reader = 'read_gsescan'
elif 'xdi' in line1:
reader = 'read_xdi'
if 'epics stepscan file' in line1:
reader = 'read_gsexdi'
self.larch("%s = %s('%s')" % (gname, reader, path))
self.larch("%s.path = '%s'" % (gname, path))
self.filelist.Append(fname)
self.file_paths.append(path)
self.file_groups[path] = gname
self.ShowFile(groupname=gname)
dlg.Destroy()
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 createMainPanel(self):
splitter = wx.SplitterWindow(self, style=wx.SP_LIVE_UPDATE)
splitter.SetMinimumPaneSize(250)
leftpanel = wx.Panel(splitter)
ltop = wx.Panel(leftpanel)
def Btn(msg, x, act):
b = Button(ltop, msg, size=(x, 30), action=act)
b.SetFont(Font(10))
return b
plot_one = Btn('Plot One', 120, self.onPlotOne)
plot_sel = Btn('Plot Selected', 120, self.onPlotSel)
sel_none = Btn('Select None', 120, self.onSelNone)
sel_all = Btn('Select All', 120, self.onSelAll)
self.controller.filelist = FileCheckList(leftpanel, main=self,
select_action=self.ShowFile,
remove_action=self.RemoveFile)
self.controller.filelist.SetBackgroundColour(wx.Colour(255, 255, 255))
tsizer = wx.GridBagSizer(1, 1)
tsizer.Add(plot_one, (0, 0), (1, 1), LCEN, 2)
tsizer.Add(plot_sel, (0, 1), (1, 1), LCEN, 2)
tsizer.Add(sel_all, (1, 0), (1, 1), LCEN, 2)
tsizer.Add(sel_none, (1, 1), (1, 1), LCEN, 2)
pack(ltop, tsizer)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(ltop, 0, LCEN|wx.GROW, 1)
sizer.Add(self.controller.filelist, 1, LCEN|wx.GROW|wx.ALL, 1)
pack(leftpanel, sizer)
# right hand side
panel = wx.Panel(splitter)
sizer = wx.BoxSizer(wx.VERTICAL)
self.title = SimpleText(panel, 'initializing...', size=(300, -1))
self.title.SetFont(Font(10))
ir = 0
sizer.Add(self.title, 0, LCEN|wx.GROW|wx.ALL, 1)
self.nb = flat_nb.FlatNotebook(panel, -1, agwStyle=FNB_STYLE)
self.nb.SetTabAreaColour(wx.Colour(250,250,250))
self.nb.SetActiveTabColour(wx.Colour(254,254,195))
self.nb.SetNonActiveTabTextColour(wx.Colour(10,10,128))
self.nb.SetActiveTabTextColour(wx.Colour(128,0,0))
panel_opts = dict(parent=self.nb, controller=self.controller)
self.proc_panel = ProcessPanel(**panel_opts)
self.fit_panel = XYFitPanel(**panel_opts)
self.nb.AddPage(self.proc_panel, ' Data Processing ', True)
self.nb.AddPage(self.fit_panel, ' Curve Fitting ', True)
sizer.Add(self.nb, 1, LCEN|wx.EXPAND, 2)
self.nb.SetSelection(0)
pack(panel, sizer)
splitter.SplitVertically(leftpanel, panel, 1)
wx.CallAfter(self.init_larch)
def SLabel(label, size=(80, -1), **kws):
return SimpleText(panel,
label,
size=size,
style=wx.ALIGN_LEFT,
**kws)
def createEpicsPanel(self):
pane = wx.Panel(self, name='epics panel')
psizer = wx.GridBagSizer(4, 12) # wx.BoxSizer(wx.HORIZONTAL)
btnpanel = wx.Panel(pane, name='buttons')
nmca = self.nmca
NPERROW = 6
self.SetFont(Font(9))
if self.det_type.lower().startswith('me-4') and nmca < 5:
btnsizer = wx.GridBagSizer(2, 2)
else:
btnsizer = wx.GridBagSizer(
int((nmca + NPERROW - 2) / (1.0 * NPERROW)), NPERROW)
style = wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL
rstyle = wx.ALIGN_RIGHT | wx.ALIGN_CENTER_VERTICAL
bkg_choices = ['None']
psizer.Add(SimpleText(pane, ' MCAs: '), (0, 0), (1, 1), style, 1)
for i in range(1, 1 + nmca):
bkg_choices.append("%i" % i)
b = Button(btnpanel,
'%i' % i,
size=(30, 25),
action=partial(self.onSelectDet, index=i))
self.wids['det%i' % i] = b
loc = divmod(i - 1, NPERROW)
if self.det_type.lower().startswith('me-4') and nmca < NPERROW - 1:
loc = self.me4_layout[i - 1]
btnsizer.Add(b, loc, (1, 1), style, 1)
pack(btnpanel, btnsizer)
nrows = 1 + loc[0]
if self.det_type.lower().startswith('me-4') and nmca < 5:
nrows = 2
psizer.Add(btnpanel, (0, 1), (nrows, 1), style, 1)
self.wids['det_status'] = SimpleText(pane,
' ',
size=(120, -1),
style=style)
self.wids['deadtime'] = SimpleText(pane,
' ',
size=(120, -1),
style=style)
self.wids['bkg_det'] = Choice(pane,
size=(75, -1),
choices=bkg_choices,
action=self.onSelectDet)
self.wids['dwelltime'] = FloatCtrl(pane,
value=0.0,
precision=1,
minval=0,
size=(80, -1),
act_on_losefocus=True,
action=self.onSetDwelltime)
self.wids['elapsed'] = SimpleText(pane,
' ',
size=(80, -1),
style=style)
b1 = Button(pane, 'Start', size=(90, 25), action=self.onStart)
b2 = Button(pane, 'Stop', size=(90, 25), action=self.onStop)
b3 = Button(pane, 'Erase', size=(90, 25), action=self.onErase)
b4 = Button(pane,
'Continuous',
size=(90, 25),
action=partial(self.onStart, dtime=0))
bkg_lab = SimpleText(pane, 'Background MCA:', size=(150, -1))
pre_lab = SimpleText(pane, 'Preset Time (s):', size=(125, -1))
ela_lab = SimpleText(pane, 'Elapsed Time (s):', size=(125, -1))
sta_lab = SimpleText(pane, 'Status :', size=(100, -1))
dea_lab = SimpleText(pane, '% Deadtime:', size=(100, -1))
psizer.Add(bkg_lab, (0, 2), (1, 1), style, 1)
psizer.Add(self.wids['bkg_det'], (1, 2), (1, 1), style, 1)
psizer.Add(pre_lab, (0, 3), (1, 1), style, 1)
psizer.Add(ela_lab, (1, 3), (1, 1), style, 1)
psizer.Add(self.wids['dwelltime'], (0, 4), (1, 1), style, 1)
psizer.Add(self.wids['elapsed'], (1, 4), (1, 1), style, 1)
psizer.Add(b1, (0, 5), (1, 1), style, 1)
psizer.Add(b4, (0, 6), (1, 1), style, 1)
psizer.Add(b2, (1, 5), (1, 1), style, 1)
psizer.Add(b3, (1, 6), (1, 1), style, 1)
psizer.Add(sta_lab, (0, 7), (1, 1), style, 1)
psizer.Add(self.wids['det_status'], (0, 8), (1, 1), style, 1)
psizer.Add(dea_lab, (1, 7), (1, 1), style, 1)
psizer.Add(self.wids['deadtime'], (1, 8), (1, 1), style, 1)
pack(pane, psizer)
# pane.SetMinSize((500, 53))
self.det.connect_displays(status=self.wids['det_status'],
elapsed=self.wids['elapsed'],
deadtime=self.wids['deadtime'])
wx.CallAfter(self.onSelectDet, index=1, init=True)
self.timer_counter = 0
self.mca_timer = wx.Timer(self)
self.Bind(wx.EVT_TIMER, self.UpdateData, self.mca_timer)
self.mca_timer.Start(100)
return pane
def add_text(text, dcol=1, newrow=True):
panel.Add(SimpleText(panel, text), dcol=dcol, newrow=newrow)
def CreateXASPanel(self, parent):
p = panel = wx.Panel(parent)
self.xas_autoe0 = Check(panel, default=True, label='auto?')
self.xas_showe0 = Check(panel, default=True, label='show?')
self.xas_autostep = Check(panel, default=True, label='auto?')
self.xas_op = Choice(
panel,
size=(225, -1),
choices=('Raw Data', 'Normalized', 'Derivative',
'Normalized + Derivative', 'Pre-edge subtracted',
'Raw Data With Pre-edge/Post-edge Curves'),
action=self.onXASChoice)
opts = {
'size': (95, -1),
'precision': 3
} # , 'action': self.onXASChoice}
self.xas_e0 = FloatCtrl(panel, value=0, **opts)
self.xas_step = FloatCtrl(panel, value=0, **opts)
opts['precision'] = 1
self.xas_pre1 = FloatCtrl(panel, value=-200, **opts)
self.xas_pre2 = FloatCtrl(panel, value=-30, **opts)
self.xas_nor1 = FloatCtrl(panel, value=50, **opts)
self.xas_nor2 = FloatCtrl(panel, value=-50, **opts)
opts = {
'size': (50, -1),
'choices': ('0', '1', '2', '3'),
'action': self.onXASChoice
}
self.xas_vict = Choice(panel, **opts)
self.xas_nnor = Choice(panel, **opts)
self.xas_vict.SetSelection(1)
self.xas_nnor.SetSelection(2)
sizer = wx.GridBagSizer(10, 4)
sizer.Add(SimpleText(p, 'Plot XAS as: '), (0, 0), (1, 1), LCEN)
sizer.Add(SimpleText(p, 'E0 : '), (1, 0), (1, 1), LCEN)
sizer.Add(SimpleText(p, 'Edge Step: '), (2, 0), (1, 1), LCEN)
sizer.Add(SimpleText(p, 'Pre-edge range: '), (3, 0), (1, 1), LCEN)
sizer.Add(SimpleText(p, 'Normalization range: '), (4, 0), (1, 1), LCEN)
sizer.Add(self.xas_op, (0, 1), (1, 3), LCEN)
sizer.Add(self.xas_e0, (1, 1), (1, 1), LCEN)
sizer.Add(self.xas_step, (2, 1), (1, 1), LCEN)
sizer.Add(self.xas_pre1, (3, 1), (1, 1), LCEN)
sizer.Add(SimpleText(p, ':'), (3, 2), (1, 1), LCEN)
sizer.Add(self.xas_pre2, (3, 3), (1, 1), LCEN)
sizer.Add(self.xas_nor1, (4, 1), (1, 1), LCEN)
sizer.Add(SimpleText(p, ':'), (4, 2), (1, 1), LCEN)
sizer.Add(self.xas_nor2, (4, 3), (1, 1), LCEN)
sizer.Add(self.xas_autoe0, (1, 2), (1, 2), LCEN)
sizer.Add(self.xas_showe0, (1, 4), (1, 2), LCEN)
sizer.Add(self.xas_autostep, (2, 2), (1, 2), LCEN)
sizer.Add(SimpleText(p, 'Victoreen:'), (3, 4), (1, 1), LCEN)
sizer.Add(self.xas_vict, (3, 5), (1, 1), LCEN)
sizer.Add(SimpleText(p, 'PolyOrder:'), (4, 4), (1, 1), LCEN)
sizer.Add(self.xas_nnor, (4, 5), (1, 1), LCEN)
pack(panel, sizer)
return panel
