def process(self, dgroup, proc_opts=None):
if not hasattr(dgroup, 'proc_opts'):
dgroup.proc_opts = {}
if 'xscale' not in dgroup.proc_opts:
dgroup.proc_opts.update(self.get_proc_opts(dgroup))
if proc_opts is not None:
dgroup.proc_opts.update(proc_opts)
opts = dgroup.proc_opts
# scaling
dgroup.x = opts['xscale']*(dgroup.xdat - opts['xshift'])
dgroup.y = opts['yscale']*(dgroup.ydat - opts['yshift'])
# smoothing
smop = opts['smooth_op'].lower()
cform = str(opts['smooth_conv'].lower())
if smop.startswith('box'):
dgroup.y = boxcar(dgroup.y, opts['smooth_c0'])
elif smop.startswith('savit'):
winsize = 2*opts['smooth_c0'] + 1
dgroup.y = savitzky_golay(dgroup.y, winsize, opts['smooth_c1'])
elif smop.startswith('conv'):
dgroup.y = smooth(dgroup.x, dgroup.y,
sigma=opts['smooth_sig'], form=cform)
# xas
if dgroup.datatype.startswith('xas'):
dgroup.energy = dgroup.x
dgroup.mu = dgroup.y
preopts = {'e0': None, 'step': None, 'make_flat':False,
'_larch':self.larch}
if not opts['auto_e0']:
_e0 = opts['e0']
if _e0 < max(dgroup.energy) and _e0 > min(dgroup.energy):
preopts['e0'] = float(_e0)
if not opts['auto_step']:
preopts['step'] = opts['step']
for attr in ('pre1', 'pre2', 'nvict', 'nnorm', 'norm1', 'norm2'):
preopts[attr] = opts[attr]
pre_edge(dgroup, **preopts)
for attr in ('e0', 'edge_step'):
opts[attr] = getattr(dgroup, attr)
for attr in ('pre1', 'pre2', 'norm1', 'norm2'):
opts[attr] = getattr(dgroup.pre_edge_details, attr)
dgroup.proc_opts.update(opts)
def onUpdate(self, value=None, evt=None):
"""column selections changed calc xdat and ydat"""
# dtcorr = self.dtcorr.IsChecked()
dtcorr = False
use_deriv = self.use_deriv.IsChecked()
rawgroup = self.rawgroup
outgroup = self.outgroup
ix = self.xarr.GetSelection()
xname = self.xarr.GetStringSelection()
if xname == '<index>':
xname = self.rawgroup.array_labels[0]
outgroup._index = 1.0*np.arange(len(getattr(rawgroup, xname)))
xname = '_index'
outgroup.datatype = self.datatype.GetStringSelection().strip().lower()
outgroup.xdat = getattr(rawgroup, xname)
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, outgroup.xdat = pre_op(self.xpop, outgroup.xdat)
self.xsuf.SetLabel(xsuf)
except:
return
try:
xunits = rawgroup.array_units[ix].strip()
xlabel = '%s (%s)' % (xname, xunits)
except:
xlabel = xname
def get_data(grp, arrayname, correct=False):
if hasattr(grp, 'get_data'):
return grp.get_data(arrayname, correct=correct)
return getattr(grp, arrayname, None)
yname1 = self.yarr1.GetStringSelection().strip()
yname2 = self.yarr2.GetStringSelection().strip()
yop = self.yop.GetStringSelection().strip()
ylabel = yname1
if len(yname2) == 0:
yname2 = '1.0'
else:
ylabel = "%s%s%s" % (ylabel, yop, yname2)
yarr1 = get_data(rawgroup, yname1, correct=dtcorr)
if yname2 in ('0.0', '1.0'):
yarr2 = float(yname2)
if yop == '/': yarr2 = 1.0
else:
yarr2 = get_data(rawgroup, yname2, correct=dtcorr)
outgroup.ydat = yarr1
if yop == '+':
outgroup.ydat = yarr1.__add__(yarr2)
elif yop == '-':
outgroup.ydat = yarr1.__sub__(yarr2)
elif yop == '*':
outgroup.ydat = yarr1.__mul__(yarr2)
elif yop == '/':
outgroup.ydat = yarr1.__truediv__(yarr2)
yerr_op = self.yerr_op.GetStringSelection().lower()
if yerr_op.startswith('const'):
yerr = self.yerr_const.GetValue()
elif yerr_op.startswith('array'):
yerr = self.yerr_arr.GetStringSelection().strip()
yerr = get_data(rawgroup, yerr)
elif yerr_op.startswith('sqrt'):
yerr = np.sqrt(outgroup.ydat)
ysuf, ypop, outgroup.ydat = pre_op(self.ypop, outgroup.ydat)
self.ysuf.SetLabel(ysuf)
if use_deriv:
try:
outgroup.ydat = (np.gradient(outgroup.ydat) /
np.gradient(outgroup.xdat))
except:
pass
# apply smoothhing here
if self.with_smooth:
smoother = self.smooth_op.GetStringSelection().lower()
if smoother.startswith('box'):
n = int(self.smooth_c0.GetValue())
outgroup.ydat = boxcar(outgroup.ydat, n)
elif smoother.startswith('savit'):
n = int(self.smooth_c0.GetValue())
win_size = 2*n + 1
order = int(self.smooth_c1.GetValue())
outgroup.ydat = savitzky_golay(outgroup.ydat, win_size, order)
elif smoother.startswith('conv'):
sigma = float(self.smooth_sig.GetValue())
form = str(self.smooth_conv.GetStringSelection()).lower()
outgroup.ydat = smooth(outgroup.xdat, outgroup.ydat,
sigma=sigma, form=form)
self.array_sel = {'xpop': xpop, 'xarr': xname,
'ypop': ypop, 'yop': yop,
'yarr1': yname1, 'yarr2': yname2,
'use_deriv': use_deriv}
try:
npts = min(len(outgroup.xdat), len(outgroup.ydat))
except AttributeError:
return
outgroup.filename = rawgroup.filename
outgroup.npts = npts
outgroup.plot_xlabel = xlabel
outgroup.plot_ylabel = ylabel
outgroup.xdat = np.array(outgroup.xdat[:npts])
outgroup.ydat = np.array(outgroup.ydat[:npts])
outgroup.y = outgroup.ydat
outgroup.yerr = yerr
if isinstance(yerr, np.ndarray):
outgroup.yerr = np.array(yerr[:npts])
if outgroup.datatype == 'xas':
outgroup.energy = outgroup.xdat
outgroup.mu = outgroup.ydat
popts = {}
path, fname = os.path.split(outgroup.filename)
popts['label'] = "%s: %s" % (fname, outgroup.plot_ylabel)
popts['title'] = fname
popts['ylabel'] = outgroup.plot_ylabel
popts['xlabel'] = outgroup.plot_xlabel
self.plotpanel.plot(outgroup.xdat, outgroup.ydat, **popts)
for i in range(self.nb.GetPageCount()):
if 'plot' in self.nb.GetPageText(i).lower():
self.nb.SetSelection(i)