def __init__(self, parent=None, prefix=None, det_type='ME-4',
ioc_type='Xspress3', nmca=4,
title='Select Epics MCA Detector'):
if prefix is None:
prefix = self.def_prefix
if det_type not in self.det_types:
det_type = self.det_types[0]
wx.Dialog.__init__(self, parent, wx.ID_ANY, title=title)
self.SetBackgroundColour((240, 240, 230))
self.SetFont(Font(9))
if parent is not None:
self.SetFont(parent.GetFont())
self.ioctype = Choice(self,size=(120, -1), choices=self.ioc_types)
self.ioctype.SetStringSelection(ioc_type)
self.dettype = Choice(self,size=(120, -1), choices=self.det_types)
self.dettype.SetStringSelection(det_type)
self.prefix = wx.TextCtrl(self, -1, prefix, size=(120, -1))
self.nelem = FloatCtrl(self, value=nmca, precision=0, minval=1,
size=(120, -1))
btnsizer = wx.StdDialogButtonSizer()
if wx.Platform != "__WXMSW__":
btn = wx.ContextHelpButton(self)
btnsizer.AddButton(btn)
btn = wx.Button(self, wx.ID_OK)
btn.SetHelpText("Use this detector")
btn.SetDefault()
btnsizer.AddButton(btn)
btn = wx.Button(self, wx.ID_CANCEL)
btnsizer.AddButton(btn)
btnsizer.Realize()
hline = wx.StaticLine(self, size=(225, 3), style=wx.LI_HORIZONTAL)
sty = LEFT|wx.ALIGN_CENTER_VERTICAL
sizer = wx.GridBagSizer(5, 2)
def txt(label):
return SimpleText(self, label, size=(120, -1), style=LEFT)
sizer.Add(txt(' Detector Type'), (0, 0), (1, 1), sty, 2)
sizer.Add(txt(' Uses Xspress3?'), (1, 0), (1, 1), sty, 2)
sizer.Add(txt(' Epics Prefix'), (2, 0), (1, 1), sty, 2)
sizer.Add(txt(' # Elements'), (3, 0), (1, 1), sty, 2)
sizer.Add(self.dettype, (0, 1), (1, 1), sty, 2)
sizer.Add(self.ioctype, (1, 1), (1, 1), sty, 2)
sizer.Add(self.prefix, (2, 1), (1, 1), sty, 2)
sizer.Add(self.nelem, (3, 1), (1, 1), sty, 2)
sizer.Add(hline, (4, 0), (1, 2), sty, 2)
sizer.Add(btnsizer, (5, 0), (1, 2), sty, 2)
self.SetSizer(sizer)
sizer.Fit(self)
def __init__(self, parent, param, size=(80, -1), precision=4, **kws):
self.param = param
self.precision = precision
wx.Panel.__init__(self, parent, -1)
self.wids = Empty()
self.wids.conf = wx.BitmapButton(self, -1, infoicon.GetBitmap(),
size=(24, 24))
self.wids.conf.Bind(wx.EVT_BUTTON, self.onConfigure)
self.wids.conf.SetToolTip(wx.ToolTip("Configure Parameter"))
self.wids.val = FloatCtrl(self, value=param.value,
minval=param.min, maxval=param.max,
precision=precision, size=size)
self.wids.vary = Choice(self, choices=VARY_CHOICES,
action=self.onVaryChoice, size=(80, -1))
vary_choice = 0
if param.vary:
vary_choice = 1
elif param.expr is not None:
vary_choice = 2
self.wids.vary.SetSelection(vary_choice)
sizer = wx.BoxSizer(wx.HORIZONTAL)
sizer.Add(self.wids.val, 0, LEFT|wx.TOP)
sizer.Add(self.wids.vary, 0, LEFT|wx.TOP|wx.ALL)
sizer.Add(self.wids.conf, 0, LEFT)
pack(self, sizer)
def __init__(self,
parent,
param,
size=(80, -1),
show_name=False,
precision=4,
**kws):
self.param = param
self.precision = precision
wx.Panel.__init__(self, parent, -1)
self.wids = Empty()
self.wids.val = FloatCtrl(self,
value=param.value,
minval=param.min,
maxval=param.max,
precision=precision,
size=size)
self.wids.name = None
self.wids.edit = wx.Button(self, label='edit', size=(45, 25))
self.wids.edit.Bind(wx.EVT_BUTTON, self.onConfigure)
self.wids.edit.SetToolTip(wx.ToolTip("Configure Parameter"))
self.wids.vary = Choice(self,
choices=VARY_CHOICES,
action=self.onVaryChoice,
size=(80, -1))
vary_choice = 0
if param.vary:
vary_choice = 1
elif param.expr is not None:
vary_choice = 2
self.wids.vary.SetSelection(vary_choice)
sizer = wx.BoxSizer(wx.HORIZONTAL)
CLEFT = LEFT | wx.ALL | wx.ALIGN_CENTER_VERTICAL
if show_name:
self.wids.name = wx.StaticText(self,
label="%s: " % param.name,
size=(len(param.name) * 8, -1))
sizer.Add(self.wids.name, 0, CLEFT)
sizer.Add(self.wids.val, 0, CLEFT)
sizer.Add(self.wids.vary, 0, CLEFT)
sizer.Add(self.wids.edit, 0, CLEFT)
pack(self, sizer)
def filters_page(self):
"create row for filters parameters"
mca = self.parent.mca
self.wids.filters = []
p = GridPanel(self, itemstyle=LEFT)
bx = Button(p,
'Customize Filter List',
size=(150, -1),
action=self.onEditFilters)
bx.Disable()
p.AddManyText(
(' filter', 'material', 'density (gr/cm^3)', 'thickness (mm)'),
style=CEN)
p.Add(HLine(p, size=(600, 3)), dcol=5, newrow=True)
for i in range(4):
_mat = Choice(p,
choices=self.Filter_Materials,
default=0,
size=(125, -1),
action=partial(self.onFilterMaterial, index=i))
_den = FloatCtrl(p,
value=0,
minval=0,
maxval=30,
precision=4,
size=(75, -1))
pnam = 'filter%i_thickness' % (i + 1)
param = Parameter(value=0.0, vary=False, min=0, name=pnam)
setattr(self.paramgroup, pnam, param)
_len = ParameterPanel(p, param, precision=4)
self.wids.filters.append((_mat, _den, _len))
p.AddText(' %i ' % (i + 1), newrow=True)
p.Add(_mat)
p.Add(_den, style=wx.ALIGN_CENTER)
p.Add(_len)
p.Add(HLine(p, size=(600, 3)), dcol=5, newrow=True)
p.AddText(' ', newrow=True)
p.Add(bx, dcol=3)
p.pack()
return p
def show_position_info(self, row=0):
img_label = self.txt("Image Size:")
sel_label = self.txt("Selected Pixel:")
cen_label = self.txt("Distance to Center(um):")
ctr_button = add_button(self,
"Bring Selected Pixel to Center",
action=self.onBringToCenter,
size=(250, -1))
sizer = self.sizer
sizer.Add(img_label, (row, 0), (1, 1), LEFT)
sizer.Add(self.img_size, (row, 1), (1, 2), LEFT)
row += 1
sizer.Add(sel_label, (row, 0), (1, 1), LEFT)
sizer.Add(self.sel_pixel, (row, 1), (1, 2), LEFT)
row += 1
sizer.Add(cen_label, (row, 0), (1, 1), LEFT)
sizer.Add(self.cen_dist, (row, 1), (1, 2), LEFT)
row += 1
sizer.Add(ctr_button, (row, 0), (1, 2), wx.ALIGN_LEFT)
self.choice_lens = None
if self.lens_choices is not None and len(self.lens_choices) > 1:
lenses = ['%ix' % i for i in self.lens_choices]
ldef = '%ix' % self.lens_default
default = 1
if ldef in lenses:
default = lenses.index(ldef)
self.choice_lens = Choice(self,
choices=lenses,
default=default,
size=(100, -1))
row += 1
_label = self.txt("Current Lens:")
sizer.Add(_label, (row, 0), (1, 1), wx.ALIGN_LEFT)
sizer.Add(self.choice_lens, (row, 1), (1, 2), wx.ALIGN_LEFT)
return row + 1
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 createEpicsPanel(self):
pane = wx.Panel(self, name='epics panel')
style = wx.ALIGN_LEFT
rstyle = wx.ALIGN_RIGHT
det_btnpanel = self.create_detbuttons(pane)
bkg_choices = ['None'] + ["%d" % (i + 1) for i in range(self.nmca)]
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=(100, -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)
self.wids['mca_sum'] = Choice(pane,
size=(100, -1),
choices=['Single', 'Accumulate'],
action=self.onMcaSumChoice,
default=1)
b1 = Button(pane, 'Start', size=(90, -1), action=self.onStart)
b2 = Button(pane, 'Stop', size=(90, -1), action=self.onStop)
b3 = Button(pane, 'Erase', size=(90, -1), action=self.onErase)
b4 = Button(pane,
'Continuous',
size=(90, -1),
action=partial(self.onStart, dtime=0.0))
sum_lab = SimpleText(pane, 'Accumulate Mode:', size=(150, -1))
bkg_lab = SimpleText(pane, 'Background MCA:', size=(150, -1))
pre_lab = SimpleText(pane, 'Dwell 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 = wx.GridBagSizer(5, 5)
psizer.Add(SimpleText(pane, ' MCAs: '), (0, 0), (1, 1), style, 1)
psizer.Add(det_btnpanel, (0, 1), (2, 1), style, 1)
psizer.Add(bkg_lab, (0, 2), (1, 1), style, 1)
psizer.Add(self.wids['bkg_det'], (0, 3), (1, 1), style, 1)
psizer.Add(sum_lab, (1, 2), (1, 1), style, 1)
psizer.Add(self.wids['mca_sum'], (1, 3), (1, 1), style, 1)
psizer.Add(pre_lab, (0, 4), (1, 1), style, 1)
psizer.Add(ela_lab, (1, 4), (1, 1), style, 1)
psizer.Add(self.wids['dwelltime'], (0, 5), (1, 1), style, 1)
psizer.Add(self.wids['elapsed'], (1, 5), (1, 1), style, 1)
psizer.Add(b1, (0, 6), (1, 1), style, 1)
psizer.Add(b4, (0, 7), (1, 1), style, 1)
psizer.Add(b2, (1, 6), (1, 1), style, 1)
psizer.Add(b3, (1, 7), (1, 1), style, 1)
psizer.Add(sta_lab, (0, 8), (1, 1), style, 1)
psizer.Add(self.wids['det_status'], (0, 9), (1, 1), style, 1)
psizer.Add(dea_lab, (1, 8), (1, 1), style, 1)
psizer.Add(self.wids['deadtime'], (1, 9), (1, 1), style, 1)
pack(pane, psizer)
# pane.SetMinSize((500, 53))
self.det.connect_displays(status=self.wids['det_status'],
elapsed=self.wids['elapsed'])
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 build_display(self):
self.mod_nb = flat_nb.FlatNotebook(self, -1, agwStyle=FNB_STYLE)
self.mod_nb.SetTabAreaColour(wx.Colour(250, 250, 250))
self.mod_nb.SetActiveTabColour(wx.Colour(254, 254, 195))
self.mod_nb.SetNonActiveTabTextColour(wx.Colour(10, 10, 128))
self.mod_nb.SetActiveTabTextColour(wx.Colour(128, 0, 0))
self.mod_nb.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, self.onNBChanged)
self.param_panel = AllParamsPanel(self, controller=self.controller)
# self.mod_nb.AddPage(self.param_panel, 'Parameters', True)
range_row = wx.Panel(self)
rsizer = wx.BoxSizer(wx.HORIZONTAL)
xmin_sel = BitmapButton(range_row,
get_icon('plus'),
action=partial(self.on_selpoint, opt='xmin'),
tooltip='use last point selected from plot')
xmax_sel = BitmapButton(range_row,
get_icon('plus'),
action=partial(self.on_selpoint, opt='xmax'),
tooltip='use last point selected from plot')
opts = {'size': (70, -1), 'gformat': True}
self.xmin = FloatCtrl(range_row, value=-np.inf, **opts)
self.xmax = FloatCtrl(range_row, value=np.inf, **opts)
rsizer.Add(SimpleText(range_row, 'Fit Range X=[ '), 0, LCEN, 3)
rsizer.Add(xmin_sel, 0, LCEN, 3)
rsizer.Add(self.xmin, 0, LCEN, 3)
rsizer.Add(SimpleText(range_row, ' : '), 0, LCEN, 3)
rsizer.Add(xmax_sel, 0, LCEN, 3)
rsizer.Add(self.xmax, 0, LCEN, 3)
rsizer.Add(SimpleText(range_row, ' ] '), 0, LCEN, 3)
rsizer.Add(
Button(range_row,
'Full Data Range',
size=(150, -1),
action=self.onResetRange), 0, LCEN, 3)
pack(range_row, rsizer)
action_row = wx.Panel(self)
rsizer = wx.BoxSizer(wx.HORIZONTAL)
self.plot_comps = Check(action_row,
label='Plot Components?',
default=True,
size=(150, -1))
rsizer.Add(
Button(action_row, 'Run Fit', size=(100, -1),
action=self.onRunFit), 0, RCEN, 3)
savebtn = Button(action_row,
'Save Fit',
size=(100, -1),
action=self.onSaveFit)
savebtn.Disable()
rsizer.Add(savebtn, 0, LCEN, 3)
rsizer.Add(
Button(action_row,
'Plot Current Model',
size=(150, -1),
action=self.onShowModel), 0, LCEN, 3)
rsizer.Add(self.plot_comps, 0, LCEN, 3)
pack(action_row, rsizer)
models_row = wx.Panel(self)
rsizer = wx.BoxSizer(wx.HORIZONTAL)
self.model_choice = Choice(models_row,
size=(200, -1),
choices=ModelChoices['peaks'],
action=self.addModel)
rsizer.Add(SimpleText(models_row, ' Add Model Type: '), 0, LCEN, 3)
rsizer.Add(
Choice(models_row,
size=(100, -1),
choices=ModelTypes,
action=self.onModelTypes), 0, LCEN, 3)
rsizer.Add(SimpleText(models_row, ' Model: '), 0, LCEN, 3)
rsizer.Add(self.model_choice, 0, LCEN, 3)
pack(models_row, rsizer)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.AddMany([(range_row, 0, LCEN, 4), ((9, 9), 0, LCEN, 4),
(models_row, 0, LCEN, 4), ((9, 9), 0, LCEN, 4),
(action_row, 0, LCEN, 4), ((9, 9), 0, LCEN, 4),
(HLine(self, size=(550, 3)), 0, LCEN, 4),
((10, 10), 0, LCEN, 2),
(self.mod_nb, 1, LCEN | wx.GROW, 10)])
pack(self, sizer)
def __init__(self, parent, controller, **kws):
self.parent = parent
self.controller = controller
self.dgroup = self.controller.get_group()
groupnames = list(self.controller.file_groups.keys())
self.data = [self.dgroup.energy[:], self.dgroup.norm[:]]
title = "Correct Over-absorption"
wx.Dialog.__init__(self, parent, wx.ID_ANY, size=(550, 275), title=title)
panel = GridPanel(self, ncols=3, nrows=4, pad=2, itemstyle=LCEN)
self.grouplist = Choice(panel, choices=groupnames, size=(250, -1),
action=self.on_groupchoice)
self.grouplist.SetStringSelection(self.dgroup.filename)
self.wids = wids = {}
opts = dict(size=(90, -1), precision=1, act_on_losefocus=True,
minval=-90, maxval=180)
wids['phi_in'] = FloatCtrl(panel, value=45, **opts)
wids['phi_out'] = FloatCtrl(panel, value=45, **opts)
opts = dict(size=(75, -1), action=self.on_correct)
wids['elem'] = Choice(panel, choices=ELEM_LIST, **opts)
wids['edge'] = Choice(panel, choices=EDGE_LIST, **opts)
wids['formula'] = wx.TextCtrl(panel, -1, '', size=(350, -1))
wids['formula'].Bind(wx.EVT_TEXT_ENTER, self.on_correct)
wids['formula'].Bind(wx.EVT_KILL_FOCUS, self.on_correct)
self.set_default_elem_edge(self.dgroup)
for wname in ('phi_in', 'phi_out'):
wids[wname].SetAction(self.on_correct)
apply_one = Button(panel, 'Save Arrays for this Group', size=(175, -1),
action=self.on_apply_one)
apply_one.SetToolTip('Save corrected data, overwrite current arrays')
# apply_sel = Button(panel, 'Apply to Selected Groups', size=(175, -1),
# action=self.on_apply_sel)
#apply_sel.SetToolTip('''Apply SA Correction to the Selected Groups
# in XAS GUI, overwriting current arrays''')
done = Button(panel, 'Done', size=(125, -1), action=self.on_done)
panel.Add(SimpleText(panel, ' Correction for Group: '), dcol=1)
panel.Add(self.grouplist, dcol=5)
panel.Add(SimpleText(panel, ' Absorbing Element: '), newrow=True)
panel.Add(wids['elem'])
panel.Add(SimpleText(panel, ' Edge: '))
panel.Add(wids['edge'])
panel.Add(SimpleText(panel, ' Material Formula: '), newrow=True)
panel.Add(wids['formula'], dcol=3)
panel.Add(SimpleText(panel, ' Incident Angle: '), newrow=True)
panel.Add(wids['phi_in'])
panel.Add(SimpleText(panel, 'degrees'))
panel.Add(SimpleText(panel, ' Exit Angle: '), newrow=True)
panel.Add(wids['phi_out'])
panel.Add(SimpleText(panel, 'degrees'))
panel.Add(apply_one, dcol=4, newrow=True)
panel.Add(HLine(panel, size=(550, 3)), dcol=7, newrow=True)
panel.Add(done, dcol=4, newrow=True)
panel.pack()
def settings_page(self):
"create fit and background settings"
mca = self.parent.mca
conf = self.parent.conf
wids = self.wids
width = getattr(mca, 'bgr_width', 4)
compr = getattr(mca, 'bgr_compress', 2)
expon = getattr(mca, 'bgr_exponent', 2)
p = GridPanel(self, itemstyle=LEFT)
wids.bgr_use = Check(p,
label='Fit Background-Subtracted Spectra',
default=True)
wids.bgr_width = FloatCtrl(p,
value=width,
minval=0,
maxval=10,
precision=1,
size=(70, -1))
wids.bgr_compress = Choice(p,
choices=['1', '2', '4', '8', '16'],
size=(70, -1),
default=1)
wids.bgr_exponent = Choice(p,
choices=['2', '4', '6'],
size=(70, -1),
default=0)
sopts = {'vary': True, 'precision': 5}
sig_offset = Parameter(value=0.050, name=self.gsig_offset, vary=True)
sig_slope = Parameter(value=0.005, name=self.gsig_slope, vary=True)
sig_quad = Parameter(value=0.000, name=self.gsig_quad, vary=False)
setattr(self.paramgroup, self.gsig_offset, sig_offset)
setattr(self.paramgroup, self.gsig_slope, sig_slope)
setattr(self.paramgroup, self.gsig_quad, sig_quad)
wids.sig_offset = ParameterPanel(p, sig_offset, vary=True, precision=5)
wids.sig_slope = ParameterPanel(p, sig_slope, vary=True, precision=5)
wids.sig_quad = ParameterPanel(p, sig_quad, vary=False, precision=5)
wids.xray_en = FloatCtrl(p,
value=20.0,
size=(70, -1),
minval=0,
maxval=1000,
precision=3)
wids.fit_emin = FloatCtrl(p,
value=conf.e_min,
size=(70, -1),
minval=0,
maxval=1000,
precision=3)
wids.fit_emax = FloatCtrl(p,
value=conf.e_max,
size=(70, -1),
minval=0,
maxval=1000,
precision=3)
wids.flyield_use = Check(
p, label='Account for Absorption, Fluorescence Efficiency')
p.AddText(' General Settings ', colour='#880000', dcol=3)
p.AddText(' X-ray Energy (keV): ', newrow=True)
p.Add(wids.xray_en)
p.AddText(' Min Energy (keV): ', newrow=True)
p.Add(wids.fit_emin)
p.AddText(' Max Energy (keV): ', newrow=False)
p.Add(wids.fit_emax)
wids.det_mat = Choice(p,
choices=self.Detector_Materials,
size=(55, -1),
default=0)
wids.det_thk = FloatCtrl(p,
value=0.40,
size=(70, -1),
minval=0,
maxval=100,
precision=3)
wids.det_use = Check(p, label='Account for Detector Thickness')
p.AddText(' Detector Material: ', newrow=True)
p.Add(wids.det_mat)
p.AddText(' Thickness (mm): ', newrow=False)
p.Add(wids.det_thk)
p.Add(wids.det_use, dcol=4, newrow=True)
p.Add(wids.flyield_use, dcol=4, newrow=True)
p.Add(HLine(p, size=(600, 3)), dcol=5, newrow=True)
p.AddText(' Energy Dependence of Peak Width:',
colour='#880000',
newrow=True,
dcol=2)
# p.AddText(' ', newrow=True)
p.AddText(' sigma = offset + slope * Energy + quad * Energy^2 (keV)',
dcol=3)
p.AddText(' Offset: ', newrow=True)
p.Add(wids.sig_offset, dcol=3)
p.AddText(' Slope: ', newrow=True)
p.Add(wids.sig_slope, dcol=3)
p.AddText(' Quad: ', newrow=True)
p.Add(wids.sig_quad, dcol=3)
p.Add(HLine(p, size=(600, 3)), dcol=5, newrow=True)
p.AddText(" Background Parameters: ",
colour='#880000',
dcol=2,
newrow=True)
p.Add(wids.bgr_use, dcol=2)
p.AddText(" Exponent:", newrow=True)
p.Add(wids.bgr_exponent)
p.AddText(" Energy Width (keV): ", newrow=False)
p.Add(wids.bgr_width)
p.AddText(" Compression: ", newrow=True)
p.Add(wids.bgr_compress)
p.Add(Button(p,
'Show Background',
size=(130, -1),
action=self.onShowBgr),
dcol=2)
p.Add(HLine(p, size=(600, 3)), dcol=5, newrow=True)
p.pack()
return p
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 createControlPanel(self):
ctrlpanel = wx.Panel(self, name='Ctrl Panel')
bkgpanel = self.createBkgdPanel()
searchpanel = self.createSearchPanel()
labstyle = wx.ALIGN_LEFT|wx.ALIGN_BOTTOM|wx.EXPAND
ctrlstyle = wx.ALIGN_LEFT|wx.ALIGN_BOTTOM
txtstyle=wx.ALIGN_LEFT|wx.ST_NO_AUTORESIZE|wx.TE_PROCESS_ENTER
Font9 = Font(9)
Font10 = Font(10)
Font11 = Font(11)
plttitle = txt(ctrlpanel, 'Plot Parameters', font=Font10, size=200)
# y scale
yscalepanel = wx.Panel(ctrlpanel, name='YScalePanel')
ysizer = wx.BoxSizer(wx.HORIZONTAL)
ytitle = txt(yscalepanel, ' Y Axis:', font=Font10, size=80)
yspace = txt(yscalepanel, ' ', font=Font10, size=20)
ylog = Choice(yscalepanel, size=(80, 30), choices=['linear', 'log'],
action=self.onLogLinear)
yaxis = Check(yscalepanel, ' Show Y Scale ', action=self.onYAxis,
default=True)
self.wids['show_yaxis'] = yaxis
ysizer.Add(ytitle, 0, wx.ALIGN_CENTER_VERTICAL|wx.ALL, 0)
ysizer.Add(ylog, 0, wx.EXPAND|wx.ALL, 0)
ysizer.Add(yspace, 0, wx.EXPAND|wx.ALL, 0)
ysizer.Add(yaxis, 0, wx.EXPAND|wx.ALL, 0)
pack(yscalepanel, ysizer)
# zoom buttons
zoompanel = wx.Panel(ctrlpanel, name='ZoomPanel')
zsizer = wx.BoxSizer(wx.HORIZONTAL)
z1 = Button(zoompanel, 'Zoom In', size=(80, 30), action=self.onZoomIn)
z2 = Button(zoompanel, 'Zoom Out', size=(80, 30), action=self.onZoomOut)
p1 = Button(zoompanel, 'Pan Lo', size=(75, 30), action=self.onPanLo)
p2 = Button(zoompanel, 'Pan Hi', size=(75, 30), action=self.onPanHi)
zsizer.Add(p1, 0, wx.EXPAND|wx.ALL, 0)
zsizer.Add(p2, 0, wx.EXPAND|wx.ALL, 0)
zsizer.Add(z1, 0, wx.EXPAND|wx.ALL, 0)
zsizer.Add(z2, 0, wx.EXPAND|wx.ALL, 0)
pack(zoompanel, zsizer)
# x scale
xscalepanel = wx.Panel(ctrlpanel, name='XScalePanel')
xsizer = wx.BoxSizer(wx.HORIZONTAL)
xtitle = txt(xscalepanel, ' X Axis:', font=Font10, size=80)
xspace = txt(xscalepanel, ' ', font=Font10, size=20)
self.xaxis = wx.RadioBox(xscalepanel, -1, '',wx.DefaultPosition, wx.DefaultSize,
('q','2th','d'),
1, wx.RA_SPECIFY_ROWS)
self.xaxis.Bind(wx.EVT_RADIOBOX, self.onXaxis)
xsizer.Add(xtitle, 0, wx.ALIGN_CENTER_VERTICAL|wx.ALL, 0)
xsizer.Add(xspace, 0, wx.EXPAND|wx.ALL, 0)
xsizer.Add(self.xaxis, 0, wx.EXPAND|wx.ALL, 0)
pack(xscalepanel, xsizer)
###########################
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(plttitle, 0, wx.ALIGN_RIGHT|wx.EXPAND|wx.ALL)
sizer.Add(lin(ctrlpanel, 195), 0, labstyle)
sizer.Add(yscalepanel, 0, wx.ALIGN_RIGHT|wx.EXPAND|wx.ALL)
sizer.Add(lin(ctrlpanel, 195), 0, labstyle)
sizer.Add(lin(ctrlpanel, 195), 0, labstyle)
sizer.Add(xscalepanel, 0, wx.ALIGN_RIGHT|wx.EXPAND|wx.ALL)
sizer.Add(lin(ctrlpanel, 195), 0, labstyle)
sizer.Add(lin(ctrlpanel, 195), 0, labstyle)
sizer.Add(zoompanel, 0, wx.ALIGN_RIGHT|wx.EXPAND|wx.ALL)
sizer.Add(lin(ctrlpanel, 195), 0, labstyle)
sizer.Add(lin(ctrlpanel, 195), 0, labstyle)
sizer.Add(bkgpanel, 0, wx.ALIGN_RIGHT|wx.EXPAND|wx.ALL)
sizer.Add(searchpanel, 0, wx.ALIGN_RIGHT|wx.EXPAND|wx.ALL)
pack(ctrlpanel, sizer)
return ctrlpanel
def __init__(self):
wx.Frame.__init__(self,
None,
-1,
'wxutil demo',
style=wx.DEFAULT_FRAME_STYLE | wx.RESIZE_BORDER
| wx.TAB_TRAVERSAL)
self.SetTitle('wxutil demo')
self.SetFont(Font(11))
self.set_menu()
self.statusbar = self.CreateStatusBar(2, 1)
self.statusbar.SetStatusWidths([-2, -1])
statusbar_fields = ['Initializing....', ' ']
for i in range(len(statusbar_fields)):
self.statusbar.SetStatusText(statusbar_fields[i], i)
self.Bind(wx.EVT_CLOSE, self.onExit)
panel = GridPanel(self, nrows=8, ncols=4)
tctrl_name = TextCtrl(panel,
value='',
action=self.onName,
size=(250, -1))
lctrl_addr = LabeledTextCtrl(self,
value='<>',
action=self.onAddr,
labeltext=' Address: ',
size=(250, -1))
lab3 = HyperText(panel,
' FloatCtrl: ',
size=(100, -1),
action=self.onHyperText)
val3 = FloatCtrl(panel,
'3',
action=self.onFloat1,
precision=2,
minval=0,
maxval=1000,
size=(250, -1))
lab4 = HyperText(panel,
' FloatSpin: ',
size=(100, -1),
action=self.onHyperText)
val4 = FloatSpin(panel,
'12.2',
action=self.onFloatSpin,
digits=2,
increment=0.1,
size=(250, -1))
labx = HyperText(panel,
' NumericCombo: ',
size=(100, -1),
action=self.onHyperText)
steps = make_steps(prec=1, tmin=0, tmax=100)
valx = NumericCombo(panel, steps, precision=1)
self.choice1 = Choice(panel, size=(200, -1), action=self.onChoice)
self.choice1.SetChoices(['Apple', 'Banana', 'Cherry'])
yesno = YesNo(panel)
check1 = Check(panel, label='enable? ', action=self.onCheck)
btn1 = Button(panel,
label='Start',
size=(100, -1),
action=self.onStart)
pinbtn = BitmapButton(panel,
get_icon('pin'),
size=(50, -1),
action=partial(self.onBMButton, opt='pin1'),
tooltip='use last point selected from plot')
togbtn = ToggleButton(panel,
'Press Me',
action=self.onToggleButton,
size=(100, -1),
tooltip='do it, do it now, you will like it')
browse_btn = Button(panel,
'Open File',
action=self.onFileOpen,
size=(150, -1))
okcancel = OkCancel(panel, onOK=self.onOK, onCancel=self.onCancel)
ptable_btn = Button(panel,
'Show Periodic Table',
action=self.onPTable,
size=(175, -1))
edlist_btn = Button(panel,
'Show Editable Listbox',
action=self.onEdList,
size=(175, -1))
filelist_btn = Button(panel,
'Show File CheckList',
action=self.onFileList,
size=(175, -1))
panel.AddText(' Name: ', style=LEFT)
panel.Add(tctrl_name, dcol=2)
panel.Add(lctrl_addr.label, newrow=True)
panel.Add(lctrl_addr, dcol=2)
panel.Add(lab3, newrow=True)
panel.Add(val3, dcol=3)
panel.Add(lab4, newrow=True)
panel.Add(val4, dcol=3)
panel.Add(labx, newrow=True)
panel.Add(valx, dcol=3)
panel.AddText(' Choice : ', newrow=True)
panel.Add(check1)
panel.Add(self.choice1)
panel.AddText(' Yes or No: ', newrow=True)
panel.Add(yesno)
panel.Add(HLine(panel, size=(500, -1)), dcol=3, newrow=True)
panel.Add(btn1, newrow=True)
panel.Add(pinbtn)
panel.Add(togbtn)
panel.Add(browse_btn, newrow=True)
panel.Add(ptable_btn)
panel.Add(edlist_btn, newrow=True)
panel.Add(filelist_btn)
panel.Add(okcancel, newrow=True)
panel.pack()
self.timer = wx.Timer(self)
self.last_time = time.time()
self.Bind(wx.EVT_TIMER, self.onTimer, self.timer)
fsizer = wx.BoxSizer(wx.VERTICAL)
fsizer.Add(panel, 0, LEFT | wx.EXPAND)
wx.CallAfter(self.init_timer)
psize = panel.GetBestSize()
self.SetSize((psize[0] + 5, psize[1] + 25))
pack(self, fsizer)
self.Refresh()
class DemoFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self,
None,
-1,
'wxutil demo',
style=wx.DEFAULT_FRAME_STYLE | wx.RESIZE_BORDER
| wx.TAB_TRAVERSAL)
self.SetTitle('wxutil demo')
self.SetFont(Font(11))
self.set_menu()
self.statusbar = self.CreateStatusBar(2, 1)
self.statusbar.SetStatusWidths([-2, -1])
statusbar_fields = ['Initializing....', ' ']
for i in range(len(statusbar_fields)):
self.statusbar.SetStatusText(statusbar_fields[i], i)
self.Bind(wx.EVT_CLOSE, self.onExit)
panel = GridPanel(self, nrows=8, ncols=4)
tctrl_name = TextCtrl(panel,
value='',
action=self.onName,
size=(250, -1))
lctrl_addr = LabeledTextCtrl(self,
value='<>',
action=self.onAddr,
labeltext=' Address: ',
size=(250, -1))
lab3 = HyperText(panel,
' FloatCtrl: ',
size=(100, -1),
action=self.onHyperText)
val3 = FloatCtrl(panel,
'3',
action=self.onFloat1,
precision=2,
minval=0,
maxval=1000,
size=(250, -1))
lab4 = HyperText(panel,
' FloatSpin: ',
size=(100, -1),
action=self.onHyperText)
val4 = FloatSpin(panel,
'12.2',
action=self.onFloatSpin,
digits=2,
increment=0.1,
size=(250, -1))
labx = HyperText(panel,
' NumericCombo: ',
size=(100, -1),
action=self.onHyperText)
steps = make_steps(prec=1, tmin=0, tmax=100)
valx = NumericCombo(panel, steps, precision=1)
self.choice1 = Choice(panel, size=(200, -1), action=self.onChoice)
self.choice1.SetChoices(['Apple', 'Banana', 'Cherry'])
yesno = YesNo(panel)
check1 = Check(panel, label='enable? ', action=self.onCheck)
btn1 = Button(panel,
label='Start',
size=(100, -1),
action=self.onStart)
pinbtn = BitmapButton(panel,
get_icon('pin'),
size=(50, -1),
action=partial(self.onBMButton, opt='pin1'),
tooltip='use last point selected from plot')
togbtn = ToggleButton(panel,
'Press Me',
action=self.onToggleButton,
size=(100, -1),
tooltip='do it, do it now, you will like it')
browse_btn = Button(panel,
'Open File',
action=self.onFileOpen,
size=(150, -1))
okcancel = OkCancel(panel, onOK=self.onOK, onCancel=self.onCancel)
ptable_btn = Button(panel,
'Show Periodic Table',
action=self.onPTable,
size=(175, -1))
edlist_btn = Button(panel,
'Show Editable Listbox',
action=self.onEdList,
size=(175, -1))
filelist_btn = Button(panel,
'Show File CheckList',
action=self.onFileList,
size=(175, -1))
panel.AddText(' Name: ', style=LEFT)
panel.Add(tctrl_name, dcol=2)
panel.Add(lctrl_addr.label, newrow=True)
panel.Add(lctrl_addr, dcol=2)
panel.Add(lab3, newrow=True)
panel.Add(val3, dcol=3)
panel.Add(lab4, newrow=True)
panel.Add(val4, dcol=3)
panel.Add(labx, newrow=True)
panel.Add(valx, dcol=3)
panel.AddText(' Choice : ', newrow=True)
panel.Add(check1)
panel.Add(self.choice1)
panel.AddText(' Yes or No: ', newrow=True)
panel.Add(yesno)
panel.Add(HLine(panel, size=(500, -1)), dcol=3, newrow=True)
panel.Add(btn1, newrow=True)
panel.Add(pinbtn)
panel.Add(togbtn)
panel.Add(browse_btn, newrow=True)
panel.Add(ptable_btn)
panel.Add(edlist_btn, newrow=True)
panel.Add(filelist_btn)
panel.Add(okcancel, newrow=True)
panel.pack()
self.timer = wx.Timer(self)
self.last_time = time.time()
self.Bind(wx.EVT_TIMER, self.onTimer, self.timer)
fsizer = wx.BoxSizer(wx.VERTICAL)
fsizer.Add(panel, 0, LEFT | wx.EXPAND)
wx.CallAfter(self.init_timer)
psize = panel.GetBestSize()
self.SetSize((psize[0] + 5, psize[1] + 25))
pack(self, fsizer)
self.Refresh()
def init_timer(self):
self.timer.Start(500)
def onTimer(self, event):
idle_time = (time.time() - self.last_time)
msg = "Time remaining = %.1f sec" % (30 - idle_time)
self.statusbar.SetStatusText(msg, 1)
if (time.time() - self.last_time) > 30:
print("quitting...")
self.onExit()
def report(self, reason, value):
self.statusbar.SetStatusText("%s: %s" % (reason, value), 0)
self.last_time = time.time()
def set_menu(self):
menu = wx.Menu()
mexit = MenuItem(self, menu, "Q&uit", "Quit Program", self.onExit)
menubar = wx.MenuBar()
menubar.Append(menu, "&File")
self.SetMenuBar(menubar)
def onOK(self, event=None):
self.report("on OK: ", '')
def onCancel(self, event=None):
self.report("on Cancel: ", '')
def onName(self, event=None):
self.report("on Name: ", event)
def onAddr(self, event=None):
self.report("on Addr: ", event)
def onHyperText(self, event=None, label=None):
self.report("on HyperText ", label)
def onFloat1(self, value=None):
self.report("on Float1 ", value)
def onFloatSpin(self, event=None):
self.report("on FloatSpin ", event.GetString())
def onChoice(self, event=None):
self.report("on Choice ", event.GetString())
def onCheck(self, event=None):
self.report("on Check ", event.IsChecked())
self.choice1.Enable(event.IsChecked())
def onStart(self, event=None):
self.report("on Start Button ", '')
def onBMButton(self, event=None, opt='xxx'):
self.report("on Bitmap Button ", opt)
def onToggleButton(self, event=None):
self.report(" on Toggle Button %s " % event.GetString(),
event.IsChecked())
def onPTable(self, event=None):
PTableFrame(fontsize=10).Show()
def onEdList(self, event=None):
frame = wx.Frame(self)
edlist = EditableListBox(frame, self.onEdListSelect)
edlist.Append(" Item 1 ")
edlist.Append(" Item 2 ")
edlist.Append(" Next ")
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(edlist, 1, wx.EXPAND | wx.ALL, 5)
pack(frame, sizer)
frame.Show()
frame.Raise()
def onEdListSelect(self, event=None, **kws):
self.report(" Editable List selected ", event.GetString())
def onFileList(self, event=None):
frame = wx.Frame(self)
edlist = FileCheckList(frame, select_action=self.onFileListSelect)
for i in range(8):
edlist.Append("File.%3.3d" % (i + 1))
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(edlist, 1, wx.EXPAND | wx.ALL, 5)
pack(frame, sizer)
frame.Show()
frame.Raise()
def onFileListSelect(self, event=None, **kws):
self.report(" File List selected ", event.GetString())
def onFileOpen(self, event=None):
wildcards = "%s|%s" % (PY_FILES, ALL_FILES)
dlg = wx.FileDialog(self,
message='Select File',
wildcard=wildcards,
style=wx.FD_OPEN)
if dlg.ShowModal() == wx.ID_OK:
path = os.path.abspath(dlg.GetPath())
self.report("file ", path)
dlg.Destroy()
def onExit(self, event=None):
self.Destroy()
class DetectorSelectDialog(wx.Dialog):
"""Connect to an Epics MCA detector
Can be either XIA xMAP or Quantum XSPress3
"""
msg = '''Select XIA xMAP or Quantum XSPress3 MultiElement MCA detector'''
det_types = ('SXD-7', 'ME-7', 'ME-4', 'other')
ioc_types = ('Xspress3.1', 'xMAP', 'Xspress3.0')
def_prefix = '13QX7:' # SDD1:'
def_nelem = 4
def __init__(self,
parent=None,
prefix=None,
det_type='ME-4',
ioc_type='Xspress3',
nmca=4,
title='Select Epics MCA Detector'):
if prefix is None:
prefix = self.def_prefix
if det_type not in self.det_types:
det_type = self.det_types[0]
wx.Dialog.__init__(self, parent, wx.ID_ANY, title=title)
self.SetBackgroundColour((240, 240, 230))
self.SetFont(Font(9))
if parent is not None:
self.SetFont(parent.GetFont())
self.ioctype = Choice(self, size=(120, -1), choices=self.ioc_types)
self.ioctype.SetStringSelection(ioc_type)
self.dettype = Choice(self, size=(120, -1), choices=self.det_types)
self.dettype.SetStringSelection(det_type)
self.prefix = wx.TextCtrl(self, -1, prefix, size=(120, -1))
self.nelem = FloatCtrl(self,
value=nmca,
precision=0,
minval=1,
size=(120, -1))
btnsizer = wx.StdDialogButtonSizer()
if wx.Platform != "__WXMSW__":
btn = wx.ContextHelpButton(self)
btnsizer.AddButton(btn)
btn = wx.Button(self, wx.ID_OK)
btn.SetHelpText("Use this detector")
btn.SetDefault()
btnsizer.AddButton(btn)
btn = wx.Button(self, wx.ID_CANCEL)
btnsizer.AddButton(btn)
btnsizer.Realize()
hline = wx.StaticLine(self, size=(225, 3), style=wx.LI_HORIZONTAL)
sty = LEFT
sizer = wx.GridBagSizer(5, 2)
def txt(label):
return SimpleText(self, label, size=(120, -1), style=LEFT)
sizer.Add(txt(' Detector Type'), (0, 0), (1, 1), sty, 2)
sizer.Add(txt(' Uses Xspress3?'), (1, 0), (1, 1), sty, 2)
sizer.Add(txt(' Epics Prefix'), (2, 0), (1, 1), sty, 2)
sizer.Add(txt(' # Elements'), (3, 0), (1, 1), sty, 2)
sizer.Add(self.dettype, (0, 1), (1, 1), sty, 2)
sizer.Add(self.ioctype, (1, 1), (1, 1), sty, 2)
sizer.Add(self.prefix, (2, 1), (1, 1), sty, 2)
sizer.Add(self.nelem, (3, 1), (1, 1), sty, 2)
sizer.Add(hline, (4, 0), (1, 2), sty, 2)
sizer.Add(btnsizer, (5, 0), (1, 2), sty, 2)
self.SetSizer(sizer)
sizer.Fit(self)
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 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 ParameterWidgets(object):
"""a set of related widgets for a lmfit Parameter
param = Parameter(value=11.22, vary=True, min=0, name='x1')
wid = ParameterPanel(parent_wid, param)
"""
def __init__(self, parent, param, name_size=None, prefix=None,
expr_size=120, stderr_size=120, float_size=80,
widgets=PAR_WIDS):
self.parent = parent
self.param = param
self._saved_expr = ''
if (prefix is not None and
not self.param.name.startswith(prefix)):
self.param.name = "%s%s" %(prefix, self.param.name)
for attr in PAR_WIDS:
setattr(self, attr, None)
# set vary_choice from param attributes
vary_choice = PAR_VAR
if param.expr not in (None, 'None', ''):
vary_choice = PAR_CON
elif not param.vary:
vary_choice = PAR_FIX
if 'name' in widgets:
name = param.name
if name in (None, 'None', ''):
name = ''
if name_size is None:
name_size = min(50, len(param.name)*10)
self.name = wx.StaticText(parent, label=name,
size=(name_size, -1))
if 'value' in widgets:
self.value = FloatCtrl(parent, value=param.value,
minval=param.min,
maxval=param.max,
action=self.onValue,
act_on_losefocus=True,
gformat=True,
size=(float_size, -1))
if 'minval' in widgets:
minval = param.min
if minval in (None, 'None', -np.inf):
minval = -np.inf
self.minval = FloatCtrl(parent, value=minval,
gformat=True,
size=(float_size, -1),
act_on_losefocus=True,
action=self.onMinval)
self.minval.Enable(vary_choice==PAR_VAR)
if 'maxval' in widgets:
maxval = param.max
if maxval in (None, 'None', np.inf):
maxval = np.inf
self.maxval = FloatCtrl(parent, value=maxval,
gformat=True,
size=(float_size, -1),
act_on_losefocus=True,
action=self.onMaxval)
self.maxval.Enable(vary_choice==PAR_VAR)
if 'vary' in widgets:
self.vary = Choice(parent, size=(90, -1),
choices=VARY_CHOICES,
action=self.onVaryChoice)
self.vary.SetStringSelection(vary_choice)
if 'expr' in widgets:
expr = param.expr
if expr in (None, 'None', ''):
expr = ''
self._saved_expr = expr
self.expr = wx.TextCtrl(parent, -1, value=expr,
size=(expr_size, -1))
self.expr.Enable(vary_choice==PAR_CON)
self.expr.Bind(wx.EVT_CHAR, self.onExprChar)
self.expr.Bind(wx.EVT_KILL_FOCUS, self.onExprKillFocus)
SetTip(self.expr, 'Enter constraint expression')
if 'stderr' in widgets:
stderr = param.stderr
if stderr in (None, 'None', ''):
stderr = ''
self.stderr = wx.StaticText(parent, label=stderr,
size=(stderr_size, -1))
def onValue(self, evt=None, value=None):
if value is not None:
self.param.value = value
def onExprChar(self, evt=None):
key = evt.GetKeyCode()
if key == wx.WXK_RETURN:
self.onExpr(value=self.expr.GetValue())
evt.Skip()
def onExprKillFocus(self, evt=None):
self.onExpr(value=self.expr.GetValue())
evt.Skip()
def onExpr(self, evt=None, value=None):
if value is None and evt is not None:
value = evt.GetString()
try:
ast.parse(value)
self.param.expr = value
bgcol, fgcol = 'white', 'black'
except SyntaxError:
bgcol, fgcol = 'red', 'yellow'
self.expr.SetForegroundColour(fgcol)
self.expr.SetBackgroundColour(bgcol)
def onMinval(self, evt=None, value=None):
if value in (None, 'None', ''):
value = -np.inf
if self.value is not None:
v = self.value.GetValue()
self.value.SetMin(value)
self.value.SetValue(v)
self.param.min = value
def onMaxval(self, evt=None, value=None):
# print "onMaxval " , value, self.value, self.value
if value in (None, 'None', ''):
value = np.inf
if self.value is not None:
v = self.value.GetValue()
self.value.SetMax( value)
self.value.SetValue(v)
self.param.max = value
def onVaryChoice(self, evt=None):
if self.vary is None:
return
vary = str(evt.GetString().lower())
self.param.vary = (vary==PAR_VAR)
if ((vary == PAR_VAR or vary == PAR_FIX) and
self.param.expr not in (None, 'None', '')):
self._saved_expr = self.param.expr
self.param.expr = ''
elif (vary == PAR_CON and self.param.expr in (None, 'None', '')):
self.param.expr = self._saved_expr
if self.value is not None:
self.value.Enable(vary!=PAR_CON)
if self.expr is not None:
self.expr.Enable(vary==PAR_CON)
if self.minval is not None:
self.minval.Enable(vary==PAR_VAR)
if self.maxval is not None:
self.maxval.Enable(vary==PAR_VAR)
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 __init__(self, parent, param, name_size=None, prefix=None,
expr_size=120, stderr_size=120, float_size=80,
widgets=PAR_WIDS):
self.parent = parent
self.param = param
self._saved_expr = ''
if (prefix is not None and
not self.param.name.startswith(prefix)):
self.param.name = "%s%s" %(prefix, self.param.name)
for attr in PAR_WIDS:
setattr(self, attr, None)
# set vary_choice from param attributes
vary_choice = PAR_VAR
if param.expr not in (None, 'None', ''):
vary_choice = PAR_CON
elif not param.vary:
vary_choice = PAR_FIX
if 'name' in widgets:
name = param.name
if name in (None, 'None', ''):
name = ''
if name_size is None:
name_size = min(50, len(param.name)*10)
self.name = wx.StaticText(parent, label=name,
size=(name_size, -1))
if 'value' in widgets:
self.value = FloatCtrl(parent, value=param.value,
minval=param.min,
maxval=param.max,
action=self.onValue,
act_on_losefocus=True,
gformat=True,
size=(float_size, -1))
if 'minval' in widgets:
minval = param.min
if minval in (None, 'None', -np.inf):
minval = -np.inf
self.minval = FloatCtrl(parent, value=minval,
gformat=True,
size=(float_size, -1),
act_on_losefocus=True,
action=self.onMinval)
self.minval.Enable(vary_choice==PAR_VAR)
if 'maxval' in widgets:
maxval = param.max
if maxval in (None, 'None', np.inf):
maxval = np.inf
self.maxval = FloatCtrl(parent, value=maxval,
gformat=True,
size=(float_size, -1),
act_on_losefocus=True,
action=self.onMaxval)
self.maxval.Enable(vary_choice==PAR_VAR)
if 'vary' in widgets:
self.vary = Choice(parent, size=(90, -1),
choices=VARY_CHOICES,
action=self.onVaryChoice)
self.vary.SetStringSelection(vary_choice)
if 'expr' in widgets:
expr = param.expr
if expr in (None, 'None', ''):
expr = ''
self._saved_expr = expr
self.expr = wx.TextCtrl(parent, -1, value=expr,
size=(expr_size, -1))
self.expr.Enable(vary_choice==PAR_CON)
self.expr.Bind(wx.EVT_CHAR, self.onExprChar)
self.expr.Bind(wx.EVT_KILL_FOCUS, self.onExprKillFocus)
SetTip(self.expr, 'Enter constraint expression')
if 'stderr' in widgets:
stderr = param.stderr
if stderr in (None, 'None', ''):
stderr = ''
self.stderr = wx.StaticText(parent, label=stderr,
size=(stderr_size, -1))
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_'})]
class ColumnDataFileFrame(wx.Frame):
"""Column Data File, select columns"""
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 read_column_file(self, path):
"""read column file, generally as initial read"""
parent, filename = os.path.split(path)
with open(path, 'r') as fh:
lines = fh.readlines()
text = ''.join(lines)
line1 = lines[0].lower()
reader = 'read_ascii'
if 'epics stepscan file' in line1:
reader = 'read_gsexdi'
elif 'xdi' in line1:
reader = 'read_xdi'
elif 'epics scan' in line1:
reader = 'read_gsescan'
tmpname = '_tmp_file_'
read_cmd = "%s = %s('%s')" % (tmpname, reader, path)
self.reader = reader
deeplarch = self._larch._larch
try:
deeplarch.eval(read_cmd, add_history=False)
except:
pass
if deeplarch.error:
# self._larch.input.clear()
msg = ["Error trying to read '%s':" % path, ""]
for err in deeplarch.error:
exc_name, errmsg = err.get_error()
msg.append(errmsg)
title = "Cannot read %s" % path
r = Popup(self.parent, "\n".join(msg), title)
return None
group = self._larch.symtable.get_symbol(tmpname)
self._larch.symtable.del_symbol(tmpname)
group.text = text
group.path = path
group.filename = filename
group.groupname = file2groupname(filename,
symtable=self._larch.symtable)
return group
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 onEditNames(self, evt=None):
self.show_subframe('editcol',
EditColumnFrame,
group=self.workgroup,
on_ok=self.set_array_labels)
def set_array_labels(self, arr_labels):
self.workgroup.array_labels = arr_labels
yarr_labels = self.yarr_labels = arr_labels + ['1.0', '0.0', '']
xarr_labels = self.xarr_labels = arr_labels + ['_index']
def update(wid, choices):
curstr = wid.GetStringSelection()
curind = wid.GetSelection()
wid.SetChoices(choices)
if curstr in choices:
wid.SetStringSelection(curstr)
else:
wid.SetSelection(curind)
update(self.xarr, xarr_labels)
update(self.yarr1, yarr_labels)
update(self.yarr2, yarr_labels)
update(self.yerr_arr, yarr_labels)
self.onUpdate()
def onOK(self, event=None):
""" build arrays according to selection """
if self.wid_groupname is not None:
groupname = fix_varname(self.wid_groupname.GetValue())
yerr_op = self.yerr_op.GetStringSelection().lower()
yerr_expr = '1'
if yerr_op.startswith('const'):
yerr_expr = "%f" % self.yerr_const.GetValue()
elif yerr_op.startswith('array'):
yerr_expr = '%%s.data[%i, :]' % self.yerr_arr.GetSelection()
elif yerr_op.startswith('sqrt'):
yerr_expr = 'sqrt(%s.ydat)'
self.expressions['yerr'] = yerr_expr
# generate script to pass back to calling program:
labels = ', '.join(self.workgroup.array_labels)
read_cmd = "%s('{path:s}', labels='%s')" % (self.reader, labels)
buff = ["{group:s} = %s" % read_cmd, "{group:s}.path = '{path:s}'"]
for attr in ('datatype', 'plot_xlabel', 'plot_ylabel'):
val = getattr(self.workgroup, attr)
buff.append("{group:s}.%s = '%s'" % (attr, val))
for aname in ('xdat', 'ydat', 'yerr'):
expr = self.expressions[aname].replace('%s', '{group:s}')
buff.append("{group:s}.%s = %s" % (aname, expr))
if getattr(self.workgroup, 'datatype', 'raw') == 'xas':
if self.reader == 'read_gsescan':
buff.append("{group:s}.energy = {group:s}.x")
else:
buff.append("{group:s}.energy = {group:s}.xdat")
buff.append("{group:s}.mu = {group:s}.ydat")
script = "\n".join(buff)
if self.read_ok_cb is not None:
self.read_ok_cb(script,
self.path,
groupname=groupname,
array_sel=self.array_sel)
self.Destroy()
def onCancel(self, event=None):
self.workgroup.import_ok = False
self.Destroy()
def onYerrChoice(self, evt=None):
yerr_choice = evt.GetString()
self.yerr_arr.Disable()
self.yerr_const.Disable()
if 'const' in yerr_choice.lower():
self.yerr_const.Enable()
elif 'array' in yerr_choice.lower():
self.yerr_arr.Enable()
self.onUpdate()
def onUpdate(self, value=None, evt=None):
"""column selections changed calc xdat and ydat"""
# dtcorr = self.dtcorr.IsChecked()
# print("Column Frame on Update ")
dtcorr = False
use_deriv = self.use_deriv.IsChecked()
rawgroup = self.initgroup
workgroup = self.workgroup
rdata = self.initgroup.data
# print("onUpdate ", dir(rawgroup))
ix = self.xarr.GetSelection()
xname = self.xarr.GetStringSelection()
exprs = dict(xdat=None, ydat=None, yerr=None)
ncol, npts = rdata.shape
if xname.startswith('_index') or ix >= ncol:
workgroup.xdat = 1.0 * np.arange(npts)
xname = '_index'
exprs['xdat'] = 'arange(%i)' % npts
else:
workgroup.xdat = rdata[ix, :]
exprs['xdat'] = '%%s.data[%i, : ]' % ix
workgroup.datatype = self.datatype.GetStringSelection().strip().lower()
def pre_op(opwid, arr):
opstr = opwid.GetStringSelection().strip()
suf = ''
if opstr in ('-log(', 'log('):
suf = ')'
if opstr == 'log(':
arr = np.log(arr)
elif opstr == '-log(':
arr = -np.log(arr)
return suf, opstr, arr
try:
xsuf, xpop, workgroup.xdat = pre_op(self.xpop, workgroup.xdat)
self.xsuf.SetLabel(xsuf)
exprs['xdat'] = '%s%s%s' % (xpop, exprs['xdat'], xsuf)
except:
return
try:
xunits = rawgroup.array_units[ix].strip()
xlabel = '%s (%s)' % (xname, xunits)
except:
xlabel = xname
yname1 = self.yarr1.GetStringSelection().strip()
yname2 = self.yarr2.GetStringSelection().strip()
iy1 = self.yarr1.GetSelection()
iy2 = self.yarr2.GetSelection()
yop = self.yop.GetStringSelection().strip()
ylabel = yname1
if len(yname2) == 0:
yname2 = '1.0'
else:
ylabel = "%s%s%s" % (ylabel, yop, yname2)
if yname1 == '0.0':
yarr1 = np.zeros(npts) * 1.0
yexpr1 = 'zeros(%i)' % npts
elif len(yname1) == 0 or yname1 == '1.0' or iy1 >= ncol:
yarr1 = np.ones(npts) * 1.0
yexpr1 = 'ones(%i)' % npts
else:
yarr1 = rdata[iy1, :]
yexpr1 = '%%s.data[%i, : ]' % iy1
if yname2 == '0.0':
yarr2 = np.zeros(npts) * 1.0
yexpr2 = '0.0'
elif len(yname2) == 0 or yname2 == '1.0' or iy2 >= ncol:
yarr2 = np.ones(npts) * 1.0
yexpr2 = '1.0'
else:
yarr2 = rdata[iy2, :]
yexpr2 = '%%s.data[%i, : ]' % iy2
workgroup.ydat = yarr1
exprs['ydat'] = yexpr1
if yop in ('+', '-', '*', '/'):
exprs['ydat'] = "%s %s %s" % (yexpr1, yop, yexpr2)
if yop == '+':
workgroup.ydat = yarr1.__add__(yarr2)
elif yop == '-':
workgroup.ydat = yarr1.__sub__(yarr2)
elif yop == '*':
workgroup.ydat = yarr1.__mul__(yarr2)
elif yop == '/':
workgroup.ydat = yarr1.__truediv__(yarr2)
ysuf, ypop, workgroup.ydat = pre_op(self.ypop, workgroup.ydat)
self.ysuf.SetLabel(ysuf)
exprs['ydat'] = '%s%s%s' % (ypop, exprs['ydat'], ysuf)
yerr_op = self.yerr_op.GetStringSelection().lower()
exprs['yerr'] = '1'
if yerr_op.startswith('const'):
yerr = self.yerr_const.GetValue()
exprs['yerr'] = '%f' % yerr
elif yerr_op.startswith('array'):
iyerr = self.yerr_arr.GetSelection()
yerr = rdata[iyerr, :]
exprs['yerr'] = '%%s.data[%i, :]' % iyerr
elif yerr_op.startswith('sqrt'):
yerr = np.sqrt(workgroup.ydat)
exprs['yerr'] = 'sqrt(%s.ydat)'
if use_deriv:
try:
workgroup.ydat = (np.gradient(workgroup.ydat) /
np.gradient(workgroup.xdat))
exprs['ydat'] = 'deriv(%s)/deriv(%s)' % (exprs['ydat'],
exprs['xdat'])
except:
pass
self.expressions = exprs
self.array_sel = {
'xpop': xpop,
'xarr': xname,
'ypop': ypop,
'yop': yop,
'yarr1': yname1,
'yarr2': yname2,
'use_deriv': use_deriv
}
try:
npts = min(len(workgroup.xdat), len(workgroup.ydat))
except AttributeError:
return
workgroup.filename = rawgroup.filename
workgroup.npts = npts
workgroup.plot_xlabel = xlabel
workgroup.plot_ylabel = ylabel
workgroup.xdat = np.array(workgroup.xdat[:npts])
workgroup.ydat = np.array(workgroup.ydat[:npts])
workgroup.y = workgroup.ydat
workgroup.yerr = yerr
if isinstance(yerr, np.ndarray):
workgroup.yerr = np.array(yerr[:npts])
if workgroup.datatype == 'xas':
workgroup.energy = workgroup.xdat
workgroup.mu = workgroup.ydat
path, fname = os.path.split(workgroup.filename)
popts = dict(marker='o',
markersize=4,
linewidth=1.5,
title=fname,
ylabel=ylabel,
xlabel=xlabel,
label="%s: %s" % (fname, workgroup.plot_ylabel))
self.plotpanel.plot(workgroup.xdat, workgroup.ydat, **popts)
for i in range(self.nb.GetPageCount()):
if 'plot' in self.nb.GetPageText(i).lower():
self.nb.SetSelection(i)
def plot_messages(self, msg, panel=1):
self.SetStatusText(msg, panel)
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 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 createControlPanel(self):
ctrlpanel = wx.Panel(self, name='Ctrl Panel')
ptable = PeriodicTablePanel(ctrlpanel, onselect=self.onShowLines,
tooltip_msg='Select Element for KLM Lines')
self.wids['ptable'] = ptable
labstyle = wx.ALIGN_LEFT|wx.ALIGN_BOTTOM|wx.EXPAND
ctrlstyle = wx.ALIGN_LEFT|wx.ALIGN_BOTTOM
txtstyle=wx.ALIGN_LEFT|wx.ST_NO_AUTORESIZE|wx.TE_PROCESS_ENTER
Font9 = Font(9)
Font10 = Font(10)
Font11 = Font(11)
#
arrowpanel = wx.Panel(ctrlpanel)
ssizer = wx.BoxSizer(wx.HORIZONTAL)
for wname, dname in (('uparrow', 'up'),
('leftarrow', 'left'),
('rightarrow', 'right'),
('downarrow', 'down')):
self.wids[wname] = wx.BitmapButton(arrowpanel, -1,
get_icon(wname),
size=(25, 25),
style=wx.NO_BORDER)
self.wids[wname].Bind(wx.EVT_BUTTON,
partial(ptable.onKey, name=dname))
ssizer.Add(self.wids[wname], 0, wx.EXPAND|wx.ALL)
self.wids['kseries'] = Check(arrowpanel, ' K ', action=self.onKLM)
self.wids['lseries'] = Check(arrowpanel, ' L ', action=self.onKLM)
self.wids['mseries'] = Check(arrowpanel, ' M ', action=self.onKLM)
self.wids['holdbtn'] = wx.ToggleButton(arrowpanel, -1, 'Hold ', size=(65, 25))
self.wids['holdbtn'].Bind(wx.EVT_TOGGLEBUTTON, self.onToggleHold)
ssizer.Add(txt(arrowpanel, ' '), 0, wx.EXPAND|wx.ALL, 0)
ssizer.Add(self.wids['holdbtn'], 0, wx.EXPAND|wx.ALL, 2)
ssizer.Add(self.wids['kseries'], 0, wx.EXPAND|wx.ALL, 0)
ssizer.Add(self.wids['lseries'], 0, wx.EXPAND|wx.ALL, 0)
ssizer.Add(self.wids['mseries'], 0, wx.EXPAND|wx.ALL, 0)
pack(arrowpanel, ssizer)
# roi section...
rsizer = wx.GridBagSizer(4, 6)
roipanel = wx.Panel(ctrlpanel, name='ROI Panel')
self.wids['roilist'] = wx.ListBox(roipanel, size=(135, 120))
self.wids['roilist'].Bind(wx.EVT_LISTBOX, self.onROI)
self.wids['roilist'].SetMinSize((135, 120))
self.wids['roiname'] = wx.TextCtrl(roipanel, -1, '', size=(150, -1))
#
roibtns= wx.Panel(roipanel, name='ROIButtons')
zsizer = wx.BoxSizer(wx.HORIZONTAL)
z1 = Button(roibtns, 'Add', size=(70, 30), action=self.onNewROI)
z2 = Button(roibtns, 'Delete', size=(70, 30), action=self.onConfirmDelROI)
z3 = Button(roibtns, 'Rename', size=(70, 30), action=self.onRenameROI)
zsizer.Add(z1, 0, wx.EXPAND|wx.ALL, 0)
zsizer.Add(z2, 0, wx.EXPAND|wx.ALL, 0)
zsizer.Add(z3, 0, wx.EXPAND|wx.ALL, 0)
pack(roibtns, zsizer)
rt1 = txt(roipanel, ' Channels:', size=75, font=Font9)
rt2 = txt(roipanel, ' Energy:', size=75, font=Font9)
rt3 = txt(roipanel, ' Cen/Wid:', size=75, font=Font9)
m = ''
self.wids['roi_msg1'] = txt(roipanel, m, size=135, font=Font9)
self.wids['roi_msg2'] = txt(roipanel, m, size=135, font=Font9)
self.wids['roi_msg3'] = txt(roipanel, m, size=135, font=Font9)
rsizer.Add(txt(roipanel, ' Regions of Interest:', size=125, font=Font11),
(0, 0), (1, 3), labstyle)
rsizer.Add(self.wids['roiname'], (1, 0), (1, 3), labstyle)
rsizer.Add(roibtns, (2, 0), (1, 3), labstyle)
rsizer.Add(rt1, (3, 0), (1, 1), LEFT)
rsizer.Add(rt2, (4, 0), (1, 1), LEFT)
rsizer.Add(rt3, (5, 0), (1, 1), LEFT)
rsizer.Add(self.wids['roi_msg1'], (3, 1), (1, 2), labstyle)
rsizer.Add(self.wids['roi_msg2'], (4, 1), (1, 2), labstyle)
rsizer.Add(self.wids['roi_msg3'], (5, 1), (1, 2), labstyle)
rsizer.Add(self.wids['roilist'], (0, 3), (6, 1),
wx.EXPAND|wx.ALL|wx.ALIGN_RIGHT)
rsizer.SetHGap(1)
pack(roipanel, rsizer)
# end roi section
# y scale
yscalepanel = wx.Panel(ctrlpanel, name='YScalePanel')
ysizer = wx.BoxSizer(wx.HORIZONTAL)
ytitle = txt(yscalepanel, ' Y Axis:', font=Font10, size=80)
yspace = txt(yscalepanel, ' ', font=Font10, size=20)
ylog = Choice(yscalepanel, size=(80, 30), choices=['log', 'linear'],
action=self.onLogLinear)
yaxis = Check(yscalepanel, ' Show Y Scale ', action=self.onYAxis,
default=False)
self.wids['show_yaxis'] = yaxis
ysizer.Add(ytitle, 0, wx.ALIGN_CENTER_VERTICAL|wx.ALL, 0)
ysizer.Add(ylog, 0, wx.EXPAND|wx.ALL, 0)
ysizer.Add(yspace, 0, wx.EXPAND|wx.ALL, 0)
ysizer.Add(yaxis, 0, wx.EXPAND|wx.ALL, 0)
pack(yscalepanel, ysizer)
# zoom buttons
zoompanel = wx.Panel(ctrlpanel, name='ZoomPanel')
zsizer = wx.BoxSizer(wx.HORIZONTAL)
z1 = Button(zoompanel, 'Zoom In', size=(80, 30), action=self.onZoomIn)
z2 = Button(zoompanel, 'Zoom Out', size=(80, 30), action=self.onZoomOut)
p1 = Button(zoompanel, 'Pan Lo', size=(75, 30), action=self.onPanLo)
p2 = Button(zoompanel, 'Pan Hi', size=(75, 30), action=self.onPanHi)
zsizer.Add(p1, 0, wx.EXPAND|wx.ALL, 0)
zsizer.Add(p2, 0, wx.EXPAND|wx.ALL, 0)
zsizer.Add(z1, 0, wx.EXPAND|wx.ALL, 0)
zsizer.Add(z2, 0, wx.EXPAND|wx.ALL, 0)
pack(zoompanel, zsizer)
#
self.wids['xray_lines'] = None
if HAS_DV:
dvstyle = dv.DV_SINGLE|dv.DV_VERT_RULES|dv.DV_ROW_LINES
xlines = dv.DataViewListCtrl(ctrlpanel, style=dvstyle)
self.wids['xray_lines'] = xlines
xlines.AppendTextColumn('Line ', width=55)
xlines.AppendTextColumn('Energy(keV) ', width=110)
xlines.AppendTextColumn('Strength ', width=85)
xlines.AppendTextColumn('Levels ', width=75)
for col in (0, 1, 2, 3):
this = xlines.Columns[col]
this.Sortable = True
align = RIGHT
if col in (0, 3): align = wx.ALIGN_LEFT
this.Alignment = this.Renderer.Alignment = align
xlines.SetMinSize((300, 240))
xlines.Bind(dv.EVT_DATAVIEW_SELECTION_CHANGED,
self.onSelectXrayLine)
# main layout
# may have to adjust comparison....
store = xlines.GetStore()
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(roipanel, 0, labstyle)
sizer.Add(lin(ctrlpanel, 195), 0, labstyle)
sizer.Add(yscalepanel, 0, wx.ALIGN_RIGHT|wx.EXPAND|wx.ALL)
sizer.Add(zoompanel, 0, wx.ALIGN_RIGHT|wx.EXPAND|wx.ALL)
sizer.Add(lin(ctrlpanel, 195), 0, labstyle)
sizer.Add(ptable, 0, wx.ALIGN_RIGHT|wx.EXPAND|wx.ALL, 4)
sizer.Add(arrowpanel, 0, labstyle)
sizer.Add(lin(ctrlpanel, 195), 0, labstyle)
if self.wids['xray_lines'] is not None:
sizer.Add(xlines, 0, wx.ALIGN_CENTER|wx.GROW|wx.ALL|wx.EXPAND)
pack(ctrlpanel, sizer)
return ctrlpanel
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 XYFitPanel(wx.Panel):
def __init__(self, parent=None, controller=None, **kws):
wx.Panel.__init__(self, parent, -1, size=(550, 500), **kws)
self.parent = parent
self.controller = controller
self.larch = controller.larch
self.fit_components = OrderedDict()
self.fit_model = None
self.fit_params = None
self.user_added_params = None
self.summary = None
self.sizer = wx.GridBagSizer(10, 6)
self.build_display()
self.pick2_timer = wx.Timer(self)
self.pick2_group = None
self.Bind(wx.EVT_TIMER, self.onPick2Timer, self.pick2_timer)
self.pick2_t0 = 0.
self.pick2_timeout = 15.
self.pick2erase_timer = wx.Timer(self)
self.pick2erase_panel = None
self.Bind(wx.EVT_TIMER, self.onPick2EraseTimer, self.pick2erase_timer)
def build_display(self):
self.mod_nb = flat_nb.FlatNotebook(self, -1, agwStyle=FNB_STYLE)
self.mod_nb.SetTabAreaColour(wx.Colour(250, 250, 250))
self.mod_nb.SetActiveTabColour(wx.Colour(254, 254, 195))
self.mod_nb.SetNonActiveTabTextColour(wx.Colour(10, 10, 128))
self.mod_nb.SetActiveTabTextColour(wx.Colour(128, 0, 0))
self.mod_nb.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, self.onNBChanged)
self.param_panel = AllParamsPanel(self, controller=self.controller)
# self.mod_nb.AddPage(self.param_panel, 'Parameters', True)
range_row = wx.Panel(self)
rsizer = wx.BoxSizer(wx.HORIZONTAL)
xmin_sel = BitmapButton(range_row,
get_icon('plus'),
action=partial(self.on_selpoint, opt='xmin'),
tooltip='use last point selected from plot')
xmax_sel = BitmapButton(range_row,
get_icon('plus'),
action=partial(self.on_selpoint, opt='xmax'),
tooltip='use last point selected from plot')
opts = {'size': (70, -1), 'gformat': True}
self.xmin = FloatCtrl(range_row, value=-np.inf, **opts)
self.xmax = FloatCtrl(range_row, value=np.inf, **opts)
rsizer.Add(SimpleText(range_row, 'Fit Range X=[ '), 0, LCEN, 3)
rsizer.Add(xmin_sel, 0, LCEN, 3)
rsizer.Add(self.xmin, 0, LCEN, 3)
rsizer.Add(SimpleText(range_row, ' : '), 0, LCEN, 3)
rsizer.Add(xmax_sel, 0, LCEN, 3)
rsizer.Add(self.xmax, 0, LCEN, 3)
rsizer.Add(SimpleText(range_row, ' ] '), 0, LCEN, 3)
rsizer.Add(
Button(range_row,
'Full Data Range',
size=(150, -1),
action=self.onResetRange), 0, LCEN, 3)
pack(range_row, rsizer)
action_row = wx.Panel(self)
rsizer = wx.BoxSizer(wx.HORIZONTAL)
self.plot_comps = Check(action_row,
label='Plot Components?',
default=True,
size=(150, -1))
rsizer.Add(
Button(action_row, 'Run Fit', size=(100, -1),
action=self.onRunFit), 0, RCEN, 3)
savebtn = Button(action_row,
'Save Fit',
size=(100, -1),
action=self.onSaveFit)
savebtn.Disable()
rsizer.Add(savebtn, 0, LCEN, 3)
rsizer.Add(
Button(action_row,
'Plot Current Model',
size=(150, -1),
action=self.onShowModel), 0, LCEN, 3)
rsizer.Add(self.plot_comps, 0, LCEN, 3)
pack(action_row, rsizer)
models_row = wx.Panel(self)
rsizer = wx.BoxSizer(wx.HORIZONTAL)
self.model_choice = Choice(models_row,
size=(200, -1),
choices=ModelChoices['peaks'],
action=self.addModel)
rsizer.Add(SimpleText(models_row, ' Add Model Type: '), 0, LCEN, 3)
rsizer.Add(
Choice(models_row,
size=(100, -1),
choices=ModelTypes,
action=self.onModelTypes), 0, LCEN, 3)
rsizer.Add(SimpleText(models_row, ' Model: '), 0, LCEN, 3)
rsizer.Add(self.model_choice, 0, LCEN, 3)
pack(models_row, rsizer)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.AddMany([(range_row, 0, LCEN, 4), ((9, 9), 0, LCEN, 4),
(models_row, 0, LCEN, 4), ((9, 9), 0, LCEN, 4),
(action_row, 0, LCEN, 4), ((9, 9), 0, LCEN, 4),
(HLine(self, size=(550, 3)), 0, LCEN, 4),
((10, 10), 0, LCEN, 2),
(self.mod_nb, 1, LCEN | wx.GROW, 10)])
pack(self, sizer)
def onNBChanged(self, event=None):
idx = self.mod_nb.GetSelection()
if self.mod_nb.GetPage(idx) is self.param_panel:
self.build_fitmodel()
self.param_panel.show_parameters(self.fit_params,
self.user_added_params)
def onModelTypes(self, event=None):
modtype = event.GetString().lower()
self.model_choice.SetChoices(ModelChoices[modtype])
def addModel(self, event=None, model=None):
if model is None and event is not None:
model = event.GetString()
if model is None or model.startswith('<'):
return
curmodels = [
"c%i_" % (i + 1) for i in range(1 + len(self.fit_components))
]
for comp in self.fit_components:
if comp in curmodels:
curmodels.remove(comp)
prefix = curmodels[0]
label = "%s(prefix='%s')" % (model, prefix)
title = "%s: %s" % (prefix[:-1], (model + ' ' * 8)[:8])
mclass_kws = {'prefix': prefix}
if 'step' in model.lower():
form = model.lower().replace('step', '').strip()
if form.startswith('err'): form = 'erf'
label = "Step(form='%s', prefix='%s')" % (form, prefix)
title = "%s: Step %s" % (prefix[:-1], form[:3])
mclass = lm_models.StepModel
mclass_kws['form'] = form
minst = mclass(form=form, prefix=prefix)
else:
mclass = getattr(lm_models, model + 'Model')
minst = mclass(prefix=prefix)
panel = GridPanel(self.mod_nb, ncols=1, nrows=1, pad=1, itemstyle=CEN)
def SLabel(label, size=(80, -1), **kws):
return SimpleText(panel,
label,
size=size,
style=wx.ALIGN_LEFT,
**kws)
usebox = Check(panel, default=True, label='Use?', size=(75, -1))
delbtn = Button(panel,
'Delete Model',
size=(120, -1),
action=partial(self.onDeleteComponent, prefix=prefix))
pick2msg = SimpleText(panel, " ", size=(75, -1))
pick2btn = Button(panel,
'Pick Data Range',
size=(135, -1),
action=partial(self.onPick2Points, prefix=prefix))
# SetTip(mname, 'Label for the model component')
SetTip(usebox, 'Use this component in fit?')
SetTip(delbtn, 'Delete this model component')
SetTip(pick2btn, 'Select X range on Plot to Guess Initial Values')
panel.Add(HLine(panel, size=(520, 3)), style=wx.ALIGN_CENTER, dcol=6)
panel.Add(SLabel(label, size=(200, -1), colour='#0000AA'),
dcol=3,
newrow=True)
panel.AddMany((usebox, pick2msg, pick2btn))
panel.Add(SLabel("Parameter"), newrow=True)
panel.AddMany((SLabel("Value"), SLabel("Type"), SLabel("Min"),
SLabel("Max"), SLabel("Expression")))
parwids = OrderedDict()
parnames = sorted(minst.param_names)
for a in minst._func_allargs:
pname = "%s%s" % (prefix, a)
if (pname not in parnames and a in minst.param_hints
and a not in minst.independent_vars):
parnames.append(pname)
for pname in parnames:
sname = pname[len(prefix):]
hints = minst.param_hints.get(sname, {})
par = Parameter(name=pname, value=0, vary=True)
if 'min' in hints:
par.min = hints['min']
if 'max' in hints:
par.max = hints['max']
if 'value' in hints:
par.value = hints['value']
if 'expr' in hints:
par.expr = hints['expr']
pwids = ParameterWidgets(panel,
par,
name_size=80,
expr_size=175,
float_size=80,
prefix=prefix,
widgets=('name', 'value', 'minval',
'maxval', 'vary', 'expr'))
parwids[par.name] = pwids
panel.Add(pwids.name, newrow=True)
panel.AddMany((pwids.value, pwids.vary, pwids.minval, pwids.maxval,
pwids.expr))
for sname, hint in minst.param_hints.items():
pname = "%s%s" % (prefix, sname)
if 'expr' in hint and pname not in parnames:
par = Parameter(name=pname, value=0, expr=hint['expr'])
pwids = ParameterWidgets(panel,
par,
name_size=80,
expr_size=275,
float_size=80,
prefix=prefix,
widgets=('name', 'value', 'vary',
'expr'))
parwids[par.name] = pwids
panel.Add(pwids.name, newrow=True)
panel.AddMany((pwids.value, pwids.vary))
panel.Add(pwids.expr, dcol=3, style=wx.ALIGN_RIGHT)
pwids.value.Disable()
pwids.vary.Disable()
panel.Add(HLine(panel, size=(90, 3)),
style=wx.ALIGN_CENTER,
newrow=True)
panel.Add(delbtn, dcol=2)
panel.Add(HLine(panel, size=(250, 3)), dcol=3, style=wx.ALIGN_CENTER)
fgroup = Group(prefix=prefix,
title=title,
mclass=mclass,
mclass_kws=mclass_kws,
usebox=usebox,
panel=panel,
parwids=parwids,
float_size=65,
expr_size=150,
pick2_msg=pick2msg)
self.fit_components[prefix] = fgroup
panel.pack()
self.mod_nb.AddPage(panel, title, True)
sx, sy = self.GetSize()
self.SetSize((sx, sy + 1))
self.SetSize((sx, sy))
def onDeleteComponent(self, evt=None, prefix=None):
fgroup = self.fit_components.get(prefix, None)
if fgroup is None:
return
for i in range(self.mod_nb.GetPageCount()):
if fgroup.title == self.mod_nb.GetPageText(i):
self.mod_nb.DeletePage(i)
for attr in dir(fgroup):
setattr(fgroup, attr, None)
self.fit_components.pop(prefix)
sx, sy = self.GetSize()
self.SetSize((sx, sy + 1))
self.SetSize((sx, sy))
def onPick2EraseTimer(self, evt=None):
"""erases line trace showing automated 'Pick 2' guess """
self.pick2erase_timer.Stop()
panel = self.pick2erase_panel
ntrace = panel.conf.ntrace - 1
trace = panel.conf.get_mpl_line(ntrace)
panel.conf.get_mpl_line(ntrace).set_data(np.array([]), np.array([]))
panel.conf.ntrace = ntrace
panel.draw()
def onPick2Timer(self, evt=None):
"""checks for 'Pick 2' events, and initiates 'Pick 2' guess
for a model from the selected data range
"""
try:
plotframe = self.controller.get_display(stacked=False)
curhist = plotframe.cursor_hist[:]
plotframe.Raise()
except:
return
if (time.time() - self.pick2_t0) > self.pick2_timeout:
msg = self.pick2_group.pick2_msg.SetLabel(" ")
plotframe.cursor_hist = []
self.pick2_timer.Stop()
return
if len(curhist) < 2:
self.pick2_group.pick2_msg.SetLabel("%i/2" % (len(curhist)))
return
self.pick2_group.pick2_msg.SetLabel("done.")
self.pick2_timer.Stop()
# guess param values
xcur = (curhist[0][0], curhist[1][0])
xmin, xmax = min(xcur), max(xcur)
dgroup = getattr(self.larch.symtable, self.controller.groupname)
x, y = dgroup.x, dgroup.y
i0 = index_of(dgroup.x, xmin)
i1 = index_of(dgroup.x, xmax)
x, y = dgroup.x[i0:i1 + 1], dgroup.y[i0:i1 + 1]
mod = self.pick2_group.mclass(prefix=self.pick2_group.prefix)
parwids = self.pick2_group.parwids
try:
guesses = mod.guess(y, x=x)
except:
return
for name, param in guesses.items():
if name in parwids:
parwids[name].value.SetValue(param.value)
dgroup._tmp = mod.eval(guesses, x=dgroup.x)
plotframe = self.controller.get_display(stacked=False)
plotframe.cursor_hist = []
plotframe.oplot(dgroup.x, dgroup._tmp)
self.pick2erase_panel = plotframe.panel
self.pick2erase_timer.Start(5000)
def onPick2Points(self, evt=None, prefix=None):
fgroup = self.fit_components.get(prefix, None)
if fgroup is None:
return
plotframe = self.controller.get_display(stacked=False)
plotframe.Raise()
plotframe.cursor_hist = []
fgroup.npts = 0
self.pick2_group = fgroup
if fgroup.pick2_msg is not None:
fgroup.pick2_msg.SetLabel("0/2")
self.pick2_t0 = time.time()
self.pick2_timer.Start(250)
def onSaveFit(self, event=None):
dgroup = self.get_datagroup()
deffile = dgroup.filename.replace('.', '_') + '.fitconf'
outfile = FileSave(self,
'Save Fit Configuration and Results',
default_file=deffile,
wildcard=FITCONF_WILDCARDS)
if outfile is None:
return
buff = ['#XYFit Config version 1']
buff.append(
json.dumps(encode4js(self.summary), encoding='UTF-8', default=str))
buff.append('')
try:
fout = open(outfile, 'w')
fout.write('\n'.join(buff))
fout.close()
except IOError:
print('could not write %s' % outfile)
def onResetRange(self, event=None):
dgroup = self.get_datagroup()
self.xmin.SetValue(min(dgroup.x))
self.xmax.SetValue(max(dgroup.x))
def on_selpoint(self, evt=None, opt='xmin'):
xval = None
try:
xval = self.larch.symtable._plotter.plot1_x
except:
xval = None
if xval is not None:
if opt == 'xmin':
self.xmin.SetValue(xval)
elif opt == 'xmax':
self.xmax.SetValue(xval)
def get_datagroup(self):
dgroup = None
if self.controller.groupname is not None:
try:
dgroup = getattr(self.larch.symtable,
self.controller.groupname)
except:
pass
return dgroup
def get_xranges(self, x):
xmin, xmax = min(x), max(x)
i1, i2 = 0, len(x)
_xmin = self.xmin.GetValue()
_xmax = self.xmax.GetValue()
if _xmin > min(x):
i1 = index_of(x, _xmin)
xmin = x[i1]
if _xmax < max(x):
i2 = index_of(x, _xmax) + 1
xmax = x[i2]
xv1 = max(min(x), xmin - (xmax - xmin) / 5.0)
xv2 = min(max(x), xmax + (xmax - xmin) / 5.0)
return i1, i2, xv1, xv2
def build_fitmodel(self):
""" use fit components to build model"""
dgroup = self.get_datagroup()
fullmodel = None
params = Parameters()
self.summary = {'components': [], 'options': {}}
for comp in self.fit_components.values():
if comp.usebox is not None and comp.usebox.IsChecked():
for parwids in comp.parwids.values():
params.add(parwids.param)
self.summary['components'].append(
(comp.mclass.__name__, comp.mclass_kws))
thismodel = comp.mclass(**comp.mclass_kws)
if fullmodel is None:
fullmodel = thismodel
else:
fullmodel += thismodel
self.fit_model = fullmodel
self.fit_params = params
if dgroup is not None:
i1, i2, xv1, xv2 = self.get_xranges(dgroup.x)
xsel = dgroup.x[slice(i1, i2)]
dgroup.xfit = xsel
dgroup.yfit = self.fit_model.eval(self.fit_params, x=xsel)
dgroup.ycomps = self.fit_model.eval_components(
params=self.fit_params, x=xsel)
return dgroup
def onShowModel(self, event=None):
dgroup = self.build_fitmodel()
if dgroup is not None:
with_components = (self.plot_comps.IsChecked()
and len(dgroup.ycomps) > 1)
self.plot_fitmodel(dgroup,
show_resid=False,
with_components=with_components)
def plot_fitmodel(self, dgroup, show_resid=False, with_components=None):
if dgroup is None:
return
i1, i2, xv1, xv2 = self.get_xranges(dgroup.x)
ysel = dgroup.y[slice(i1, i2)]
plotframe = self.controller.get_display(stacked=True)
plotframe.plot(dgroup.xfit,
ysel,
new=True,
panel='top',
xmin=xv1,
xmax=xv2,
label='data',
xlabel=dgroup.plot_xlabel,
ylabel=dgroup.plot_ylabel,
title='Larch XYFit: %s' % dgroup.filename)
plotframe.oplot(dgroup.xfit, dgroup.yfit, label='fit')
plotframe.plot(dgroup.xfit,
ysel - dgroup.yfit,
grid=False,
marker='o',
markersize=4,
linewidth=1,
panel='bot')
if with_components is None:
with_components = (self.plot_comps.IsChecked()
and len(dgroup.ycomps) > 1)
if with_components:
for label, _y in dgroup.ycomps.items():
plotframe.oplot(dgroup.xfit,
_y,
label=label,
style='short dashed')
line_opts = dict(color='#AAAAAA',
label='_nolegend_',
linewidth=1,
zorder=-5)
plotframe.panel_bot.axes.axhline(0, **line_opts)
axvline = plotframe.panel.axes.axvline
if i1 > 0:
axvline(dgroup.x[i1], **line_opts)
if i2 < len(dgroup.x):
axvline(dgroup.x[i2 - 1], **line_opts)
plotframe.panel.canvas.draw()
def onRunFit(self, event=None):
dgroup = self.build_fitmodel()
if dgroup is None:
return
i1, i2, xv1, xv2 = self.get_xranges(dgroup.x)
dgroup.xfit = dgroup.x[slice(i1, i2)]
ysel = dgroup.y[slice(i1, i2)]
weights = np.ones(len(ysel))
if hasattr(dgroup, 'yerr'):
yerr = dgroup.yerr
if not isinstance(yerr, np.ndarray):
yerr = yerr * np.ones(len(ysel))
else:
yerr = yerr[slice(i1, i2)]
yerr_min = 1.e-9 * ysel.mean()
yerr[np.where(yerr < yerr_min)] = yerr_min
weights = 1.0 / yerr
result = self.fit_model.fit(ysel,
params=self.fit_params,
x=dgroup.xfit,
weights=weights,
method='leastsq')
self.summary['xmin'] = xv1
self.summary['xmax'] = xv2
for attr in ('aic', 'bic', 'chisqr', 'redchi', 'ci_out', 'covar',
'flatchain', 'success', 'nan_policy', 'nfev', 'ndata',
'nfree', 'nvarys', 'init_values'):
self.summary[attr] = getattr(result, attr)
self.summary['params'] = result.params
dgroup.fit_history = []
dgroup.fit_history.append(self.summary)
dgroup.yfit = result.best_fit
dgroup.ycomps = self.fit_model.eval_components(params=result.params,
x=dgroup.xfit)
with_components = (self.plot_comps.IsChecked()
and len(dgroup.ycomps) > 1)
self.plot_fitmodel(dgroup,
show_resid=True,
with_components=with_components)
# print(" == fit model == ", self.fit_model)
# print(" == fit result == ", result)
model_repr = self.fit_model._reprstring(long=True)
report = fit_report(result,
show_correl=True,
min_correl=0.25,
sort_pars=True)
report = '[[Model]]\n %s\n%s\n' % (model_repr, report)
self.summary['report'] = report
self.controller.show_report(report)
# fill parameters with best fit values
allparwids = {}
for comp in self.fit_components.values():
if comp.usebox is not None and comp.usebox.IsChecked():
for name, parwids in comp.parwids.items():
allparwids[name] = parwids
for pname, par in result.params.items():
if pname in allparwids:
allparwids[pname].value.SetValue(par.value)
class XASNormPanel(wx.Panel):
"""XAS normalization Panel"""
def __init__(self, parent, controller=None, reporter=None, **kws):
wx.Panel.__init__(self, parent, -1, **kws)
self.parent = parent
self.controller = controller
self.reporter = reporter
self.skip_process = False
self.build_display()
def onPanelExposed(self, **kws):
# called when notebook is selected
try:
fname = self.controller.filelist.GetStringSelection()
gname = self.controller.file_groups[fname]
dgroup = self.controller.get_group(gname)
self.fill_form(dgroup)
except:
pass
def larch_eval(self, cmd):
"""eval"""
self.controller.larch.eval(cmd)
def build_display(self):
self.SetFont(Font(10))
titleopts = dict(font=Font(11), colour='#AA0000')
xas = self.xaspanel = GridPanel(self,
ncols=4,
nrows=4,
pad=2,
itemstyle=LCEN)
self.plotone_op = Choice(xas,
choices=list(PlotOne_Choices.keys()),
action=self.onPlotOne,
size=(200, -1))
self.plotsel_op = Choice(xas,
choices=list(PlotSel_Choices.keys()),
action=self.onPlotSel,
size=(200, -1))
self.plotone_op.SetStringSelection('Normalized')
self.plotsel_op.SetStringSelection('Normalized')
plot_one = Button(xas,
'Plot This Group',
size=(150, -1),
action=self.onPlotOne)
plot_sel = Button(xas,
'Plot Selected Groups',
size=(150, -1),
action=self.onPlotSel)
self.btns = {}
opts = dict(action=self.onReprocess)
self.deconv_ewid = FloatCtrl(xas,
value=0.5,
precision=2,
minval=0,
size=(50, -1),
**opts)
self.deconv_form = Choice(xas,
choices=DECONV_OPS,
size=(100, -1),
**opts)
e0opts_panel = wx.Panel(xas)
self.xas_autoe0 = Check(e0opts_panel,
default=True,
label='auto?',
**opts)
self.xas_showe0 = Check(e0opts_panel,
default=True,
label='show?',
**opts)
sx = wx.BoxSizer(wx.HORIZONTAL)
sx.Add(self.xas_autoe0, 0, LCEN, 4)
sx.Add(self.xas_showe0, 0, LCEN, 4)
pack(e0opts_panel, sx)
self.xas_autostep = Check(xas, default=True, label='auto?', **opts)
for name in ('e0', 'pre1', 'pre2', 'nor1', 'nor2'):
bb = BitmapButton(xas,
get_icon('plus'),
action=partial(self.on_selpoint, opt=name),
tooltip='use last point selected from plot')
self.btns[name] = bb
opts['size'] = (50, -1)
self.xas_vict = Choice(xas, choices=('0', '1', '2', '3'), **opts)
self.xas_nnor = Choice(xas, choices=('0', '1', '2', '3'), **opts)
self.xas_vict.SetSelection(1)
self.xas_nnor.SetSelection(1)
opts.update({'size': (75, -1), 'precision': 1})
self.xas_pre1 = FloatCtrl(xas, value=-np.inf, **opts)
self.xas_pre2 = FloatCtrl(xas, value=-30, **opts)
self.xas_nor1 = FloatCtrl(xas, value=50, **opts)
self.xas_nor2 = FloatCtrl(xas, value=np.inf, **opts)
opts = {'size': (75, -1), 'gformat': True}
self.xas_e0 = FloatCtrl(xas, value=0, action=self.onSet_XASE0, **opts)
self.xas_step = FloatCtrl(xas,
value=0,
action=self.onSet_XASStep,
**opts)
saveconf = Button(xas,
'Save as Default Settings',
size=(200, -1),
action=self.onSaveConfigBtn)
def CopyBtn(name):
return Button(xas,
'Copy',
size=(50, -1),
action=partial(self.onCopyParam, name))
xas.Add(SimpleText(xas, ' XAS Pre-edge subtraction and Normalization',
**titleopts),
dcol=6)
xas.Add(SimpleText(xas, ' Copy to Selected Groups?'),
style=RCEN,
dcol=3)
xas.Add(plot_sel, newrow=True)
xas.Add(self.plotsel_op, dcol=6)
xas.Add(plot_one, newrow=True)
xas.Add(self.plotone_op, dcol=6)
xas.Add((10, 10))
xas.Add(CopyBtn('plotone_op'), style=RCEN)
xas.Add(SimpleText(xas, 'E0 : '), newrow=True)
xas.Add(self.btns['e0'])
xas.Add(self.xas_e0)
xas.Add(e0opts_panel, dcol=4)
xas.Add((10, 1))
xas.Add(CopyBtn('xas_e0'), style=RCEN)
xas.Add(SimpleText(xas, 'Edge Step: '), newrow=True)
xas.Add((10, 1))
xas.Add(self.xas_step)
xas.Add(self.xas_autostep, dcol=3)
xas.Add((10, 1))
xas.Add((10, 1))
xas.Add(CopyBtn('xas_step'), style=RCEN)
xas.Add(SimpleText(xas, 'Pre-edge range: '), newrow=True)
xas.Add(self.btns['pre1'])
xas.Add(self.xas_pre1)
xas.Add(SimpleText(xas, ':'))
xas.Add(self.btns['pre2'])
xas.Add(self.xas_pre2)
xas.Add(SimpleText(xas, 'Victoreen:'))
xas.Add(self.xas_vict)
xas.Add(CopyBtn('xas_pre'), style=RCEN)
xas.Add(SimpleText(xas, 'Normalization range: '), newrow=True)
xas.Add(self.btns['nor1'])
xas.Add(self.xas_nor1)
xas.Add(SimpleText(xas, ':'))
xas.Add(self.btns['nor2'])
xas.Add(self.xas_nor2)
xas.Add(SimpleText(xas, 'Poly Order:'))
xas.Add(self.xas_nnor)
xas.Add(CopyBtn('xas_norm'), style=RCEN)
xas.Add(SimpleText(xas, ' Deconvolution:'), newrow=True)
xas.Add(self.deconv_form, dcol=5)
xas.Add(SimpleText(xas, 'Energy width:'))
xas.Add(self.deconv_ewid)
xas.Add(CopyBtn('deconv'), style=RCEN)
xas.Add(saveconf, dcol=6, newrow=True)
xas.pack()
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add((5, 5), 0, LCEN, 3)
sizer.Add(HLine(self, size=(550, 2)), 0, LCEN, 3)
sizer.Add(xas, 0, LCEN, 3)
sizer.Add((5, 5), 0, LCEN, 3)
sizer.Add(HLine(self, size=(550, 2)), 0, LCEN, 3)
pack(self, sizer)
def get_config(self, dgroup=None):
"""get processing configuration for a group"""
if dgroup is None:
dgroup = self.controller.get_group()
conf = getattr(dgroup, 'xasnorm_config', {})
if 'e0' not in conf:
conf = default_xasnorm_config()
dgroup.xasnorm_config = conf
return conf
def fill_form(self, dgroup):
"""fill in form from a data group"""
opts = self.get_config(dgroup)
self.skip_process = True
widlist = (self.xas_e0, self.xas_step, self.xas_pre1, self.xas_pre2,
self.xas_nor1, self.xas_nor2, self.xas_vict, self.xas_nnor,
self.xas_showe0, self.xas_autoe0, self.xas_autostep,
self.deconv_form, self.deconv_ewid)
if dgroup.datatype == 'xas':
for k in widlist:
k.Enable()
self.plotone_op.SetChoices(list(PlotOne_Choices.keys()))
self.plotsel_op.SetChoices(list(PlotSel_Choices.keys()))
self.plotone_op.SetStringSelection(opts['plotone_op'])
self.plotsel_op.SetStringSelection(opts['plotsel_op'])
self.xas_e0.SetValue(opts['e0'])
self.xas_step.SetValue(opts['edge_step'])
self.xas_pre1.SetValue(opts['pre1'])
self.xas_pre2.SetValue(opts['pre2'])
self.xas_nor1.SetValue(opts['norm1'])
self.xas_nor2.SetValue(opts['norm2'])
self.xas_vict.SetSelection(opts['nvict'])
self.xas_nnor.SetSelection(opts['nnorm'])
self.xas_showe0.SetValue(opts['show_e0'])
self.xas_autoe0.SetValue(opts['auto_e0'])
self.xas_autostep.SetValue(opts['auto_step'])
self.deconv_form.SetStringSelection(opts['deconv_form'])
self.deconv_ewid.SetValue(opts['deconv_ewid'])
else:
self.plotone_op.SetChoices(list(PlotOne_Choices_nonxas.keys()))
self.plotsel_op.SetChoices(list(PlotSel_Choices_nonxas.keys()))
self.plotone_op.SetStringSelection('Raw Data')
self.plotsel_op.SetStringSelection('Raw Data')
for k in widlist:
k.Disable()
self.skip_process = False
self.process(dgroup)
def read_form(self):
"read for, returning dict of values"
form_opts = {}
form_opts['e0'] = self.xas_e0.GetValue()
form_opts['edge_step'] = self.xas_step.GetValue()
form_opts['pre1'] = self.xas_pre1.GetValue()
form_opts['pre2'] = self.xas_pre2.GetValue()
form_opts['norm1'] = self.xas_nor1.GetValue()
form_opts['norm2'] = self.xas_nor2.GetValue()
form_opts['nnorm'] = int(self.xas_nnor.GetSelection())
form_opts['nvict'] = int(self.xas_vict.GetSelection())
form_opts['plotone_op'] = self.plotone_op.GetStringSelection()
form_opts['plotsel_op'] = self.plotsel_op.GetStringSelection()
form_opts['show_e0'] = self.xas_showe0.IsChecked()
form_opts['auto_e0'] = self.xas_autoe0.IsChecked()
form_opts['auto_step'] = self.xas_autostep.IsChecked()
form_opts['deconv_form'] = self.deconv_form.GetStringSelection()
form_opts['deconv_ewid'] = self.deconv_ewid.GetValue()
return form_opts
def onPlotOne(self, evt=None):
self.plot(self.controller.get_group())
def onPlotSel(self, evt=None):
newplot = True
group_ids = self.controller.filelist.GetCheckedStrings()
if len(group_ids) < 1:
return
last_id = group_ids[-1]
yarray_name = PlotSel_Choices[self.plotsel_op.GetStringSelection()]
ylabel = getattr(plotlabels, yarray_name)
# print("Plot Sel:: ", group_ids)
for checked in group_ids:
groupname = self.controller.file_groups[str(checked)]
dgroup = self.controller.get_group(groupname)
plot_yarrays = [(yarray_name, PLOTOPTS_1, dgroup.filename)]
dgroup.plot_ylabel = ylabel
if dgroup is not None:
dgroup.plot_extras = []
# print(" PlotSel -> plot ", checked, (last_id!=checked) )
self.plot(dgroup,
title='',
new=newplot,
plot_yarrays=plot_yarrays,
show_legend=True,
with_extras=False,
delay_draw=(last_id != checked))
newplot = False
self.controller.get_display(stacked=False).panel.canvas.draw()
def onSaveConfigBtn(self, evt=None):
conf = self.controller.larch.symtable._sys.xas_viewer
opts = {}
opts.update(getattr(conf, 'xas_norm', {}))
opts.update(self.read_form())
conf.xas_norm = opts
def onCopyParam(self, name=None, evt=None):
conf = self.get_config()
conf.update(self.read_form())
opts = {}
name = str(name)
def copy_attrs(*args):
for a in args:
opts[a] = conf[a]
if name == 'plotone_op':
copy_attrs('plotone_op')
elif name == 'xas_e0':
copy_attrs('e0', 'show_e0')
opts['auto_e0'] = False
elif name == 'xas_step':
copy_attrs('edge_step')
opts['auto_step'] = False
elif name == 'xas_pre':
copy_attrs('pre1', 'pre2', 'nvict')
elif name == 'xas_norm':
copy_attrs('nnorm', 'norm1', 'norm2')
elif name == 'deconv':
copy_attrs('deconv_form', 'deconv_ewid')
for checked in self.controller.filelist.GetCheckedStrings():
groupname = self.controller.file_groups[str(checked)]
grp = self.controller.get_group(groupname)
if grp != self.controller.group:
grp.xasnorm_config.update(opts)
self.fill_form(grp)
self.process(grp)
def onSet_XASE0(self, evt=None, value=None):
self.xas_autoe0.SetValue(0)
self.onReprocess()
def onSet_XASStep(self, evt=None, value=None):
self.xas_autostep.SetValue(0)
self.onReprocess()
def onReprocess(self, evt=None, value=None, **kws):
if self.skip_process:
return
try:
dgroup = self.controller.get_group()
except TypeError:
return
self.process(dgroup)
self.plot(dgroup)
def on_selpoint(self, evt=None, opt='e0'):
xval, yval = self.controller.get_cursor()
if xval is None:
return
e0 = self.xas_e0.GetValue()
if opt == 'e0':
self.xas_e0.SetValue(xval)
self.xas_autoe0.SetValue(0)
elif opt == 'pre1':
self.xas_pre1.SetValue(xval - e0)
elif opt == 'pre2':
self.xas_pre2.SetValue(xval - e0)
elif opt == 'nor1':
self.xas_nor1.SetValue(xval - e0)
elif opt == 'nor2':
self.xas_nor2.SetValue(xval - e0)
else:
print(" unknown selection point ", opt)
def process(self, dgroup, **kws):
""" handle process (pre-edge/normalize, deconvolve) of XAS data from XAS form
"""
if self.skip_process:
return
self.skip_process = True
dgroup.custom_plotopts = {}
# print("XAS norm process ", dgroup.datatype)
if dgroup.datatype != 'xas':
self.skip_process = False
dgroup.mu = dgroup.ydat * 1.0
return
en_units = getattr(dgroup, 'energy_units', None)
if en_units is None:
en_units = 'eV'
units = guess_energy_units(dgroup.energy)
if units != 'eV':
dlg = EnergyUnitsDialog(self.parent, units, dgroup.energy)
res = dlg.GetResponse()
dlg.Destroy()
if res.ok:
en_units = res.units
dgroup.xdat = dgroup.energy = res.energy
dgroup.energy_units = en_units
form = self.read_form()
e0 = form['e0']
edge_step = form['edge_step']
form['group'] = dgroup.groupname
copts = [dgroup.groupname]
if not form['auto_e0']:
if e0 < max(dgroup.energy) and e0 > min(dgroup.energy):
copts.append("e0=%.4f" % float(e0))
if not form['auto_step']:
copts.append("step=%.4f" % float(edge_step))
for attr in ('pre1', 'pre2', 'nvict', 'nnorm', 'norm1', 'norm2'):
copts.append("%s=%.2f" % (attr, form[attr]))
self.larch_eval("pre_edge(%s)" % (', '.join(copts)))
if form['auto_e0']:
self.xas_e0.SetValue(dgroup.e0, act=False)
if form['auto_step']:
self.xas_step.SetValue(dgroup.edge_step, act=False)
self.xas_pre1.SetValue(dgroup.pre_edge_details.pre1)
self.xas_pre2.SetValue(dgroup.pre_edge_details.pre2)
self.xas_nor1.SetValue(dgroup.pre_edge_details.norm1)
self.xas_nor2.SetValue(dgroup.pre_edge_details.norm2)
# deconvolution
deconv_form = form['deconv_form'].lower()
deconv_ewid = float(form['deconv_ewid'])
if not deconv_form.startswith('none') and deconv_ewid > 1.e-3:
dopts = [
dgroup.groupname,
"form='%s'" % (deconv_form),
"esigma=%.4f" % (deconv_ewid)
]
self.larch_eval("xas_deconvolve(%s)" % (', '.join(dopts)))
for attr in ('e0', 'edge_step'):
dgroup.xasnorm_config[attr] = getattr(dgroup, attr)
for attr in ('pre1', 'pre2', 'nnorm', 'norm1', 'norm2'):
dgroup.xasnorm_config[attr] = getattr(dgroup.pre_edge_details,
attr)
self.skip_process = False
def get_plot_arrays(self, dgroup):
form = self.read_form()
lab = plotlabels.norm
dgroup.plot_y2label = None
dgroup.plot_xlabel = plotlabels.energy
dgroup.plot_yarrays = [('norm', PLOTOPTS_1, lab)]
if dgroup.datatype != 'xas':
pchoice = PlotOne_Choices_nonxas[
self.plotone_op.GetStringSelection()]
dgroup.plot_xlabel = 'x'
dgroup.plot_ylabel = 'y'
dgroup.plot_yarrays = [('ydat', PLOTOPTS_1, 'ydat')]
dgroup.dmude = np.gradient(dgroup.ydat) / np.gradient(dgroup.xdat)
if pchoice == 'dmude':
dgroup.plot_ylabel = 'dy/dx'
dgroup.plot_yarrays = [('dmude', PLOTOPTS_1, 'dy/dx')]
elif pchoice == 'norm+deriv':
lab = plotlabels.norm
dgroup.plot_y2label = 'dy/dx'
dgroup.plot_yarrays = [('ydat', PLOTOPTS_1, 'y'),
('dmude', PLOTOPTS_D, 'dy/dx')]
return
pchoice = PlotOne_Choices[self.plotone_op.GetStringSelection()]
if pchoice in ('mu', 'norm', 'flat', 'dmude'):
lab = getattr(plotlabels, pchoice)
dgroup.plot_yarrays = [(pchoice, PLOTOPTS_1, lab)]
elif pchoice == 'prelines':
dgroup.plot_yarrays = [('mu', PLOTOPTS_1, lab),
('pre_edge', PLOTOPTS_2, 'pre edge'),
('post_edge', PLOTOPTS_2, 'post edge')]
elif pchoice == 'preedge':
dgroup.pre_edge_sub = dgroup.norm * dgroup.edge_step
dgroup.plot_yarrays = [('pre_edge_sub', PLOTOPTS_1,
r'pre-edge subtracted $\mu$')]
lab = r'pre-edge subtracted $\mu$'
elif pchoice == 'norm+deriv':
lab = plotlabels.norm
lab2 = plotlabels.dmude
dgroup.plot_yarrays = [('norm', PLOTOPTS_1, lab),
('dmude', PLOTOPTS_D, lab2)]
dgroup.plot_y2label = lab2
elif pchoice == 'deconv' and hasattr(dgroup, 'deconv'):
lab = plotlabels.deconv
dgroup.plot_yarrays = [('deconv', PLOTOPTS_1, lab)]
elif pchoice == 'deconv+norm' and hasattr(dgroup, 'deconv'):
lab1 = plotlabels.norm
lab2 = plotlabels.deconv
dgroup.plot_yarrays = [('deconv', PLOTOPTS_1, lab2),
('norm', PLOTOPTS_1, lab1)]
lab = lab1 + ' + ' + lab2
dgroup.plot_ylabel = lab
y4e0 = dgroup.ydat = getattr(dgroup, dgroup.plot_yarrays[0][0],
dgroup.mu)
dgroup.plot_extras = []
if form['show_e0']:
ie0 = index_of(dgroup.energy, dgroup.e0)
dgroup.plot_extras.append(('marker', dgroup.e0, y4e0[ie0], {}))
def plot(self,
dgroup,
title=None,
plot_yarrays=None,
delay_draw=False,
new=True,
zoom_out=True,
with_extras=True,
**kws):
self.get_plot_arrays(dgroup)
ppanel = self.controller.get_display(stacked=False).panel
viewlims = ppanel.get_viewlimits()
plotcmd = ppanel.oplot
if new:
plotcmd = ppanel.plot
groupname = dgroup.groupname
if not hasattr(dgroup, 'xdat'):
print("Cannot plot group ", groupname)
if ((getattr(dgroup, 'plot_yarrays', None) is None
or getattr(dgroup, 'energy', None) is None
or getattr(dgroup, 'mu', None) is None)):
self.process(dgroup)
if plot_yarrays is None and hasattr(dgroup, 'plot_yarrays'):
plot_yarrays = dgroup.plot_yarrays
popts = kws
path, fname = os.path.split(dgroup.filename)
if not 'label' in popts:
popts['label'] = dgroup.plot_ylabel
zoom_out = (zoom_out or min(dgroup.xdat) >= viewlims[1]
or max(dgroup.xdat) <= viewlims[0]
or min(dgroup.ydat) >= viewlims[3]
or max(dgroup.ydat) <= viewlims[2])
if not zoom_out:
popts['xmin'] = viewlims[0]
popts['xmax'] = viewlims[1]
popts['ymin'] = viewlims[2]
popts['ymax'] = viewlims[3]
popts['xlabel'] = dgroup.plot_xlabel
popts['ylabel'] = dgroup.plot_ylabel
if getattr(dgroup, 'plot_y2label', None) is not None:
popts['y2label'] = dgroup.plot_y2label
plot_extras = None
if new:
if title is None:
title = fname
plot_extras = getattr(dgroup, 'plot_extras', None)
popts['title'] = title
popts['delay_draw'] = delay_draw
if hasattr(dgroup, 'custom_plotopts'):
popts.update(dgroup.custom_plotopts)
narr = len(plot_yarrays) - 1
for i, pydat in enumerate(plot_yarrays):
yaname, yopts, yalabel = pydat
popts.update(yopts)
if yalabel is not None:
popts['label'] = yalabel
popts['delay_draw'] = delay_draw or (i != narr)
# print("plot:: ", i, popts['delay_draw'], plotcmd)
# print(popts)
plotcmd(dgroup.xdat, getattr(dgroup, yaname), **popts)
plotcmd = ppanel.oplot
if with_extras and plot_extras is not None:
axes = ppanel.axes
for etype, x, y, opts in plot_extras:
if etype == 'marker':
xpopts = {
'marker': 'o',
'markersize': 4,
'label': '_nolegend_',
'markerfacecolor': 'red',
'markeredgecolor': '#884444'
}
xpopts.update(opts)
axes.plot([x], [y], **xpopts)
elif etype == 'vline':
xpopts = {
'ymin': 0,
'ymax': 1.0,
'label': '_nolegend_',
'color': '#888888'
}
xpopts.update(opts)
axes.axvline(x, **xpopts)
if not popts['delay_draw']:
ppanel.canvas.draw()
def __init__(self, parent, param, precision=4, vary=None, **kws):
self.param = param
title = " Parameter: %s " % (param.name)
wx.Dialog.__init__(self, parent, wx.ID_ANY, title=title)
panel = GridPanel(self)
self.SetFont(parent.GetFont())
if vary is None:
vary = 0
if param.vary:
vary = 1
elif param.expr is not None:
vary = 2
minval, maxval = param.min, param.max
stderr, expr = param.stderr, param.expr
sminval = "%s" % minval
smaxval = "%s" % maxval
if minval in (None, 'None', -np.inf): minval = -np.inf
if maxval in (None, 'None', np.inf): maxval = np.inf
if stderr is None: stderr = ''
if expr is None: expr = ''
self.wids = Empty()
self.wids.vary = Choice(panel,
choices=VARY_CHOICES,
action=self.onVaryChoice,
size=(110, -1))
self.wids.vary.SetSelection(vary)
self.wids.val = FloatCtrl(panel,
value=param.value,
size=(100, -1),
precision=precision,
minval=minval,
maxval=maxval)
self.wids.min = FloatCtrl(panel, value=minval, size=(100, -1))
self.wids.max = FloatCtrl(panel, value=maxval, size=(100, -1))
self.wids.expr = wx.TextCtrl(panel, value=expr, size=(300, -1))
self.wids.err = wx.StaticText(panel, label="%s" % stderr)
SetTip(self.wids.expr, "Mathematical expression to calcutate value")
btnsizer = wx.StdDialogButtonSizer()
ok_btn = wx.Button(panel, wx.ID_OK)
ok_btn.SetDefault()
btnsizer.AddButton(ok_btn)
btnsizer.AddButton(wx.Button(panel, wx.ID_CANCEL))
btnsizer.Realize()
panel.AddText(' Name:', style=LEFT)
panel.AddText(param.name, style=LEFT)
panel.AddText(' Type:', style=LEFT)
panel.Add(self.wids.vary, style=LEFT)
panel.AddText(' Value:', style=LEFT, newrow=True)
panel.Add(self.wids.val, style=LEFT)
panel.AddText(' Std Error:', style=LEFT)
panel.Add(self.wids.err, style=LEFT)
panel.AddText(' Min Value:', style=LEFT, newrow=True)
panel.Add(self.wids.min, style=LEFT)
panel.AddText(' Max Value:', style=LEFT)
panel.Add(self.wids.max, style=LEFT)
panel.AddText(' Constraint:', style=LEFT, newrow=True)
panel.Add(self.wids.expr, style=LEFT, dcol=3)
panel.Add(HLine(panel, size=(375, 2)), dcol=4, newrow=True)
panel.Add(btnsizer, dcol=4, newrow=True, style=LEFT)
panel.pack()
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(panel, 0, 0, 25)
self.onVaryChoice()
pack(self, sizer)
bsize = self.GetBestSize()
self.SetSize((bsize[0] + 10, bsize[1] + 10))
def __init__(self,
parent,
group=None,
last_array_sel=None,
read_ok_cb=None,
edit_groupname=True):
self.parent = parent
self.dgroup = group
if not hasattr(self.dgroup, 'is_xas'):
try:
self.dgroup.is_xas = 'energ' in self.dgroup.array_labels[
0].lower()
except:
self.dgroup.is_xas = False
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 self.dgroup.array_labels:
self.array_sel['yarr2'] = 'i0'
if self.array_sel['yarr1'] is None:
if 'itrans' in self.dgroup.array_labels:
self.array_sel['yarr1'] = 'itrans'
elif 'i1' in self.dgroup.array_labels:
self.array_sel['yarr1'] = 'i1'
message = "Build Arrys from Data Columns for %s" % self.dgroup.filename
wx.Frame.__init__(self,
None,
-1,
'Build Arrays from Data Columns for %s' %
self.dgroup.filename,
style=FRAMESTYLE)
self.SetFont(Font(10))
panel = scrolled.ScrolledPanel(self)
self.SetMinSize((600, 600))
self.colors = GUIColors()
self.plotframe = None
# title row
title = SimpleText(panel,
message,
font=Font(13),
colour=self.colors.title,
style=LCEN)
opts = dict(action=self.onColumnChoice, size=(120, -1))
arr_labels = self.dgroup.array_labels
yarr_labels = arr_labels + ['1.0', '0.0', '']
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)
opts['size'] = (90, -1)
self.xpop = Choice(panel, choices=XPRE_OPS, **opts)
self.ypop = Choice(panel, choices=YPRE_OPS, **opts)
opts['size'] = (50, -1)
self.yop = Choice(panel, choices=ARR_OPS, **opts)
ylab = SimpleText(panel, 'Y = ')
xlab = SimpleText(panel, 'X = ')
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)
opts['size'] = (150, -1)
self.use_deriv = Check(panel,
label='use derivative',
default=self.array_sel['use_deriv'],
**opts)
self.is_xas = Check(panel,
label='use as XAS data',
default=self.dgroup.is_xas,
**opts)
bpanel = wx.Panel(panel)
bsizer = wx.BoxSizer(wx.HORIZONTAL)
bsizer.Add(Button(bpanel, 'Preview', action=self.onColumnChoice), 4)
bsizer.Add(Button(bpanel, 'OK', action=self.onOK), 4)
bsizer.Add(Button(bpanel, 'Cancel', action=self.onCancel), 4)
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), CEN, 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), CEN, 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)
ir += 1
sizer.Add(self.use_deriv, (ir, 0), (1, 3), LCEN, 0)
ir += 1
sizer.Add(self.is_xas, (ir, 0), (1, 3), LCEN, 0)
self.wid_groupname = None
if edit_groupname:
wid_grouplab = SimpleText(panel, 'Use Group Name: ')
self.wid_groupname = wx.TextCtrl(panel,
value=self.dgroup._groupname,
size=(100, -1))
ir += 1
sizer.Add(wid_grouplab, (ir, 0), (1, 2), LCEN, 3)
sizer.Add(self.wid_groupname, (ir, 2), (1, 3), LCEN, 3)
ir += 1
sizer.Add(bpanel, (ir, 0), (1, 5), LCEN, 3)
pack(panel, sizer)
ftext = wx.TextCtrl(self,
style=wx.TE_MULTILINE | wx.TE_READONLY,
size=(-1, 150))
try:
m = open(self.dgroup.filename, 'r')
text = m.read()
m.close()
except:
text = "The file '%s'\n was not found" % self.dgroup.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()
