SignalTables
Package SignalTables (see docu) provides abstract and concrete types and functions for signal tables. A signal table is basically a table where the table columns can be multi-dimensional arrays with attributes. Typically, simulation results, reference signals, table-based input signals, measurement data, look-up tables can be represented by a signal table.
A signal table is an ordered dictionary of signals with string keys. A signal can be defined in the following forms:
- As Var dictionary that has a required values key
(or an alias key) representing a signal array of any element type as function of the independent signal(s) (or is the k-th independent signal). A signal array is a multi-dimensional array with indices
[i1,i2,...,j1,j2,...]to hold variable elements[j1,j2,...]at the[i1,i2,...]independent signal(s). If an element of a signal array is not defined, it has a value of missing. - As Par dictionary that has a required value key (or and alias key) representing a constant of any type.
- As Map dictionary that has no required keys and collects attributes/meta-data that are associated with a Var, Par, Map, or signal table dictionary.
In all these dictionaries, additional attributes can be stored, for example unit, info, variability (continuous, clocked, ...), interpolation, extrapolation, and user-defined attributes.
This logical view is directly mapped to Julia data structures, but can be also mapped to data structures in other programming languages. It is then possible to use existing textual or binary persistent serialization formats (JSON, HDF5, BSON, MessagePack, ...) to store a signal table in these formats on file. Furthermore, a subset of a signal table can also be stored in traditional tables (Excel, CSV, pandas, DataFrames.jl, ...) by flattening the multi-dimensional arrays and not storing constants and attributes.
Examples
using SignalTables
t = 0.0:0.1:0.5
sigTable = SignalTable(
"time" => Var(values= t, unit="s", independent=true),
"load.r" => Var(values= [sin.(t) cos.(t) sin.(t)], unit="m"),
"motor.angle" => Var(values= sin.(t), unit="rad", state=true, der="motor.w"),
"motor.w" => Var(values= cos.(t), unit="rad/s"),
"motor.w_ref" => Var(values= 0.9*[sin.(t) cos.(t)], unit = ["rad", "1/s"],
info="Reference angle and speed"),
"wm" => Var(alias = "motor.w"),
"ref.clock" => Var(values= [true, missing, missing, true, missing, missing],
variability="clock"),
"motor.w_c" => Var(values= [0.8, missing, missing, 1.5, missing, missing],
variability="clocked", clock="ref.clock"),
"motor.inertia"=> Par(value = 0.02f0, unit="kg*m/s^2"),
"motor.data" => Par(value = "resources/motorMap.json"),
"attributes" => Map(experiment=Map(stoptime=0.5, interval=0.01))
)
phi_m_sig = getSignal( sigTable, "motor.angle") # = Var(values=..., unit=..., ...)
phi_m = getValuesWithUnit(sigTable, "motor.angle") # = [0.0, 0.0998, 0.1986, ...]u"rad"
w_c = getValues( sigTable, "motor.w_c" ) # = [0.8, missing, missing, 1.5, ...]
inertia = getValueWithUnit( sigTable, "motor.inertia") # = 0.02u"kg*m/s^2"
getValues(sigTable, "motor.w") === getValues(sigTable, "wm")
showInfo(sigTable)
Command showInfo generates the following output:
name unit size eltypeOrType kind attributes
───────────────────────────────────────────────────────────────────────────────────────────────────────
time "s" [6] Float64 Var independent=true
load.r "m" [6,3] Float64 Var
motor.angle "rad" [6] Float64 Var state=true, der="motor.w"
motor.w "rad/s" [6] Float64 Var
motor.w_ref ["rad", "1/s"] [6,2] Float64 Var info="Reference angle and speed"
wm "rad/s" [6] Float64 Var alias="motor.w"
ref.clock [6] Union{Missing,Bool} Var variability="clock"
motor.w_c [6] Union{Missing,Float64} Var variability="clocked", clock="ref.clock"
motor.inertia "kg*m/s^2" Float32 Par
motor.data String Par
attributes Map experiment=Map(stoptime=0.5, interval=0.01)
The various Julia FileIO functions can be directly used to save a signal table in various formats, e.g. JSON or HDF5 (see FileIO Examples, json file of sigTable above ).
using SignalTable
usePlotPackage("PyPlot") # or ENV["SignalTablesPlotPackage"] = "PyPlot"
sigTable = getSignalTableExample("MissingValues")
@usingPlotPackage # = using SignalTablesInterface_PyPlot
plot(sigTable, [("sigC", "load.r[2:3]"), ("sigB", "sigD")]) # generate plots
generate the following plot:
Concrete implementations of the Abstract Signal Table Interface are provided for:
-
SignalTable(included in SignalTables.jl). -
Modia.jl (a modeling and simulation environment; version >= 0.9.0)
-
DataFrames.jl (tabular data; first column is independent variable; only scalar variables))
-
Tables.jl (abstract tables, e.g. CSV tables; first column is independent variable; only scalar variables).
Concrete implementations of the Abstract Plot Interface are provided for:
-
PyPlot (plots with Matplotlib from Python; via SignalTablesInterface_PyPlot.jl),
-
GLMakie (interactive plots in an OpenGL window; via SignalTablesInterface_GLMakie.jl),
-
WGLMakie (interactive plots in a browser window; via SignalTablesInterface_WGLMakie.jl),
-
CairoMakie (static plots on file with publication quality; via SignalTablesInterface_CairoMakie.jl).
Furthermore, there is a dummy implementation included in SignalTables that is useful when performing tests with runtests.jl, in order that no plot package needs to be loaded during the tests:
- SilentNoPlot (= all plot calls are silently ignored).
Installation
julia> ]add SignalTables
add SignalTablesInterface_PyPlot # if plotting with PyPlot desired
add SignalTablesInterface_GLMakie # if plotting with GLMakie desired
add SignalTablesInterface_WGLMakie # if plotting with WGLMakie desired
add SignalTablesInterface_CairoMakie # if plotting with CairoMakie desired
If you have trouble installing SignalTablesInterface_PyPlot, see
Installation of PyPlot.jl
Main developer
Martin Otter, DLR - Institute of System Dynamics and Control