def report(self):
"return text report of parameters"
tmpvals = self.__path_params()
pathpars = {}
for pname in ('degen', 's02', 'e0', 'deltar', 'sigma2', 'third',
'fourth', 'ei'):
parname = fix_varname(PATHPAR_FMT % (pname, self.label))
if parname in self.params:
pathpars[pname] = (self.params[parname].value,
self.params[parname].stderr)
geomlabel = ' atom x y z ipot'
geomformat = ' %4s % .4f, % .4f, % .4f %i'
out = [' Path %s, Feff.dat file = %s' % (self.label, self.filename)]
out.append(geomlabel)
for atsym, iz, ipot, amass, x, y, z in self.geom:
s = geomformat % (atsym, x, y, z, ipot)
if ipot == 0: s = "%s (absorber)" % s
out.append(s)
stderrs = {}
out.append(' {:7s}= {:s}'.format('reff',
gformat(self._feffdat.reff)))
for pname in ('degen', 's02', 'e0', 'r', 'deltar', 'sigma2', 'third',
'fourth', 'ei'):
val = strval = getattr(self, pname, 0)
parname = fix_varname(PATHPAR_FMT % (pname, self.label))
std = None
if pname == 'r':
parname = fix_varname(PATHPAR_FMT % ('deltar', self.label))
par = self.params.get(parname, None)
val = par.value + self._feffdat.reff
strval = 'reff + ' + getattr(self, 'deltar', 0)
std = par.stderr
else:
if pname in pathpars:
val, std = pathpars[pname]
else:
par = self.params.get(parname, None)
if par is not None:
val = par.value
std = par.stderr
if std is None or std <= 0:
svalue = gformat(val)
else:
svalue = "{:s} +/-{:s}".format(gformat(val), gformat(std))
if pname == 's02':
pname = 'n*s02'
svalue = " {:7s}= {:s}".format(pname, svalue)
if isinstance(strval, str):
svalue = "{:s} '{:s}'".format(svalue, strval)
if val == 0 and pname in ('third', 'fourth', 'ei'):
continue
out.append(svalue)
return '\n'.join(out)
def onLoadCSV(self, event=None):
dlg = wx.FileDialog(self,
message="Load CSV Data File",
defaultDir=os.getcwd(),
wildcard=CSV_WILDCARDS,
style=wx.FD_OPEN)
fname = None
if dlg.ShowModal() == wx.ID_OK:
fname = dlg.GetPath()
dlg.Destroy()
if fname is None:
return
self.save_csvfile = os.path.split(fname)[1]
varname = fix_varname(self.wids['varname'].GetValue())
csvgroup = read_csv(fname)
script = []
grid_data = []
for sname, yval in zip(csvgroup.col_01, csvgroup.col_02):
if sname.startswith('#'):
continue
if sname in self.controller.file_groups:
gname = self.controller.file_groups[sname]
script.append('%s.%s = %f' % (gname, varname, yval))
grid_data.append([sname, yval, 0])
self.larch_eval('\n'.join(script))
self.wids['table'].table.data = grid_data
self.wids['table'].table.View.Refresh()
self.write_message('Read CSV File %s ' % fname)
def onLoadCSV(self, event=None):
dlg = wx.FileDialog(self, message="Load CSV Data File",
defaultDir=os.getcwd(),
wildcard=CSV_WILDCARDS, style=wx.FD_OPEN)
fname = None
if dlg.ShowModal() == wx.ID_OK:
fname = dlg.GetPath()
dlg.Destroy()
if fname is None:
return
self.save_csvfile = os.path.split(fname)[1]
varname = fix_varname(self.wids['varname'].GetValue())
csvgroup = read_csv(fname)
script = []
grid_data = []
for sname, yval in zip(csvgroup.col_01, csvgroup.col_02):
if sname.startswith('#'):
continue
if sname in self.controller.file_groups:
gname = self.controller.file_groups[sname]
script.append('%s.%s = %f' % (gname, varname, yval))
grid_data.append([sname, yval, 0])
self.larch_eval('\n'.join(script))
self.wids['table'].table.data = grid_data
self.wids['table'].table.View.Refresh()
self.write_message('Read CSV File %s ' % fname)
def report(self):
"return text report of parameters"
(deg, s02, e0, ei, delr, ss2, c3, c4) = self.__path_params()
geomlabel = ' atom x y z ipot'
geomformat = ' %4s % .4f, % .4f, % .4f %i'
out = [' Path %s, Feff.dat file = %s' % (self.label, self.filename)]
out.append(geomlabel)
for atsym, iz, ipot, amass, x, y, z in self.geom:
s = geomformat % (atsym, x, y, z, ipot)
if ipot == 0: s = "%s (absorber)" % s
out.append(s)
stderrs = {}
out.append(' {:7s}= {:s}'.format('reff',
gformat(self._feffdat.reff)))
for pname in ('degen', 's02', 'e0', 'r',
'deltar', 'sigma2', 'third', 'fourth', 'ei'):
val = strval = getattr(self, pname, 0)
parname = fix_varname(PATHPAR_FMT % (pname, self.label))
std = None
if pname == 'r':
parname = fix_varname(PATHPAR_FMT % ('deltar', self.label))
par = self.params.get(parname, None)
val = par.value + self._feffdat.reff
strval = 'reff + ' + getattr(self, 'deltar', 0)
std = par.stderr
else:
par = self.params.get(parname, None)
if par is not None:
val = par.value
std = par.stderr
if std is None or std <= 0:
svalue = gformat(val)
else:
svalue = "{:s} +/-{:s}".format(gformat(val), gformat(std))
if pname == 's02': pname = 'n*s02'
svalue = " {:7s}= {:s}".format(pname, svalue)
if isinstance(strval, six.string_types):
svalue = "{:s} '{:s}'".format(svalue, strval)
if val == 0 and pname in ('third', 'fourth', 'ei'):
continue
out.append(svalue)
return '\n'.join(out)
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}', labels='%s')" % (self.reader, labels)
buff = ["{group} = %s" % read_cmd,
"{group}.path = '{path}'",
"{group}.is_frozen = False"]
for label, selection in self.extra_sums.items():
buff.append("{group}.array_labels.append('%s')" % label)
buff.append("_tmparr = {group}.data[%s, :].sum(axis=0)" % repr(selection))
buff.append("_tmpn = len(_tmparr)")
buff.append("{group}.data = append({group}.data, _tmparr.reshape(1, _tmpn), axis=0)")
buff.append("del _tmparr, _tmpn")
for attr in ('datatype', 'plot_xlabel', 'plot_ylabel'):
val = getattr(self.workgroup, attr)
buff.append("{group}.%s = '%s'" % (attr, val))
for aname in ('xdat', 'ydat', 'yerr'):
expr = self.expressions[aname].replace('%s', '{group:s}')
buff.append("{group}.%s = %s" % (aname, expr))
if getattr(self.workgroup, 'datatype', 'raw') == 'xas':
if self.reader == 'read_gsescan':
buff.append("{group}.energy = {group}.x")
else:
buff.append("{group}.energy = {group}.xdat")
buff.append("{group}.mu = {group}.ydat")
buff.append("sort_xafs({group}, overwrite=True, fix_repeats=True)")
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)
for f in self.subframes.values():
try:
f.Destroy()
except:
pass
self.Destroy()
def __init__(self, parent, group, on_ok=None):
self.group = group
self.on_ok = on_ok
wx.Frame.__init__(self,
None,
-1,
'Edit Array Names',
style=wx.DEFAULT_FRAME_STYLE | wx.TAB_TRAVERSAL)
self.SetFont(Font(10))
sizer = wx.GridBagSizer(4, 4)
self.SetMinSize((600, 600))
self.wids = {}
cind = SimpleText(self, label='Column')
cold = SimpleText(self, label='Current Name')
cnew = SimpleText(self, label='Enter New Name')
cret = SimpleText(self, label=' Result ', size=(150, -1))
cinfo = SimpleText(self, label=' Data Range')
ir = 0
sizer.Add(cind, (ir, 0), (1, 1), LCEN, 3)
sizer.Add(cold, (ir, 1), (1, 1), LCEN, 3)
sizer.Add(cnew, (ir, 2), (1, 1), LCEN, 3)
sizer.Add(cret, (ir, 3), (1, 1), LCEN, 3)
sizer.Add(cinfo, (ir, 4), (1, 1), LCEN, 3)
for i, name in enumerate(group.array_labels):
ir += 1
cind = SimpleText(self, label=' %i ' % (i + 1))
cold = SimpleText(self, label=' %s ' % name)
cret = SimpleText(self, label=fix_varname(name), size=(150, -1))
cnew = wx.TextCtrl(self, value=name, size=(150, -1))
cnew.Bind(wx.EVT_KILL_FOCUS, partial(self.update, index=i))
cnew.Bind(wx.EVT_CHAR, partial(self.update_char, index=i))
cnew.Bind(wx.EVT_TEXT_ENTER, partial(self.update, index=i))
# cnew.Bind(wx.EVT_TEXT, partial(self.update3, index=i))
arr = group.data[i, :]
info_str = " [ %8g : %8g ] " % (arr.min(), arr.max())
cinfo = SimpleText(self, label=info_str)
self.wids[i] = cnew
self.wids["ret_%i" % i] = cret
sizer.Add(cind, (ir, 0), (1, 1), LCEN, 3)
sizer.Add(cold, (ir, 1), (1, 1), LCEN, 3)
sizer.Add(cnew, (ir, 2), (1, 1), LCEN, 3)
sizer.Add(cret, (ir, 3), (1, 1), LCEN, 3)
sizer.Add(cinfo, (ir, 4), (1, 1), LCEN, 3)
sizer.Add(Button(self, 'OK', action=self.onOK), (ir + 1, 1), (1, 2),
LCEN, 3)
pack(self, sizer)
self.Show()
self.Raise()
def parse_jsonathena(text, filename):
"""parse a JSON-style athena file"""
jsdict = json.loads(text)
out = Group()
out.__doc__ = """XAFS Data from Athena Project File %s""" % (filename)
header = []
athena_names = []
for key, val in jsdict.items():
if key.startswith('_____head'):
header.append(val)
elif key.startswith('_____journ'):
journal = val
elif key.startswith('_____order'):
athena_names = val
out.journal = journal
out.header = '\n'.join(header)
out.group_names = []
for name in athena_names:
label = name
dat = jsdict[name]
x = np.array(dat['x'], dtype='float64')
y = np.array(dat['y'], dtype='float64')
this = Group(athena_id=name,
energy=x,
mu=y,
bkg_params=Group(),
fft_params=Group(),
athena_params=Group())
if 'i0' in dat:
this.i0 = np.array(dat['i0'], dtype='float64')
if 'signal' in dat:
this.signal = np.array(dat['signal'], dtype='float64')
if 'stddev' in dat:
this.stddev = np.array(dat['stddev'], dtype='float64')
if 'args' in dat:
for key, val in dat['args'].items():
if key.startswith('bkg_'):
setattr(this.bkg_params, key[4:], asfloat(val))
elif key.startswith('fft_'):
setattr(this.fft_params, key[4:], asfloat(val))
elif key == 'label':
label = this.label = val
else:
setattr(this.athena_params, key, asfloat(val))
this.__doc__ = """Athena Group Name %s (key='%s')""" % (label, name)
name = fix_varname(label)
if name.startswith('_'):
name = 'd' + name
setattr(out, name, this)
out.group_names.append(name)
return out
def get_label(self):
label_in = self.wids["arrayname"].GetValue()
label = fix_varname(label_in)
if label in self.group.array_labels:
count = 1
while label in self.group.array_labels and count < 1000:
label = "%s_%d" % (label, count)
count += 1
if label != label_in:
self.wids["arrayname"].SetValue(label)
return label
def get_label(self):
label_in = self.wids["arrayname"].GetValue()
label = fix_varname(label_in)
if label in self.group.array_labels:
count = 1
while label in self.group.array_labels and count < 1000:
label = "%s_%d" % (label, count)
count +=1
if label != label_in:
self.wids["arrayname"].SetValue(label)
return label
def onFillTable(self, event=None):
selected_groups = self.controller.filelist.GetCheckedStrings()
varname = fix_varname(self.wids['varname'].GetValue())
predname = varname + '_predicted'
grid_data = []
for fname in self.controller.filelist.GetCheckedStrings():
gname = self.controller.file_groups[fname]
grp = self.controller.get_group(gname)
grid_data.append([fname, getattr(grp, varname, 0.0),
getattr(grp, predname, 0.0)])
self.wids['table'].table.data = grid_data
self.wids['table'].table.View.Refresh()
def parse_jsonathena(text, filename):
"""parse a JSON-style athena file"""
jsdict = json.loads(text)
out = Group()
out.__doc__ = """XAFS Data from Athena Project File %s""" % (filename)
header = []
athena_names = []
for key, val in jsdict.items():
if key.startswith('_____head'):
header.append(val)
elif key.startswith('_____journ'):
journal = val
elif key.startswith('_____order'):
athena_names = val
out.journal = journal
out.header = '\n'.join(header)
out.group_names = []
for name in athena_names:
label = name
dat = jsdict[name]
x = np.array(dat['x'], dtype='float64')
y = np.array(dat['y'], dtype='float64')
this = Group(athena_id=name, energy=x, mu=y,
bkg_params=Group(), fft_params=Group(),
athena_params=Group())
if 'i0' in dat:
this.i0 = np.array(dat['i0'], dtype='float64')
if 'signal' in dat:
this.signal = np.array(dat['signal'], dtype='float64')
if 'stddev' in dat:
this.stddev = np.array(dat['stddev'], dtype='float64')
if 'args' in dat:
for key, val in dat['args'].items():
if key.startswith('bkg_'):
setattr(this.bkg_params, key[4:], asfloat(val))
elif key.startswith('fft_'):
setattr(this.fft_params, key[4:], asfloat(val))
elif key == 'label':
label = this.label = val
else:
setattr(this.athena_params, key, asfloat(val))
this.__doc__ = """Athena Group Name %s (key='%s')""" % (label, name)
name = fix_varname(label)
if name.startswith('_'):
name = 'd' + name
setattr(out, name, this)
out.group_names.append(name)
return out
def onFillTable(self, event=None):
selected_groups = self.controller.filelist.GetCheckedStrings()
varname = fix_varname(self.wids['varname'].GetValue())
predname = varname + '_predicted'
grid_data = []
for fname in self.controller.filelist.GetCheckedStrings():
gname = self.controller.file_groups[fname]
grp = self.controller.get_group(gname)
grid_data.append([
fname,
getattr(grp, varname, 0.0),
getattr(grp, predname, 0.0)
])
self.wids['table'].table.data = grid_data
self.wids['table'].table.View.Refresh()
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
# if array_labels is None and getattr(datagroup, 'array_labels', None) is not None:
# array_labels = datagroup.array_labels
leval = self._larch.eval
cmd = "'%s'" % self.path
if self.array_labels is not None:
cmd = "%s, labels='%s'" % (cmd, ', '.join(self.array_labels))
leval("%s = %s(%s)" % (groupname, self.reader, cmd))
for attr in ('datatype', 'groupname', 'filename',
'path', 'plot_xlabel', 'plot_ylabel'):
val = getattr(self.outgroup, attr)
leval("%s.%s = '%s'" % (groupname, attr, val))
print("--- EXPRESSION ", self.expressions)
for aname in ('xdat', 'ydat', 'yerr'):
expr = self.expressions[aname].replace('%s', groupname)
leval("%s.%s = %s" % (groupname, aname, expr))
if getattr(self.outgroup, 'datatype', 'raw') == 'xas':
leval("%s.energy = %s.xdat" % (gname, gname))
leval("%s.mu = %s.ydat" % (gname, gname))
if self.read_ok_cb is not None:
self.read_ok_cb(self.outgroup, array_sel=self.array_sel,
array_labels=self.array_labels,
expressions=self.expressions)
self.Destroy()
def __path_params(self, **kws):
"""evaluate path parameter value. Returns
(degen, s02, e0, ei, deltar, sigma2, third, fourth)
"""
# put 'reff' and '_feffdat' into the symboltable so that
# they can be used in constraint expressions
self.store_feffdat()
if self.params is None:
self.create_path_params()
out = []
for pname in PATH_PARS:
val = kws.get(pname, None)
parname = fix_varname(PATHPAR_FMT % (pname, self.label))
if val is None:
val = self.params[parname]._getval()
out.append(val)
return out
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 create_path_params(self):
"""
create Path Parameters within the current fiteval
"""
self.params = Parameters(asteval=self._larch.symtable._sys.fiteval)
if self.label is None:
self.label = self.__geom2label()
self.store_feffdat()
for pname in PATH_PARS:
val = getattr(self, pname)
attr = 'value'
if isinstance(val, six.string_types):
attr = 'expr'
kws = {'vary': False, attr: val}
parname = fix_varname(PATHPAR_FMT % (pname, self.label))
self.params.add(parname, **kws)
def create_path_params(self):
"""
create Path Parameters within the current fiteval
"""
self.params = Parameters(asteval=self._larch.symtable._sys.fiteval)
if self.label is None:
self.label = self.__geom2label()
self.store_feffdat()
for pname in PATH_PARS:
val = getattr(self, pname)
attr = 'value'
if isinstance(val, str):
attr = 'expr'
kws = {'vary': False, attr: val}
parname = fix_varname(PATHPAR_FMT % (pname, self.label))
self.params.add(parname, **kws)
def __path_params(self, **kws):
"""evaluate path parameter value. Returns
(degen, s02, e0, ei, deltar, sigma2, third, fourth)
"""
# put 'reff' and '_feffdat' into the symboltable so that
# they can be used in constraint expressions, and get
# fiteval evaluator
self.store_feffdat()
if self.params is None:
self.create_path_params()
out = []
for pname in PATH_PARS:
val = kws.get(pname, None)
parname = fix_varname(PATHPAR_FMT % (pname, self.label))
if val is None:
val = self.params[parname]._getval()
out.append(val)
return out
def create_path_params(self, params=None):
"""
create Path Parameters within the current lmfit.Parameters namespace
"""
if params is not None:
self.params = params
if self.params is None:
self.params = Parameters()
if self.params._asteval.symtable.get('sigma2_debye', None) is None:
add_sigma2funcs(self.params)
if self.label is None:
self.label = self.__geom2label()
self.store_feffdat()
for pname in PATH_PARS:
val = getattr(self, pname)
attr = 'value'
if isinstance(val, str):
attr = 'expr'
kws = {'vary': False, attr: val}
parname = fix_varname(PATHPAR_FMT % (pname, self.label))
self.params.add(parname, **kws)
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 = '\n'.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
self._larch.eval(read_cmd, add_history=False)
group = self._larch.symtable.get_symbol(tmpname)
self._larch.symtable.del_symbol(tmpname)
gname = fix_varname(filename.replace('.', '_'))
if len(gname) > 16:
gname = gname[:16]
groupname, count, maxcount = gname, 0, 999
while hasattr(self._larch.symtable, groupname) and count < maxcount:
count += 1
groupname = '%s_%3.3i' % (gname, count)
group.text = text
group.path = path
group.filename = filename
group.groupname = groupname
return group
def update(self, evt=None, index=-1):
newval = fix_varname(self.wids["%d" % index].GetValue())
self.wids["ret_%i" % index].SetLabel(newval)
def parse_perlathena(text, filename):
"""
parse old athena file format to Group of Groups
"""
lines = text.split('\n')
athenagroups = []
raw = {'name':''}
vline = lines.pop(0)
if "Athena project file -- Demeter version" not in vline:
raise ValueError("%s '%s': invalid Athena File" % (ERR_MSG, filename))
major, minor, fix = '0', '0', '0'
try:
vs = vline.split("Athena project file -- Demeter version")[1]
major, minor, fix = vs.split('.')
except:
raise ValueError("%s '%s': cannot read version" % (ERR_MSG, filename))
if int(minor) < 9 or int(fix[:2]) < 21:
raise ValueError("%s '%s': file is too old to read" % (ERR_MSG, filename))
header = [vline]
journal = {}
is_header = True
for t in lines:
if t.startswith('#') or len(t) < 2 or 'undef' in t:
if is_header:
header.append(t)
continue
is_header = False
key = t.split(' ')[0].strip()
key = key.replace('$', '').replace('@', '')
if key == 'old_group':
raw['name'] = plarray2json(t)
elif key == '[record]':
athenagroups.append(raw)
raw = {'name':''}
elif key == 'journal':
journal = plarray2json(t)
elif key == 'args':
raw['args'] = plarray2json(t)
elif key == 'xdi':
raw['xdi'] = t
elif key in ('x', 'y', 'i0', 'signal', 'stddev'):
raw[key] = np.array([float(x) for x in plarray2json(t)])
elif key == '1;': # end of list
pass
else:
print(" do not know what to do with key ", key, raw['name'])
out = Group()
out.__doc__ = """XAFS Data from Athena Project File %s""" % (filename)
out.journal = journal
out.group_names = []
out.header = '\n'.join(header)
for dat in athenagroups:
label = dat.get('name', 'unknown')
this = Group(athena_id=label, energy=dat['x'], mu=dat['y'],
bkg_params=Group(), fft_params=Group(),
athena_params=Group())
if 'i0' in dat:
this.i0 = dat['i0']
if 'signal' in dat:
this.signal = dat['signal']
if 'stddev' in dat:
this.stddev = dat['stddev']
if 'args' in dat:
for i in range(len(dat['args'])//2):
key = dat['args'][2*i]
val = dat['args'][2*i+1]
if key.startswith('bkg_'):
setattr(this.bkg_params, key[4:], asfloat(val))
elif key.startswith('fft_'):
setattr(this.fft_params, key[4:], asfloat(val))
elif key == 'label':
label = this.label = val
elif key in ('valence', 'lasso_yvalue',
'epsk', 'epsr', 'importance'):
setattr(this, key, asfloat(val))
elif key in ('atsym', 'edge', 'provenance'):
setattr(this, key, val)
else:
setattr(this.athena_params, key, asfloat(val))
this.__doc__ = """Athena Group Name %s (key='%s')""" % (label, dat['name'])
name = fix_varname(label)
if name.startswith('_'):
name = 'd' + name
setattr(out, name, this)
out.group_names.append(name)
return out
def parse_sisnames(text):
return [fix_varname(s.strip()) for s in text.replace('#', '').split('|')]
def read_athena(filename,
match=None,
do_preedge=True,
do_bkg=True,
do_fft=True,
use_hashkey=False,
_larch=None):
"""read athena project file
returns a Group of Groups, one for each Athena Group in the project file
Arguments:
filename (string): name of Athena Project file
match (string): pattern to use to limit imported groups (see Note 1)
do_preedge (bool): whether to do pre-edge subtraction [True]
do_bkg (bool): whether to do XAFS background subtraction [True]
do_fft (bool): whether to do XAFS Fast Fourier transform [True]
use_hashkey (bool): whether to use Athena's hash key as the
group name instead of the Athena label [False]
Returns:
group of groups each named according the label used by Athena.
Notes:
1. To limit the imported groups, use the pattern in `match`,
using '*' to match 'all' '?' to match any single character,
or [sequence] to match any of a sequence of letters. The match
will always be insensitive to case.
3. do_preedge, do_bkg, and do_fft will attempt to reproduce the
pre-edge, background subtraction, and FFT from Athena by using
the parameters saved in the project file.
2. use_hashkey=True will name groups from the internal 5 character
string used by Athena, instead of the group label.
Example:
1. read in all groups from a project file:
cr_data = read_athena('My Cr Project.prj')
2. read in only the "merged" data from a Project, and don't do FFT:
zn_data = read_athena('Zn on Stuff.prj', match='*merge*', do_fft=False)
"""
from larch_plugins.xafs import pre_edge, autobk, xftf
if not os.path.exists(filename):
raise IOError("%s '%s': cannot find file" % (ERR_MSG, filename))
try:
fh = GzipFile(filename)
lines = [bytes2str(t) for t in fh.readlines()]
fh.close()
except:
raise ValueError("%s '%s': invalid gzip file" % (ERR_MSG, filename))
athenagroups = []
dat = {'name': ''}
Athena_version = None
vline = lines.pop(0)
if "Athena project file -- Demeter version" not in vline:
raise ValueError("%s '%s': invalid Athena File" % (ERR_MSG, filename))
major, minor, fix = '0', '0', '0'
try:
vs = vline.split("Athena project file -- Demeter version")[1]
major, minor, fix = vs.split('.')
except:
raise ValueError("%s '%s': cannot read version" % (ERR_MSG, filename))
if int(minor) < 9 or int(fix[:2]) < 21:
raise ValueError("%s '%s': file is too old to read" %
(ERR_MSG, filename))
for t in lines:
if t.startswith('#') or len(t) < 2 or 'undef' in t:
continue
key = t.split(' ')[0].strip()
key = key.replace('$', '').replace('@', '')
if key == 'old_group':
dat['name'] = perl2json(t)
elif key == '[record]':
athenagroups.append(dat)
dat = {'name': ''}
elif key == 'args':
dat['args'] = perl2json(t)
elif key in ('x', 'y', 'i0', 'signal'):
dat[key] = np.array([float(x) for x in perl2json(t)])
if match is not None:
match = match.lower()
out = Group()
out.__doc__ = """XAFS Data from Athena Project File %s""" % (filename)
for dat in athenagroups:
label = dat.get('name', 'unknown')
this = Group(athena_id=label,
energy=dat['x'],
mu=dat['y'],
bkg_params=Group(),
fft_params=Group(),
athena_params=Group())
if 'i0' in dat:
this.i0 = dat['i0']
if 'args' in dat:
for i in range(len(dat['args']) // 2):
key = dat['args'][2 * i]
val = dat['args'][2 * i + 1]
if key.startswith('bkg_'):
setattr(this.bkg_params, key[4:], val)
elif key.startswith('fft_'):
setattr(this.fft_params, key[4:], val)
elif key == 'label':
this.label = val
if not use_hashkey:
label = this.label
else:
setattr(this.athena_params, key, val)
this.__doc__ = """Athena Group Name %s (key='%s')""" % (label,
dat['name'])
olabel = fix_varname(label)
if match is not None:
if not fnmatch(olabel.lower(), match):
continue
if do_preedge or do_bkg:
pars = this.bkg_params
pre_edge(this,
_larch=_larch,
e0=float(pars.e0),
pre1=float(pars.pre1),
pre2=float(pars.pre2),
norm1=float(pars.nor1),
norm2=float(pars.nor2),
nnorm=float(pars.nnorm) - 1,
make_flat=bool(pars.flatten))
if do_bkg and hasattr(pars, 'rbkg'):
autobk(this,
_larch=_larch,
e0=float(pars.e0),
rbkg=float(pars.rbkg),
kmin=float(pars.spl1),
kmax=float(pars.spl2),
kweight=float(pars.kw),
dk=float(pars.dk),
clamp_lo=float(pars.clamp1),
clamp_hi=float(pars.clamp2))
if do_fft:
pars = this.fft_params
kweight = 2
if hasattr(pars, 'kw'):
kweight = float(pars.kw)
xftf(this,
_larch=_larch,
kmin=float(pars.kmin),
kmax=float(pars.kmax),
kweight=kweight,
window=pars.kwindow,
dk=float(pars.dk))
setattr(out, olabel, this)
return out
def update(self, evt=None, index=-1):
newval = fix_varname(self.wids[index].GetValue())
self.wids["ret_%i" % index].SetLabel(newval)
def parse_sisnames(text):
return [fix_varname(s.strip()) for s in text.replace('#', '').split('|')]
def parse_perlathena(text, filename):
"""
parse old athena file format to Group of Groups
"""
lines = text.split('\n')
athenagroups = []
raw = {'name':''}
vline = lines.pop(0)
if "Athena project file -- " not in vline:
raise ValueError("%s '%s': invalid Athena File" % (ERR_MSG, filename))
major, minor, fix = '0', '0', '0'
if 'Demeter' in vline:
try:
vs = vline.split("Athena project file -- Demeter version")[1]
major, minor, fix = vs.split('.')
except:
raise ValueError("%s '%s': cannot read version" % (ERR_MSG, filename))
else:
try:
vs = vline.split("Athena project file -- Athena version")[1]
major, minor, fix = vs.split('.')
except:
raise ValueError("%s '%s': cannot read version" % (ERR_MSG, filename))
header = [vline]
journal = ['']
is_header = True
for t in lines:
if t.startswith('#') or len(t) < 2 or 'undef' in t:
if is_header:
header.append(t)
continue
is_header = False
key = t.split(' ')[0].strip()
key = key.replace('$', '').replace('@', '').replace('%', '').strip()
if key == 'old_group':
raw['name'] = plarray2json(t)
elif key == '[record]':
athenagroups.append(raw)
raw = {'name':''}
elif key == 'journal':
journal = parse_arglist(t)
elif key == 'args':
raw['args'] = parse_arglist(t)
elif key == 'xdi':
raw['xdi'] = t
elif key in ('x', 'y', 'i0', 'signal', 'stddev'):
raw[key] = np.array([float(x) for x in plarray2json(t)])
elif key in ('1;', 'indicator', 'lcf_data', 'plot_features'):
pass
else:
print(" do not know what to do with key '%s' at '%s'" % (key, raw['name']))
out = Group()
out.__doc__ = """XAFS Data from Athena Project File %s""" % (filename)
out.journal = '\n'.join(journal)
out.group_names = []
out.header = '\n'.join(header)
for dat in athenagroups:
label = dat.get('name', 'unknown')
this = Group(athena_id=label, energy=dat['x'], mu=dat['y'],
bkg_params=Group(),
fft_params=Group(),
athena_params=Group())
if 'i0' in dat:
this.i0 = dat['i0']
if 'signal' in dat:
this.signal = dat['signal']
if 'stddev' in dat:
this.stddev = dat['stddev']
if 'args' in dat:
for i in range(len(dat['args'])//2):
key = dat['args'][2*i]
val = dat['args'][2*i+1]
if key.startswith('bkg_'):
setattr(this.bkg_params, key[4:], asfloat(val))
elif key.startswith('fft_'):
setattr(this.fft_params, key[4:], asfloat(val))
elif key == 'label':
label = this.label = val
elif key in ('valence', 'lasso_yvalue',
'epsk', 'epsr', 'importance'):
setattr(this, key, asfloat(val))
elif key in ('atsym', 'edge', 'provenance'):
setattr(this, key, val)
else:
setattr(this.athena_params, key, asfloat(val))
this.__doc__ = """Athena Group Name %s (key='%s')""" % (label, dat['name'])
name = fix_varname(label)
if name.startswith('_'):
name = 'd' + name
setattr(out, name, this)
out.group_names.append(name)
return out
def __init__(self, parent, group, on_ok=None):
self.parent = parent
self.group = group
self.on_ok = on_ok
wx.Frame.__init__(self, None, -1, 'Edit Array Names',
style=wx.DEFAULT_FRAME_STYLE|wx.TAB_TRAVERSAL)
self.SetFont(Font(10))
sizer = wx.GridBagSizer(2, 2)
panel = scrolled.ScrolledPanel(self)
self.SetMinSize((675, 450))
self.wids = {}
ir = 0
sizer.Add(Button(panel, 'Apply Changes', size=(200, -1),
action=self.onOK),
(0, 1), (1, 2), LCEN, 3)
sizer.Add(Button(panel, 'Use Column Number', size=(200, -1),
action=self.onColNumber),
(0, 3), (1, 2), LCEN, 3)
sizer.Add(HLine(panel, size=(550, 2)),
(1, 1), (1, 5), LCEN, 3)
cind = SimpleText(panel, label='Column')
cold = SimpleText(panel, label='Current Name')
cnew = SimpleText(panel, label='Enter New Name')
cret = SimpleText(panel, label=' Result ', size=(150, -1))
cinfo = SimpleText(panel, label=' Data Range')
cplot = SimpleText(panel, label=' Plot')
ir = 2
sizer.Add(cind, (ir, 0), (1, 1), LCEN, 3)
sizer.Add(cold, (ir, 1), (1, 1), LCEN, 3)
sizer.Add(cnew, (ir, 2), (1, 1), LCEN, 3)
sizer.Add(cret, (ir, 3), (1, 1), LCEN, 3)
sizer.Add(cinfo, (ir, 4), (1, 1), LCEN, 3)
sizer.Add(cplot, (ir, 5), (1, 1), LCEN, 3)
for i, name in enumerate(group.array_labels):
ir += 1
cind = SimpleText(panel, label=' %i ' % (i+1))
cold = SimpleText(panel, label=' %s ' % name)
cret = SimpleText(panel, label=fix_varname(name), size=(150, -1))
cnew = wx.TextCtrl(panel, value=name, size=(150, -1))
cnew.Bind(wx.EVT_KILL_FOCUS, partial(self.update, index=i))
cnew.Bind(wx.EVT_CHAR, partial(self.update_char, index=i))
cnew.Bind(wx.EVT_TEXT_ENTER, partial(self.update, index=i))
arr = group.data[i,:]
info_str = " [ %8g : %8g ] " % (arr.min(), arr.max())
cinfo = SimpleText(panel, label=info_str)
cplot = Button(panel, 'Plot', action=partial(self.onPlot, index=i))
self.wids["%d" % i] = cnew
self.wids["ret_%d" % i] = cret
sizer.Add(cind, (ir, 0), (1, 1), LCEN, 3)
sizer.Add(cold, (ir, 1), (1, 1), LCEN, 3)
sizer.Add(cnew, (ir, 2), (1, 1), LCEN, 3)
sizer.Add(cret, (ir, 3), (1, 1), LCEN, 3)
sizer.Add(cinfo, (ir, 4), (1, 1), LCEN, 3)
sizer.Add(cplot, (ir, 5), (1, 1), LCEN, 3)
pack(panel, sizer)
panel.SetupScrolling()
mainsizer = wx.BoxSizer(wx.VERTICAL)
mainsizer.Add(panel, 1, wx.GROW|wx.ALL, 1)
pack(self, mainsizer)
self.Show()
self.Raise()
def __init__(self, parent, group, on_ok=None):
self.parent = parent
self.group = group
self.on_ok = on_ok
wx.Frame.__init__(self,
None,
-1,
'Edit Array Names',
style=wx.DEFAULT_FRAME_STYLE | wx.TAB_TRAVERSAL)
self.SetFont(Font(10))
sizer = wx.GridBagSizer(2, 2)
panel = scrolled.ScrolledPanel(self)
self.SetMinSize((675, 450))
self.wids = {}
ir = 0
sizer.Add(
Button(panel, 'Apply Changes', size=(200, -1), action=self.onOK),
(0, 1), (1, 2), LEFT, 3)
sizer.Add(
Button(panel,
'Use Column Number',
size=(200, -1),
action=self.onColNumber), (0, 3), (1, 2), LEFT, 3)
sizer.Add(HLine(panel, size=(550, 2)), (1, 1), (1, 5), LEFT, 3)
cind = SimpleText(panel, label='Column')
cold = SimpleText(panel, label='Current Name')
cnew = SimpleText(panel, label='Enter New Name')
cret = SimpleText(panel, label=' Result ', size=(150, -1))
cinfo = SimpleText(panel, label=' Data Range')
cplot = SimpleText(panel, label=' Plot')
ir = 2
sizer.Add(cind, (ir, 0), (1, 1), LEFT, 3)
sizer.Add(cold, (ir, 1), (1, 1), LEFT, 3)
sizer.Add(cnew, (ir, 2), (1, 1), LEFT, 3)
sizer.Add(cret, (ir, 3), (1, 1), LEFT, 3)
sizer.Add(cinfo, (ir, 4), (1, 1), LEFT, 3)
sizer.Add(cplot, (ir, 5), (1, 1), LEFT, 3)
for i, name in enumerate(group.array_labels):
ir += 1
cind = SimpleText(panel, label=' %i ' % (i + 1))
cold = SimpleText(panel, label=' %s ' % name)
cret = SimpleText(panel, label=fix_varname(name), size=(150, -1))
cnew = wx.TextCtrl(panel, value=name, size=(150, -1))
cnew.Bind(wx.EVT_KILL_FOCUS, partial(self.update, index=i))
cnew.Bind(wx.EVT_CHAR, partial(self.update_char, index=i))
cnew.Bind(wx.EVT_TEXT_ENTER, partial(self.update, index=i))
arr = group.data[i, :]
info_str = " [ %8g : %8g ] " % (arr.min(), arr.max())
cinfo = SimpleText(panel, label=info_str)
cplot = Button(panel, 'Plot', action=partial(self.onPlot, index=i))
self.wids["%d" % i] = cnew
self.wids["ret_%d" % i] = cret
sizer.Add(cind, (ir, 0), (1, 1), LEFT, 3)
sizer.Add(cold, (ir, 1), (1, 1), LEFT, 3)
sizer.Add(cnew, (ir, 2), (1, 1), LEFT, 3)
sizer.Add(cret, (ir, 3), (1, 1), LEFT, 3)
sizer.Add(cinfo, (ir, 4), (1, 1), LEFT, 3)
sizer.Add(cplot, (ir, 5), (1, 1), LEFT, 3)
pack(panel, sizer)
panel.SetupScrolling()
mainsizer = wx.BoxSizer(wx.VERTICAL)
mainsizer.Add(panel, 1, wx.GROW | wx.ALL, 1)
pack(self, mainsizer)
self.Show()
self.Raise()
def onOK(self, event=None):
""" build arrays according to selection """
user_filename = self.wid_filename.GetValue()
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:
read_cmd = "%s('{path}', labels='%s')" % (self.reader, ', '.join(
self.orig_labels))
buff = [
"{group} = %s" % read_cmd, "{group}.path = '{path}'",
"{group}.is_frozen = False"
]
for label, selection in self.extra_sums.items():
buff.append("{group}.array_labels.append('%s')" % label)
buff.append("_tmparr = {group}.data[%s, :].sum(axis=0)" %
repr(selection))
buff.append("_tmpn = len(_tmparr)")
buff.append(
"{group}.data = append({group}.data, _tmparr.reshape(1, _tmpn), axis=0)"
)
buff.append("del _tmparr, _tmpn")
for attr in ('datatype', 'plot_xlabel', 'plot_ylabel'):
val = getattr(self.workgroup, attr)
buff.append("{group}.%s = '%s'" % (attr, val))
for aname in ('xdat', 'ydat', 'yerr'):
expr = self.expressions[aname].replace('%s', '{group:s}')
buff.append("{group}.%s = %s" % (aname, expr))
if getattr(self.workgroup, 'datatype', 'raw') == 'xas':
if self.reader == 'read_gsescan':
buff.append("{group}.energy = {group}.x")
else:
buff.append("{group}.energy = {group}.xdat")
buff.append("{group}.mu = {group}.ydat")
buff.append("sort_xafs({group}, overwrite=True, fix_repeats=True)")
else:
buff.append("{group}.scale = 1./({group}.ydat.ptp()+1.e-16)")
script = "\n".join(buff)
if self.read_ok_cb is not None:
self.read_ok_cb(script,
self.path,
groupname=groupname,
filename=user_filename,
array_sel=self.array_sel)
for f in self.subframes.values():
try:
f.Destroy()
except:
pass
self.Destroy()
