TPT Assessment-Language - PikeTec

TPT assessments analyse and generate signals over time. The
computational model is based on the concept of intervals, assessment
variables and step sizes (aka sample rates). This quick reference should
not replace the “Assessment Manual” shipped with the TPT installation.
It just gives users a brief overview over the most important assessment
features.
Standard Python
The following section describes basic concepts of the standard Python
syntax. Beside the TPT specific syntax elements for handling signals and
signal analysis this syntax can be used to compute auxiliary values,
whenever appropriate.
Python Variables
x = 3 / 2.4;
y = 2 * x;
# print infos to stdout
print “x is ” + x + “ and y is ” + y;
Using Sequences in Python
s = [1, 4, 5];
print s[2]; # -> "5"
print s[1:2]; # -> "[4, 5]" to stdout
Control Flow in Python
For block-like structures Python uses indentation (no braces or
begin/end pairs such as common in other language).
if x == 3:
print “x is 3”;
else:
print “x is not 3”;
print “instead, x is ” + x;
Iterations and loops can be expressed like this:
# compute 5+6+7+8+9+10
y = 0;
for i in range(5, 10):
y = y + i;
Time, during, “this”, and context interval
For time values the following time units are supported: usec, us,
msec, ms, sec, s, min, h, d (1000ms = 1s = 1).
TPT.setStepSize(10ms);
myStepSize = TPT.getStepSize(); # “0.01”
myStepSize = @; # the same: “0.01”
Assessment Quick Reference.docx PikeTec GmbH, Berlin Copyright © 2009
TPT Assessment Quick Reference
Version 3.1.0
Intervals can be defined explicitly:
myInterval = TPT.Interval(100ms, n * 3s);
With intervals the context interval can be determined. Within a
during-block this represents the context interval itself (in local
time):
during TPT.Interval(2s, 5s):
print this.getStartTime (); # -> 0.0
print this.getEndTime (); # -> 3.0
# local “t” betw. 0s..3s
f(t) := sin(t); # f is defined betw. 2s..5s
Within a during-block “t” represents local time (always starts with 0s).
Global time can be accessed as follows:
during TPT.Interval(2s, 5s):
x = TPT.toGlobal(this.getEndTime()); # 5.0
Assessment Variables (Signals)
Creating Assessment Variables
The assessment concept supports the data types uint8, int8, uint16,
int16, uint32, int32, int64, double, float, boolean. Creating an
assessment variable requires the specification of the data type:
f = TPT.Double(); # creating a double var
i = TPT.UInt16(); # creating a uint16 var
Assigning Variables
f = TPT.Double();
f(t) := sin(t);
g = TPT.Double();
g := average / 2; # constant over time
Using Variables
A variable supports the following functions:
f.getSize();
f.getStartTime();
f.getEndTime();
f.getLength();
f.isDefined(20ms);
print “value at 2ms is ” + str(f(20ms));
f.getLeftValue
f.getRightValue();
f.isConstant();
Dejittering Variables
Resamples a signal according to the step size
f.dejitter();
File I/O
Reading Signals from Files
TPT supports the file formats CSV, MDF, TPTBIN, MAT and some
proprietary customer specific formats.
file1 = TPT.readRecord(“mydata.csv”);
file2 = TPT.readRecord(“mydata2.mdf”);
f = file1.getVariable(“signal01”);
g = file2.getVariable(“torque[Nm]”);
Writing to Signal Files
Signals can be exported to signal files. Default mechanism is to “export”
the signals. Supported Formats: CSV, MAT, TPTBIN
f = TPT.Double();
g = TPT.Int32();
...
TPT.export(f);
TPT.export(g);
h = TPT.BooleanX(); # “X” means implicit “export”
...
TPT.writeExportRecord(“results.tptbin”);
In addition, records can be used if necessary:
myrecord = TPT.Record();
myrecord.add(f);
myrecord.add(g);
myrecord.add(h);
myrecord.writeRecord(“results.csv”);
Regular expressions
Regular expressions can be used to identify intervals with custom
characteristics.
# find all intervals with f above 7
# within the first 12 sec
iv = TPT.regexp([f(t) > 7 and t < 12sec]);
In more complex cases additional features can be used:
# f exceeds 7 for at least 2, at most 3 seconds
iv = TPT.regexp([f(t) > 7]{2s, 3s});
# a is 1 and afterwards immediately 2
iv = TPT.regexp([a(t) == 1][a(t) == 2]);
Seite 1

Signal analysis functions: value computations
TPT.always()
Checks if the condition is true in current context interval
res = TPT.always(f(t) < 2);
TPT.average()
Computes average value of the given signal in current context interval
res = TPT.average(2 * t);
TPT.check()
Behaves similar to a switch-case-operator
TPT.check(mode == MODE1, 1, “mode 1”,
mode == MODE2, 2, “mode 2”,
-1, “unknown mode”);
TPT.checkAlways()
Average value of the given signal in current context interval
res = TPT.checkAlwys(f(t) < 2,
“f below 2”, “f partially above 2!”);
TPT.exists()
Checks if the condition is true at least once in current context
res = TPT.exits(f(t) < 2);
TPT.max()
Maximum value of the given signal in current context interval
res = TPT.max(2 * t);
TPT.min()
Minimum value of the given signal in current context interval
res = TPT.min(2 * t);
TPT.never()
Checks if the condition is never fulfilled in current context interval
res = TPT.never(f(2) < 2);
Signal analysis functions: signal computations
TPT.boundControl()
Signed distance to the min/max-area for every t; 0 if in range min/max
Assessment Quick Reference.docx PikeTec GmbH, Berlin Copyright © 2009
TPT Assessment Quick Reference
Version 3.1.0
b(t) := TPT.boundControl(sin(t), -0.5, 0.5);
TPT.deviation()
Distance of two signals with time tolerance
d(t) := TPT.deviation(f(t), 2*g(t), 30ms);
TPT.dt()
First derivative (more precisely: the difference quotient) over time
d(t) := TPT.dt(2* f(t/2));
TPT.dt2()
Second derivative (difference quotient) over time
d(t) := TPT.dt2(2* f(t/2));
TPT.hose()
Generates bounds around a reference signal (2nd argument) and checks
if the signal (1st argument) is encapsulated within these bounds, taking
x-tolerance (3rd argument) and y-tolerance (4th argument) into account.
res(t) := TPT.hose(f(t), f_ref(t), 0.01, 5.0);
TPT.integrate()
Integrates a signal over time
res(t) = TPT.integrate(f(t), TPT.TUSTIN);
TPT.monotony()
Analyses the monotony of a signal for every t; delivers true or false.
m(t) := TPT.monotony(f(t)-x, TPT.INCREASING);
TPT.filterFIR()
Applies a FIR-filter to a signal (1st arg) with order (2nd arg), type
(LOWPASS, HIGHPASS, BANDPASS; 3rd arg), window type
(RECTANGULAR, HANNING, HAMMING, BACKMAN; 4th arg), lower pass
band freq (5th arg); max pass band freq (6th arg)
f2(t) := TPT.filterFIR(f(t), 100, TPT.LOWPASS,
TPT.HANNING, 0.0, 5.0);
TPT.filterIIR()
Similar to filterFIR for an IIR-Filter; uses a prototype parameter
(BUTTERWORTH, CHEBYSHEV; 4th arg) instead of a window type
f2(t) := TPT.filterIIR(f(t), 100, TPT.LOWPASS,
TPT. BUTTERWORTH, 0.0, 5.0);
TPT.filterMA()
Moving average filter with order (2 nd arg) and type (SIGNAL, SIGMA)
f2(t) := TPT.filterMA(f(t), 100, TPT.SIGNAL);
TPT.stepDetection()
Analyses signals (1st arg) in order to find significant steps with order (2nd arg) and scale (3rd arg); works also for noisy signals
f2(t) := TPT.stepDetection(f(t), 50, 1.7);
Comments and Results
When assigning assessment variables, a result (SUCCESS, FAILED,
DONT_KNOW) and a comment can be attached to this definition.
f = TPT.Double():
f(t) := somedef(t);
f.setResult(SUCCESS); # ... means “as expected”
f.setComment(“feature behaves as expected”);
##-comments can be used instead of setComment() if appropriate:
f = TPT.Double():
## feature behaves as expected
f(t) := somedef(t);
f.setResult(SUCCESS); # ... means “as expected”
Debug features
Assessment scripts can be interactively suspended using the
TPT.debug() statement:
f(t) := sin(t);
TPT.debug(); # opens a console window
In the console, a signal viewer can be opened with TPT.show():
TPT.show();
Seite 2