def __init__(self): self._larch = Interpreter() self.input = self._larch.input # InputText(prompt='test>', _larch=self._larch) self.symtable = self._larch.symtable setsym = self.symtable.set_symbol setsym('testdir', os.getcwd()) setsym('_plotter.no_plotting', True) setsym('_plotter.get_display', nullfunction) self.set_stdout()
def __init__(self): self._larch = Interpreter() self.input = InputText(prompt='test>', _larch=self._larch) self.symtable = self._larch.symtable self.symtable.set_symbol('_plotter.newplot', nullfunction) self.symtable.set_symbol('_plotter.plot', nullfunction) self.symtable.set_symbol('_plotter.oplot', nullfunction) self.symtable.set_symbol('_plotter.imshow', nullfunction) self.symtable.set_symbol('_plotter.plot_text', nullfunction) self.symtable.set_symbol('_plotter.plot_arrow', nullfunction) self.symtable.set_symbol('_plotter.xrfplot', nullfunction) self._larch.writer = sys.stdout = open('_stdout_', 'w')
def __init__(self, wxparent=None, _larch=None): self.wxparent = wxparent self.larch = _larch if self.larch is None: self.larch = Interpreter() self.filelist = None self.file_groups = OrderedDict() self.fit_opts = {} self.group = None self.groupname = None self.report_frame = None self.symtable = self.larch.symtable
def __init__(self): self._larch = Interpreter() self.input = self._larch.input # InputText(prompt='test>', _larch=self._larch) self.symtable = self._larch.symtable self.symtable.set_symbol('testdir', os.getcwd()) self.symtable.set_symbol('_plotter.newplot', nullfunction) self.symtable.set_symbol('_plotter.plot', nullfunction) self.symtable.set_symbol('_plotter.oplot', nullfunction) self.symtable.set_symbol('_plotter.imshow', nullfunction) self.symtable.set_symbol('_plotter.plot_text', nullfunction) self.symtable.set_symbol('_plotter.plot_arrow', nullfunction) self.symtable.set_symbol('_plotter.xrfplot', nullfunction) self.set_stdout()
def setUp(self): self.interp = Interpreter() self.symtable = self.interp.symtable self.interp.eval('x = 1') self.outfile = '_stdout_' self.outfile = '_stdout_' self.interp.writer = NamedTemporaryFile('w', delete=False, prefix='larchtest') if not HAS_NUMPY: self.interp("arange = range")
def __init__(self, wxparent=None, _larch=None): self.wxparent = wxparent self.larch = _larch if self.larch is None: self.larch = Interpreter() self.filelist = None self.file_groups = {} self.proc_opts = {} self.fit_opts = {} self.group = None self.groupname = None self.report_frame = None self.symtable = self.larch.symtable self.symtable.set_symbol('_sys.wx.wxapp', wx.GetApp()) self.symtable.set_symbol('_sys.wx.parent', self)
class LarchSession(object): def __init__(self): self._larch = Interpreter() self.input = InputText(prompt='test>', _larch=self._larch) self.symtable = self._larch.symtable self.symtable.set_symbol('_plotter.newplot', nullfunction) self.symtable.set_symbol('_plotter.plot', nullfunction) self.symtable.set_symbol('_plotter.oplot', nullfunction) self.symtable.set_symbol('_plotter.imshow', nullfunction) self.symtable.set_symbol('_plotter.plot_text', nullfunction) self.symtable.set_symbol('_plotter.plot_arrow', nullfunction) self.symtable.set_symbol('_plotter.xrfplot', nullfunction) def run(self, text): self.input.put(text) ret = None while len(self.input) > 0: block, fname, lineno = self.input.get() if len(block) <= 0: continue ret = self._larch.eval(block, fname=fname, lineno=lineno) if self._larch.error: break return ret def get_errors(self): return self._larch.error def get_symbol(self, name): return self.symtable.get_symbol(name, create=False)
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')
def init_larch(self): if self.larch is None: self.larch = Interpreter() symtab = self.larch.symtable if not symtab.has_symbol('_sys.wx.wxapp'): symtab.set_symbol('_sys.wx.wxapp', wx.GetApp()) if not symtab.has_symbol('_sys.wx.parent'): symtab.set_symbol('_sys.wx.parent', self)
def init_larch(self): t0 = time.time() from larch.wxlib import inputhook self.larch = Interpreter() self.larch.symtable.set_symbol('_sys.wx.wxapp', wx.GetApp()) self.larch.symtable.set_symbol('_sys.wx.parent', self) self.larch('%s = group(filename="%s")' % (SCANGROUP, CURSCAN)) self.SetStatusText('ready') self.datagroups = self.larch.symtable self.title.SetLabel('')
def __init__(self, host='localhost', port=4966, logRequests=False, allow_none=True, keepalive_time=3 * 24 * 3600): self.out_buffer = [] self.larch = Interpreter(writer=self) self.larch.input.prompt = '' self.larch.input.prompt2 = '' self.larch.run_init_scripts() self.larch('_sys.client = group(keepalive_time=%f)' % keepalive_time) self.larch('_sys.wx = group(wxapp=None)') _sys = self.larch.symtable._sys _sys.color_exceptions = False _sys.client.last_event = int(time()) _sys.client.pid_server = int(os.getpid()) _sys.client.app = 'unknown' _sys.client.pid = 0 _sys.client.user = '******' _sys.client.machine = 'unknown' self.client = self.larch.symtable._sys.client SimpleXMLRPCServer.__init__(self, (host, port), logRequests=logRequests, allow_none=allow_none) self.register_introspection_functions() self.register_function(self.larch_exec, 'larch') for method in ('ls', 'chdir', 'cd', 'cwd', 'shutdown', 'set_keepalive_time', 'set_client_info', 'get_client_info', 'get_data', 'get_rawdata', 'get_messages', 'len_messages'): self.register_function(getattr(self, method), method) # sys.stdout = self self.finished = False signal.signal(signal.SIGINT, self.signal_handler) self.activity_thread = Thread(target=self.check_activity)
def __init__(self, folder=None, _larch=None, **kws): kwargs = dict(name='FeffPath wrapper') kwargs.update(kws) Group.__init__(self, **kwargs) self._larch = Interpreter() self.wrapper = feffpathwrapper.FEFFPATH() feffpathwrapper.create_path(self.wrapper) self.wrapper.phpad = '' self.ipot = [] self.rat = [] self.geom = []
def __init__(self): self._larch = Interpreter() self.input = InputText(prompt='test>', _larch=self._larch) self.symtable = self._larch.symtable self.symtable.set_symbol('_plotter.newplot', nullfunction) self.symtable.set_symbol('_plotter.plot', nullfunction) self.symtable.set_symbol('_plotter.oplot', nullfunction) self.symtable.set_symbol('_plotter.imshow', nullfunction) self.symtable.set_symbol('_plotter.plot_text', nullfunction) self.symtable.set_symbol('_plotter.plot_arrow', nullfunction) self.symtable.set_symbol('_plotter.xrfplot', nullfunction)
def init_larch(self): if self.larch is None: self.larch = Interpreter() symtab = self.larch.symtable if not symtab.has_symbol('_sys.wx.wxapp'): symtab.set_symbol('_sys.wx.wxapp', wx.GetApp()) if not symtab.has_symbol('_sys.wx.parent'): symtab.set_symbol('_sys.wx.parent', self) fico = os.path.join(site_config.larchdir, 'icons', ICON_FILE) try: self.SetIcon(wx.Icon(fico, wx.BITMAP_TYPE_ICO)) except: pass
def __init__(self, energy=None, mu=None, z=None, edge='K', mback_kws=None, _larch=None, **kws): kwargs = dict(name='diffKK') kwargs.update(kws) Group.__init__(self, **kwargs) self.energy = energy self.mu = mu self.z = z self.edge = edge self.mback_kws = mback_kws if _larch == None: self._larch = Interpreter() else: self._larch = _larch
def __init__(self, wxparent=None, writer=None, _larch=None, prompt=None, historyfile=None, output=None, input=None): self._larch = _larch self.textstyle = None if _larch is None: self._larch = Interpreter(historyfile=historyfile, writer=self) self._larch.run_init_scripts() self.symtable = self._larch.symtable self.prompt = prompt self.input = input self.output = output self.set_textstyle(mode='text') self._larch("_sys.display.colors['text2'] = {'color': 'blue'}", add_history=False) self._larch.add_plugin('wx', wxparent=wxparent) self.symtable.set_symbol('_builtin.force_wxupdate', False) self.symtable.set_symbol('_sys.wx.force_wxupdate', False) self.symtable.set_symbol('_sys.wx.wxapp', output) self.symtable.set_symbol('_sys.wx.parent', wx.GetApp().GetTopWindow()) if self.output is not None: style = self.output.GetDefaultStyle() bgcol = style.GetBackgroundColour() sfont = style.GetFont() self.textstyle = wx.TextAttr('black', bgcol, sfont) self.SetPrompt(True) self.flush_timer = wx.Timer(wxparent) self.needs_flush = True wxparent.Bind(wx.EVT_TIMER, self.onFlushTimer, self.flush_timer) self.flush_timer.Start(500)
def initialize_group(self): """ initalize larch group """ # Create 3 empty group self.mylarch = Interpreter() self.g = read_ascii(self.data_path) self.best = read_ascii(self.data_path) self.sumgroup = read_ascii(self.data_path) # Check if try: self.g.chi except AttributeError: autobk(self.g, rbkg=rbkg, kweight=bkgkw, kmax=bkgkmax, _larch=self.mylarch) autobk(self.best, rbkg=rbkg, _larch=self.mylarch) autobk(self.sumgroup, rbkg=rbkg, _larch=self.mylarch)
class LarchSession(object): def __init__(self): self._larch = Interpreter() self.input = InputText(prompt='test>', _larch=self._larch) self.symtable = self._larch.symtable self.symtable.set_symbol('_plotter.newplot', nullfunction) self.symtable.set_symbol('_plotter.plot', nullfunction) self.symtable.set_symbol('_plotter.oplot', nullfunction) self.symtable.set_symbol('_plotter.imshow', nullfunction) self.symtable.set_symbol('_plotter.plot_text', nullfunction) self.symtable.set_symbol('_plotter.plot_arrow', nullfunction) self.symtable.set_symbol('_plotter.xrfplot', nullfunction) self._larch.writer = sys.stdout = open('_stdout_', 'w') def read_stdout(self): sys.stdout.flush() time.sleep(0.1) with open(sys.stdout.name) as inp: out = inp.read() sys.stdout.close() self._larch.writer = sys.stdout = open('_stdout_', 'w') return out def run(self, text): self.input.put(text) ret = None buff = [] while len(self.input) > 0: block, fname, lineno = self.input.get() buff.append(block) if not self.input.complete: continue ret = self._larch.eval("\n".join(buff), fname=fname, lineno=lineno) if self._larch.error: break return ret def get_errors(self): return self._larch.error def get_symbol(self, name): return self.symtable.get_symbol(name, create=False)
def __init__(self, folder=None, _larch=None, **kws): kwargs = dict(name='Feff85exafs unit test: %s' % folder) kwargs.update(kws) Group.__init__(self, **kwargs) self._larch = Interpreter() self.doplot = True self.doscf = False # True = use self-consistency self.verbose = True # True = print Feff's screen messages and other screen messages self.feffran = False # True = Feff calculation has been run self.count = 0 self.feffcount = 0 self.datacount = 0 self.failed = list() if folder[-1] == '/': folder = folder[:-1] # strip trailing / self.folder = folder if not isdir(folder): folder = join('tests', folder) if not isdir(folder): print colored(folder + " isn't one of the available tests", 'magenta', attrs=['bold']) return None self.path = realpath(folder) self.testrun = realpath(join(self.path, 'testrun')) self.fefflog = realpath(join(self.path, 'testrun', 'f85e.log')) self.__testpaths() self.repotop = getcwd() if not self.repotop.endswith('feff85exafs'): self.repotop = realpath(join('..')) # the f85e shell script emulates the behavior of the monolithic Feff application self.eps5 = 0.00001 self.eps4 = 0.0001 self.eps3 = 0.001 self.epsilon = self.eps4 self.epsfit = self.eps3 self.firstshell = False self.fittest = None self.wrapper_available = wrapper_available if wrapper_available: self.sp = scatpath()
class LarchSession(object): def __init__(self): self._larch = Interpreter() self.input = self._larch.input # InputText(prompt='test>', _larch=self._larch) self.symtable = self._larch.symtable self.symtable.set_symbol('testdir', os.getcwd()) self.symtable.set_symbol('_plotter.newplot', nullfunction) self.symtable.set_symbol('_plotter.plot', nullfunction) self.symtable.set_symbol('_plotter.oplot', nullfunction) self.symtable.set_symbol('_plotter.imshow', nullfunction) self.symtable.set_symbol('_plotter.plot_text', nullfunction) self.symtable.set_symbol('_plotter.plot_arrow', nullfunction) self.symtable.set_symbol('_plotter.xrfplot', nullfunction) self.set_stdout() def set_stdout(self, fname='_stdout_'): self._outfile = os.path.abspath(fname) self._larch.writer = open(self._outfile, 'w') def read_stdout(self): self._larch.writer.flush() t0 = time.time() time.sleep(0.1) while (not os.path.exists(self._outfile) and (time.time() - t0) < 5.0): time.sleep(0.1) with open(self._outfile) as inp: out = inp.read() os.unlink(self._outfile) self._larch.writer = open(self._outfile, 'w') return out def run(self, text): return self._larch.eval(text, fname='test', lineno=0) def get_errors(self): return self._larch.error def get_symbol(self, name): return self.symtable.get_symbol(name, create=False)
def __init__(self, feffinp=None, verbose=True, repo=None, _larch=None, **kws): kwargs = dict(name='Feff runner') kwargs.update(kws) Group.__init__(self, **kwargs) if _larch == None: self._larch = Interpreter() else: self._larch = _larch self.feffinp = feffinp self.verbose = verbose self.mpse = False self.repo = repo self.resolved = None self.threshold = [] self.chargetransfer = []
class LarchSession(object): def __init__(self): self._larch = Interpreter() self.input = self._larch.input # InputText(prompt='test>', _larch=self._larch) self.symtable = self._larch.symtable self.symtable.set_symbol('testdir', os.getcwd()) self.symtable.set_symbol('_plotter.newplot', nullfunction) self.symtable.set_symbol('_plotter.plot', nullfunction) self.symtable.set_symbol('_plotter.oplot', nullfunction) self.symtable.set_symbol('_plotter.imshow', nullfunction) self.symtable.set_symbol('_plotter.plot_text', nullfunction) self.symtable.set_symbol('_plotter.plot_arrow', nullfunction) self.symtable.set_symbol('_plotter.xrfplot', nullfunction) self.set_stdout() def set_stdout(self, fname='_stdout_'): # self._outfile = os.path.abspath(fname) # self._larch.writer = open(self._outfile, 'w') self._larch.writer = StringIO() def read_stdout(self): self._larch.writer.flush() self._larch.writer.seek(0) t0 = time.time() time.sleep(0.01) out = self._larch.writer.read() self._larch.writer.close() self.set_stdout() return out def run(self, text): return self._larch.eval(text, fname='test', lineno=0) def get_errors(self): return self._larch.error def get_symbol(self, name): return self.symtable.get_symbol(name, create=False)
def __init__(self, host='localhost', port=4966, logRequests=False, allow_none=True, keepalive_time=3*24*3600): self.out_buffer = [] self.larch = Interpreter(writer=self) self.input = InputText(prompt='', _larch=self.larch) self.larch.run_init_scripts() self.larch('_sys.client = group(keepalive_time=%f)' % keepalive_time) self.larch('_sys.wx = group(wxapp=None)') _sys = self.larch.symtable._sys _sys.color_exceptions = False _sys.client.last_event = int(time()) _sys.client.pid_server = int(os.getpid()) _sys.client.app = 'unknown' _sys.client.pid = 0 _sys.client.user = '******' _sys.client.machine = 'unknown' self.client = self.larch.symtable._sys.client SimpleXMLRPCServer.__init__(self, (host, port), logRequests=logRequests, allow_none=allow_none) self.register_introspection_functions() self.register_function(self.larch_exec, 'larch') for method in ('ls', 'chdir', 'cd', 'cwd', 'shutdown', 'set_keepalive_time', 'set_client_info', 'get_client_info', 'get_data', 'get_rawdata', 'get_messages', 'len_messages'): self.register_function(getattr(self, method), method) # sys.stdout = self self.finished = False signal.signal(signal.SIGINT, self.signal_handler) self.activity_thread = Thread(target=self.check_activity)
def __init__(self, _larch=None, **kws): kwargs = dict(name='Feff test framework') kwargs.update(kws) Group.__init__(self, **kwargs) self._larch = Interpreter() self.materials = ("Copper", "NiO", "FeS2", "UO2", "BaZrO3", "bromoadamantane", "uranyl") self.tests = ('scf', 'iorder', 'mpse') self.__material = None self.__test = None self.testmodule = None self.json = None self.mustache = None self.dryrun = False self.dopathfinder = False self.tableformat = 'pipe' # 'plain', 'simple', 'grid', 'fancy_grid', 'pipe', 'orgtbl' # 'rst', 'mediawiki', 'html', 'latex', 'latex_booktabs' ## some things to make the cohabitation with f85ut happy self.doplot = False self.verbose = False self.firstshell = False self.folder = None self.path = None
class LarchSession(object): def __init__(self): self._larch = Interpreter() self.input = self._larch.input # InputText(prompt='test>', _larch=self._larch) self.symtable = self._larch.symtable setsym = self.symtable.set_symbol setsym('testdir', os.getcwd()) setsym('_plotter.no_plotting', True) setsym('_plotter.get_display', nullfunction) self.set_stdout() def set_stdout(self, fname='_stdout_'): # self._outfile = os.path.abspath(fname) # self._larch.writer = open(self._outfile, 'w') self._larch.writer = StringIO() def read_stdout(self): self._larch.writer.flush() self._larch.writer.seek(0) t0 = time.time() time.sleep(0.01) out = self._larch.writer.read() self._larch.writer.close() self.set_stdout() return out def run(self, text): return self._larch.eval(text, fname='test', lineno=0) def get_errors(self): return self._larch.error def get_symbol(self, name): return self.symtable.get_symbol(name, create=False)
Interpreter) from larch.xafs import (find_e0, pre_edge, autobk, xftf, xftr) from larch.io import create_athena import larch.utils.show as lus import matplotlib.pyplot as plt import matplotlib.gridspec as gridspec from BMM.functions import etok, ktoe from BMM import user_ns as user_ns_module user_ns = vars(user_ns_module) from BMM.user_ns.bmm import BMMuser LARCH = Interpreter() class Pandrosus(): '''A thin wrapper around basic XAS data processing for individual data sets as implemented in Larch. The plotting capabilities of this class are very similar to the orange plot buttons in Athena. Attributes ---------- uid : str Databroker unique ID of the data set, used to fetch mu(E) from the database name : str Human-readable name of the data set
class XASController(): """ class hollding the Larch session and doing the processing work for Larch XAS GUI """ config_file = 'xas_viewer.conf' def __init__(self, wxparent=None, _larch=None): self.wxparent = wxparent self.larch = _larch if self.larch is None: self.larch = Interpreter() self.filelist = None self.file_groups = OrderedDict() self.fit_opts = {} self.group = None self.groupname = None self.report_frame = None self.symtable = self.larch.symtable def init_larch(self): fico = self.get_iconfile() _larch = self.larch _larch.eval(XASGUI_STARTUP) old_config = read_config(self.config_file) config = self.make_default_config() for sname in config: if old_config is not None and sname in old_config: val = old_config[sname] if isinstance(val, dict): config[sname].update(val) else: config[sname] = val for key, value in config.items(): setattr(_larch.symtable._sys.xas_viewer, key, value) os.chdir(config['workdir']) def make_default_config(self): """ default config, probably called on first run of program""" config = {'chdir_on_fileopen': True, 'workdir': os.getcwd()} return config def get_config(self, key, default=None): "get configuration setting" confgroup = self.larch.symtable._sys.xas_viewer return getattr(confgroup, key, default) def save_config(self): """save configuration""" conf = group2dict(self.larch.symtable._sys.xas_viewer) conf.pop('__name__') save_config(self.config_file, conf) def set_workdir(self): self.larch.symtable._sys.xas_viewer.workdir = os.getcwd() def show_report(self, fitresult, evt=None): shown = False try: self.report_frame.Raise() shown = True except: del self.report_frame if not shown: self.report_frame = ReportFrame(self.wxparent) model_repr = fitresult.model._reprstring(long=True) report = fit_report(fitresult, show_correl=True, min_correl=0.25, sort_pars=True) self.report_frame.SetFont(Font(FONTSIZE - 1)) self.report_frame.set_text(report) self.report_frame.SetFont(Font(FONTSIZE - 1)) self.report_frame.Raise() def get_iconfile(self): larchdir = self.symtable._sys.config.larchdir return os.path.join(larchdir, 'icons', ICON_FILE) def get_display(self, win=1, stacked=False): wintitle = 'Larch XAS Plot Window %i' % win # if stacked: # win = 2 # wintitle='Larch XAS Plot Window' opts = dict(wintitle=wintitle, stacked=stacked, win=win, size=PLOTWIN_SIZE) out = self.symtable._plotter.get_display(**opts) if win > 1: p1 = getattr(self.symtable._plotter, 'plot1', None) if p1 is not None: try: siz = p1.GetSize() pos = p1.GetPosition() pos[0] += int(siz[0] / 4) pos[1] += int(siz[1] / 4) out.SetSize(pos) if not stacked: out.SetSize(siz) except Exception: pass return out def get_group(self, groupname=None): if groupname is None: groupname = self.groupname if groupname is None: return None dgroup = getattr(self.symtable, groupname, None) if dgroup is None and groupname in self.file_groups: groupname = self.file_groups[groupname] dgroup = getattr(self.symtable, groupname, None) return dgroup def merge_groups(self, grouplist, master=None, yarray='mu', outgroup=None): """merge groups""" cmd = """%s = merge_groups(%s, master=%s, xarray='energy', yarray='%s', kind='cubic', trim=True)""" glist = "[%s]" % (', '.join(grouplist)) outgroup = fix_varname(outgroup.lower()) if outgroup is None: outgroup = 'merged' outgroup = unique_name(outgroup, self.file_groups, max=1000) cmd = cmd % (outgroup, glist, master, yarray) self.larch.eval(cmd) if master is None: master = grouplist[0] this = self.get_group(outgroup) master = self.get_group(master) if not hasattr(this, 'xasnorm_config'): this.xasnorm_config = {} this.xasnorm_config.update(master.xasnorm_config) this.datatype = master.datatype this.xdat = 1.0 * this.energy this.ydat = 1.0 * getattr(this, yarray) this.plot_xlabel = 'energy' this.plot_ylabel = yarray return outgroup def copy_group(self, filename, new_filename=None): """copy XAS group (by filename) to new group""" groupname = self.file_groups[filename] if not hasattr(self.larch.symtable, groupname): return ogroup = self.get_group(groupname) ngroup = Group(datatype=ogroup.datatype, copied_from=groupname) for attr in dir(ogroup): do_copy = True if attr in ('xdat', 'ydat', 'i0', 'data' 'yerr', 'energy', 'mu'): val = getattr(ogroup, attr) * 1.0 elif attr in ('norm', 'flat', 'deriv', 'deconv', 'post_edge', 'pre_edge'): do_copy = False else: try: val = copy.deepcopy(getattr(ogroup, attr)) except ValueError: do_copy = False if do_copy: setattr(ngroup, attr, val) if new_filename is None: new_filename = filename + '_1' ngroup.filename = unique_name(new_filename, self.file_groups.keys()) ngroup.groupname = unique_name(groupname, self.file_groups.values()) setattr(self.larch.symtable, ngroup.groupname, ngroup) return ngroup def get_cursor(self, win=None): """get last cursor from selected window""" return last_cursor_pos(win=win, _larch=self.larch) def plot_group(self, groupname=None, title=None, plot_yarrays=None, new=True, zoom_out=True, **kws): ppanel = self.get_display(stacked=False).panel newplot = ppanel.plot oplot = ppanel.oplot plotcmd = oplot viewlims = ppanel.get_viewlimits() if new: plotcmd = newplot dgroup = self.get_group(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 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'] = (i != narr) plotcmd(dgroup.xdat, getattr(dgroup, yaname), **popts) plotcmd = oplot if plot_extras is not None: axes = ppanel.axes for etype, x, y, opts in plot_extras: if etype == 'marker': popts = { 'marker': 'o', 'markersize': 4, 'label': '_nolegend_', 'markerfacecolor': 'red', 'markeredgecolor': '#884444' } popts.update(opts) axes.plot([x], [y], **popts) elif etype == 'vline': popts = {'ymin': 0, 'ymax': 1.0, 'color': '#888888'} popts.update(opts) axes.axvline(x, **popts) ppanel.canvas.draw()
class LarchServer(SimpleXMLRPCServer): def __init__(self, host='localhost', port=4966, logRequests=False, allow_none=True, keepalive_time=3*24*3600): self.out_buffer = [] self.larch = Interpreter(writer=self) self.input = InputText(prompt='', _larch=self.larch) self.larch.run_init_scripts() self.larch('_sys.client = group(keepalive_time=%f)' % keepalive_time) self.larch('_sys.wx = group(wxapp=None)') _sys = self.larch.symtable._sys _sys.color_exceptions = False _sys.client.last_event = int(time()) _sys.client.pid_server = int(os.getpid()) _sys.client.app = 'unknown' _sys.client.pid = 0 _sys.client.user = '******' _sys.client.machine = 'unknown' self.client = self.larch.symtable._sys.client SimpleXMLRPCServer.__init__(self, (host, port), logRequests=logRequests, allow_none=allow_none) self.register_introspection_functions() self.register_function(self.larch_exec, 'larch') for method in ('ls', 'chdir', 'cd', 'cwd', 'shutdown', 'set_keepalive_time', 'set_client_info', 'get_client_info', 'get_data', 'get_rawdata', 'get_messages', 'len_messages'): self.register_function(getattr(self, method), method) # sys.stdout = self self.finished = False signal.signal(signal.SIGINT, self.signal_handler) self.activity_thread = Thread(target=self.check_activity) def write(self, text, **kws): if text is None: text = '' self.out_buffer.append(str(text)) def flush(self): pass def set_keepalive_time(self, keepalive_time): """set keepalive time the server will self destruct after keepalive_time of inactivity Arguments: keepalive_time (number): time in seconds """ self.larch("_sys.client.keepalive_time = %f" % keepalive_time) def set_client_info(self, key, value): """set client info Arguments: key (str): category value (str): value to use Notes: the key can actually be any string but include by convention: app application name user user name machine machine name pid process id """ self.larch("_sys.client.%s = '%s'" % (key, value)) def get_client_info(self): """get client info: returns json dictionary of client information """ out = {} client = self.larch.symtable._sys.client for attr in dir(client): out[attr] = getattr(client, attr) return encode4js(out) def get_messages(self): """get (and clear) all output messages (say, from "print()") """ out = "".join(self.out_buffer) self.out_buffer = [] return out def len_messages(self): "length of message buffer" return len(self.out_buffer) def ls(self, dir_name): """list contents of a directory: """ return os.listdir(dir_name) def chdir(self, dir_name): """change directory""" return os.chdir(dir_name) def cd(self, dir_name): """change directory""" return os.chdir(dir_name) def cwd(self): """change directory""" ret = os.getcwd() if sys.platform == 'win32': ret = ret.replace('\\','/') return ret def signal_handler(self, sig=0, frame=None): self.kill() def kill(self): """handle alarm signal, generated by signal.alarm(t)""" sleep(2.0) self.shutdown() self.server_close() def shutdown(self): "shutdown LarchServer" self.finished = True if self.activity_thread.is_alive(): self.activity_thread.join(POLL_TIME) return 1 def check_activity(self): while not self.finished: sleep(POLL_TIME) # print("Tick ", time()- (self.client.keepalive_time + self.client.last_event)) if time() > (self.client.keepalive_time + self.client.last_event): t = Thread(target=self.kill) t.start() break def larch_exec(self, text): "execute larch command" text = text.strip() if text in ('quit', 'exit', 'EOF'): self.shutdown() else: self.input.put(text, lineno=0) if self.input.complete: self.larch('_sys.client.last_event = %i' % time()) self.input.run() self.flush() return 1 def get_rawdata(self, expr): "return non-json encoded data for a larch expression" return self.larch.eval(expr) def get_data(self, expr): "return json encoded data for a larch expression" self.larch('_sys.client.last_event = %i' % time()) return encode4js(self.larch.eval(expr)) def run(self): """run server until times out""" self.activity_thread.start() while not self.finished: try: self.handle_request() except: break
class XASController(): """ class hollding the Larch session and doing the processing work for Larch XAS GUI """ config_file = 'xas_viewer.conf' def __init__(self, wxparent=None, _larch=None): self.wxparent = wxparent self.larch = _larch if self.larch is None: self.larch = Interpreter() self.filelist = None self.file_groups = OrderedDict() self.fit_opts = {} self.group = None self.groupname = None self.report_frame = None self.symtable = self.larch.symtable def init_larch(self): _larch = self.larch old_config = read_config(self.config_file) config = self.make_default_config() for sname in config: if old_config is not None and sname in old_config: val = old_config[sname] if isinstance(val, dict): config[sname].update(val) else: config[sname] = val for key, value in config.items(): setattr(_larch.symtable._sys.xas_viewer, key, value) os.chdir(config['workdir']) self.wxparent.SetIcon(wx.Icon(self.get_iconfile(), wx.BITMAP_TYPE_ICO)) def make_default_config(self): """ default config, probably called on first run of program""" config = {'chdir_on_fileopen': True, 'workdir': os.getcwd()} return config def get_config(self, key, default=None): "get configuration setting" confgroup = self.larch.symtable._sys.xas_viewer return getattr(confgroup, key, default) def save_config(self): """save configuration""" conf = group2dict(self.larch.symtable._sys.xas_viewer) conf.pop('__name__') save_config(self.config_file, conf) def set_workdir(self): self.larch.symtable._sys.xas_viewer.workdir = os.getcwd() def get_iconfile(self): larchdir = self.symtable._sys.config.larchdir return os.path.join(larchdir, 'icons', ICON_FILE) def get_display(self, win=1, stacked=False): wintitle='Larch XAS Plot Window %i' % win # if stacked: # win = 2 # wintitle='Larch XAS Plot Window' opts = dict(wintitle=wintitle, stacked=stacked, win=win, size=PLOTWIN_SIZE) out = self.symtable._plotter.get_display(**opts) if win > 1: p1 = getattr(self.symtable._plotter, 'plot1', None) if p1 is not None: try: siz = p1.GetSize() pos = p1.GetPosition() pos[0] += int(siz[0]/4) pos[1] += int(siz[1]/4) out.SetSize(pos) if not stacked: out.SetSize(siz) except Exception: pass return out def get_group(self, groupname=None): if groupname is None: groupname = self.groupname if groupname is None: return None dgroup = getattr(self.symtable, groupname, None) if dgroup is None and groupname in self.file_groups: groupname = self.file_groups[groupname] dgroup = getattr(self.symtable, groupname, None) return dgroup def filename2group(self, filename): "convert filename (as displayed) to larch group" return self.get_group(self.file_groups[str(filename)]) def merge_groups(self, grouplist, master=None, yarray='mu', outgroup=None): """merge groups""" cmd = """%s = merge_groups(%s, master=%s, xarray='energy', yarray='%s', kind='cubic', trim=True)""" glist = "[%s]" % (', '.join(grouplist)) outgroup = fix_varname(outgroup.lower()) if outgroup is None: outgroup = 'merged' outgroup = unique_name(outgroup, self.file_groups, max=1000) cmd = cmd % (outgroup, glist, master, yarray) self.larch.eval(cmd) if master is None: master = grouplist[0] this = self.get_group(outgroup) master = self.get_group(master) if not hasattr(this, 'xasnorm_config'): this.xasnorm_config = {} this.xasnorm_config.update(master.xasnorm_config) this.datatype = master.datatype this.xdat = 1.0*this.energy this.ydat = 1.0*getattr(this, yarray) this.yerr = getattr(this, 'd' + yarray, 1.0) if yarray != 'mu': this.mu = this.ydat this.plot_xlabel = 'energy' this.plot_ylabel = yarray return outgroup def copy_group(self, filename, new_filename=None): """copy XAS group (by filename) to new group""" groupname = self.file_groups[filename] if not hasattr(self.larch.symtable, groupname): return ogroup = self.get_group(groupname) ngroup = Group(datatype=ogroup.datatype, copied_from=groupname) for attr in dir(ogroup): do_copy = True if attr in ('xdat', 'ydat', 'i0', 'data' 'yerr', 'energy', 'mu'): val = getattr(ogroup, attr)*1.0 elif attr in ('norm', 'flat', 'deriv', 'deconv', 'post_edge', 'pre_edge', 'norm_mback', 'norm_vict', 'norm_poly'): do_copy = False else: try: val = copy.deepcopy(getattr(ogroup, attr)) except ValueError: do_copy = False if do_copy: setattr(ngroup, attr, val) if new_filename is None: new_filename = filename + '_1' ngroup.filename = unique_name(new_filename, self.file_groups.keys()) ngroup.groupname = unique_name(groupname, self.file_groups.values()) setattr(self.larch.symtable, ngroup.groupname, ngroup) return ngroup def get_cursor(self, win=None): """get last cursor from selected window""" return last_cursor_pos(win=win, _larch=self.larch) def plot_group(self, groupname=None, title=None, plot_yarrays=None, new=True, zoom_out=True, **kws): ppanel = self.get_display(stacked=False).panel newplot = ppanel.plot oplot = ppanel.oplot plotcmd = oplot viewlims = ppanel.get_viewlimits() if new: plotcmd = newplot dgroup = self.get_group(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 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'] = (i != narr) plotcmd(dgroup.xdat, getattr(dgroup, yaname), **popts) plotcmd = oplot if plot_extras is not None: axes = ppanel.axes for etype, x, y, opts in plot_extras: if etype == 'marker': popts = {'marker': 'o', 'markersize': 4, 'label': '_nolegend_', 'markerfacecolor': 'red', 'markeredgecolor': '#884444'} popts.update(opts) axes.plot([x], [y], **popts) elif etype == 'vline': popts = {'ymin': 0, 'ymax': 1.0, 'color': '#888888'} popts.update(opts) axes.axvline(x, **popts) ppanel.canvas.draw()
def setUp(self): self.session = Interpreter() self.symtable = self.session.symtable self.set_stdout()
#!/usr/bin/env python ## Autobk (XAFS background subtraction) in pure Python, ## using Python code from Lxsarch. from larch import Interpreter from larch_plugins.xafs import pre_edge, autobk from larch_plugins.io import read_ascii # create plain interpreter, don't load all the plugins _larch = Interpreter(with_plugins=False) fname = '../xafsdata/cu_rt01.xmu' cu = read_ascii(fname, labels='energy mu i0', _larch=_larch) print( 'Read ASCII File:', cu) print( dir(cu)) pre_edge(cu, _larch=_larch) print( 'After pre-edge:') print( dir(cu)) autobk(cu, rbkg=1.0, kweight=1, _larch=_larch) print( 'After autobk:') print( dir(cu))
import time import matplotlib as mpl #mpl.use('Agg') import matplotlib.pyplot as plt import sys import csv from pathlib import Path global mylarch global base # global front # global end # global intervalK # global Kmin mylarch = Interpreter() base = Path(os.getcwd()).parent.parent # front = os.path.join(base,"path_files/TcCl6/feff") # end = '.dat' # Larch has two types of files, from Larch which is the chik, and the experimential files def larch_init(CSV_sub, params): r""" Larch initialization for data analysis Inputs: CSV_sub (str): files location of the data files (CSV/XMU) params (dics): dicts contain all parameters """ global intervalK
class SpykShell(): ps1 = 'Spyk >' ps2 = ' ... >' def __init__(self, wxparent=None, writer=None, _larch=None, prompt=None, historyfile=None, output=None, input=None): self._larch = _larch self.textstyle = None if _larch is None: self._larch = Interpreter(historyfile=historyfile, writer=self) self._larch.run_init_scripts() self.symtable = self._larch.symtable self.prompt = prompt self.input = input self.output = output self.set_textstyle(mode='text') self._larch("_sys.display.colors['text2'] = {'color': 'blue'}", add_history=False) self._larch.add_plugin('wx', wxparent=wxparent) self.symtable.set_symbol('_builtin.force_wxupdate', False) self.symtable.set_symbol('_sys.wx.force_wxupdate', False) self.symtable.set_symbol('_sys.wx.wxapp', output) self.symtable.set_symbol('_sys.wx.parent', wx.GetApp().GetTopWindow()) if self.output is not None: style = self.output.GetDefaultStyle() bgcol = style.GetBackgroundColour() sfont = style.GetFont() self.textstyle = wx.TextAttr('black', bgcol, sfont) self.SetPrompt(True) self.flush_timer = wx.Timer(wxparent) self.needs_flush = True wxparent.Bind(wx.EVT_TIMER, self.onFlushTimer, self.flush_timer) self.flush_timer.Start(500) def onUpdate(self, event=None): symtable = self.symtable if symtable.get_symbol('_builtin.force_wxupdate', create=True): app = wx.GetApp() evtloop = wx.EventLoop() while evtloop.Pending(): evtloop.Dispatch() app.ProcessIdle() symtable.set_symbol('_builtin.force_wxupdate', False) def SetPrompt(self, complete): if self.prompt is None: return sprompt, scolor = self.ps1, '#000075' if not complete: sprompt, scolor = self.ps2, '#E00075' self.prompt.SetLabel(sprompt) self.prompt.SetForegroundColour(scolor) self.prompt.Refresh() def set_textstyle(self, mode='text'): if self.output is None: return display_colors = self._larch.symtable._sys.display.colors textattrs = display_colors.get(mode, {'color':'black'}) color = textattrs['color'] style = self.output.GetDefaultStyle() bgcol = style.GetBackgroundColour() sfont = style.GetFont() self.textstyle = wx.TextAttr(color, bgcol, sfont) def write(self, text, **kws): if self.output is None: sys.stdout.write(text) sys.stdout.flush() else: pos0 = self.output.GetLastPosition() self.output.WriteText(text) pos1 = self.output.GetLastPosition() self.output.SetStyle(pos0, pos1, self.textstyle) self.needs_flush = True def flush(self, *args): try: self.output.SetInsertionPoint(self.output.GetLastPosition()) except: pass self.output.Refresh() self.output.Update() self.needs_flush = False def clear_input(self): self._larch.input.clear() self.SetPrompt(True) def onFlushTimer(self, event=None): if self.needs_flush: self.flush() def eval(self, text, add_history=True, **kws): if text is None: return if text.startswith('!'): return os.system(text[1:]) else: if add_history: self.input.AddToHistory(text) self.write(">%s\n" % text) ret = self._larch.eval(text, add_history=add_history) if self._larch.error: self._larch.input.clear() self._larch.writer.set_textstyle('error') self._larch.show_errors() self._larch.writer.set_textstyle('text') elif ret is not None: self._larch.writer.write("%s\n" % repr(ret)) self.SetPrompt(self._larch.input.complete)
class XYFitController(): """ class hollding the Larch session and doing the processing work for Larch XYFit """ config_file = 'xyfit.conf' def __init__(self, wxparent=None, _larch=None): self.wxparent = wxparent self.larch = _larch if self.larch is None: self.larch = Interpreter() self.filelist = None self.file_groups = {} self.proc_opts = {} self.fit_opts = {} self.group = None self.groupname = None self.report_frame = None self.symtable = self.larch.symtable self.symtable.set_symbol('_sys.wx.wxapp', wx.GetApp()) self.symtable.set_symbol('_sys.wx.parent', self) def init_larch(self): fico = self.get_iconfile() _larch = self.larch _larch.eval("import xafs_plots") _larch.symtable._sys.xyfit = Group() config = read_config(self.config_file) if (config is None or 'workdir' not in config or 'data_proc' not in config or 'xas_proc' not in config): config = self.make_default_config() for key, value in config.items(): setattr(_larch.symtable._sys.xyfit, key, value) os.chdir(config['workdir']) def make_default_config(self): """ default config, probably called on first run of program""" config = {'chdir_on_fileopen': True, 'workdir': os.getcwd()} config['data_proc'] = dict(xshift=0, xscale=1, yshift=0, yscale=1, smooth_op='None', smooth_conv='Lorentzian', smooth_c0=2, smooth_c1=1, smooth_sig=1) config['xas_proc'] = dict(e0=0, pre1=-200, pre2=-10, edge_step=0, nnorm=2, norm1=25, norm2=-10, nvict=1, auto_step=True, auto_e0=True, show_e0=True, xas_op='Normalized') return config def get_config(self, key, default=None): "get configuration setting" confgroup = self.larch.symtable._sys.xyfit return getattr(confgroup, key, default) def save_config(self): """save configuration""" conf = group2dict(self.larch.symtable._sys.xyfit) conf.pop('__name__') save_config(self.config_file, conf) def set_workdir(self): self.larch.symtable._sys.xyfit.workdir = os.getcwd() def show_report(self, text, evt=None): shown = False try: self.report_frame.Raise() shown = True except: del self.report_frame if not shown: self.report_frame = ReportFrame(self.wxparent) self.report_frame.SetFont(Font(8)) self.report_frame.set_text(text) self.report_frame.SetFont(Font(8)) self.report_frame.Raise() def get_iconfile(self): larchdir = self.symtable._sys.config.larchdir return os.path.join(larchdir, 'icons', ICON_FILE) def get_display(self, stacked=False): win = 1 wintitle='Larch XYFit Array Plot Window' if stacked: win = 2 wintitle='Larch XYFit Fit Plot Window' opts = dict(wintitle=wintitle, stacked=stacked, win=win) out = self.symtable._plotter.get_display(**opts) return out def get_group(self, groupname): if groupname is None: groupname = self.groupname grp = getattr(self.symtable, groupname, None) if not hasattr(grp, 'proc_opts'): grp.proc_opts = {} return grp def get_proc_opts(self, dgroup): opts = {} opts.update(self.get_config('data_proc', default={})) if dgroup.datatype == 'xas': opts.update(self.get_config('xas_proc', {})) if hasattr(dgroup, 'proc_opts'): opts.update(dgroup.proc_opts) return opts 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 = {'group': dgroup.groupname} opts.update(dgroup.proc_opts) # scaling cmds = [] cmds.append("{group:s}.x = {xscale:f}*({group:s}.xdat + {xshift:f})") cmds.append("{group:s}.y = {yscale:f}*({group:s}.ydat + {yshift:f})") # smoothing smop = opts['smooth_op'].lower() smcmd = None if smop.startswith('box'): opts['smooth_c0'] = int(opts['smooth_c0']) smcmd = "boxcar({group:s}.y, {smooth_c0:d})" elif smop.startswith('savit'): opts['smooth_c0'] = int(opts['smooth_c0']) opts['smooth_c1'] = int(opts['smooth_c1']) smcmd = "savitzky_golay({group:s}.y, {smooth_c0:d}, {smooth_c1:d})" elif smop.startswith('conv'): cform = str(opts['smooth_conv'].lower()) smcmd = "smooth({group:s}.x, {group:s}.y, sigma={smooth_sig:f}, form='{smooth_conv:s}')" if smcmd is not None: cmds.append("{group:s}.y = " + smcmd) for cmd in cmds: self.larch.eval(cmd.format(**opts)) # xas if dgroup.datatype.startswith('xas'): dgroup.energy = dgroup.x*1.0 dgroup.mu = dgroup.y*1.0 copts = [dgroup.groupname] if not opts['auto_e0']: _e0 = opts['e0'] if _e0 < max(dgroup.energy) and _e0 > min(dgroup.energy): copts.append("e0=%.4f" % float(_e0)) if not opts['auto_step']: copts.append("step=%.4f" % opts['edge_step']) for attr in ('pre1', 'pre2', 'nvict', 'nnorm', 'norm1', 'norm2'): copts.append("%s=%.4f" % (attr, opts[attr])) self.larch.eval("pre_edge(%s)" % (','.join(copts))) opts['e0'] = dgroup.e0 opts['edge_step'] = dgroup.edge_step for attr in ('pre1', 'pre2', 'norm1', 'norm2'): opts[attr] = getattr(dgroup.pre_edge_details, attr) dgroup.proc_opts.update(opts) def get_cursor(self): try: xval = self.symtable._plotter.plot1_x yval = self.symtable._plotter.plot1_y except: xval, yval = None, None return xval, yval def plot_group(self, groupname=None, title=None, new=True, **kws): ppanel = self.get_display(stacked=False).panel newplot = ppanel.plot oplot = ppanel.oplot plotcmd = oplot if new: plotcmd = newplot dgroup = self.get_group(groupname) if not hasattr(dgroup, 'xdat'): print("Cannot plot group ", groupname) if dgroup.datatype == 'xas': if ((getattr(dgroup, 'plot_yarrays', None) is None or getattr(dgroup, 'energy', None) is None or getattr(dgroup, 'mu', None) is None)): # print("-> Mode.process") self.process(dgroup) if not hasattr(dgroup, 'x'): dgroup.x = dgroup.xdat[:] if not hasattr(dgroup, 'y'): dgroup.y = dgroup.ydat[:] if hasattr(dgroup, 'plot_yarrays'): plot_yarrays = dgroup.plot_yarrays else: plot_yarrays = [(dgroup.y, {}, None)] popts = kws path, fname = os.path.split(dgroup.filename) if not 'label' in popts: popts['label'] = dgroup.plot_ylabel 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_ymarkers = None if new: if title is None: title = fname plot_ymarkers = getattr(dgroup, 'plot_ymarkers', None) popts['title'] = title for yarr in plot_yarrays: popts.update(yarr[1]) if popts['label'] is None and yarr[2] is not None: popts['label'] = yarr[2] plotcmd(dgroup.x, yarr[0], **popts) plotcmd = oplot if plot_ymarkers is not None: axes = ppanel.axes for x, y, opts in plot_ymarkers: popts = {'marker': 'o', 'markersize': 4, 'markerfacecolor': 'red', 'label': '', 'markeredgecolor': 'black'} popts.update(opts) axes.plot([x], [y], **popts) ppanel.canvas.draw()
from larch import Interpreter linp = Interpreter() def onVarChange(group=None, symbolname=None, value=None, **kws): print('var changed ', group, symbolname, value, kws) linp('x = 100.0') linp.symtable.add_callback('x', onVarChange) linp.symtable.set_symbol('x', 30) linp.symtable.set_symbol('x', 'a string') linp('x = arange(7)')
if overwrite is False: _logger.info(f"overwrite is {overwrite} -> nothing to do!") return else: _fileExists = False if overwrite and _fileExists: os.remove(fileout) h5out = h5py.File(fileout, mode="a", track_order=True) create_ds_args = {"track_order": True} dicttoh5(adict, h5out, create_dataset_args=create_ds_args) h5out.close() _logger.info(f"Athena project converted to {fileout}") if __name__ == "__main__": # some tests while devel _curdir = os.path.dirname(os.path.realpath(__file__)) _exdir = os.path.join(os.path.dirname(os.path.dirname(_curdir)), "examples", "pca") fnroot = "cyanobacteria" atpfile = os.path.join(_exdir, f"{fnroot}.prj") if 0: from larch import Interpreter aprj = AthenaProject(_larch=Interpreter()) aprj.read(atpfile, do_bkg=False) # there is currently a bug in do_bkg! adict = aprj.as_dict() if 0: athena_to_hdf5(atpfile, fileout=f"{fnroot}.h5", overwrite=True) pass
class XYFitController(): """ class hollding the Larch session and doing the processing work for Larch XYFit """ def __init__(self, wxparent=None, _larch=None): self.wxparent = wxparent self.larch = _larch if self.larch is None: self.larch = Interpreter() self.filelist = None self.file_groups = {} self.proc_opts = {} self.fit_opts = {} self.group = None self.groupname = None self.report_frame = None self.symtable = self.larch.symtable self.symtable.set_symbol('_sys.wx.wxapp', wx.GetApp()) self.symtable.set_symbol('_sys.wx.parent', self) def show_report(self, text, evt=None): shown = False try: self.report_frame.Raise() shown = True except: del self.report_frame if not shown: self.report_frame = ReportFrame(self.wxparent) self.report_frame.SetFont(Font(8)) self.report_frame.set_text(text) self.report_frame.SetFont(Font(8)) self.report_frame.Raise() def get_iconfile(self): larchdir = self.symtable._sys.config.larchdir return os.path.join(larchdir, 'icons', ICON_FILE) def get_display(self, stacked=False): win = 1 wintitle = 'Larch XYFit Array Plot Window' if stacked: win = 2 wintitle = 'Larch XYFit Fit Plot Window' opts = dict(wintitle=wintitle, stacked=stacked, win=win) out = self.symtable._plotter.get_display(**opts) return out def get_group(self, groupname): if groupname is None: groupname = self.groupname grp = getattr(self.symtable, groupname, None) if not hasattr(grp, 'proc_opts'): grp.proc_opts = {} return grp def get_proc_opts(self, dgroup): opts = dict(xshift=0, xscale=1, yshift=0, yscale=1, smooth_op='None', smooth_conv='Lorentzian', smooth_c0=2, smooth_c1=1, smooth_sig=1) if dgroup.datatype == 'xas': opts.update( dict(e0=0, pre1=-200, pre2=-30, edge_step=0, nnorm=3, norm1=50, norm2=-10, nvict=2, auto_step=True, auto_e0=True, show_e0=True, xas_op='Raw Data')) if hasattr(dgroup, 'proc_opts'): opts.update(dgroup.proc_opts) return opts 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 = {'group': dgroup.groupname} opts.update(dgroup.proc_opts) # scaling cmds = [ "{group:s}.x = {xscale:f}*({group:s}.xdat + {xshift:f})", "{group:s}.y = {yscale:f}*({group:s}.ydat + {yshift:f})" ] # smoothing smop = opts['smooth_op'].lower() smcmd = None if smop.startswith('box'): opts['smooth_c0'] = int(opts['smooth_c0']) smcmd = "boxcar({group:s}.y, {smooth_c0:d})" elif smop.startswith('savit'): opts['smooth_c0'] = int(opts['smooth_c0']) opts['smooth_c1'] = int(opts['smooth_c1']) smcmd = "savitzky_golay({group:s}.y, {smooth_c0:d}, {smooth_c1:d})" elif smop.startswith('conv'): cform = str(opts['smooth_conv'].lower()) smcmd = "smooth({group:s}.x, {group:s}.y, sigma={smooth_sig:f}, form='{smooth_conv:s}')" if smcmd is not None: cmds.append("{group:s}.y = " + smcmd) for cmd in cmds: self.larch.eval(cmd.format(**opts)) # xas if dgroup.datatype.startswith('xas'): dgroup.energy = dgroup.x dgroup.mu = dgroup.y popts = dict(group=dgroup.groupname, e0='None', step='None', make_flat='False') if not opts['auto_e0']: _e0 = opts['e0'] if _e0 < max(dgroup.energy) and _e0 > min(dgroup.energy): popts['e0'] = "%.f" % float(_e0) if not opts['auto_step']: popts['step'] = "%.f" % opts['step'] for attr in ('pre1', 'pre2', 'nvict', 'nnorm', 'norm1', 'norm2'): popts[attr] = "%.f" % opts[attr] cmd = """pre_edge({group:s}, e0={e0:s}, step={step:s}, pre1={pre1:s}, pre2={pre2:s}, norm1={norm1:s}, norm2={norm2:s}, nnorm={nnorm:s}, nvict={nvict:s})""".format( **popts) self.larch.eval(cmd) 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 get_cursor(self): try: xval = self.symtable._plotter.plot1_x yval = self.symtable._plotter.plot1_y except: xval, yval = None, None return xval, yval def plot_group(self, groupname=None, title=None, new=True, **kws): ppanel = self.get_display(stacked=False).panel newplot = ppanel.plot oplot = ppanel.oplot plotcmd = oplot if new: plotcmd = newplot dgroup = self.get_group(groupname) if not hasattr(dgroup, 'xdat'): print("Cannot plot group ", groupname) if dgroup.datatype == 'xas': if ((getattr(dgroup, 'plot_yarrays', None) is None or getattr(dgroup, 'energy', None) is None or getattr(dgroup, 'mu', None) is None)): # print("-> Mode.process") self.process(dgroup) if not hasattr(dgroup, 'x'): dgroup.x = dgroup.xdat[:] if not hasattr(dgroup, 'y'): dgroup.y = dgroup.ydat[:] if hasattr(dgroup, 'plot_yarrays'): plot_yarrays = dgroup.plot_yarrays else: plot_yarrays = [(dgroup.y, {}, None)] popts = kws path, fname = os.path.split(dgroup.filename) if not 'label' in popts: popts['label'] = "%s: %s" % (fname, dgroup.plot_ylabel) popts['xlabel'] = dgroup.plot_xlabel popts['ylabel'] = dgroup.plot_ylabel if getattr(dgroup, 'plot_y2label', None) is not None: popts['y2label'] = dgroup.plot_y2label if plotcmd == newplot and title is None: title = fname popts['title'] = title for yarr in plot_yarrays: popts.update(yarr[1]) if yarr[2] is not None: popts['label'] = yarr[2] plotcmd(dgroup.x, yarr[0], **popts) plotcmd = oplot if hasattr(dgroup, 'plot_ymarkers'): axes = ppanel.axes for x, y, opts in dgroup.plot_ymarkers: popts = { 'marker': 'o', 'markersize': 4, 'markerfacecolor': 'red', 'markeredgecolor': 'black' } popts.update(opts) axes.plot([x], [y], **popts) ppanel.canvas.draw()
class TestCase(unittest.TestCase): """testing of asteval""" def setUp(self): self.interp = Interpreter() self.symtable = self.interp.symtable self.interp.eval('x = 1') self.outfile = '_stdout_' self.outfile = '_stdout_' self.interp.writer = NamedTemporaryFile('w', delete=False, prefix='larchtest') if not HAS_NUMPY: self.interp("arange = range") def read_stdout(self): time.sleep(0.1) self.interp.writer.flush() out = None with open(self.interp.writer.name) as inp: out = inp.read() return out def tearDown(self): pass # noinspection PyUnresolvedReferences def isvalue(self, sym, val): """assert that a symboltable symbol has a particular value""" tval = self.interp.symtable.get_symbol(sym) if isinstance(val, np.ndarray): return self.assertTrue(np.all(tval == val)) else: return self.assertTrue(tval == val) def isnear(self, expr, val, places=7): """assert that a symboltable symbol is near a particular value""" oval = self.interp(expr) if HAS_NUMPY and isinstance(val, np.ndarray): for x, y in zip(oval, val): self.assertAlmostEqual(x, y, places=places) else: return self.assertAlmostEqual(oval, val, places=places) # noinspection PyUnresolvedReferences def istrue(self, expr): """assert that an expression evaluates to True""" val = self.interp(expr) if HAS_NUMPY and isinstance(val, np.ndarray): val = np.all(val) return self.assertTrue(val) # noinspection PyUnresolvedReferences def isfalse(self, expr): """assert that an expression evaluates to False""" val = self.interp(expr) if HAS_NUMPY and isinstance(val, np.ndarray): val = np.all(val) return self.assertFalse(val) def check_output(self, chk_str, exact=False): self.interp.writer.flush() out = self.read_stdout().split('\n') if out: if exact: return chk_str == out[0] return chk_str in out[0] return False def check_error(self, chk_type, chk_msg=''): #trye if chk_type is None: self.assertEqual(0, len(self.interp.error)) else: errtype, errmsg = self.interp.error[0].get_error() self.assertEqual(errtype, chk_type) if chk_msg: self.assertTrue(chk_msg in errmsg)