TPT Assessment-Language - Tutorial and Reference Book - PikeTec

TPT Assessment-Language 

Tutorial and Reference Book 

Version 3.0 

29. February 2008

Contents 

Page 2 TPT Assessment-Language 

1 Introduction _____________________________________________________________________________ 3 

1.1 Paradigm of the assessment language___________________________________________________ 4 

1.2 Some words about intervals and assessment variables __________________________________ 4 

1.2.1 Annotations of assessments _____________________________________________________________ 7 

2 Assessment reference manual __________________________________________________________ 9 

2.1 Data types ________________________________________________________________________________ 9 

2.2 Creation of assessment variables _______________________________________________________ 10 

2.3 Operations for assessment variables ____________________________________________________ 12 

2.4 Operations for time intervals ____________________________________________________________ 19 

2.5 Operations for records (file I/O operators) ______________________________________________ 22 

2.5.1 Reading records from file system ______________________________________________________ 23 

2.5.2 Writing records to the file system ______________________________________________________ 24 

2.5.3 Writing the default output record to the file system ___________________________________ 25 

2.5.4 Accessing reference data in assessment scripts ________________________________________ 26 

2.6 Global operations _______________________________________________________________________ 27 

2.7 Signal processing functions: value computations _______________________________________ 28 

2.8 Signal processing functions: signal computations ______________________________________ 30 

2.8.1 Filter operations ________________________________________________________________________ 33 

2.9 Temporal regular expressions ___________________________________________________________ 38 

2.10 Context intervals and the during operator ______________________________________________ 41 

2.10.1 During-Operator _______________________________________________________________________ 41 

2.10.2 “This” operator _________________________________________________________________________ 42 

2.11 Transformations of the assessment pre-processor _____________________________________ 42 

2.11.1 Compatibility with former versions of TPT _____________________________________________ 42 

2.11.2 Obsolete assessment functions in TPT 2.6 _____________________________________________ 42

TPT Assessment-Language Page 3 

1 Introduction 

The goal of the test assessment is to determine whether system behaviours are correct or 

not. In order to run test assessments automatically the expected behaviour must be 

specified for each test case. The test assessment may be thought of as the evaluation of 

the test pass criteria, as in simple cases ‘pass/fail’ or ‘within given limits’. 

To get a better understanding of the test assessments of TPT it is useful to make clear the 

major goals of the assessment. There are two main points. 

1. The main goal of the test assessment is to determine if the system behaves 

correctly or incorrectly for the specific test case 

2. Besides this go/no-go health check a system typically contains information which 

can help us understand what is happening in the system during test execution. 

This information is of particular interest when the test ‘fails’ and we wish to 

investigate the reasons for failure. 

In many practical cases the first goal of the assessment, namely the binary decision 

(correct/incorrect), is problematic or even impossible. There are different reasons for this. 

For example in embedded system design it is often impossible to access or measure all 

relevant signals, or the formal description of expected values may be too complex to 

make automated test assessments. 

So in reality the automated test tool can monitor the behaviour of system elements, but 

the analysis of the result is done manually by stakeholders or test personnel 

This means that in many practical cases one dismisses the fully automated test 

assessment that gives only a “true” or “false”. For that reason the test assessment of TPT is 

based on calculations of system properties rather than bottom line “true” and “false”. In 

the following section the basic ideas of the assessment modelling using TPT assessments 

are described.


1.1 Paradigm of the assessment language 

The goal of the TPT test assessment is to calculate and extract summary information from 

the usually large amount of test data to determine whether a test case was successful or if 

an error occurred. Thus the test assessment can be seen as the challenge of abstracting a 

small set of adequate information about the system behaviour during the test from the 

very detailed and comprehensive data available. 

The TPT assessment language allows evaluation of the system characteristics required to 

assess system performance. 

A few examples: the duration of certain system-phases, adherence to defined signal limits, 

monotony properties, the maximum values of signals, etc. . Such characteristics are 

helpful as error indicators and they can simplify finding the cause of an error. 

Case 1: Observation of limits. Signals can be assigned limits and monitored for their 

adherence to the limit(s). Crossing a limit may not be all that is of interest; the duration, 

time and frequency of this non conforming behaviour can also be pertinent. 

Case 2: Comparison to reference signals. A signal x shall be compared to a signal xref. 

Again it may be important to monitor not only whether the signals differ but if the 

difference took place during a critical period or was particularly large, etc.. 

Case 3: Relative timing of events. is the difference in time between the occurrence of 

event A (e.g. Signal x has the value 1) and the occurrence of event B shall be monitored. 

Case 4: Assessment periods. Analysis of the cases above may only be relevant during 

certain periods of the test. This means only in certain time intervals the observation of 

limits, the comparison to reference signals or the event timing is necessary. The 

assessment of a signal for example may only be defined during the initialization phase of 

a system. 

Case 5: Qualitative statements. During test assessment it shall be decided in which 

mode the system was operating at a certain time where mode is here something like 

NORMAL, OVERHEAT and OFF. Since the system mode may vary over time it is necessary 

to analyze the periods where a certain mode is valid. 

This list of examples is not exhaustive but shows that there is a variety of statements that 

may be relevant for the test assessment. The TPT assessment is designed to consider all 

such cases. 

1.2 Some words about intervals and assessment variables 

As mentioned previously, the goal of the assessment is to reduce the immense amount of 

data recorded during test execution to a summary of information required for evaluation 

of system performance. 

To support the specification and computation of such properties the TPT assessment uses 

three core concepts: time intervals, context intervals and assessment variables. 

time intervals are any time segments, mostly defined implicitly using the “during” 

operator but maybe also defined explicitly using 

TPT.Interval(start_time,end_time).


A context interval is a time interval defined by the “during” operator in which a certain 

assessment is calculated. For example when a test result has been loaded the largest 

context interval is that for which the test result is defined. From this largest context 

interval smaller context intervals can be defined where certain assessments can be 

calculated. These context intervals can be defined explicitly in time (e.g. during 

TPT.Interval(10ms, 100ms):) or implicitly in time for example when a variable is 

larger than a certain value. 

An assessment variable is a variable used for this evaluation, which contains data 

structures relating the variable values to time intervals. 

The during keyword operates like ‘while(time intervals)’ of an assessment variable 

Let’s explain the meaning of these terms with a simple example: Assume that the system 

under test has an output signal called foo which can be observed and recorded during 

the test execution. Now we want to check whether or not the signal foo is always below a 

certain limit — say 100.0. The signal foo has been recorded during the test execution in 

the time period t=[0.0s … 10.5s). What does it mean to assess if there is an 

overflow? 

The first example to check the overflow is very simple: 

overflow = TPT.exists(foo(t) > 100.0); 

if overflow: 

# … do something if there is an overflow 

Here we evaluate whether or not there exists at least one point t in overall test case time 

t ∈ [0.0s, 10.5s] where signal foo exceeds the limit 100.0. The disadvantage of 

this computation is that overflow just carries the information true or false without 

any information about in which context (time) interval the overflow has been detected. We 

can get more information about the overflow behaviour by introducing the assessment 

variable concept: 

overflow = TPT.Boolean(); #declare the assessment variable 

overflow := TPT.exists(foo(t) > 100.0); #assignment to the assessment variable 

if overflow: 


So what’s the difference here? overflow is now no longer a Boolean variable carrying 

values true or false but an assessment variable of type Boolean. Assessment variables 

must be declared before use. This is done in the first line of our example above. In the 

second line the result of the TPT.exists() operation is assigned to overflow with the 

following information: 

• the value of the variable (which is true or false depending on the result of 

TPT.exists()), and 

• the context interval in which the assessment has been computed.


This means that overflow carries not only the Boolean value but also the information 

about the interval where this information has been computed. The result can be 

represented as follows: 

Assessment variable Start Time End Time Value 

Overflow 0.0s 10.5s True 

We can even use this extra information during the subsequent calculations. As an 

example we can query where the computation of the overflow analysis has been started 

and where it has been stopped: 

# … 

if overflow: 


from = overflow.getStartTime(); # start of the overflow analysis (== 0.0s) 

to = overflow.getEndTime(); # end of the overflow analysis (== 10.5s) 

This might still be not good enough. We know already that there is an overflow between 

0.0s and 10.5s but we do not know when exactly! To improve this situation we must 

modify the example again: 

overflow = TPT.Boolean(); 

overflow := TPT.regexp([foo(t) > 100.0]); 

# … 

In this example, instead of using the operator TPT.exists() (which only can determine 

whether or not there is an instance when the expression was true), we use the operator 

TPT.regexp(). Without explaining the full power of this operator here, it is sufficient to 

know that it searches only for those time intervals where the expression foo(t) > 

100.0 is true. Depending on the behaviour of foo, this can be a single interval, multiple 

intervals, or not at all. 

Now the full power of assessment variables can be used since assessment variables can 

carry information about different context intervals. This is an important fact — therefore I 

repeat it: Assessment variables are not just variables carrying single values but data 

structures carrying different values according to different time intervals. For each time 

interval an assessment variable may or may not have a value. In our example the 

overflow variable has three definition intervals with three associated values (in our case 

all of them are true): 





The meaning of such assessment variables is very intuitive: In the intervals shown above 

the signal foo exceeds the limit 100.0. This information is much more detailed than the 

simple fact that there is an overflow somewhere. In addition the information carried by 

assessment variables can be exported to the test report:




TPT.export(overflow); # export this information to the test report 

Furthermore one can use the assessment variable to derive even more detail: 



overflowAmount = TPT.Double(); # create an assessment var of type `double` 

during overflow: 

overflowAmount := TPT.integral(foo(t)-100); # integrate the exceedance 

In this example we define a second assessment variable called overflowAmount. It is 

defined by integrating the expression foo(t)-100. However, since the overflow is 

limited to 3 intervals we want to integrate the expression only in these intervals. This is 

done by means of the so called during-operator. It restricts the subsequent 

computation to the three intervals defined by the variable overflow. The result of this 

computation is the assessment variable overflowAmount which can be represented as 

follows: 


overflowAmount 2.2s 2.5s 0.0002 



As you can see this is a very efficient way of dealing with information that is dependent 

on the associated context interval. In the example above the “severity” of the overflow (i.e. 

how much it deviates from the limit) depends on the context interval. The three different 

values of overflowAmount quantify the severity for a particular time interval. 

Summary: 

(1) Time intervals are time segments from a start to an end time. (2) All assessment 

computations are performed within a well-defined context (time) interval. The default 

time interval being used is the “overall time interval” of the test case (i.e. from the 

beginning of the test case to the end). (3) Assessment variables are able to store different 

values for different time intervals. 

1.2.1 Annotations of assessments 

The assessment scripts are always associated to a state of the TPT testlet. It is possible to 

write assessments that are valid for all the tests. Also it is possible to write assessments 

that are evaluated in certain states or even scenarios. Please use the assessment tab in the 

TPT-main window. 

Assessments at a state are valid for the state itself and all sub-states. Thus assessment 

scripts at the top level will be executed for the complete automaton. 

Assessment Header: 

For functions of the assessment script that are more general and shall be visible for all 

assessments in all contexts the assessment header shall be used. Please use View/Edit 

Assess Header or the shortcut Ctrl-H.


The assessment header will be included into the assessment-script prior to all other 

assessments and has no time-context.


2 Assessment reference manual 

The TPT Assessment Language is derived from the scripting language Python 1 . This means that in 

general TPT assessments can do everything that can be done with Python — with a few exceptions. 

This chapter explains the features of the TPT assessment language which are not features of standard 

Python. 

2.1 Data types 

The TPT assessment supports different data types for signals and constants. Every 

assessment variable has to be explicitly declared with a type. The possible types are listed 

below: 

Data type Data range 

Boolean true, false 

Int8 -128 … +127 

UInt8 0 ... 255 

Int16 -32768 … + 32767 

UInt16 0 … 65536 

Int32 -2147483648 … +2147483647 

UInt32 0 … 4294967296 

Int64 -2 63 … +(2 63 -1) 

Double Floating point double precision 

Float Floating point single precision 

Table 1: Available data types 

1 

We don’t give a general introduction to the Python language in this document. Python reference guides and 

tutorials can be downloaded from www.python.org.


2.2 Creation of assessment variables 

TPT assessment uses so called assessment variables in order to specify and process data 

of interest. These variables differ from the normal Python variable types. This allows 

handling of large amounts of data efficiently by optimising internal data structures and 

makes access and interaction with the data efficient and readable. 

In order to use signals they must be declared as follows. 

d = TPT.Double(); # data range: floating point double accuracy (64 Bit) 

f = TPT.Float(); # data range: flaoating point (32 Bit) 

i = TPT.Int(); # data range: -2^31 .. 2^31-1 (= 32 Bit signed integer) 

b = TPT.Boolean(); # data range: “true“ and “false“ 

Additionally for integer variables the data type can be selectively controlled. This might be 

useful to reduce the large amount of data in larger projects. 

i = TPT.Int8(); # data range: -128 .. 127 

i = TPT.Int16(); # Data range: -2^15 .. 2^15-1 



i = TPT.UInt8(); # Data range: 0 .. 255 

i = TPT.UInt16(); # Data range: 0 .. 65535 

i = TPT.UInt32(); # Data range: 0 .. 2^32-1 

If variables should be exported later on, there is a smart abbreviation of declaring a 

variable and tagging it for export (see TPT.export() in section 2.5 for more details) by 

adding an ‘X’ to the creation method such as in the following examples: 

f = TPT.DoubleX(); # create a double variable and tag it for export 

i = TPT.Int16X(); # create an int16 variable and tag it for export 

b = TPT.BooleanX(); # create a boolean variable and tag it for export 

... 

variable TPT.Double() 

TPT.Double() declares a new assessment variable of type double. 

dv = TPT.Double(); 

dv := 2.1; 

dc = TPT.Double(); 

dc(t) := 2.1 * sin(t); 

In the example above a variable dv is declared and the value 2.1 is assigned. The variable 

dc is declared and the sine signal 2.1*sin(t) is assigned. Both dv and dc are TPT 

assessment variables.


Please note that the assignment is not been done by using a simple “=” but “:=”. The 

reason for using this special operator is that the assessment variable dv and dc are 

Python objects. Replacing the “:=” by “=”in the second statement has a completely 

different meaning: it will assign the value and the native Python type: the variable will no 

longer be a TPT assessment variable. The difference might be clearer in the following 

example. 

dv = TPT.Double(); 

dv := 2.1; 

# correct! 2.1 is assigned to the object “dv“. Now we can operate 

# with dv, i.e. assign a comment or read the length of the interval 

# where the value has been assigned: 

# 

dv.setComment(“Assign a comment to explain this value for reporting“); 

res = dv.getLength(); 

… 

Fig 1: Correct example for the variable definition 

dv = TPT.DoubleVariable(); 

dv = 2.1; 

# WRONG !! “dv” becomes a simple integer “object“. The assessment variable 

# object is deleted. Using the access methods of the example above would 

# cause a runtime error: 

dv.setComment(“Assign a comment …“); # abort!!! “dv“ not an assessment var. 

res = dv.getLength(); # abort!!! “dv“ not an assessment var. 

variable TPT.Float() 

Fig 2: Wrong usage for the variable definition 

TPT.Float() declares a new assessment variable of type float. 

dv = TPT.Float(); 

dv := 2123.2; 

dc = TPT.Float(); 

dc(t) := 223 * t; 

Function is analogous to TPT.Double(). 

variable TPT.Int() 

TPT.Int() declares a new assessment variable of type integer. 

dv = TPT.Int(); 

dv := 2123; 

dc = TPT.Int(); 

dc(t) := int(223 * t);



variable TPT.Boolean() 

TPT.Boolean() declares a new assessment variable of type Boolean. 

dv = TPT.Boolean(); 

dv := true; 

dc = TPT.Boolean(); 

dc(t) := (t > 1) ? true : false; 


variable TPT.Int8(), .Int16(), .Int32(), .Int64(), .UInt8(), .UInt16(), UInt32() 

For the declaration of the specific integer variables the following functions can be used. 

TPT.Int8(), TPT.Int16(), TPT.Int32(), TPT.Int64(), TPT.UInt8(), 

TPT.UInt16(), and TPT.UInt32(). 

dv = TPT.Int8(); 

dv := 12; 

dc = TPT.Int8(); 

dc(t) := int(t*256); # not allowed if t >= 1.0s 


2.3 Operations for assessment variables 

Various methods exist to modify or read information of the variables. 

string variable.getName() 

This method returns the logical name of the variable as it will be used in the test report. 

i = TPT.Int(); 

res = i.getName(); # returns “i“ 

int variable.getSize() 

This operator returns the overall number of (time) intervals in which the variable is 

defined. Thus, the number returned is independent of the current context interval. It may 

even be used without any context interval defined. 


res = i.getSize(); # for newly created variables: res == 0


float variable.getStartTime() 

Returns the earliest point in time where the assessment variable is defined relative to the 

start time of the current context interval. The definition of a variable is independent of a 

context interval but variable.getStartTime() returns the earliest “local” time where 

the variable is defined and is independent of whether or not this point in time is 

contained in the current context interval. This time might be outside the context interval 

within which variable.getStartTime() is evaluated. If, for example, the variable is 

defined before the context interval a negative time value is returned. 

Example: variable ‘i’ is defined in intervals [3,15] and [21,30], the current context is 

[2,4]. i.getStartTime(); is 3-2=1. If the context interval is [20,400], 

i.getStartTime(); is 3-20=-17. 

Special case: For a new (and still empty) assessment variable (created with TPT.Int(), 

for example), the global start point is 0.0 by definition. If the context interval is 

[20,400], this method returns -20. 


… 

res = i.getStartTime(); 

float variable.getEndTime() 

Returns the time where the variable is no longer defined relative to the start of the 

context interval. 

The result is returned in local time. It does not matter if the variable occurs outwith the 

current context interval or not. 

Example: The variable is defined in intervals [3,15] and [21,30], whereas the current 

context is [2,4]. The resulting time value is 30-2=28. If the context interval is 

[20,400], the resulting time value is 30-20=10. 

Special case: For a new (and still empty) assessment variable (e.g. created with TPT.Int), 

the global end point is 0.0 by definition. If the context interval is [20,400], this 

method returns -20. 


… 

res = i.getEndTime(); 

float variable.getLength() 

Returns the difference between the start of the first instance of the variable and the end 

of its last instance: 

getLength() = getEndTime() – getStartTime(). 

Info: This is not the same as the sum of all periods of definition. Periods of no definition 

are not included in this calculation.



… 

res = i.getLength(); 

boolean variable.isDefined(float time) 

Checks whether or not values of a signal can be accessed at the given local time time. 

This means that c.isDefined(2.0) returns true if the value of c at local time 2.0 

(which is 2 seconds after the start time of the current context interval) exists. 

interval variable[int index]-Operator 

As mentioned in section 1.2 assessment variables may consist of multiple definition 

intervals. The different intervals are indexed using variable[ n-1] where n is the nth 

definition interval. Hence the first interval can be accessed with index 0, the last one with 

index getSize()-1. Using indices outside this range will raise a runtime error. 

(“Variable xyz has no definition interval with index …“). Accessing the 

definition intervals using the []-operator is independent from the current context interval. 


… 

iv = i[0]; 

# iv is the globally first interval of the assessment variable 

number variable(float time)-Operator: Accessing values at a particular time 

Snapshot values of a signal can be accessed using the ()-operator. Accessing single 

values always uses local time. This means that c(0.0) returns the value of c at local time 

0.0 (which is the start time of the current context interval and not the global time 0.0. 

The assessment variable must exist at local time t , otherwise a runtime error will be 

raised. 


… 

res = 2 * i(12.0); # reads the value of i at t = 12.0 (local time) 

number variable: Autocast for accessing values of a variable 

If an assessment variable is part of a numerical calculation without any special operators, 

the “current value” of the variable will be used. 

If the variable is accessed in context of a time dependent expression (i.e. an expression 

where t is bound to the current point in time) the value of the assessment variable at t 

will be read. In other words, instead of var(t) one can simply write var with the same 

meaning.



… 

res = TPT.always(i > 2); # both lines are identical 

res = TPT.always(i(t) > 2); # in semantics. 

If the variable is accessed outwith a time dependent expression (i.e. t is not allowed in 

this expression), the value of the variable within the current context interval will be 

returned if it is unique, otherwise a runtime error will be raised. 

The unique value will be determined as follows: From all definition intervals of the 

assessment variable only those intervals are considered that intersect the current context 

interval. If the variable has the same (constant) value within all remaining intervals then 

this is the resulting unique value. A runtime error will be raised under one of the following 

conditions: 

• If there is no definition interval of the assessment variable intersecting the current 

context interval (Error: “Variable xyz is undefined in context 

interval …”) 

• If there is at least one definition interval of the assessment variable intersecting 

the context interval that is not constant (Error: “Variable xyz is not a 

constant in definition interval …”) 

• If there are at least two different definition intervals intersecting the current 

context interval with constant, but different values (Error: “Variable xyz is 

defined in multiple definition intervals with different 

constants A and B. Context interval is …”) 


… 

res = 2 * i; # reads the constant value of i from current context interval 

If it is not possible to use the auto-cast convention above in some expression context, the 

same semantics can be expressed using syntax var() instead of var. 


… 

res = i; # “res“ refers to the same object such as “i“ (no Autocast) 

res = i(); # the constant value of i in current context interv. will be read 

number variable.getLeftValue() 

This function returns the first value of a variable in the current context interval. The 

function may be applied only if there is at least one definition interval of the assessment 

variable in the current context interval, otherwise a runtime error will be raised 

(“Variable xyz is undefined in context interval …”). 

Example: The variable is defined in intervals [3,15] and [21,30], whereas the context is 

[5,25]. The result is the value of the assessment variable at global time 5.



… 

res = i.getLeftValue(); 

number variable.getRightValue() 

This function returns the last value of a variable in the current context interval. The 

function may be applied only if there is at least one definition interval of the assessment 

variable in the context interval, otherwise a runtime error will be raised (“Variable xyz 

is undefined in context interval …”). 

Example: The variable is defined in intervals [3,15] and [21,23], whereas the context is 

[5,25]. The result is the value of the assessment variable at global time 23. 


… 

res = i.getRightValue(); 

variable.setVerdict(int result) 

With this function every definition interval of an assessment variable can be tagged with a 

verdict using one of the following constants: 

• variable.setVerdict(TPT.SUCCESS): The signal indicates that the system 

behaviour was as expected . 

• variable.setVerdict(TPT.FAILED): The signal indicates that the system 

behaviour shows an error . 

• variable.setVerdict(TPT.DONT_KNOW): The signal indicates that it cannot 

be decided automatically whether or not the system behaviour was as expected. 

If setVerdict() has not been called for a variable, the default verdict is 

TPT.DONT_KNOW. However, TPT.Boolean() variables are an exception to this rule. If 

these variables are constant within a definition interval, the verdict is automatically set to 

TPT.SUCCESS if the constant value is TRUE, similarly the verdict is TPT.FAILED if the 

variable is constantly FALSE. In either case the default verdict can be overwritten by the 

user using the setVerdict() function. 

A runtime error will be raised by this function under one of the following conditions: 




• If there is more than one definition interval intersecting the context interval (Error: 

“Variable xyz is defined in more than one interval 

intersecting context interval …”)



… 

i(t) := int (2 * t); 

i.setResult(TPT.SUCCESS); # i shows a correct system behaviour -> SUCCESS 

variable.setComment(string comment) 

A comment can be added to every definition interval of an assessment variable using the 

function setComment(). Before calling this function, be sure that there is exactly one 

definition interval of the assessment variable in the current context interval. The comment 

will be assigned to the definition interval and added to the test . 

A runtime error will be raised by this function under one of the following conditions: 




• If there is more than one definition interval intersecting the context interval (Error: 

“Variable xyz is defined in more than one interval 

intersecting context interval …”) 


… 

if cond: 

i(t) := sin(t); 

i.setComment(“i is a sine “); 

else: 

i(t) := cos(t); 

i.setComment(“i is a cosine “); 

variable.setInterpolation(int mode) 

The assessment engine supports two different interpolation modes for every assessment 

variable var: TPT.LASTVALUE means that between two subsequent samples the signal 

is constant at the left sample value (excluding the right sample point). It constitutes a step 

function. On the other hand, TPT.LINEAR interpolates the signal between two 

subsequent samples. 

Note that, linear interpolation is allowed even for integer variables. However, the 

interpolated values are subject to quantization error using the integer resolution. 

Changing the interpolation mode for Boolean signals is allowed but has no effect.


x = TPT.Double(); 

… 

x(t) := sin(t); 

… 

# the interpolation mode can be changed before or even after signal definition 

x.setInterpolation(TPT.LINEAR); 

variable := number (definition of a constant) 

A value can be assigned to an assessment variable in a context interval using the syntax 

var := expr. The variable will then be constant in this context interval. However, if the 

variable was already defined in one or more definition interval(s) intersecting, but not 

identical to the current context interval, a runtime exception will be raised (“Variable 

xyz cannot be defined with overlapping definition intervals…“). In 

other words: A runtime error will occur if defining the variable would change existing 

definition intervals and not just their values. 


… 

i := 1234; # assigns a constant value to “i” in current context interval 

variable(t) := timed-number (definition of a signal) 

Using the notation var(t) := timed-number a continuous signal can be assigned to 

an assessment variable in the current context interval. The variable will have an individual 

value at every sample point in the context interval. For that purpose the reserved variable 

t can be used within the expression timed-number on the right-hand-side to represent 

the “current time”. The time variable t represents the local time, i.e. it starts at t=0.0 and 

ends at t=this.getLength()-TPT.getStepSize(). If the variable was previously 

defined in the context interval the old value will be overwritten. However, if the variable 

was previously defined in one or more definition interval(s) intersecting, but not identical 

to the current context interval, a runtime exception will be raised (“Variable xyz 

cannot be defined with overlapping definition intervals…“). In other 

words: A runtime error will occur if defining the variable would change existing definition 

intervals and not just their values. 


… 

i(t) := int(12 * t); 

variable.isConstant() 

This operator returns true if the signal is constant during the current context interval..


… 

i(t) := 2; 

j(t) := t; 

k := 2; 

i.isConstant(); # true 

j.isConstant(); # false 

k.isConstant(); # true 

sum = i + k; # accessing constant values allowed here 

j1 = j(0.0s); # since j is not a constant we must access ... 

j2 = j(0.1s); # ... values at individual points in time ... 

max = TPT.average(j(t)); # ... only 

2.4 Operations for time intervals 

There are operations to read or modify characteristics of time intervals. 

float interval.getStartTime() 

Returns the first point in time where the interval is defined. The time value is returned in 

local time and is independent of whether or not this point in time is contained in the 

current context interval. 

Example: The interval is [3,15] and the current context is [2,4]. The resulting time 

value is 3-2=1. If the context interval is [20,400], the resulting time value is 3-20=-17. 


… 

res = i[1].getStartTime(); # start time of the 2nd interval of “i” 

float interval.getEndTime() 

Returns the point in time where the interval is no longer defined. 

The result is in local time and is independent of whether or not this point in time t is 

contained in the current context interval. 

Example: The interval is defined in interval [21,30] and the current context is [2,4]. 

The resulting time value is 30-2=28. If the context interval is [20,400], the resulting 

time value is 30-20=10.



… 

res = i[1].getEndTime(); # end time of the 2nd interval of “i” 

float interval.getRightLimit() 

This method returns the greatest sample point belonging to the interval. (Note, that 

intervals in TPT are always right-open intervals with a fixed sample rate. Therefore 

getRightLimit() is the same as getEndTime()-TPT.getStepSize()). 


… 

res = i[0].getRightLimit(); # right limit of the 1st interval of “i” 

float interval.getLength() 

This method returns the overall length of the interval. This is exactly the difference 

between start and end time: getLength() = getEndTime() – getStartTime(). 


… 

res = i[1].getLength(); 

boolean interval.isDefined(float time) 

Checks whether or not the interval contains the given local time time. This means that 

j.isDefined(2.0) returns true if the value of j at local time 2.0 (which is 2 seconds 

after the start time of the current context interval) exists. 

number interval(float time)-Operator: Accessing values at a particular time 

Single values of an interval can be accessed using the ()-operator. Accessing single 

values always uses local time. This means that j(0.0) returns the value of j at local time 

0.0 (which is the start time of the current context interval and not the global time 0.0. 

t must be a value between j.getStartTime() and j.getEndTime(), otherwise a 

runtime error will be raised. 


… 

j = i[someindex]; 

res = 2 * j(12.0); # j must be defined at t=12.0 

number interval: Autocast for accessing values of an interval 

If an interval is part of a numerical calculation without any special operators, the “current 

value” of the interval will be used. 

If the interval is accessed in context of a time dependent expression (i.e. an expression 

where t is bound to the current point in time) the value of the interval at t will be read. In


other words, instead of j(t) one can simply write j with the same meaning for any 

interval j. 


… 


res = TPT.always(j > 2); # both lines are identical 

res = TPT.always(j(t) > 2); # in semantics. 

If the interval is accessed outside of a time dependent expression (i.e. t is not allowed in 

this expression), the value of the interval within the current context interval will be 

returned if it is constant, otherwise a runtime error will be raised. 


… 


res = 2 * j; # reads the value of j (must be a constant) 

If it is not possible to use the auto-cast convention above, it may be expressed using 

syntax j() instead of j. 


… 


res = j; # “res“ refers to the same object as “j“ (no Auto-cast) 

res = j(); # the constant value of j will be read 

int interval.getSamplePointSize() 

This method returns the total number of sample points stored to represent the signal of 

this interval. For a constant this method returns always “1”. For continuous signals the 

returned value is the same as interval.getLength()/TPT.getStepSize(). 


… 

n = i[0].getSamplePointSize(); # no. of samples in first interval of i 

interval.setComment(string comment) 

A comment can be added to an interval using the function setComment().The comment 

will be assigned to the interval and added to the test report (if exported) .



… 

# add a comment to the 2nd definition interval of “i” 

i[1].setComment(“i is a sine “); 

interval.isConstant() 

This operator returns true if the signal is constant over time during this interval. 


… 

myIV = i[1]; 

if myIV.isConstant(): 

# we can access the constant value directly in this case: 

print myIV+1; 

else: 

# we can access the continous course only at individual times: 

print myIV(0.0s); 



bool interval.intersects(interval other) 

This function checks whether two intervals overlap each other. 

i1 = TPT.Int(); 

i2 = TPT.Int(); 

… 

if i1[0].intersect(i2[3]): 

# 1st interval of i1 intersects 4th interval of i2 ! 

… 

interval TPT.Interval(float start, float end) 

This method creates a new interval that ranges from time start (inclusive) to end 

(exclusive). Both parameters must be specified in local time. Such intervals are commonly 

used in combination with the during-operator. 

i = TPT.Interval(2,5.7); # creates a new interval btw. 2.0s and 5.7s 

2.5 Operations for records (file I/O operators) 

For the TPT assessment it is necessary to access intermediate and results files. 

string TPT.workingDirectory() 

This function returns the “working directory” of the assessment script. If you are running 

the assessment script from TPT for a particular test case the working directory is always


the directory where the data log files are located (assembled during the test execution). If 

the assessment engine has been started as a standalone process the current working 

directory is the directory where the engine has been started. 

workingdir = TPT.workingDirector(); 

# now we can locate a file within the workingDirectory as follows: 

datafilename = TPT.workingDirectory() + “/myfile.dat”; 

… 

2.5.1 Reading records from file system 

record TPT.readRecord(string filename, double jittertolerance) 

This function opens a file with the given filename for reading and reads all relevant signal 

information into the assessment engine. The individual signals can be accessed using the 

Record object returned by this function (see the access functions described below). 

TPT supports the following signal file formats: 

• TPTBIN, which is a specialized proprietary file format of TPT to store signals in a 

compact format and that supports all information necessary during test 

execution, test assessment and report generation. 

• MAT, which is the Matlab binary file format for storing signal data 

• CSV (comma-separated values), which is a simple ASCII table-like file format 

myrecord = TPT.readRecord(“myfile.tptbin”); 

a = myrecord.getVariable(“a”); # obtain var “a” from file content 

… 

len = a.getLength(); # use the variable as descibed in section 2.3 

You can use absolute or relative pathnames. If the filename is relative and if you are 

running the script form TPT for a particular test case the working directory is 

automatically added. 

The optional parameter jittertolerance indicates the maximum tolerance the time 

jittering of a signal may have in order to be interpreted as sampled with constant 

sampling time. For example a given signal has a sampling time that is not really constant. 

The sampling time varies between 0.9 and 1.1 seconds but it is known that the sampling 

time is constant 1s. The reason for this phenomenon is may be an asynchronous data 

transfer. Setting the jitter-tolerance to 0.1 would cause the signal being interpreted with a 

constant sampling time of 1s. 

variable record.getVariable(string variablename) 

An assessment variable can be retrieved from a record by its name using the 

getVariable() method.



a = myrecord.getVariable(“a”); # obtain var “a” from file content 

b = myrecord.getVariable(“b”); # obtain var “b” from file content 

… 

It is not necessary to declare variables a and b using TPT.Double(), TPT.Int() etc. 

The declaration is done implicitly when importing the variable. 

interval record.getCompleteInterval() 

This method returns the complete interval for a given record, which is the smallest interval 

that spans all definition intervals of all variables within this record. If the record is empty 

(no variables contained) or if all variables of this record are empty (newly created without 

a definition) the default interval returned by this method is [0,TPT.getStepSize()]. 


a = myrecord.getCompleteInterval(); 

… 

float record.getStepSize() 

This method returns the greatest common divisor (GCD) of all the step sizes (sampling 

rates) of all variables within this record. If there is no variable in the record at all, the step 

size returned by this method is 1.0, by definition. 


samplingRate = myrecord.getStepSize(); 

… 

2.5.2 Writing records to the file system 

record TPT. Record() 

This method generates a new empty test record into which variables can be exported. 

foo = TPT.Int(); 

bar = TPT.Float(); 

… 

rec = TPT.Record(); 

rec.add(foo); # export variable with name “foo“ 

record.add(variable var) 

Adds an assessment variable to a record. If the record is written to the file system later on, 

this variable will be stored in the exported file together with all other exported variables.




… 



record.add(variable var, string variablename) 

In some cases it might be necessary to change the name of a signal before exporting it to 

a file. This is done by appending the variable’s new name. However, be careful using this 

function because it renames the variable permanently. 



… 



rec.add(bar,”mybar”); # export “bar” with name “mybar”. 

name = bar.getName(); # read variable’s name 

# name == “mybar” !! 

record.writeRecord(string filename) 

This method exports a record to the file system. 



… 


rec.add(foo); 

rec.add(bar); 

rec.writeRecord(“foobar.tptbin“); # writes the signasl into a data file 

You can use absolute or relative pathnames. If the filename is relative and if you are 

running the script form TPT for a particular test case the working directory is 

automatically added. 

2.5.3 Writing the default output record to the file system 

Signals that are to appear in the reports must be exported while running the assessment. 

Normally the TPT assessment uses a central export file for all of the export signals. This 

record has some special access methods that are just shortcuts for the methods described 

above. 

record TPT.getExportRecord() 

This method returns the central export record. In general, it is not necessary to retrieve 

this record explicitly but to use the shorthand methods below.


TPT.export(variable var) 

Using TPT.export(var) marks the variable var for export into the default data file 

(usually testcase.tresult.tptbin). 

TPT.export(var) is shorthand for TPT.writeExportRecord().add(var). 


… 

TPT.export(foo); # same as TPT.getExportRecord().add(foo) 

TPT.export(variable var, string varname) 

Using TPT.export(var,name) marks the variable var for export into the default data 

file (usually testcase.tresult.tptbin). In this case one can use this function to 

rename the assessment variable before exporting it. However, be careful using this 

function because it renames the variable permanently. 

TPT.export(var, name) is shorthand for TPT.writeExportRecord().add(var, 

name). 



… 


TPT.export(bar, “mybar“);# same as TPT.getExportRecord().add(foo,”mybar“) 

TPT.writeExportRecord(string filename) 

This method exports all variables added to the central record to the file system (usually to 

the file named testcase.tresult.tptbin). 

Using TPT.writeExportRecord(filename) is shorthand for calling 

TPT.getExportRecord().writeRecord(filename). 



… 


TPT.export(bar, “mybar“);# same as TPT.getExportRecord().add(foo,”mybar“) 

… 

TPT.writeExportRecord(“testcase.tresult.tptbin”); # write now 

# same effect: 

TPT.getExportRecord().writeRecord(“testcase.tresult.tptbin”); 

If the assessment script has been generated by TPT this command will be inserted 

automatically into the script. 

2.5.4 Accessing reference data in assessment scripts 

If a reference base directory has been specified in the execution configuration of TPT the 

reference signals are accessible using the operations described in the section below.


record TPT.getReferenceData() 

This method returns a record that contains all the signals from reference data. You can 

use this to read reference signals in the same way as reading measured signals: 

… 

ref = TPT.getReferenceData(); 

a_ref = ref.getVariable(“a”); # obtain var “a” from reference file content 

b_ref = ref.getVariable(“b”); # obtain var “b” from reference file content 

… 

string TPT.getReferenceDataFile() 

This method delivers the name of the file that contains the reference data for this test 

case. If no reference base directory has been specified in the execution configuration this 

method returns an empty string. 

2.6 Global operations 

TPT.setStepSize(float sampleSize) 

This function sets the global step size (sampling rate) used in all computations of the TPT 

assessment engine. The default step size is 1.0s. As a rule, the step size should be set only 

once at the beginning of the assessment computation. Even if updating the step size 

between some calculations is possible, the semantics are quite complicated and may 

cause a behaviour which is difficult to predict. 

TPT.getStepSize() 

This function returns the global step size (sample rate) used in all computations of the 

TPT assessment engine. This has the same meaning as the ‘@‘-operator (see below). 

@-Operator 

This operator returns the global step size (sample rate) used in all computations of the 

TPT assessment engine. This has the same meaning as the TPT.getStepSize()operation 

(see above). 

float TPT.toGlobal(float time) 

This operator returns the global time that belongs to the given local time ‘time’. 

during TPT.Interval(2,4): 

TPT.toGlobal(0s); # delivers 2s 

void TPT.setTestResult(int result) 

This function sets the global test result for the test case to TPT.FAILED, TPT.SUCCESS 

or TPT.DONT_KNOW (TPT.setTestResult(TPT.FAILED)), (TPT.setTestResult 

(TPT.SUCCESS) or (TPT.setTestResult(TPT.DONT_KNOW))). This will be exported


as an Integer variable “TPT_TestResult“. When TPT.setTestResult() is not used 

in a test case it won’t be exported. 

# Test was successful 

TPT.setTestResult(TPT.SUCCESS); 

void TPT.setTestComment(string comment) 

This function sets the global comment that will be assigned to the test case (more 

precisely: to the implicitly defined variable TPT_TestResult that will be exported). This 

comment will be shown in the overview report generated as a summary over all test cases 

as well as in the details reports for individual test cases. 

# Test had a particual shift time problem 

TPT.setTestResult(TPT.FAILED); 

TPT.setTestComment(”shift time too long”); 

Lazy conditional expression: cond ? thenExpr : elseExpr 

To use conditional expressions there is a “cond ? thenExpr : elseExpr“-operator 

as known from languages such as C, C++ or Java. 

# compare signals a and b, but shift b 2s to the right. Since this comparision 

# is not allowed if t < 2 we define the expression to be true (1) if t < 2 

TPT.always(t < 2 ? 1: a(t) == b(t-2)); 

2.7 Signal processing functions: value computations 

boolean TPT.always(timed-boolean expr) 

This operation checks if the expression expr of type boolean is true for all points in 

time of the current context interval. If the expression is false during at least one sample 

period the result is false. 

res = TPT.always(sin(t) < 2); 

# res == 1 

double TPT.average(timed-float expr) 

This method returns the mean average value of the numeric expression over all time steps 

within the current context interval.


res = TPT.average(2 * t); 

# res == this.getLength() 

boolean TPT.check( boolean cond1, float val1, string text1, 

boolean cond2, float val2, string text2, 

..., 

float valOtherwise, string textOtherwise) 

This operation checks if the expression cond1 of type boolean is true and delivers the 

value val1 associated with the comment text1 in this case. Otherwise the expression 

cond2 will be checked. If true the value val2 associated with the comment text2 will be 

returned, and so on. If none of the conditions cond1 to condN are fulfilled the function 

returns valOtherwise associated with comment textOtherwise. 

a = TPT.Double(); 

a := t < 3 ? t : (t-3); 

res = TPT.Int8(); 

res := TPT.check( 

a.getLeftValue() == A_CONST_X, 1, “a is initially X”, 

a.getLeftValue() == A_CONST_Y, 2, “a is initially Y”, 

-1, “neither X nor Y”); 

boolean TPT.checkAlways(timed-boolean expr, string successText, string 

errorText) 

This operation checks if the time dependent expression expr of type boolean is true 

for all points in time of the current context interval. If the expression is always true the 

result is true in the current context interval and the given successText is automatically 

used as the comment. Otherwise (if the expression is false at least for one sample) the 

result is false in all sub-intervals of the current context interval where the expr failed. 

a = TPT.Double(); 

a(t) := t < 3 ? t : (t-3); 

res = TPT.Boolean(); 

res := TPT.checkAlways(a(t) >= 2, “a is in range” ,”a exceeds limit”); 

# res is true in ranges [2..3] and [5..end] 

boolean TPT.exists(timed-boolean expr) 

This operation checks if the time dependent expression expr of type boolean is true 

during at least one sample period of the current context interval. If the expression is 

false for there is no time t with expr(t)==true.


res = TPT.exists(t > 2); 

# res == 1 if the context interval is longer than 2s 

float TPT.max(timed-float expr) 

This method returns the maximum of all values expr(t) within the current context 

interval. 

res = TPT.max(sin(t)); 

# res == 1 if context interval is longer than PI/2 

float TPT.min(timed-float expr) 

This method returns the minimum of all values expr(t) within the current context 

interval. 

res = TPT.min(sin(t)); 

# res == -1 if context interval is longer than PI*3/2 

boolean TPT.never(timed-boolean expr) 

This operation checks if the expression expr of type boolean is false during all of the 

current context interval. If the expression is true during at least one sample period the 

result is false. 

res = TPT.never(sin(t) < 2); 

# res == 0 

2.8 Signal processing functions: signal computations 

timed-float TPT.boundControl(timed-float expr, float min, float max) 

The operation checks whether or not the course of expr is out of the limits [min, max] 

within the current context interval. The result is for a given time t is defined as follows: 

• the negative value expr(t)-min if expr(t) is below bounds (expr(t) max), 

and 

• the value 0.0, if min ≤ expr(t) ≤ max 

Note that boundControl() can be considered as a special form of the hose() 

function. The expression boundControl(expr, min, max) has the same meaning as 

the equivalent term hose(expr, (max+min)/2, 0, (max-min)/2). However, the 

implementation is more efficient.


res = TPT.Double(); 

# defines res in a way to check for being off the limits of 0.5 or -0.5 

res(t) := TPT.boundControl(sin(t), -0.5, 0.5); 

timed-float TPT.deviation(timed-float expr1, timed-float expr2, float x) 

This operator calculates the deviation of expr1 and expr2 and returns the difference as 

a signal. The parameter ± x specifies the time tolerance, i.e. for a given time t the value 

expr1(t) is compared with all values expr2(t ± x). The smallest absolute difference 

will be returned as the deviation at t. 

Note that deviation() can be considered as a special case of hose(). The expression 

deviation(expr1, expr2, x) is equivalent to |hose(expr1, expr2, x, 0)|. 

However, the implementation is more efficient. 

foo = TPT.Double(); 

bar = TPT.Double(); 


foo(t) := … 

bar(t) := … 

# tolerate +/-1 seconds when comparing foo and 2*bar(t/2) 

res(t) := TPT.deviation(foo(t), 2*bar(t/2), 1.0s); 

timed-float TPT.dt(timed-float expr) 

This operator calculates the first derivative or more precisely, the difference quotient over 

time. 

foo = TPT.Double(); 


foo(t) := sin(t); 

res(t) := TPT.dt(2* foo(t/2)); # first derivative 2*foo(t/2) 

timed-float TPT.dt2(timed-float expr) 

Analogous to TPT.dt() this function returns the second derivative (difference quotient) 

over time. 


res(t) := TPT.dt2(2*t*t); # 2nd derivative is constant 4 

timed-float TPT.hose(timed-float expr, timed-float ref, float xtol, float ytol) 

This method generates bounds around the signal ref(t) and checks if the signal expr 

is encapsulated within these bounds. The hose consists of all the rectanles with the size 

xtol and ytol around every sample point of the reference signal ref. The result for a 

time t is the smallest delta between the signal expr(t) and the hose around ref. When 

the signal expr(t) is covered by the hose, the result is 0.0, otherwise the smallest 

(signed) delta between expr(t) and the reference hose ref will be returned.


Figure 3 shows an example of the hose function. The red signal is expr(t) and the blue 

signal with dots is the reference signal ref(t). The hose function is build from 

rectangles depicted in grey. The hose function returns 0.0 when the original signal 

expr(t) is inside the grey boxes and is the difference between the border of the boxes 

and the original signal when the signal is outside of the grey boxes (cf. red dotted line 

unequal zero for t > te). 

For sampled systems xtol must be at least the step size to be relevant. 

y 

ytol xtol original signal 

reference signal 

hose 

return valuesof the hose function 

t e 

Figure 3: Hose function 

# hose function example 

foo = TPT.Double();# reference signal 

bar = TPT.Double();# original signal 


foo(t) := … 

bar(t) := … 

# x-tol: 0.01 

# y-tol: 5.0 

res(t) := TPT.hose(bar(t), foo(t), 0.01, 5.0); 

timed-float TPT.integrate(timedFloat expr, int type) 

This method integrates the signal expr over time in the current context interval. As 

numeric integration type the following options are available: 

• TPT.EULER_FORWARD (default, if type is omitted) 

• TPT.EULER_BACKWARD 

• TPT.TUSTIN (bilinear) 

t


timed-boolean TPT.monotony(timed-float expr, int type) 

Analyses the monotony of a signal in a time interval and returns true for every time t 

where expr has the desired monotonic behaviour. The type parameter controls which 

monotonic characteristics are to be observed: 

• TPT.INCREASING 

• TPT.DECREASING 

• TPT.STRICTLY_INCREASING 

• TPT.STRICTLY_DECREASING 

res = TPT.Boolean(); 

2.8.1 Filter operations 

res(t) := TPT.monotony(t * t * f(t), TPT.INCREASING); 

A filter has the ability to remove certain frequency-elements from a signal. For example a 

low pass filter removes frequency elements above a cut off frequency fc. The higher 

frequencies will be removed without affecting other (lower) frequency elements. If this is 

done using an ideal low pass filter, the transfer function of such a filter might be

Page 34 TPT Assessment-Language


IIR-Filter design 

One method for IIR-filter design is the transformation of analogous filter prototypes. A 

classic or perfect filter design is achieved through discrete filters. This is usually be done 

using a low pass filter model and sampling of the signal to a series of discrete elements. 

Well known methods of this are Butterworth or Chebycheff filters. All filter specifications 

are given in the frequency domain (cut-off frequency etc.) and supplemented by the filter 

order. 

Other methods exist which have not been implemented yet. 

IIR-filter usually have the advantage of fulfilling the frequency-domain specifications with 

a small filter order N. The disadvantage of a nonlinear phase response can be negotiated 

by bi-directional filtering. Time domain requirements like impulse response requirements 

can be fulfilled by the direct methods. A specification in time and frequency domain is 

usually not easy. 

FIR-filter design 

In contrast to IIR-filter design FIR-filter design is thoroughly limited to discrete 

implementations. Thus the design methods for FIR-filter are based on the direct 

approximation of the specified frequency response of the discrete system. The simplest 

design method is called the windowing method. The order and amplitude response of the 

filter is stated in the frequency domain. From this transfer function the ideal impulse 

response is calculated. This impulse response is usually infinite and not causal and thus 

cannot be modelled. In order to realise the filter only a section of the ideal impulse 

response is considered. The section is built by using a window function. Within TPT 

different windowing functions are provided (RECTANGULAR, HANNING, HAMMING, 

BLACKMAN). The filter coefficients correspond to the coefficients of the window function. 

The signal will be multiplied in the time domain. Thus the impulse response of the filter is 

equal to the values of the filter function. The multiplication in the time domain leads to a 

convolution of the signal with the window function in the frequency domain. 

In this sense the rectangular window is optimal in the time domain but due to the 

convolution it leads to ripples in the frequency domain. This means the gain of all 

frequency fractions in the pass-band is not equal. By using different window-functions 

this can be improved to the expense of the time domain behaviour. For example the 

Hamming-window is a good compromise between time and frequency domains. 

1 

0.9 

0.8 

0.7 

0.6 

0.5 

0.4 

0.3 

0.2 

0.1 

Rectangular 

Blackman 

Hamming 

Hanning 

0 

-25 -20 -15 -10 -5 0 5 10 15 20 25 

The impact of choice of window width is that the larger the window, the ripples in time 

domain are more pronounced (Gibbs phenomenon). Also the steepness between pass 

and blocking band of the filter increases with the window width or order respectively. 

With increasing filter order the frequencies are better separated but the distortion also 

increases. The balance between distortion and frequency-separation must be found.


The right filter design method 

In the context of filtering the requirements from chapter 2.8.1must be considered. 

A good frequency separation can be achieved with an IIR-filter. Butterworth or Chebycheff 

approximations result in a ripple free pass band. Also the non-linear phase response can 

be controlled by bi-directional filtering. The major disadvantage of frequency-domain IIR 

filter is the poorly controlled time domain behaviour. FIR-filters achieve a better frequency 

selection by increasing the order M. The time domain requirements behave similarly to 

IIR-filters. Filter coefficients and impulse response can be adapted to meet cut-off and 

overshoot requirements. Manipulation of bidirectional filtering or the linear phase can 

achieve delay-free filtering. 

All FIR-methods result in ripple of the pass-band gain. By normalization of filter 

coefficients for any FIR-filter a gain of 0db at a frequency of zero Hz can be achieved. 

Thus the filter design using windowing method combines zero phase, frequency 

separation and overshoot. 

timed-float TPT.filterFIR(timed-float expr, int order, int type, int windowtype, 

float passbandMin, float passbandMax) 

Applies a FIR-filter to the signal expr and returns the filtered signal. The filter order and 

the window function is specified. The filter coefficients are identical to the ideal windowed 

impulse response. FIR filters have the disadvantage of fulfilling frequency requirements 

with a high filter order. The implemented methods design filter with a linear phase 

response. From this the major advantage compared to IIR filter arise, the constant time 

delay d = M/2 which can be utilized for delay compensation off-line. 

Another advantage is the simple relation between filter coefficients and impulse response. 

The time domain behaviour can be seen easily at the filter coefficients: 

The parameters are defined as follows: 

expr Signal 

order Order M of the filter 

type Filter type: 

• TPT.LOWPASS 

• TPT.HIGHPASS 

• TPT.BANDPASS 

windowtype window type for filter: 

• TPT.RECTANGULAR 

• TPT.HANNING 

• TPT.HAMMING 

• TPT.BLACKMAN 

passbandMin lower pass band frequency [Hz] 

passbandMax maximum pass band frequency [Hz]


# Low pass FIR filter of order 100 and a cutoff frequency of 5 Hertz. 

# The filter coefficient or window type is Hanning 

acc_flt(t) := TPT.filterFIR(acc(t), 100, TPT.LOWPASS, TPT.HANNING, 0.0, 5.0); 

timed-float TPT.filterIIR(timed-float expr, int order, int type, int prototype, float 

passbandMin, float passbandMax) 

Similar to FIR filter this function filters the signal expr using the specified IIR-filter and 

returns the filtered signal. 

A classically designed analogue filter is transformed into the discrete filter via frequency 

transformation of the low-pass prototype and discretization. The methods are called 

similar to the analogous design methods Butterworth and Chebycheff (type one with 

ripples of 1db). The filter specification is given in frequency domain extended with filter 

order. 

IIR-Filter have the advantage to fulfill frequency requirements with a small filter order N. 

The disadvantage of the nonlinear phase response can be negotiated with bi-directional 

filtering. The time domain requirements (e.g. overshoot) could be fulfilled with direct 

methods (not implemented). Specification in time and frequency domain is not possible 

offhand. 


expr Signal 

order order 

type filter type: 

TPT.LOWPASS 

TPT.HIGHPASS 

TPT.BANDPASS 

prototype prototype of the filter 

TPT.BUTTERWORTH 

TPT.CHEBYSHEV 

passbandMin lower pass band frequency [Hz] 

passbandMax maximum pass band frequency [Hz] 

# Second order lowpass Butterworth filter with a cut off frequency of 5 Hertz 

acc_flt(t) := TPT.filterIIR(acc(t), 2, TPT.LOWPASS, TPT.BUTTERWORTH, 0.0, 5.0); 

timed-float TPT.filterMA(timed-float expr, int order, int type) 

Filters the signal expr using a moving average filter and returns the mean value or the 

standard deviation of the last time steps using order. This filter is a special kind of an FIR 

filter having the same filter coefficients for all time steps. 


expr Signal 

order order of the filter 

type one of the following: 

TPT.SIGNAL (filtered signal) 

TPT.SIGMA (standard deviation)


# Moving average of the last 100 time samples 

acc_flt(t) := TPT.filterMA(acc(t), 100, TPT.SIGNAL); 

timed-boolean TPT.stepDetection(timed-float expr, int order, float scale) 

Step detection analyses signals in order to find significant steps in the signal. This 

function works also for noisy signals. 

The step detection uses the so called “double sigma method”. A step in a signal is 

detected when two consecutive samples of the signal have a minimum difference to a 

moving average of the signal that is larger as scale times the standard deviation of the 

moving average with order “order”. 


expr Signal 

order order of the moving average filter 

scale scales the standard deviation sigma. 

# step detection in the acceleration pedal value 

# the moving average must be exceeded with at minimum 1.7 * Sigma 

# the moving average uses the 50 last time steps 

x = TPT.BooleanX(); 

x(t) := TPT.stepDetection(accleleration_pedal(t), 50, 1.7); 

2.9 Temporal regular expressions 

TPT.regexp(regexp re) 

This function defines a regular expression in TPT. A regular expression on the basis of the 

following operators can be defined in the braces. The function TPT.regexp() gives 

each interval where the expression is true. 

# search each interval where c is first 3 and then 4 

iv = TPT.Boolean(); 

iv := TPT.regexp([c(t) == 3] [c(t) == 4]); 

[timedExpr e] 

[timedExpr e]{float min} 

[timedExpr e]{float min, float max} 

This element is the basis of regular expressions. In the simplest case a time dependent 

logical expression is specified in brackets. 


iv := TPT.regexp([(t >= 1 and t < 2) or (t >= 4 and t < 7)]); 

# iv is defined in the interval [1,2) and [4,7) 

Optionally the minimum time of the matching intervals can be specified in curly braces. If 

the operation e is true in a given interval but is only true for a time shorter than min, it 

does not match.



iv := TPT.regexp([(t >= 1 and t < 2) or (t >= 4 and t < 7)]{2}); 

# iv is defined only in the interval [4,7) because [1,2) is shorter than 2 

Also a minimum and maximum time can be specified in curly braces. Only intervals of a 

minimum length will match. If the interval is longer than the maximum specified it will be 

set at the maximum. 


iv := TPT.regexp([(t >= 1 and t < 2) or (t >= 4 and t < 7)]{2,2}); 

# iv is defined in the interval [4,6) it is cut to length 2 

regexp1 regexp2 

As many regular expressions as desired can be written one after another without an 

explicit operator. The expressions will be evaluated in order left to right. 

# search each interval where c is first 3 and then 4 


iv := TPT.regexp([c(t) == 3] [c(t) == 4]); 

regexp? 

The suffix “?” helps to define expression that match conditionally. This means that the 

expression matches also to a void interval. 


iv := TPT.regexp([c(t) == 3] [c(t) == 5]? [c(t) == 4]); # 333444 or 33355444 

regexp+ 

The suffix “ + “ helps to define expressions that match at least once but also very often (1 

to n-times). 


iv := TPT.regexp(([c(t) == 3][c(t) == 2])+); # 3333222333222333222……… 

regexp* 

The suffix “ * “ helps to define expressions that match arbitrarily often (0- to n-times). 


iv := TPT.regexp(([c(t) == 3][c(t) == 2])*); # 3333222333222333222……… 

(regexp) 

Expressions can be parenthesized generating blocks using braces ‚(’ and ‚)’.



iv := TPT.regexp(([c(t) == 3][c(t) == 4])+); # 333444333444333444……… 

name := regexp 

Expressions in parentheses can be explicitly named in order to access the matched 

expression later on. 


iv := TPT.regexp(([c(t) == 3] cEquals4 := [c(t) == 4])+); # 

333444333444333444……… 

In this example cEquals4 is defined as a void variable. After the calculation the part 

intervals that match c(t)==4 are taken. 

regexp1 | regexp2 

This operator is used to match either the left or the right expression. 


iv := TPT.regexp(([c(t) == 3][c(t) == 4])|[c(t) == 5]); # 333444 oder 555555 

The example matches to intervals where c is first 3 and then 4 or constant 5. 

^regexp 

The prefix “^“ of a regular expression says that this expression must start at the very 

beginning of the actual time interval. 

iv1 = TPT.Boolean(); 

iv1 := TPT.regexp([t >= 1]); # matches to the interval [1, tende) 

iv2 = TPT.Boolean(); 

iv2 := TPT.regexp(^[t >= 1]); # doesn’t match since t >= 1 is not true at t=0 

regexp$ 

The suffix “$“ says that the expression must match until the very end of a time interval. 


iv := TPT.regexp([c(t) == 3]$); 

This expression matches only to intervals where in the actual context c(t) == 3 is true 

until the end of the interval.


2.10 Context intervals and the during operator 

2.10.1 During-Operator 

The during-operator gets a time interval as a parameter and is used in the same way as 

a Python keyword like (if, for etc.). An intersection of the actual assessment and the 

specified time interval is build. For each interval in the given intersection, the code of the 

during-block is executed. 

In other words the during-operator defines a interval of time where operations are 

evaluated similar to “while(time interval)”. This interval is the context interval. The 

definition of the time interval where the statements inside “during” can be done explicitly 

or implicitly. Within the during-statement the time is defined locally and starts with zero. 

Example explicit definition: 

# define the variable x 

x = TPT.Double(); 

during TPT.Interval(10ms, 100ms): 

# the actual context interval is limited to [10ms … 100ms) 

x(t) := sin(t*50)+1.0; 

# the function x(t) is evaluated for “local” times 0..90ms 

Example implicit definition: 

foo = TPT.Double (); 


foo := … 


overflowAmount = TPT.Double(); # create an assessment var of type `double` 

during overflow: 

overflowAmount := TPT.integral(foo(t)-100); # integrate the exceedance 

Example nested during:foo = TPT.Double (); 

bar = TPT.Boolean(); 

foo := … 

bar := … 

# assume, foo is defined in the interval [1, 17) and bar 

# is defined in the intervals [2,5) and [6,19) 

during foo: 

# the actual context interval is limited to [1,17). This block is executed 

# once 

[…] 

# nested during: 

during bar: 

# the actual context interval is limited to [2,5) resp [6,17). This 

# is executed twice 

[…]


2.10.2 “This” operator 

Within a context interval defined by “during” some operations on the interval itself can be 

executed. The pre-defined “interval variable” is named “This”. The executable operations 

are all operations that can be used for intervals (cf. Section 2.4). Useful are only some of 

these operations namely: 

• This.getEndTime() returns the last time value of the context interval. 

• This.getLength() returns the length of the context interval and is 

semantically the same as This.getEndTime(). 

• This.getRightLimit() returns the largest sampling-point of the interval. 

2.11 Transformations of the assessment pre-processor 

The pre-processor transforms all elements and statements of the assessment script that 

are not standard-python into standard python. It is generally possible to write assessment 

script in standard-Python but this code is much more complicated to understand 

2.11.1 Compatibility with former versions of TPT 

Since the language for test assessment has been consolidated and slightly redesigned to 

be easier to use, there are some important compatibility issues to know when upgrading 

from older TPT versions. 

A lot of additional features of the new Assessment language do not affect the behaviour 

of assessment scripts written with older versions (up to 2.4) of TPT. These features are 

described in the previous sections. 

In the following only those features are listed that must be considered when upgrading 

from TPT version 2.2 - 2.4 to version 2.6 or above. These features can be summarized as 

follows: 

• The distinction between assessment channels and assessment variables has been 

omitted 

• Meaning of time variable “t” has been consolidated 

The time „t“ within regular expressions is in TPT 2.6 the local time within the 

context-intervals. 

2.11.2 Obsolete assessment functions in TPT 2.6 

The following functions of the former assessment-versions should not be used anymore. 

variable.getStepSize() 

This function should not be used anymore. Please use TPT.getStepSize() ad. It 

returns the step-size independent of the variable. 

res = TPT.getStepSize(); # Abfrage der Schrittweite 

variable.left() 

This function should not be used anymore. Please use variable.getLeft() instead.


res = TPT.getLeft(); 

variable.right() 

This function should not be used anymore. Please use variable.getRight() instead. 

res = TPT.getRight(); 

number variable.getLeft () 

renamed to getLeftValue() 

number variable.getRight () 

renamed to getRightValue() 

## - Comment 

This function should not be used anymore. Please use variable.setComment() 

instead. 


… 

if cond: 

i(t) := sin(t); 

i.setComment(“i ist ein Sinuskanal“); 

else: 

i(t) := cos(t); 

i.setComment(“i ist ein Kosinuskanal“); 

variable.result 

Please use variable.setResult() instead. 

interval.getSize() 

This function doesn’t exist anymore please use interval.getSamplePointSize() 

instead. 

TPT.DoubleVariable([string varname]) 

dv = TPT.DoubleVariable() is identical to dv = TPT.Double(„dv“). 

TPT.FloatVariable([string varname]) 

Cf. TPT.DoubleVariable() 

TPT.Int8Variable([string varname]) 

Cf. TPT.DoubleVariable()


TPT.UInt8Variable([string varname]) 












TPT.BooleanVariable([string varname]) 


TPT.StringVariable([string varname]) 


TPT.VoidVariable([string varname]) 


TPT.DoubleChannel([string channelname]) 


TPT.FloatChannel([string channelname]) 


TPT.Int8Channel([string channelname]) 


TPT.UInt8Channel([string channelname]) 

Cf. TPT.DoubleVariable()












TPT.BooleanChannel([string channelname]) 


Channel.setName(string exportName) 

Please declare the Name with the declaration. 

variable record.getChannel(string variablename) 

Obsolete function. Use record.getVariable(string variablename) instead. 

record.getOverallTimeScope() 

Obsolete function. Use record.getCompleteInterval() instead. 

record PyTestRecord(string filename) 

Obsolete function. Use TPT.readRecord() instead. 

record TPT.TestRecord() 

Obsolete function. Use TPT. Record() instead. 

record PyTestRecord(string filenameToRead) 

Obsolete function. Use TPT. readRecord(filenameToRead) instead. 

TPT.writeExportRecord() 

Obsolete. Same as TPT.writeExportRecord(“testcase.tresult.tptbin”). 

Use this statement instead.


TPT.writeExportedRecord() 

Obsolete. Same as TPT.writeExportRecord(“testcase.tresult.tptbin”). Use 

this statement instead. 

TPT.writeExportedRecord(string filename) 

Obsolete. Same as TPT.writeExportRecord(filename). Use this statement 

instead. 

TPT.getExportedRecord() 

Obsolete (renamed). Same as TPT.getExportRecord(). 

TPT.clearExportRecord() 

Obsolete. 

TPT.clearExportedRecord() 

Obsolete.

TPT Assessment-Language - Tutorial and Reference Book - PikeTec

Create successful ePaper yourself

Delete template?

Save as template?