I/O System PlugIn
[PlugIns]

Classes

class  faudes::TioGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >
 Generator with I/O-system attributes. More...

Functions

bool faudes::IsIoSystem (const IoSystem &rIoSystem, StateSet &rQU, StateSet &rQY, StateSet &rQErr)
 Test whether the system satisfies basic I/O conditions.
bool faudes::IsIoSystem (IoSystem &rIoSystem)
 Test whether the system satisfies the IO conditions.
bool faudes::IsInputLocallyFree (const IoSystem &rIoSystem, StateSet &rQErr)
 Test whether the system has a locally free input.
bool faudes::IsInputLocallyFree (IoSystem &rIoSystem)
 Test whether the system has a locally free input.
void faudes::IoFreeInput (Generator &rIoSystem, const EventSet &rUAlph)
 Enable all input events for each input state.
void faudes::IoFreeInput (IoSystem &rIoSystem)
 Enable all input events for each input state.
void faudes::RemoveIoDummyStates (IoSystem &rIoSystem)
 Remove dummy states.
bool faudes::IsInputOmegaFree (const IoSystem &rIoSystem, StateSet &rQErr)
 Test whether the system behaviour exhibits a free input.
bool faudes::IsInputOmegaFree (IoSystem &rIoSystem)
 Test whether the system behaviour has exhibits a free input.

Detailed Description

Overview

This plug-in implements discrete event systems with alternating input and output events that satisfy Willems' conditions on I/O behaviours. Special attention is payed to non-closed languages and their not necessarily complete omega extensions.

A detailed discussion on the subject is given in Thomas Wittmann's Diploma Thesis, including how the results relate to earlier work of Moor/Raisch on abstraction based control of hybrid systems. A technical report has been submitted for publication and is currently under review. For a consise introduction, see the libFAUDES user reference, section IoSystem.

License

This plug-in is distributed with libFAUDES and under the terms of the LGPL.


Copyright (C) 2010 Thomas Wittmann, Thomas Moor


Function Documentation

void faudes::IoFreeInput ( IoSystem &  rIoSystem  ) 

Enable all input events for each input state.

Alternative interface to IoFreeInput(Generator&, const EventSet&), which extracts the input alphabet from the given IO System.

Parameters:
rIoSystem Generator argument.
void faudes::IoFreeInput ( Generator &  rIoSystem,
const EventSet &  rUAlph 
)

Enable all input events for each input state.

If this procedure detetecs a state with some but not all input events enabled, an error state is introduced and transitions with the missing input events are inserted. The error state is setup to allow any alternating sequence of input and output events.

Note that his procedure only ensures a locally free input. It does not guarantee a free input in the behavioural sense.

It is considered an error if the specified set of input events is not contained in the generator alphabet.

Parameters:
rIoSystem Generator argument.
rUAlph Input alphabet
Exceptions:
Exception 
  • Alphabets don't match (id 100)
bool faudes::IsInputLocallyFree ( IoSystem &  rIoSystem  ) 

Test whether the system has a locally free input.

See also bool IsInputLocallyFree(const IoSystem&,StateSet&). This version will set the state error attribute to the set of critical states.

Parameters:
rIoSystem Generator to test.
Returns:
True <> system has a locally-free input
bool faudes::IsInputLocallyFree ( const IoSystem &  rIoSystem,
StateSet &  rQErr 
)

Test whether the system has a locally free input.

The procedure returns True, if every state that enables some input event enables all input events. If the system in addition satisfies the basic I/O properties, a locally free input implies that the behaviour induced by the generated closed language exhibits a free input in the behavioural sense. This implication does not hold for the behaviour induced by the marked language.

If the test fails, any critical states are returned in rQErr.

Parameters:
rIoSystem Generator to test.
rQErr Error states.
Returns:
True <> system has an omega-free input
bool faudes::IsInputOmegaFree ( IoSystem &  rIoSystem  ) 

Test whether the system behaviour has exhibits a free input.

See also bool IsInputOmegaFree(const IoSystem&,StateSet&). This version will set the error flag for stytes that conflict with a free input.

Parameters:
rIoSystem Generator to test.
Returns:
True <> system has an omega-free input
bool faudes::IsInputOmegaFree ( const IoSystem &  rIoSystem,
StateSet &  rQErr 
)

Test whether the system behaviour exhibits a free input.

The procedure assumes that the specified system satisfies the basic I/O properties. It returns True, if it has a locally free input and additionally can allways control its output to reach a marked state. Technically, the latter condition can be stated as a controllability condition, referring to the notion of omega-controllabilaty in the definition of Thistle/Wonham.

This implementation performs the test in that it iteratively constructs a set of "good" states: a state is good, if

  • it is marked, or
  • it can be controlled to a good state by disableing output events

If all reachable states are good, the test is passed. Else, all other state are reported as error states.

Parameters:
rIoSystem Generator to test.
rQErr Error states.
Returns:
True <> system has an omega-free input
bool faudes::IsIoSystem ( IoSystem &  rIoSystem  ) 

Test whether the system satisfies the IO conditions.

Performs the same tests as bool IsIoSystem(const IoSystem&,StateSet&,StateSet&,StateSet&), but does set the state attributes accordingly.

Parameters:
rIoSystem Generator to test.
Returns:
True <> system is an io system.
bool faudes::IsIoSystem ( const IoSystem &  rIoSystem,
StateSet &  rQU,
StateSet &  rQY,
StateSet &  rQErr 
)

Test whether the system satisfies basic I/O conditions.

The I/O conditions tested are

  • Lm(G) is complete (each string can be extended);
  • U and Y are a disjoint decomposition of Sigma;
  • neither U nor Y is empty;
  • U and Y events alternate;

To test the last propertie, the procedure partitions the state set in states QU that enable input events and states QY that enables output-put events. The latter two state sets are returned in rQY and rQU. States that either block or enable both input and outputs are return in rQErr.

Note: this procedure is not concerned with whether the first event should be an input or an output; neither does it require the input to be free; see bool IsInputLocallyFree(IoSystem&).

Note: this procedure does not set the state attributes; see also bool IsIoSystem(IoSystem&).

Parameters:
rIoSystem Generator to test.
rQY Output states
rQU Input states
rQErr Undecided states
Returns:
True <> system is an io system.
void faudes::RemoveIoDummyStates ( IoSystem &  rIoSystem  ) 

Remove dummy states.

Parameters:
rIoSystem Generator argument.

libFAUDES 2.23h --- 2014.04.03 --- c++ api documentaion by doxygen