def main(): parser = OptionParser(usage=usage, version="%prog 42") parser.add_option("-s", "--scale", type=int, metavar='scale', action="store", dest="scale", default=2, help=help['scale']) parser.add_option("-r", "--repeat", type='str', metavar='nx,ny[,nz]', action="callback", dest="repeat", callback=parse_repeat, default=None, help=help['repeat']) parser.add_option("-e", "--eps", type=float, metavar='eps', action="store", dest="eps", default=1e-8, help=help['eps']) (options, args) = parser.parse_args() if (len( args ) == 2): filename_in = args[0] filename_out = args[1] else: parser.print_help() return output = Output('tpm:') output('scale:', options.scale) output('repeat:', options.repeat) output('eps:', options.eps) mesh_in = Mesh.from_file(filename_in) mesh_out = gen_tiled_mesh(mesh_in, options.repeat, 1./options.scale, options.eps) mesh_out.write(filename_out, io='auto') output('done.')
def test_verbose_output(self): try: from StringIO import StringIO # Python 2 except ImportError: from io import StringIO # Python 3 from sfepy.base.base import Output, goptions fd = StringIO() output = Output('test', filename=fd) output('test1') goptions['verbose'] = False output('test2') goptions['verbose'] = 1 output('test3') _ok1 = bool(goptions['verbose']) _ok2 = fd.getvalue() == 'test test1\ntest test3\n' fd.close() ok = _ok1 and _ok2 return ok
def test_log_rw(self): from sfepy.base.base import Output from sfepy.base.log import read_log, write_log log, info = read_log(self.log_filename) output = Output('', filename=os.path.join(self.options.out_dir, 'test_log2.txt'), quiet=True) write_log(output, log, info) log2, info2 = read_log(self.log_filename) ok = True _ok = info == info2 if not _ok: self.report('headers are not equal!') self.report(info) self.report(info2) ok = ok and _ok for key, val2 in log2.items(): val = log[key] _ok = nm.allclose(val[0], val2[0], rtol=0.0, atol=1e-14) if not _ok: self.report('x values are not equal!') self.report(val[0]) self.report(val2[0]) ok = ok and _ok _ok = nm.allclose(val[1], val2[1], rtol=0.0, atol=1e-14) if not _ok: self.report('y values are not equal!') self.report(val[1]) self.report(val2[1]) ok = ok and _ok _ok = nm.allclose(val[2], val2[2], rtol=0.0, atol=1e-14) if not _ok: self.report('vlines are not equal!') self.report(val[2]) self.report(val2[2]) ok = ok and _ok return ok
def main(): parser = ArgumentParser(description=__doc__) parser.add_argument("--version", action="version", version="%(prog)s 42") parser.add_argument("-s", "--scale", type=int, metavar='scale', action="store", dest="scale", default=2, help=help['scale']) parser.add_argument("-r", "--repeat", type=str, metavar='nx,ny[,nz]', action=ParseRepeat, dest="repeat", default=None, help=help['repeat']) parser.add_argument("-e", "--eps", type=float, metavar='eps', action="store", dest="eps", default=1e-8, help=help['eps']) parser.add_argument('filename_in') parser.add_argument('filename_out') options = parser.parse_args() filename_in = options.filename_in filename_out = options.filename_out output = Output('tpm:') output('scale:', options.scale) output('repeat:', options.repeat) output('eps:', options.eps) mesh_in = Mesh.from_file(filename_in) mesh_out = gen_tiled_mesh(mesh_in, options.repeat, 1. / options.scale, options.eps) mesh_out.write(filename_out, io='auto') output('done.')
def test_verbose_output(self): import StringIO from sfepy.base.base import Output, goptions fd = StringIO.StringIO() output = Output('test', filename=fd) output('test1') goptions['verbose'] = False output('test2') goptions['verbose'] = 1 output('test3') _ok1 = goptions['verbose'] == True _ok2 = fd.getvalue() == 'test test1\ntest test3\n' fd.close() ok = _ok1 and _ok2 return ok
def print_mem_usage(usage, order_by='usage', direction='up', print_key=False): """ Print memory usage dictionary. Parameters ---------- usage : dict The dict with memory usage records. order_by : 'usage', 'name', 'kind', 'nrefs', 'traversal_order', or 'level' The sorting field name. direction : 'up' or 'down' The sorting direction. print_key : bool If True, print also the record key (object's id). """ keys = usage.keys() order_vals = nm.array( [record.get(order_by) for record in usage.itervalues()]) order = nm.argsort(order_vals) if direction == 'down': order = order[::-1] output = Output('') fmt = '%9s, %s, %s, %d %d %d' + ', %d' * print_key for ii in order: key = keys[ii] record = usage[key] if print_key: output(fmt % (record.usage, record.name, record.kind, record.nrefs, record.traversal_order, record.level, key)) else: output(fmt % (record.usage, record.name, record.kind, record.nrefs, record.traversal_order, record.level))
class LogPlotter(Struct): """ LogPlotter to be used by :class:`sfepy.base.log.Log`. """ output = Output('plotter:') output = staticmethod(output) def __init__(self, aggregate=100, sleep=1.0): Struct.__init__(self, aggregate=aggregate, sleep=sleep) def process_command(self, command): from matplotlib.ticker import LogLocator, AutoLocator self.output(command[0]) if command[0] == 'ig': self.ig = command[1] elif command[0] == 'plot': xdata, ydata, plot_kwargs = command[1:] ig = self.ig ax = self.ax[ig] ax.set_yscale(self.yscales[ig]) ax.yaxis.grid(True) ax.plot(xdata, ydata, **plot_kwargs) if self.yscales[ig] == 'log': ymajor_formatter = ax.yaxis.get_major_formatter() ymajor_formatter.label_minor(True) yminor_locator = LogLocator() else: yminor_locator = AutoLocator() self.ax[ig].yaxis.set_minor_locator(yminor_locator) elif command[0] == 'vline': x, kwargs = command[1:] self.vlines[self.ig].append((x, kwargs)) elif command[0] == 'clear': self.ax[self.ig].cla() elif command[0] == 'legends': for ig, ax in enumerate(self.ax): try: ax.legend(self.data_names[ig]) except: pass if self.xlabels[ig]: ax.set_xlabel(self.xlabels[ig]) if self.ylabels[ig]: ax.set_ylabel(self.ylabels[ig]) for x, kwargs in self.vlines[ig]: ax.axvline(x, **kwargs) try: self.plt.tight_layout(pad=0.5) except: pass elif command[0] == 'add_axis': ig, names, yscale, xlabel, ylabel = command[1:] self.data_names[ig] = names self.yscales[ig] = yscale self.xlabels[ig] = xlabel self.ylabels[ig] = ylabel self.n_gr = len(self.data_names) self.make_axes() elif command[0] == 'save': self.fig.savefig(command[1]) self.pipe.send(True) # Acknowledge save. def terminate(self): if self.ii: self.output('processed %d commands' % self.ii) self.output('ended.') self.plt.close('all') def poll_draw(self): while 1: self.ii = 0 while 1: if not self.pipe.poll(): break command = self.pipe.recv() can_break = False if command is None: self.terminate() return False elif command[0] == 'continue': can_break = True else: self.process_command(command) if (self.ii >= self.aggregate) and can_break: break self.ii += 1 if self.ii: self.fig.canvas.draw() self.output('processed %d commands' % self.ii) time.sleep(self.sleep) return True def make_axes(self): from sfepy.linalg import cycle self.fig.clf() self.ax = [] n_col = min(5.0, nm.fix(nm.sqrt(self.n_gr))) if int(n_col) == 0: n_row = 0 else: n_row = int(nm.ceil(self.n_gr / n_col)) n_col = int(n_col) for ii, (ir, ic) in enumerate(cycle((n_col, n_row))): if ii == self.n_gr: break self.ax.append(self.fig.add_subplot(n_row, n_col, ii + 1)) self.vlines.setdefault(ii, []) def __call__(self, pipe, log_file, data_names, yscales, xlabels, ylabels): """ Sets-up the plotting window, starts a thread calling self.poll_draw() that does the actual plotting, taking commands out of `pipe`. Note that pyplot _must_ be imported here and not in this module so that the import occurs _after_ the plotting process is started in that process. """ import matplotlib.pyplot as plt self.plt = plt self.output.set_output(filename=log_file) self.output('starting plotter...') self.pipe = pipe self.data_names = data_names self.yscales = yscales self.xlabels = xlabels self.ylabels = ylabels self.n_gr = len(data_names) self.vlines = {} self.fig = self.plt.figure() self.make_axes() import threading draw_thread = threading.Thread(target=self.poll_draw) draw_thread.start() self.output('...done') self.plt.show() draw_thread.join()
def __init__(self, data_names=None, plot_kwargs=None, xlabels=None, ylabels=None, yscales=None, show_legends=True, is_plot=True, aggregate=100, sleep=1.0, log_filename=None, formats=None): """ Parameters ---------- data_names : list of lists of str The data names grouped by subplots: [[name1, name2, ...], [name3, name4, ...], ...], where name<n> are strings to display in (sub)plot legends. plot_kwargs : list of (lists of dicts) or dicts The keyword arguments dicts passed to plot(). For each group the item can be either a dict that is applied to all lines in the group, or a list of dicts for each line in the group. xlabels : list of str The x axis labels of subplots. ylabels : list of str The y axis labels of subplots. yscales : list of 'linear' or 'log' The y axis scales of subplots. show_legends : bool If True, show legends in plots. is_plot : bool If True, try to use LogPlotter for plotting. aggregate : int The number of plotting commands to process before a redraw. sleep : float The number of seconds to sleep between polling draw commands. log_filename : str, optional If given, save log data into a log file. formats : list of lists of number format strings The print formats of data to be used in a log file, group in the same way as subplots. """ try: import matplotlib as mpl except: mpl = None Struct.__init__(self, show_legends=show_legends, is_plot=is_plot, aggregate=aggregate, sleep=sleep, data_names={}, n_arg=0, n_gr=0, data={}, x_values={}, n_calls=0, plot_kwargs={}, yscales={}, xlabels={}, ylabels={}, plot_pipe=None, formats={}, _format_styles={}, output=None) if data_names is not None: n_gr = len(data_names) else: n_gr = 0 data_names = [] plot_kwargs = get_default(plot_kwargs, [{}] * n_gr) yscales = get_default(yscales, ['linear'] * n_gr) xlabels = get_default(xlabels, ['iteration'] * n_gr) ylabels = get_default(ylabels, [''] * n_gr) if formats is None: formats = [None] * n_gr for ig, names in enumerate(data_names): self.add_group(names, plot_kwargs[ig], yscales[ig], xlabels[ig], ylabels[ig], formats[ig]) self.can_plot = (mpl is not None) and (Process is not None) if log_filename is not None: self.output = Output('', filename=log_filename) self.output('# started: %s' % time.asctime()) self.output('# groups: %d' % n_gr) for ig, names in enumerate(data_names): self.output('# %d' % ig) self.output('# xlabel: "%s", ylabel: "%s", yscales: "%s"' % (xlabels[ig], ylabels[ig], yscales[ig])) self.output('# names: "%s"' % ', '.join(names)) self.output('# plot_kwargs: "%s"' % ', '.join('%s' % ii for ii in self.plot_kwargs[ig])) if self.is_plot and (not self.can_plot): output(_msg_no_live)
def __init__(self, data_names=None, xlabels=None, ylabels=None, yscales=None, is_plot=True, aggregate=200, log_filename=None, formats=None): """ Parameters ---------- data_names : list of lists of str The data names grouped by subplots: [[name1, name2, ...], [name3, name4, ...], ...], where name<n> are strings to display in (sub)plot legends. xlabels : list of str The x axis labels of subplots. ylabels : list of str The y axis labels of subplots. yscales : list of 'linear' or 'log' The y axis scales of subplots. is_plot : bool If True, try to use LogPlotter for plotting. aggregate : int The number of plotting commands to process before a redraw. log_filename : str, optional If given, save log data into a log file. formats : list of lists of number format strings The print formats of data to be used in a log file, group in the same way as subplots. """ try: import matplotlib as mpl except: mpl = None if (mpl is not None) and mpl.rcParams['backend'] == 'GTKAgg': can_live_plot = True else: can_live_plot = False Struct.__init__(self, data_names = {}, n_arg = 0, n_gr = 0, data = {}, x_values = {}, n_calls = 0, yscales = {}, xlabels = {}, ylabels = {}, plot_pipe = None, formats = {}, output = None) if data_names is not None: n_gr = len(data_names) else: n_gr = 0 data_names = [] yscales = get_default(yscales, ['linear'] * n_gr) xlabels = get_default(xlabels, ['iteration'] * n_gr) ylabels = get_default(ylabels, [''] * n_gr) if formats is None: formats = [None] * n_gr for ig, names in enumerate(data_names): self.add_group(names, yscales[ig], xlabels[ig], ylabels[ig], formats[ig]) self.is_plot = get_default(is_plot, True) self.aggregate = get_default(aggregate, 100) self.can_plot = (can_live_plot and (mpl is not None) and (Process is not None)) if log_filename is not None: self.output = Output('', filename=log_filename) self.output('# started: %s' % time.asctime()) self.output('# groups: %d' % n_gr) for ig, names in enumerate(data_names): self.output('# %d' % ig) self.output('# xlabel: "%s", ylabel: "%s", yscales: "%s"' % (xlabels[ig], ylabels[ig], yscales[ig])) self.output('# names: "%s"' % ', '.join(names)) if self.is_plot and (not self.can_plot): output(_msg_no_live)
The agreement should be very good, even though the mesh is coarse. View the results using:: python postproc.py unit_ball.h5 --wireframe -b -d'u,plot_displacements,rel_scaling=1' --step=-1 """ import os import numpy as nm from sfepy.base.base import Output from sfepy.discrete.fem import MeshIO from sfepy.linalg import get_coors_in_ball from sfepy import data_dir output = Output('balloon:') def get_nodes(coors, radius, eps, mode): if mode == 'ax1': centre = nm.array([0.0, 0.0, -radius], dtype=nm.float64) elif mode == 'ax2': centre = nm.array([0.0, 0.0, radius], dtype=nm.float64) elif mode == 'equator': centre = nm.array([radius, 0.0, 0.0], dtype=nm.float64) else: raise ValueError('unknown mode %s!' % mode)
def __init__(self, data_names=None, yscales=None, xlabels=None, ylabels=None, is_plot=True, aggregate=200, formats=None, log_filename=None): """`data_names` ... tuple of names grouped by subplots: ([name1, name2, ...], [name3, name4, ...], ...) where name<n> are strings to display in (sub)plot legends.""" try: import matplotlib as mpl except: mpl = None if (mpl is not None) and mpl.rcParams['backend'] == 'GTKAgg': can_live_plot = True else: can_live_plot = False Struct.__init__(self, data_names={}, n_arg=0, n_gr=0, data={}, x_values={}, n_calls=0, yscales={}, xlabels={}, ylabels={}, plot_pipe=None, formats={}, output=None) if data_names is not None: n_gr = len(data_names) else: n_gr = 0 data_names = [] yscales = get_default(yscales, ['linear'] * n_gr) xlabels = get_default(xlabels, ['iteration'] * n_gr) ylabels = get_default(ylabels, [''] * n_gr) if formats is None: formats = [None] * n_gr for ig, names in enumerate(data_names): self.add_group(names, yscales[ig], xlabels[ig], ylabels[ig], formats[ig]) self.is_plot = get_default(is_plot, True) self.aggregate = get_default(aggregate, 100) self.can_plot = (can_live_plot and (mpl is not None) and (Process is not None)) if log_filename is not None: self.output = Output('', filename=log_filename) self.output('# started: %s' % time.asctime()) self.output('# groups: %d' % n_gr) for ig, names in enumerate(data_names): self.output('# %d' % ig) self.output('# xlabel: "%s", ylabel: "%s", yscales: "%s"' % (xlabels[ig], ylabels[ig], yscales[ig])) self.output('# names: "%s"' % ', '.join(names)) if self.is_plot and (not self.can_plot): output(_msg_no_live)