Visualization¶
Here are some frequently used plot types with the packages pyqtgraph
and/or matplotlib
implemented. The respective
pyinduct.visualization
plotting function get an EvalData
object whose definition also placed in this module.
A EvalData
-object in turn can easily generated from simulation
data. The function pyinduct.simulation.simulate_system()
for example
already provide the simulation result as EvalData object.
- class DataPlot(data)¶
Base class for all plotting related classes.
- class Domain(bounds=None, num=None, step=None, points=None)¶
Bases:
object
Helper class that manages ranges for data evaluation, containing parameters.
- Parameters:
bounds (tuple) – Interval bounds.
num (int) – Number of points in interval.
step (numbers.Number) – Distance between points (if homogeneous).
points (array_like) – Points themselves.
Note
If num and step are given, num will take precedence.
- property bounds¶
- property ndim¶
- property points¶
- property step¶
- class EvalData(input_data, output_data, input_labels=None, input_units=None, enable_extrapolation=False, fill_axes=False, fill_value=None, name=None)¶
This class helps managing any kind of result data.
The data gained by evaluation of a function is stored together with the corresponding points of its evaluation. This way all data needed for plotting or other postprocessing is stored in one place. Next to the points of the evaluation the names and units of the included axes can be stored. After initialization an interpolator is set up, so that one can interpolate in the result data by using the overloaded
__call__()
method.- Parameters:
input_data – (List of) array(s) holding the axes of a regular grid on which the evaluation took place.
output_data – The result of the evaluation.
- Keyword Arguments:
input_labels – (List of) labels for the input axes.
input_units – (List of) units for the input axes.
name – Name of the generated data set.
fill_axes – If the dimension of output_data is higher than the length of the given input_data list, dummy entries will be appended until the required dimension is reached.
enable_extrapolation (bool) – If True, internal interpolators will allow extrapolation. Otherwise, the last giben value will be repeated for 1D cases and the result will be padded with zeros for cases > 1D.
fill_value – If invalid data is encountered, it will be replaced with this value before interpolation is performed.
Examples
When instantiating 1d EvalData objects, the list can be omitted
>>> axis = Domain((0, 10), 5) >>> data = np.random.rand(5,) >>> e_1d = EvalData(axis, data)
For other cases, input_data has to be a list
>>> axis1 = Domain((0, 0.5), 5) >>> axis2 = Domain((0, 1), 11) >>> data = np.random.rand(5, 11) >>> e_2d = EvalData([axis1, axis2], data)
Adding two Instances (if the boundaries fit, the data will be interpolated on the more coarse grid.) Same goes for subtraction and multiplication.
>>> e_1 = EvalData(Domain((0, 10), 5), np.random.rand(5,)) >>> e_2 = EvalData(Domain((0, 10), 10), 100*np.random.rand(5,)) >>> e_3 = e_1 + e_2 >>> e_3.output_data.shape (5,)
Interpolate in the output data by calling the object
>>> e_4 = EvalData(np.array(range(5)), 2*np.array(range(5)))) >>> e_4.output_data array([0, 2, 4, 6, 8]) >>> e_5 = e_4([2, 5]) >>> e_5.output_data array([4, 8]) >>> e_5.output_data.size 2
one may also give a slice
>>> e_6 = e_4(slice(1, 5, 2)) >>> e_6.output_data array([2., 6.]) >>> e_5.output_data.size 2
For multi-dimensional interpolation a list has to be provided
>>> e_7 = e_2d([[.1, .5], [.3, .4, .7)]) >>> e_7.output_data.shape (2, 3)
- abs()¶
Get the absolute value of the elements form self.output_data .
- Returns:
EvalData
with self.input_data and output_data as result of absolute value calculation.
- add(other, from_left=True)¶
Perform the element-wise addition of the output_data arrays from self and other
This method is used to support addition by implementing __add__ (fromLeft=True) and __radd__(fromLeft=False)). If other** is a
EvalData
, the input_data lists of self and other are adjusted usingadjust_input_vectors()
The summation operation is performed on the interpolated output_data. If other is anumbers.Number
it is added according to numpy’s broadcasting rules.
- adjust_input_vectors(other)¶
Check the the inputs vectors of self and other for compatibility (equivalence) and harmonize them if they are compatible.
The compatibility check is performed for every input_vector in particular and examines whether they share the same boundaries. and equalize to the minimal discretized axis. If the amount of discretization steps between the two instances differs, the more precise discretization is interpolated down onto the less precise one.
- Parameters:
other (
EvalData
) – Other EvalData class.- Returns:
(list) - New common input vectors.
(numpy.ndarray) - Interpolated self output_data array.
(numpy.ndarray) - Interpolated other output_data array.
- Return type:
tuple
- interpolate(interp_axis)¶
Main interpolation method for output_data.
If one of the output dimensions is to be interpolated at one single point, the dimension of the output will decrease by one.
- Parameters:
interp_axis (list(list)) – axis positions in the form
1D (-) – axis with axis=[1,2,3]
2D (-) – [axis1, axis2] with axis1=[1,2,3] and axis2=[0,1,2,3,4]
- Returns:
EvalData
with interp_axis as new input_data and interpolated output_data.
- matmul(other, from_left=True)¶
Perform the matrix multiplication of the output_data arrays from self and other .
This method is used to support matrix multiplication (@) by implementing __matmul__ (from_left=True) and __rmatmul__(from_left=False)). If other** is a
EvalData
, the input_data lists of self and other are adjusted usingadjust_input_vectors()
. The matrix multiplication operation is performed on the interpolated output_data. If other is anumbers.Number
it is handled according to numpy’s broadcasting rules.
- mul(other, from_left=True)¶
Perform the element-wise multiplication of the output_data arrays from self and other .
This method is used to support multiplication by implementing __mul__ (from_left=True) and __rmul__(from_left=False)). If other** is a
EvalData
, the input_data lists of self and other are adjusted usingadjust_input_vectors()
. The multiplication operation is performed on the interpolated output_data. If other is anumbers.Number
it is handled according to numpy’s broadcasting rules.
- sqrt()¶
Radicate the elements form self.output_data element-wise.
- Returns:
EvalData
with self.input_data and output_data as result of root calculation.
- sub(other, from_left=True)¶
Perform the element-wise subtraction of the output_data arrays from self and other .
This method is used to support subtraction by implementing __sub__ (from_left=True) and __rsub__(from_left=False)). If other** is a
EvalData
, the input_data lists of self and other are adjusted usingadjust_input_vectors()
. The subtraction operation is performed on the interpolated output_data. If other is anumbers.Number
it is handled according to numpy’s broadcasting rules.
- FORCE_MPL_ON_WINDOWS = True¶
- class Function(eval_handle, domain=(-np.inf, np.inf), nonzero=(-np.inf, np.inf), derivative_handles=None)¶
Bases:
BaseFraction
Most common instance of a
BaseFraction
. This class handles all tasks concerning derivation and evaluation of functions. It is used broad across the toolbox and therefore incorporates some very specific attributes. For example, to ensure the accurateness of numerical handling functions may only evaluated in areas where they provide nonzero return values. Also their domain has to be taken into account. Therefore the attributes domain and nonzero are provided.To save implementation time, ready to go version like
LagrangeFirstOrder
are provided in thepyinduct.simulation
module.For the implementation of new shape functions subclass this implementation or directly provide a callable eval_handle and callable derivative_handles if spatial derivatives are required for the application.
- Parameters:
eval_handle (derivatives of) – Callable object that can be evaluated.
domain (nonzero output. Must be a subset of) – Domain on which the eval_handle is defined.
nonzero (tuple) – Region in which the eval_handle will return
domain –
derivative_handles (list) – List of callable(s) that contain
eval_handle –
- add_neutral_element()¶
Return the neutral element of addition for this object.
In other words: self + ret_val == self.
- property derivative_handles¶
- derive(order=1)¶
Spatially derive this
Function
.This is done by neglecting order derivative handles and to select handle as the new evaluation_handle.
- Parameters:
order (int) – the amount of derivations to perform
- Raises:
TypeError – If order is not of type int.
ValueError – If the requested derivative order is higher than the provided one.
- Returns:
Function
the derived function.
- static from_data(x, y, **kwargs)¶
Create a
Function
based on discrete data by interpolating.The interpolation is done by using
interp1d
from scipy, the kwargs will be passed.
- property function_handle¶
- function_space_hint()¶
Return the hint that this function is an element of the an scalar product space which is uniquely defined by the scalar product
scalar_product_hint()
.Note
If you are working on different function spaces, you have to overwrite this hint in order to provide more properties which characterize your specific function space. For example the domain of the functions.
- get_member(idx)¶
Implementation of the abstract parent method.
Since the
Function
has only one member (itself) the parameter idx is ignored and self is returned.- Parameters:
idx – ignored.
- Returns:
self
- mul_neutral_element()¶
Return the neutral element of multiplication for this object.
In other words: self * ret_val == self.
- raise_to(power)¶
Raises the function to the given power.
Warning
Derivatives are lost after this action is performed.
- Parameters:
power (
numbers.Number
) – power to raise the function to- Returns:
raised function
- scalar_product_hint()¶
Return the hint that the
_dot_product_l2()
has to calculated to gain the scalar product.
- class MplSlicePlot(eval_data_list, time_point=None, spatial_point=None, ylabel='', legend_label=None, legend_location=1, figure_size=(10, 6))¶
Bases:
PgDataPlot
Get list (eval_data_list) of ut.EvalData objects and plot the temporal/spatial slice, by spatial_point/time_point, from each ut.EvalData object, in one plot. For now: only ut.EvalData objects with len(input_data) == 2 supported
- class MplSurfacePlot(data, keep_aspect=False, fig_size=(12, 8), zlabel='$\\quad x(z,t)$', title='')¶
Bases:
DataPlot
Plot as 3d surface.
- class PgAnimatedPlot(data, title='', refresh_time=40, replay_gain=1, save_pics=False, create_video=False, labels=None)¶
Bases:
PgDataPlot
Wrapper that shows an updating one dimensional plot of n-curves discretized in t time steps and z spatial steps. It is assumed that time propagates along axis 0 and and location along axis 1 of values. Values are therefore expected to be a array of shape (n, t, z).
- Parameters:
data ((iterable of)
EvalData
) – results to animatetitle (basestring) – Window title.
refresh_time (int) – Time in msec to refresh the window must be greater than zero
replay_gain (float) – Values above 1 acc- and below 1 decelerate the playback process, must be greater than zero
save_pics (bool) – Export snapshots for animation purposes.
labels (dict) – Axis labels for the plot that are passed to
pyqtgraph.PlotItem
.
- property exported_files¶
- class PgDataPlot(data)¶
Bases:
DataPlot
,pyqtgraph.QtCore.QObject
Base class for all pyqtgraph plotting related classes.
- class PgLinePlot3d(data, n=50, scale=1)¶
Bases:
PgDataPlot
Ulots a series of n-lines of the systems state. Scaling in z-direction can be changed with the scale setting.
- class PgSlicePlot(data, title=None)¶
Bases:
PgDataPlot
Plot selected slice of given DataSets.
This class is a work in progress.
- class PgSurfacePlot(data, scales=None, animation_axis=None, title='')¶
Bases:
PgDataPlot
Plot 3 dimensional data as a surface using OpenGl.
- Parameters:
data (
EvalData
) – Data to display, if the the input-vector has length of 2, a 3d surface is plotted, if has length 3, this surface is animated. Hereby, the time axis is assumed to be the first entry of the input vector.scales (tuple) – Factors to scale the displayed data, each entry corresponds to an axis in the input vector with one additional scale for the output_data. It therefore must be of the size: len(input_data) + 1 . If no scale is given, all axis are scaled uniformly.
animation_axis (int) – Index of the axis to use for animation. Not implemented, yet and therefore defaults to 0 by now.
title (str) – Window title to display.
Note
For animation this object spawns a QTimer which needs an running event loop. Therefore remember to store a reference to this object.
- color_map = viridis¶
- colors = ['g', 'c', 'm', 'b', 'y', 'k', 'w', 'r']¶
- complex_wrapper(func)¶
Wraps complex valued functions into two-dimensional functions. This enables the root-finding routine to handle it as a vectorial function.
- Parameters:
func (callable) – Callable that returns a complex result.
- Returns:
function handle, taking x = (re(x), im(x) and returning [re(func(x), im(func(x)].
- Return type:
two-dimensional, callable
- create_animation(input_file_mask='', input_file_names=None, target_format='.mp4')¶
Create an animation from the given files.
If no file names are given, a file selection dialog will appear.
- Parameters:
input_file_mask (basestring) – file name mask with c-style format string
input_file_names (iterable) – names of the files
- Returns:
animation file
- create_colormap(cnt)¶
Create a colormap containing cnt values.
- Parameters:
cnt (int) – Number of colors in the map.
- Returns:
List of QColor instances.
- create_dir(dir_name)¶
Create a directory with name
dir_name
relative to the current path if it doesn’t already exist and return its full path.- Parameters:
dir_name (str) – Directory name.
- Returns:
Full absolute path of the created directory.
- Return type:
str
- deregister_base(label)¶
Removes a set of initial functions from the packages registry.
- Parameters:
label (str) – String, label of functions that are to be removed.
- Raises:
ValueError – If label is not found in registry.
- get_colors(cnt, scheme='tab10', samples=10)¶
Create a list of colors.
- Parameters:
cnt (int) – Number of colors in the list.
scheme (str) – Mpl color scheme to use.
samples (cnt) – Number of samples to take from the scheme before starting from the beginning.
- Returns:
List of np.Array holding the rgb values.
- mpl_3d_remove_margins()¶
Remove thin margins in matplotlib 3d plots. The Solution is from Stackoverflow.
- mpl_activate_latex()¶
Activate full (label, ticks, …) latex printing in matplotlib plots.
- save_2d_pg_plot(plot, filename)¶
Save a given pyqtgraph plot in the folder <current path>.pictures_plot under the given filename
filename
.- Parameters:
plot (
pyqtgraph.plotItem
) – Pyqtgraph plot.filename (str) – Png picture filename.
- Returns:
Path with filename and path only.
- Return type:
tuple of 2 str’s
- show(show_pg=True, show_mpl=True)¶
Shortcut to show all pyqtgraph and matplotlib plots / animations.
- Parameters:
show_pg (bool) – Show matplotlib plots? Default: True
show_mpl (bool) – Show pyqtgraph plots? Default: True
- surface_plot(data, **kwargs)¶
Compatibility wrapper for PgSurfacePLot and MplSurfacePlot
Since OpenGL suffers under some problems in current windows versions, the matplotlib implementation is used there.
- tear_down(labels, plots=None)¶
Deregister labels and delete plots.
- Parameters:
labels (array-like) – All labels to deregister.
plots (array-like) – All plots to delete.
- visualize_functions(functions, points=100, return_window=False)¶
Visualizes a set of
Function
s on their domain.- Parameters:
functions (iterable) – collection of
Function
s to display.points (int) – Points to use for sampling the domain.
return_window (bool) – If True the graphics window is not shown directly. In this case, a reference to the plot window is returned.
Returns: A PgPlotWindow if delay_exec is True.
- visualize_roots(roots, grid, func, cmplx=False, return_window=False)¶
Visualize a given set of roots by examining the output of the generating function.
- Parameters:
roots (array like) – Roots to display, if None is given, no roots will be displayed, this is useful to get a view of func and choosing an appropriate grid.
grid (list) – List of arrays that form the grid, used for the evaluation of the given func.
func (callable) – Possibly vectorial function handle that will take input of of the shape (‘len(grid)’, ).
cmplx (bool) – If True, the complex valued func is handled as a vectorial function returning [Re(func), Im(func)].
return_window (bool) – If True the graphics window is not shown directly. In this case, a reference to the plot window is returned.
Returns: A PgPlotWindow if delay_exec is True.