libFAUDES
Sections
Index
|
faudes Namespace Reference
libFAUDES resides within the namespace faudes.
More...
Classes |
class | TaBaseSet |
| Set with nontrivial attributes. More...
|
class | TaGenerator |
| Generator with specified attribute types. More...
|
class | AttributeVoid |
| Minimal Attribute. More...
|
class | AttributeFlags |
| Boolean flags Attribute. More...
|
class | TBaseSet |
| STL style set template. More...
|
class | vBaseVector |
| Vector bass class. More...
|
class | TBaseVector |
| Vector template. More...
|
class | AttributeCFlags |
| Attribute class to model event controllability properties. More...
|
class | TcGenerator |
| Compatibility: pre 2.20b used cEventSet as C++ class name. More...
|
class | Integer |
| Elementary type. More...
|
class | String |
| Elementary type. More...
|
class | Boolean |
| Elementary type. More...
|
class | Exception |
| Faudes exception class. More...
|
class | Parameter |
| Structure to model a parameter type within the Signature of a Function. More...
|
class | Signature |
| Signature of a Function. More...
|
class | FunctionDefinition |
| A FunctionDefinition defines the interface to a faudes-function. More...
|
class | Function |
| A faudes-function hosts parameter values of some faudes type and provides a method to perform an operation on the specified paramters, e.g. More...
|
class | vGenerator |
| Base class of all FAUDES generators. More...
|
class | SccFilter |
| Filter for strictly connected components (SCC) search/compute routines. More...
|
class | ConsoleOut |
| Console Out. More...
|
class | ObjectCount |
| Debugging counter. More...
|
class | IndexSet |
| Set of indices. More...
|
class | TaIndexSet |
| Set of indices with attributes. More...
|
class | NameSet |
| Set of indices with symbolic names. More...
|
class | TaNameSet |
| Set of indices with symbolic names and attributes. More...
|
class | OPState |
class | ProductCompositionMap |
| Rti-wrapper for reverse composition maps. More...
|
class | TypeRegistry |
| The TypeRegistry registers faudes-types. More...
|
class | AutoRegisterType |
| Auto register faudes-type with specified type name. More...
|
class | AutoRegisterXElementTag |
class | FunctionRegistry |
| The FunctionRegistry registers faudes-functions. More...
|
class | SymbolSet |
| Set of symbols. More...
|
class | SymbolTable |
| A SymbolTable associates sybolic names with indices. More...
|
class | Token |
| Tokens model atomic data for stream IO. More...
|
class | TokenReader |
| A TokenReader reads sequential tokens from a file or string. More...
|
class | TokenWriter |
| A TokenWriter writes sequential tokens to a file, a string or stdout. More...
|
class | Transition |
| Triple (X1,Ev,X2) to represent current state, event and next state. More...
|
class | TransSort |
| Alternative ordering of Transitions. More...
|
class | TTransSet |
| Set of Transitions. More...
|
class | TaTransSet |
| Set of Transitions with attributes. More...
|
class | Type |
| Base class of all libFAUDES objects that participate in the run-time interface. More...
|
class | Documentation |
| faudes type implementation macros, overall, debug version More...
|
class | TypeDefinition |
| A TypeDefinition defines a faudes-type in that it specifies a faudes-type name to identify the type and a method NewObject() to instantiate objects of the respective type. More...
|
struct | ReductionStateInfo |
| Data structure for identifying states in the same coset for supervisor reduction. More...
|
class | OPSState |
class | Bisimulation |
| This class implements the algorithms needed for the computation of the coarsest quasi-congruence (=Bisimulation) of a given generator. More...
|
class | EventRelabelMap |
| Rti convenience wrapper for relabeling maps. More...
|
struct | Partition |
| This struct implements a coset (=equivalence class) as needed for the computation of the coarsest quasi-congruence on an automaton. More...
|
class | AttributeDiagnoserState |
| Implements state estimates for the current status of the generator. More...
|
class | AttributeFailureEvents |
| Stores the failure and indicator events for a particular failure type. More...
|
class | AttributeFailureTypeMap |
| Partitions the failure and indicator events. More...
|
class | DiagLabelSet |
| Implements the label representation for state estimates. More...
|
struct | CoVerifierState |
class | TdiagGenerator |
| Provides the structure and methods to build and handle diagnosers. More...
|
struct | VerifierState |
class | HioEventFlags |
| Event attributes for hierarchical discrete event systems with inputs and outputs. More...
|
class | HioStateFlags |
| State attributes for hierarchical discrete event systems with inputs and outputs. More...
|
class | THioConstraint |
| Generator with I/O-constraint attributes. More...
|
class | THioController |
| Generator with I/O-controller attributes. More...
|
class | THioEnvironment |
| Generator with I/O-environment attributes. More...
|
class | HioModule |
| Recurring structure in hierarchies designed according to the I/O based DES framework. More...
|
class | THioPlant |
| Generator with I/O-plant attributes. More...
|
class | AttributeIosEvent |
| Attributes for events in DES with in- and outputs. More...
|
class | AttributeIosState |
| Attributes for states in DESs with in- and outputs. More...
|
class | TioGenerator |
| Generator with I/O-system attributes. More...
|
class | AttributeColoredState |
| State attributes for multitasking automata. More...
|
class | ColorSet |
| Container for colors: this is a NameSet with its own static symboltable. More...
|
class | TmtcGenerator |
| Allows to create colored marking generators (CMGs) as the common five tupel consisting of alphabet, stateset, transition relation, initial states, marked states, and attributes for state and event properties. More...
|
class | adjlist |
class | AttributeTimedTrans |
| Transition Attribute with guard and resets. More...
|
class | AttributeTimedState |
| State attribute with invariant. More...
|
class | AttributeTimedGlobal |
| Globat attribute with clockset. More...
|
class | TtGenerator |
| Generator with timing extensions. More...
|
class | ClockSet |
| Container class to model a set of clocks. More...
|
class | ElemConstraint |
| Model of an elementary clock constraint formula. More...
|
class | TimeConstraint |
| A TimeConstraint is a set of elementary clock constraints. More...
|
class | tpTime |
| Type to represent time. More...
|
class | TimeInterval |
| Model of a time interval. More...
|
class | DiscreteDensityFunction |
| Density Function. More...
|
class | SampledDensityFunction |
class | DeviceExecutor |
| Executer with IO device to handle external/physical events. More...
|
struct | TimedEvent |
| Global Tyoedefs. More...
|
class | Executor |
| An Executor is a timed generator that maintains a current state. More...
|
class | LoggingExecutor |
| Executor with logging facilities. More...
|
class | ParallelExecutor |
| Synchronized parallel execution of TimedGenerators. More...
|
class | ProposingExecutor |
| Executer that proposes which transition to execute. More...
|
class | SimEventCondition |
| Defining data of event based simulation condition. More...
|
class | SimStateCondition |
| Defining data of state based simulation condition. More...
|
class | AttributeSimCondition |
| Attribute for a simulation condition. More...
|
class | SimConditionSet |
| Set of simulation named conditions. More...
|
class | SimPriorityEventAttribute |
| Defining data to prioritise events. More...
|
class | SimStochasticEventAttribute |
| Defining data of stochastic behaviour. More...
|
class | SimEventAttribute |
| Attribute for an event in the context of simulation. More...
|
class | AttributeSignalOutput |
| Configuration of a signal based output mapping. More...
|
class | AttributeSignalInput |
| Configuration of a signal based input mapping. More...
|
class | AttributeSignalEvent |
| Configuration of a signal based input or output. More...
|
class | sDevice |
| An sDevice implements signal based semantics for faudes events. More...
|
class | SimplenetAddress |
| Simplenet node address. More...
|
class | AttributeSimplenetOutput |
| Configuration of a network output mapping. More...
|
class | AttributeSimplenetInput |
| Configuration of a network input mapping. More...
|
class | AttributeSimplenetEvent |
| Configuration of a networked input or output. More...
|
class | nDevice |
| An nDevice implements networked IO via a simple tcp/ip protocol. More...
|
class | AttributeDeviceEvent |
| Attribute for the configuration of a input or output mapping. More...
|
class | vDevice |
| Virtual base class to define the interface for event io. More...
|
class | xDevice |
| Container of devices. More...
|
struct | swig_cast_info |
struct | swig_type_info |
struct | swig_lua_userdata |
class | LuaFunctionDefinition |
| A LuaFunctionDefinition is derived from FanctionDefinition to define a faudes-function by a Lua script. More...
|
class | LuaState |
class | LuaFunction |
| A LuaFunction is a faudes-function that executes a luafaudes script. More...
|
Typedefs |
typedef unsigned long int | fType |
| Convenience typdef flag data.
|
typedef TaNameSet
< AttributeCFlags > | Alphabet |
| Convenience typedef for event sets with controllability attributes.
|
typedef TBaseVector< Alphabet > | AlphaberVector |
| Convenience typedef.
|
typedef TcGenerator
< AttributeVoid, AttributeVoid,
AttributeCFlags, AttributeVoid > | System |
| Convenience typedef for std System.
|
typedef TBaseVector< System > | SystemVector |
| Convenience typedef for vectors of systems.
|
typedef long unsigned int | Idx |
| Type definition for index type.
|
typedef long int | SignedIdx |
| Type definition for signed index type.
|
typedef TBaseVector< Integer > | IntegerVector |
typedef vGenerator | Generator |
| Plain generator, api typedef for generator with no attributes.
|
typedef TBaseVector< Generator > | GeneratorVector |
| Convenience typedef for vectors og generators.
|
typedef IndexSet | StateSet |
typedef NameSet | EventSet |
| Convenience typedef for plain event sets.
|
typedef TBaseVector< EventSet > | EventSetVector |
typedef TTransSet
< TransSort::X1EvX2 > | TransSet |
| Type definition for default sorted TTransSet.
|
typedef TTransSet
< TransSort::X1EvX2 > | TransSetX1EvX2 |
| Type definition for default sorted TTransSet.
|
typedef TTransSet
< TransSort::EvX1X2 > | TransSetEvX1X2 |
| Type definition for ev, x1, x2 sorted TTransSet.
|
typedef TTransSet
< TransSort::EvX2X1 > | TransSetEvX2X1 |
| Type definition for ev, x2, x1 sorted TTransSet.
|
typedef TTransSet
< TransSort::X2EvX1 > | TransSetX2EvX1 |
| Type definition for x2, ev, x1 sorted TTransSet.
|
typedef TTransSet
< TransSort::X2X1Ev > | TransSetX2X1Ev |
| Type definition for x2, x1, ev sorted TTransSet.
|
typedef TTransSet
< TransSort::X1X2Ev > | TransSetX1X2Ev |
| Type definition for x1, x2, ev sorted TTransSet.
|
typedef TdiagGenerator
< AttributeFailureTypeMap,
AttributeDiagnoserState,
AttributeCFlags, AttributeVoid > | Diagnoser |
typedef THioConstraint
< AttributeVoid, HioStateFlags,
HioEventFlags, AttributeVoid > | HioConstraint |
typedef THioController
< AttributeVoid, HioStateFlags,
HioEventFlags, AttributeVoid > | HioController |
typedef THioEnvironment
< AttributeVoid, HioStateFlags,
HioEventFlags, AttributeVoid > | HioEnvironment |
typedef THioPlant
< AttributeVoid, HioStateFlags,
HioEventFlags, AttributeVoid > | HioPlant |
typedef TaNameSet
< AttributeIosEvent > | IosEventSet |
typedef TaIndexSet
< AttributeIosState > | IosStateSet |
typedef TioGenerator
< AttributeVoid,
AttributeIosState,
AttributeIosEvent,
AttributeVoid > | IoSystem |
typedef TmtcGenerator
< AttributeVoid,
AttributeColoredState,
AttributeCFlags, AttributeVoid > | MtcSystem |
typedef TtGenerator
< AttributeTimedGlobal,
AttributeTimedState,
AttributeCFlags,
AttributeTimedTrans > | TimedGenerator |
| Convenience typedef for std TimedGenerator.
|
typedef void | vDevice |
| Dummy typedef in the absence of the IO Device plugin.
|
typedef TaNameSet
< SimEventAttribute > | sEventSet |
| Typedef for events with simulation attributes.
|
typedef void *(* | swig_converter_func )(void *, int *) |
typedef struct swig_type_info *(* | swig_dycast_func )(void **) |
typedef struct
faudes::swig_cast_info | swig_cast_info |
typedef struct
faudes::swig_type_info | swig_type_info |
Enumerations |
enum | VerifierStateLabel { NORMAL,
CONFUSED,
BLOCK
} |
Functions |
template<class T , class Cmp > |
void | SetUnion (const TBaseSet< T, Cmp > &rSetA, const TBaseSet< T, Cmp > &rSetB, TBaseSet< T, Cmp > &rRes) |
template<class T , class Cmp > |
void | SetIntersection (const TBaseSet< T, Cmp > &rSetA, const TBaseSet< T, Cmp > &rSetB, TBaseSet< T, Cmp > &rRes) |
template<class T , class Cmp > |
void | SetDifference (const TBaseSet< T, Cmp > &rSetA, const TBaseSet< T, Cmp > &rSetB, TBaseSet< T, Cmp > &rRes) |
template<class T , class Cmp > |
bool | SetEquality (const TBaseSet< T, Cmp > &rSetA, const TBaseSet< T, Cmp > &rSetB) |
template<class T , class Cmp > |
bool | SetInclusion (const TBaseSet< T, Cmp > &rSetA, const TBaseSet< T, Cmp > &rSetB) |
long int | IntegerSum (const Integer &arg1, const Integer &arg2) |
long int | IntegerSum (const IntegerVector &intvect) |
bool | IsAccessible (const vGenerator &rGen) |
| RTI wrapper function.
|
bool | IsCoaccessible (const vGenerator &rGen) |
| RTI wrapper function.
|
bool | IsTrim (const vGenerator &rGen) |
| RTI wrapper function.
|
bool | IsOmegaTrim (const vGenerator &rGen) |
| RTI wrapper function.
|
bool | IsComplete (const vGenerator &rGen) |
| RTI wrapper function.
|
bool | IsComplete (const vGenerator &rGen, const StateSet &rStateSet) |
bool | IsDeterministic (const vGenerator &rGen) |
| RTI wrapper function.
|
void | Accessible (vGenerator &rGen) |
| RTI wrapper function.
|
void | Accessible (const vGenerator &rGen, vGenerator &rRes) |
| RTI wrapper function.
|
void | Coaccessible (vGenerator &rGen) |
| RTI wrapper function.
|
void | Coaccessible (const vGenerator &rGen, vGenerator &rRes) |
| RTI wrapper function.
|
void | Complete (vGenerator &rGen) |
| RTI wrapper function.
|
void | Complete (const vGenerator &rGen, vGenerator &rRes) |
| RTI wrapper function.
|
void | Trim (vGenerator &rGen) |
| RTI wrapper function.
|
void | Trim (const vGenerator &rGen, vGenerator &rRes) |
| RTI wrapper function.
|
void | OmegaTrim (vGenerator &rGen) |
| RTI wrapper function.
|
void | OmegaTrim (const vGenerator &rGen, vGenerator &rRes) |
| RTI wrapper function.
|
void | MarkAllStates (vGenerator &rGen) |
| RTI wrapper function.
|
void | AlphabetExtract (const vGenerator &rGen, EventSet &rRes) |
| RTI wrapper function.
|
void | SetIntersection (const GeneratorVector &rGenVec, EventSet &rRes) |
| RTI convenience function.
|
void | SetUnion (const GeneratorVector &rGenVec, EventSet &rRes) |
| RTI convenience function.
|
void | SetIntersection (const vGenerator &rGenA, const vGenerator &rGenB, EventSet &rRes) |
| RTI convenience function.
|
void | SetUnion (const vGenerator &rGenA, const vGenerator &rGenB, EventSet &rRes) |
| RTI convenience function.
|
void | SetDifference (const vGenerator &rGenA, const vGenerator &rGenB, EventSet &rRes) |
| RTI convenience function.
|
void | SearchScc (const Idx vState, int &vRcount, const Generator &rGen, const SccFilter &rFilter, StateSet &rTodo, std::stack< Idx > &rStack, StateSet &rStackStates, std::map< const Idx, int > &rDfn, std::map< const Idx, int > &rLowLnk, std::list< StateSet > &rSccList, StateSet &rRoots) |
| Search for strongly connected components (SCC).
|
bool | ComputeScc (const Generator &rGen, const SccFilter &rFilter, std::list< StateSet > &rSccList, StateSet &rRoots) |
| Compute strongly connected components (SCC).
|
bool | ComputeScc (const Generator &rGen, std::list< StateSet > &rSccList, StateSet &rRoots) |
| Compute strongly connected components (SCC).
|
bool | HasScc (const Generator &rGen, const SccFilter &rFilter, StateSet &rScc) |
| Test for strongly connected components (SCC).
|
bool | HasScc (const Generator &rGen, const SccFilter &rFilter) |
| Test for strongly connected components (SCC).
|
std::string | ToStringInteger (long int number) |
| integer to string
|
std::string | ToStringInteger16 (long int number) |
| integer to string base 16
|
std::string | ToStringFloat (double number) |
| float to string
|
std::string | ExpandString (const std::string &rString, unsigned int len) |
| Fill string with spaces up to a given length if length of the string is smaller than given length parameter.
|
std::string | CollapsString (const std::string &rString, unsigned int len=FD_MAXCONTAINERNAME) |
| Limit length of string, return head and tail of string.
|
Idx | ToIdx (const std::string &rString) |
| Convert a string to Idx.
|
std::string | StringSubstitute (const std::string &rString, const std::string &rFrom, const std::string &rTo) |
| Substitute in string.
|
std::string | FDVersionString () |
| Return FAUDES_VERSION as std::string.
|
std::string | FDPluginsString () |
| Return FAUDES_PLUGINS as std::string.
|
std::string | FDContributorsString () |
| Return contributors as std::string.
|
void | ProcessDot (const std::string &rDotFile, const std::string &rOutFile, const std::string &rOutFormat="", const std::string &rDotExec="dot") |
| Convenience function: process dot file to graphics output.
|
std::string | CreateTempFile (void) |
| Create a temp file, length 0.
|
bool | RemoveFile (const std::string &rFileName) |
| Delete a file.
|
const std::string & | DirSeparator (void) |
| Std dir-separator.
|
std::string | ExtractDirectory (const std::string &rFullPath) |
| Extract directory from full path.
|
std::string | ExtractFilename (const std::string &rFullName) |
| Extract file name from full path.
|
std::string | ExtractBasename (const std::string &rFullName) |
| Extract file name from full path.
|
std::string | ExtractExtension (const std::string &rFullName) |
| Extract file name from full path.
|
std::string | PrependDirectory (const std::string &rDirectory, const std::string &rFileName) |
| Construct full path from directory and filename.
|
std::set< std::string > | ReadDirectory (const std::string &rDirectory) |
| Read the contents of the specified directors.
|
bool | FileExists (const std::string &rFilename) |
| Test existence of file.
|
void | ExitFunction (void) |
std::string | TestProtocol (const std::string &rSource) |
| Test Protocol.
|
void | TestProtocol (const std::string &rMessage, const Type &rData, bool core=false) |
| Test Protocol.
|
void | TestProtocol (const std::string &rMessage, bool data) |
| Test Protocol.
|
void | TestProtocol (const std::string &rMessage, long int data) |
| Test Protocol.
|
void | TestProtocol (const std::string &rMessage, const std::string &data) |
| Test Protocol.
|
bool | TestProtocol (void) |
| Test Protocol.
|
void | LoopCallback (bool pBreak(void)) |
void | LoopCallback (void) |
| Algorithm loop callback.
|
void | LoopCallback (bool(*pBreakFnct)(void)) |
| Algorithm loop callback.
|
StateSet | LowExitStates (const Generator &rLowGen, const EventSet &rHighAlph, const std::map< Idx, StateSet > &rEntryStatesMap, const TransSetX2EvX1 &rLowRevTransRel, Idx highState) |
| LowExitStates return-copy function:
|
void | LowExitStates (const EventSet &rHighAlph, const std::map< Idx, StateSet > &rEntryStatesMap, const TransSetX2EvX1 &rLowRevTransRel, Idx highState, StateSet &rLowExitStates) |
| LowExitStates call-by-reference function:
|
EventSet | ReachableEvents (const Generator &rLowGen, const EventSet &rHighAlph, Idx lowState) |
| ReachableEvents return-copy function:
|
void | ReachableEvents (const Generator &rLowGen, const EventSet &rHighAlph, Idx lowState, EventSet &rReachableEvents) |
| ReachableEvents call-by-reference function:
|
void | LocalCoaccessibleReach (const TransSetX2EvX1 &rRevTransRel, const EventSet &rHighAlph, Idx lowState, StateSet &rCoaccessibleReach) |
| Compute the coaccessible reach for a local automaton.
|
void | LocalAccessibleReach (const Generator &rLowGen, const EventSet &rHighAlph, Idx lowState, StateSet &rAccessibleReach) |
| Compute the accessible reach for a local automaton.
|
void | aOmegaParallel (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Parallel composition with relaxed acceptance condition.
|
void | OmegaParallel (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Parallel composition with relaxed acceptance condition.
|
void | OmegaClosure (Generator &rGen) |
| Topological closure.
|
bool | IsOmegaClosed (const Generator &rGen) |
| Test for topologically closed omega language.
|
void | Parallel (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Parallel composition.
|
void | aParallel (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Parallel composition.
|
void | aParallel (const GeneratorVector &rGenVec, Generator &rResGen) |
| Parallel composition.
|
void | aParallel (const Generator &rGen1, const Generator &rGen2, ProductCompositionMap &rCompositionMap, Generator &rResGen) |
| Parallel composition.
|
void | Parallel (const Generator &rGen1, const Generator &rGen2, ProductCompositionMap &rCompositionMap, Generator &rResGen) |
| Parallel composition.
|
void | Parallel (const Generator &rGen1, const Generator &rGen2, ProductCompositionMap &rCompositionMap, StateSet &rMark1, StateSet &rMark2, Generator &rResGen) |
| Parallel composition.
|
void | Parallel (const Generator &rGen1, const Generator &rGen2, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, Generator &rResGen) |
| Parallel composition.
|
void | Product (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Product composition.
|
void | aProduct (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Product composition.
|
void | aProduct (const Generator &rGen1, const Generator &rGen2, ProductCompositionMap &rCompositionMap, Generator &rResGen) |
| Product composition.
|
void | Product (const Generator &rGen1, const Generator &rGen2, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, StateSet &rMark1, StateSet &rMark2, Generator &rResGen) |
| Product composition.
|
void | Product (const Generator &rGen1, const Generator &rGen2, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, Generator &rResGen) |
| Product composition.
|
void | SetComposedStateNames (const Generator &rGen1, const Generator &rGen2, const std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, Generator &rGen12) |
| Helper: uses reverse composition map to track state names in a paralell composition.
|
void | CompositionMap1 (const std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, std::map< Idx, Idx > &rCompositionMap) |
void | CompositionMap2 (const std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, std::map< Idx, Idx > &rCompositionMap) |
void | UniqueInit (Generator &rGen) |
| Make initial states unique.
|
void | UniqueInit (const Generator &rGen, Generator &rResGen) |
| Make initial states unique.
|
void | Deterministic (const Generator &rGen, Generator &rResGen) |
| Make generator deterministic.
|
void | aDeterministic (const Generator &rGen, Generator &rResGen) |
| Make generator deterministic.
|
void | Deterministic (const Generator &rGen, std::map< Idx, StateSet > &rEntryStatesMap, Generator &rResGen) |
| Make generator deterministic.
|
void | Deterministic (const Generator &rGen, std::vector< StateSet > &rPowerStates, std::vector< Idx > &rDetStates, Generator &rResGen) |
| Make generator deterministic.
|
void | ProjectNonDet (Generator &rGen, const EventSet &rProjectAlphabet) |
| Language projection.
|
void | aProjectNonDet (Generator &rGen, const EventSet &rProjectAlphabet) |
| Language projection.
|
void | Project (const Generator &rGen, const EventSet &rProjectAlphabet, Generator &rResGen) |
| Minimized deterministic projection.
|
void | aProject (const Generator &rGen, const EventSet &rProjectAlphabet, Generator &rResGen) |
| Minimized deterministic projection.
|
void | Project (const Generator &rGen, const EventSet &rProjectAlphabet, std::map< Idx, StateSet > &rEntryStatesMap, Generator &rResGen) |
| Minimized Deterministic projection.
|
void | InvProject (Generator &rGen, const EventSet &rProjectAlphabet) |
| Inverse projection.
|
void | aInvProject (Generator &rGen, const EventSet &rProjectAlphabet) |
| Inverse projection.
|
void | aInvProject (const Generator &rGen, const EventSet &rProjectAlphabet, Generator &rResGen) |
| Inverse projection.
|
void | CreateEntryStatesMap (const std::map< StateSet, Idx > &rRevEntryStatesMap, std::map< Idx, StateSet > &rEntryStatesMap) |
void | LoadRegistry (const std::string &rPath="") |
| Load all registered types and functions.
|
void | SaveRegistry (const std::string &rPath="") |
| Dump all registered types and functions.
|
void | ClearRegistry (void) |
| Clear all registry.
|
Type * | NewFaudesObject (const std::string &rTypeName) |
| Instantiate faudes typed objects by type name.
|
Function * | NewFaudesFunction (const std::string &rFunctName) |
| Instantiate faudes function objects by function name.
|
const std::string & | FaudesTypeName (const Type &rObject) |
| Query type name.
|
bool | FaudesTypeTest (const std::string &rTypeName, const Type &rObject) |
| Test type compatibility.
|
const std::string & | FaudesFunctionName (const Function &rObject) |
const std::string & | FaudesFunctionName (const Type &rObject) |
| Query function name.
|
void | LanguageUnionNonDet (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Language union, nondeterministic version.
|
void | LanguageUnion (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Language union, deterministic version.
|
void | LanguageUnion (const GeneratorVector &rGenVec, Generator &rResGen) |
| Language union.
|
void | LanguageIntersection (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Language intersection.
|
void | LanguageIntersection (const GeneratorVector &rGenVec, Generator &rResGen) |
| Language intersection.
|
bool | EmptyLanguageIntersection (const Generator &rGen1, const Generator &rGen2) |
| Test for empty language intersection (same as Disjoind()).
|
bool | LanguageDisjoint (const Generator &rGen1, const Generator &rGen2) |
| Test whether two languages are disjoint.
|
void | Automaton (Generator &rGen, const EventSet &rAlphabet) |
| Convert generator to automaton wrt specified alphabet.
|
void | Automaton (Generator &rGen) |
| Convert generator to automaton.
|
void | LanguageComplement (Generator &rGen, const EventSet &rAlphabet) |
| Language complement wrt specified alphabet.
|
void | LanguageComplement (Generator &rGen) |
| Language complement.
|
void | LanguageComplement (const Generator &rGen, Generator &rRes) |
| Language Complement (uniform API wrapper).
|
void | LanguageComplement (const Generator &rGen, const EventSet &rSigma, Generator &rRes) |
| Language Complement (uniform API wrapper).
|
void | LanguageDifference (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Language difference (set-theoretic difference).
|
void | LanguageConcatenateNonDet (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Language concatenation, nondeterministic version.
|
void | LanguageConcatenate (const Generator &rGen1, const Generator &rGen2, Generator &rResGen) |
| Language concatenation, deterministic version.
|
void | FullLanguage (const EventSet &rAlphabet, Generator &rResGen) |
| Full Language, L(G)=Lm(G)=Sigma*.
|
void | AlphabetLanguage (const EventSet &rAlphabet, Generator &rResGen) |
| Alphabet Language, L(G)=Lm(G)=Sigma.
|
void | EmptyStringLanguage (const EventSet &rAlphabet, Generator &rResGen) |
| Empty string language, L(G)=Lm(G)={epsilon}.
|
void | EmptyLanguage (const EventSet &rAlphabet, Generator &rResGen) |
| Empty language Lm(G)={}.
|
bool | IsEmptyLanguage (const Generator &rGen) |
| Test for Empty language Lm(G)=={}.
|
bool | LanguageInclusion (const Generator &rGen1, const Generator &rGen2) |
| Test language inclusion, Lm1<=Lm2.
|
bool | LanguageEquality (const Generator &rGen1, const Generator &rGen2) |
| Language equality, Lm1==Lm2.
|
void | KleeneClosure (Generator &rGen) |
| Kleene Closure.
|
void | KleeneClosure (const Generator &rGen, Generator &rResGen) |
| Kleene Closure.
|
void | KleeneClosureNonDet (Generator &rGen) |
| Kleene Closure, nondeterministic version.
|
void | PrefixClosure (Generator &rGen) |
| Prefix Closure.
|
bool | IsPrefixClosed (const Generator &rGen) |
| Test for prefix closed marked language.
|
bool | IsNonblocking (const Generator &rGen) |
| Test for nonblocking generator.
|
bool | IsNonblocking (const Generator &rGen1, const Generator &rGen2) |
| Test for nonblocking marked languages.
|
void | SelfLoop (Generator &rGen, const EventSet &rAlphabet) |
| Self-loop all states.
|
void | SelfLoopMarkedStates (Generator &rGen, const EventSet &rAlphabet) |
| Self-loop all marked states.
|
void | SelfLoop (Generator &rGen, const EventSet &rAlphabet, const StateSet &rStates) |
| Self-loop specified states.
|
void | StateMin (const Generator &rGen, Generator &rResGen) |
| State set minimization.
|
void | aStateMin (const Generator &rGen, Generator &rResGen) |
| State set minimization.
|
void | aStateMin (Generator &rGen) |
| State set minimization.
|
void | StateMin (Generator &rGen, Generator &rResGen) |
| State set minimization.
|
void | StateMin (Generator &rGen, Generator &rResGen, std::vector< StateSet > &rSubsets, std::vector< Idx > &rNewIndices) |
| State set minimization.
|
bool | IsRelativelyMarked (const Generator &rGenPlant, const Generator &rGenCand) |
| Test for relative marking.
|
bool | IsRelativelyPrefixClosed (const Generator &rGenPlant, const Generator &rGenCand) |
| Test for relative prefix-closedness.
|
bool | IsRelativelyOmegaMarked (const Generator &rGenPlant, const Generator &rGenCand) |
| Test for relative marking, omega langauges.
|
bool | IsRelativelyOmegaClosed (const Generator &rGenPlant, const Generator &rGenCand) |
| Test for relative closedness, omega languages.
|
bool | IsRelativelyOmegaClosedUnchecked (const Generator &rGenPlant, const Generator &rGenCand) |
| Test for relative closedness, omega languages.
|
void | SupConUnchecked (const Generator &rPlantGen, const EventSet &rCAlph, Generator &rSupCandGen) |
| Supremal Controllable Sublangauge (internal function).
|
bool | IsControllableUnchecked (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, StateSet &rCriticalStates) |
| Controllability (internal function).
|
void | SupconParallel (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, Generator &rResGen) |
| Parallel composition optimized for the purpose of SupCon (internal function).
|
void | SupConNBUnchecked (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, Generator &rResGen) |
| Nonblocking Supremal Controllable Sublanguage (internal function).
|
void | ControlProblemConsistencyCheck (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen) |
| Consistency check for controlproblem input data.
|
bool | IsControllable (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSupCandGen) |
| Test controllability.
|
bool | IsControllable (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSupCandGen, StateSet &rCriticalStates) |
| Test controllability.
|
void | SupConNB (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, Generator &rResGen) |
| Nonblocking Supremal Controllable Sublanguage.
|
void | SupConNBNonDet (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, Generator rDetPlantGen, Generator rDetSpecGen, std::map< Idx, StateSet > &rPowerStatesPlant, std::map< Idx, StateSet > &rPowerStatesSpec, bool &rDetPlantBool, bool &rDetSpecBool, Generator &rResGen) |
| Nonblocking Supremal Controllable Sublanguage.
|
void | SupCon (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, Generator &rResGen) |
| Supremal Controllable Sublanguage.
|
void | SupCon (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, Generator &rResGen) |
| Supremal Controllable Sublanguage.
|
void | TraverseUncontrollableBackwards (const EventSet &rCAlph, TransSetX2EvX1 &rtransrel, StateSet &rCriticalStates, Idx current) |
| Helper function for IsControllable.
|
bool | IsControllable (const System &rPlantGen, const Generator &rSupCandGen) |
| Test controllability.
|
void | SupConNB (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen) |
| Nonblocking Supremal Controllable Sublanguage.
|
void | SupCon (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen) |
| Supremal Controllable Sublanguage.
|
void | NormalityConsistencyCheck (const Generator &rL, const EventSet &rOAlph, const Generator &rK) |
| NormalityConsistencyCheck: Consistency check for normality input data.
|
bool | IsNormal (const Generator &rL, const EventSet &rOAlph, const Generator &rK) |
| IsNormal: checks normality of a language K generated by rK wrt a language L generated by rL and the subset of observable events rOAlph.
|
bool | IsNormal (const System &rPlantGen, const Generator &rSupCandGen) |
| IsNormal wrapper.
|
void | ConcatenateFullLanguage (Generator &rGen) |
| ConcatenateFullLanguage: concatenate Sigma* to language marked by rGen.
|
bool | SupNorm (const Generator &rL, const EventSet &rOAlph, const Generator &rK, Generator &rResult) |
| SupNorm: compute supremal normal sublanguage.
|
bool | SupNormClosed (const Generator &rL, const EventSet &rOAlph, const Generator &rK, Generator &rResult) |
| SupNormClosed - compute supremal normal and closed sublanguage.
|
void | SupConNorm (const Generator &rL, const EventSet &rCAlph, const EventSet &rOAlph, const Generator &rK, Generator &rResult) |
| SupConNormClosed: compute supremal controllable, normal and closed sublanguage.
|
void | SupConNormNB (const Generator &rL, const EventSet &rCAlph, const EventSet &rOAlph, const Generator &rK, Generator &rResult) |
| SupConNormNB: compute supremal controllable and normal sublanguage.
|
bool | SupPrefixClosed (const Generator &rK, Generator &rResult) |
| SupPrefixClosed: supremal closed sublanguage of K by cancelling all tranistions leading to a non-marked state.
|
void | SupNorm (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen) |
| rti wrapper
|
void | SupNormClosed (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen) |
| rti wrapper
|
void | SupConNorm (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen) |
| rti wrapper
|
void | SupConNormNB (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen) |
| rti wrapper
|
bool | SupReduce (const System &rPlantGen, const System &rSupGen, System &rReducedSup) |
| Supervisor Reduction algorithm.
|
bool | CheckMergibility (Idx stateI, Idx stateJ, std::vector< std::set< Idx > > &rWaitList, Idx cNode, const System &rSupGen, const std::map< Idx, ReductionStateInfo > &rSupStateInfo, const std::map< Idx, Idx > &rState2Class, const std::vector< StateSet > &rClass2States) |
| Supervisor Reduction mergibility algorithm.
|
bool | IsOmegaControllable (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSupCandGen) |
| Test omega controllability.
|
bool | IsOmegaControllable (const System &rPlantGen, const Generator &rSupCandGen) |
| Test omega-controllability.
|
void | SupConComplete (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, Generator &rResGen) |
| Supremal controllable and complete sublanguage.
|
void | SupConComplete (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen) |
| Supremal controllable and complete sublanguage.
|
void | SupConCompleteNB (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, Generator &rResGen) |
| Supremal controllable and complete sublanguage.
|
void | SupConCompleteNB (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen) |
| Supremal controllable and complete sublanguage.
|
bool | OmegaControlledLiveness (Generator &rSupCandGen, const EventSet &rCAlph, StateSet &rMarkedPlantStates, StateSet &rMarkedSpecStates) |
void | OmegaSupconParallel (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, std::map< OPSState, Idx > &rReverseCompositionMap, StateSet &rMarkedPlantStates, StateSet &rMarkedSpecStates, Generator &rResGen) |
void | OmegaSupConNBUnchecked (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, std::map< OPSState, Idx > &rReverseCompositionMap, Generator &rResGen) |
void | OmegaSupConNB (const Generator &rPlantGen, const EventSet &rCAlph, const Generator &rSpecGen, Generator &rResGen) |
| Omega-synthesis (experimental).
|
void | OmegaSupConNB (const System &rPlantGen, const Generator &rSpecGen, Generator &rResGen) |
| Omega-synthesis (experimental).
|
void | calcBisimulation (Generator &rGenOrig, map< Idx, Idx > &rMapStateToPartition, Generator &rGenPart, vector< Idx > &rNewPartitions) |
void | calcBisimulation (Generator &rGenOrig, map< Idx, Idx > &rMapStateToPartition, vector< Idx > &rNewPartitions) |
void | calcBisimulation (Generator &rGenOrig, std::map< Idx, Idx > &rMapStateToPartition, Generator &rGenPart, std::vector< Idx > &rNewPartitions) |
| Computation of a bisimulation over a given generator.
|
void | calcBisimulation (Generator &rGenOrig, std::map< Idx, Idx > &rMapStateToPartition, std::vector< Idx > &rNewPartitions) |
| Computation of a bisimulation over a given generator.
|
bool | IsMutuallyControllable (const System &rGen1, const System &rGen2) |
| Verification of mutual controllability.
|
bool | IsMutuallyControllable (const System &rGen1, const System &rGen2, StateSet &rForbidden1, StateSet &rForbidden2) |
| Verification of mutual controllability.
|
void | IsMutuallyControllable (const System &rGen1, const System &rGen2, bool &rRes) |
| RTI wrapper.
|
void | calculateDynamicSystemClosedObs (const Generator &rGen, EventSet &rHighAlph, Generator &rGenDyn) |
| Computation of the dynamic system for Delta_sigma (reachable states after the occurrence of one high-level event).
|
void | calculateDynamicSystemObs (const Generator &rGen, EventSet &rHighAlph, Generator &rGenDyn) |
| Computation of the dynamic system for Delta_obs (local reachability of a marked state).
|
void | calculateDynamicSystemMSA (const Generator &rGen, EventSet &rHighAlph, Generator &rGenDyn) |
| Computation of the dynamic system for Delta_msa (local fulfillment of the msa-observer property).
|
bool | recursiveCheckMSAForward (const Generator &rGen, const EventSet &rHighAlph, Idx currentState, StateSet &rDoneStates) |
| Check if the msa-observer conditions is fulfilled for a given state.
|
bool | recursiveCheckMSABackward (const Generator &rGen, const TransSetX2EvX1 &rRevTransSet, const EventSet &rHighAlph, Idx currentState, StateSet &rDoneStates) |
| Check if the msa-observer conditions is fulfilled for a given state.
|
void | calculateDynamicSystemLCC (const Generator &rGen, const EventSet &rControllableEvents, const EventSet &rHighAlph, Generator &rGenDyn) |
| Computation of the dynamic system for Delta_lcc (fulfillment of the local control consistency property).
|
void | recursiveCheckLCC (const TransSetX2EvX1 &rRevTransSet, const EventSet &rControllableEvents, const EventSet &rHighAlph, Idx currentState, StateSet &rDoneStates) |
| Find states that fulfill the lcc condition.
|
Idx | calcClosedObserver (const Generator &rGenObs, EventSet &rHighAlph) |
| L(G)-observer computation by adding events to the high-level alphabet.
|
SignedIdx | calcNaturalObserver (const Generator &rGenObs, EventSet &rHighAlph) |
| Lm(G)-observer computation by adding events to the high-level alphabet.
|
SignedIdx | calcNaturalObserverLCC (const Generator &rGen, const EventSet &rControllableEvents, EventSet &rHighAlph) |
| Lm(G)-observer computation including local control consistency (LCC) by adding events to the high-level alphabet.
|
SignedIdx | calcMSAObserver (const Generator &rGen, EventSet &rHighAlph) |
| MSA-observer computation by adding events to the high-level alphabet.
|
SignedIdx | calcMSAObserverLCC (const Generator &rGen, const EventSet &rControllableEvents, EventSet &rHighAlph) |
| MSA-observer computation including local control consistency (LCC) by adding events to the high-level alphabet.
|
void | ExtendHighAlphabet (const Generator &rGen, EventSet &rHighAlph, map< Idx, Idx > &rMapStateToPartition) |
bool | CheckSplit (const Generator &rGen, const EventSet &rSplitAlphabet, const vector< pair< StateSet, Idx > > &rNondeterministicStates, Idx entryState) |
void | calcAbstAlphClosed (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents) |
void | calcAbstAlphClosed (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents) |
void | calcAbstAlphClosed (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans) |
void | calcAbstAlphObs (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents) |
void | calcAbstAlphObs (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents) |
void | calcAbstAlphObs (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans) |
void | calcAbstAlphMSA (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents) |
void | calcAbstAlphMSA (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents) |
void | calcAbstAlphMSA (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans) |
void | backwardReachabilityObsOCC (const TransSetX2EvX1 &rTransSetX2EvX1, const EventSet &rControllableEvents, const EventSet &rHighAlph, Idx exitState, Idx currentState, bool controllablePath, map< Idx, map< Idx, bool > > &rExitLocalStatesMap, StateSet &rDoneStates) |
void | calcAbstAlphObsLCC (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents) |
void | calcAbstAlphObsLCC (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans) |
void | calcAbstAlphMSALCC (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents) |
void | calcAbstAlphMSALCC (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans) |
bool | relabel (Generator &rGenRelabel, EventSet &rControllableEvents, EventSet &rHighAlph, vector< Idx > &rNewPartitions, map< Idx, Idx > &rMapStateToPartition, map< Transition, Transition > &rMapChangedTransReverse, map< Transition, Idx > &rMapChangedTrans, map< Idx, EventSet > &rMapRelabeledEvents) |
void | insertRelabeledEvents (System &rGenPlant, const map< Idx, set< Idx > > &rMapRelabeledEvents, Alphabet &rNewEvents) |
void | insertRelabeledEvents (Generator &rGenPlant, const map< Idx, set< Idx > > &rMapRelabeledEvents, EventSet &rNewEvents) |
void | insertRelabeledEvents (System &rGenPlant, const map< Idx, set< Idx > > &rMapRelabeledEvents) |
void | insertRelabeledEvents (Generator &rGenPlant, const map< Idx, set< Idx > > &rMapRelabeledEvents) |
void | calcAbstAlphObs (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, EventRelabelMap &rMapRelabeledEvents) |
| Rti convenience wrapper.
|
void | insertRelabeledEvents (Generator &rGenPlant, const EventRelabelMap &rMapRelabeledEvents, EventSet &rNewEvents) |
| Rti convenience wrapper.
|
void | insertRelabeledEvents (Generator &rGenPlant, const EventRelabelMap &rMapRelabeledEvents) |
| Rti convenience wrapper.
|
void | ExtendHighAlphabet (const Generator &rGenObs, EventSet &rHighAlph, std::map< Idx, Idx > &rMapStateToPartition) |
| Extension of the high-level alphabet to achieve the Lm-observer property.
|
bool | CheckSplit (const Generator &rGenObs, const EventSet &rSplitAlphabet, const std::vector< std::pair< StateSet, Idx > > &rNondeterministicStates, Idx entryState) |
| Check if the current alphabet splits all local automata with nondeterminims or unobservable transitions.
|
void | calcAbstAlphClosed (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents) |
| L(G)-observer computation.
|
void | calcAbstAlphClosed (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents) |
| L(G)-observer computation.
|
void | calcAbstAlphClosed (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans) |
| L(G)-observer computation.
|
void | calcAbstAlphObs (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents) |
| Lm-observer computation.
|
void | calcAbstAlphObs (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents) |
| Lm-observer computation.
|
void | calcAbstAlphObs (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans) |
| Lm-observer computation.
|
void | calcAbstAlphMSA (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents) |
| MSA-observer computation.
|
void | calcAbstAlphMSA (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents) |
| MSA-observer computation.
|
void | calcAbstAlphMSA (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans) |
| MSA-observer computation.
|
void | calcAbstAlphObsLCC (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents) |
| Lm-observer computation including output control consistency (OCC).
|
void | calcAbstAlphObsLCC (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans) |
| Lm-observer computation including local control consistency (LCC).
|
void | calcAbstAlphMSALCC (System &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents) |
| MSA-observer computation including local control consistency (LCC).
|
void | calcAbstAlphMSALCC (Generator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans) |
| MSA-observer computation including local control consistency (LCC).
|
bool | relabel (Generator &rGenRelabel, EventSet &rControllableEvents, EventSet &rHighAlph, std::vector< Idx > &rNewPartitions, std::map< Idx, Idx > &rMapStateToPartition, std::map< Transition, Transition > &rMapChangedTransReverse, std::map< Transition, Idx > &rMapChangedTrans, std::map< Idx, EventSet > &rMapRelabeledEvents) |
| Relabeling algorithm for the computation of an Lm-observer.
|
void | insertRelabeledEvents (System &rGenPlant, const std::map< Idx, std::set< Idx > > &rMapRelabeledEvents, Alphabet &rNewEvents) |
| Convenience function for relabeling events in a given generator.
|
void | insertRelabeledEvents (Generator &rGenPlant, const std::map< Idx, std::set< Idx > > &rMapRelabeledEvents, EventSet &rNewEvents) |
| Convenience function for relabeling events in a given generator.
|
void | insertRelabeledEvents (System &rGenPlant, const std::map< Idx, std::set< Idx > > &rMapRelabeledEvents) |
| Convenience function for relabeling events in a given generator.
|
void | insertRelabeledEvents (Generator &rGenPlant, const std::map< Idx, std::set< Idx > > &rMapRelabeledEvents) |
| Convenience function for relabeling events in a given generator.
|
bool | IsObs (const Generator &rLowGen, const EventSet &rHighAlph) |
| Verification of the natural observer property.
|
bool | IsMSA (const Generator &rLowGen, const EventSet &rHighAlph) |
| Verification of the MSA observer property.
|
bool | IsOCC (const System &rLowGen, const EventSet &rHighAlph) |
| Verification of output control consistency (OCC).
|
bool | IsOCC (const Generator &rLowGen, const EventSet &rControllableEvents, const EventSet &rHighAlph) |
| Verification of output control consistency (OCC).
|
bool | backwardVerificationOCC (const Generator &rLowGen, const EventSet &rControllableEvents, const EventSet &rHighAlph, Idx currentState) |
| Function that supports the verification of output control consistency (OCC).
|
bool | IsLCC (const System &rLowGen, const EventSet &rHighAlph) |
| Verification of local control consistency (LCC).
|
bool | IsLCC (const Generator &rLowGen, const EventSet &rControllableEvents, const EventSet &rHighAlph) |
| Verification of local control consistency (LCC).
|
void | backwardVerificationLCC (const TransSetX2EvX1 &rTransSetX2EvX1, const EventSet &rControllableEvents, const EventSet &rHighAlph, Idx exitState, Idx currentState, bool controllablePath, map< Idx, bool > &rLocalStatesMap, StateSet &rDoneStates) |
void | backwardVerificationLCC (const TransSetX2EvX1 &rTransSetX2EvX1, const EventSet &rControllableEvents, const EventSet &rHighAlph, Idx exitState, Idx currentState, bool controllablePath, std::map< Idx, bool > &rLocalStatesMap, StateSet &rDoneStates) |
| Function that supports the verification of local control consistency (LCC).
|
bool | LocalObservationConsistency (const System &rPlantGen, const System &rSpecGen, const EventSet &rHighAlph, const EventSet &rObsAlph) |
| Supervisor Reduction algorithm.
|
bool | IsCoDiagnosable (const System &rGen, const Generator &rSpec, const vector< const EventSet * > &rAlphabets, std::string &rReportString) |
bool | DecentralizedDiagnoser (const System &rGen, const Generator &rSpec, const std::vector< const EventSet * > &rAlphabets, std::vector< Diagnoser * > &rDiags, std::string &rReportString) |
| Computes decentralized diagnosers for multiple local sites.
|
bool | IsCoDiagnosable (const System &rGen, const Generator &rSpec, const EventSetVector &rAlphabets) |
| Function definition for run-time interface.
|
bool | DecentralizedDiagnoser (const System &rGen, const Generator &rSpec, const EventSetVector &rAlphabets, GeneratorVector &rDiags) |
| Function definition for run-time interface.
|
void | DecentralizedModularDiagnoser (const SystemVector &rGens, const Generator &rSpec, GeneratorVector &rDiags) |
| Function definition for run-time interface.
|
void | cParallel (const std::vector< const System * > &rGens, System &rResGen) |
| Parallel composition of multiple generators.
|
bool | IsEventDiagnosable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, string &rReportString) |
bool | IsEventDiagnosable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap) |
| Function definition for run-time interface.
|
bool | IsIndicatorEventDiagnosable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, string &rReportString) |
bool | IsIndicatorEventDiagnosable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap) |
| Function definition for run-time interface.
|
bool | MeetsDiagnosabilityAssumptions (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, string &rReportString) |
void | ConvertParallelCompositionMap (const map< pair< Idx, Idx >, Idx > &rReverseCompositionMap, map< Idx, pair< Idx, Idx > > &rCompositionMap) |
bool | IsLive (const System &rGen, string &rReport) |
bool | CycleOfUnobsEvents (const System &rGen, string &rReport) |
bool | FailuresUnobservable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, string &rReport) |
bool | ExistsCycle (const System &rGen, string &rReport) |
bool | ExistsCycleSearch (const System &rGen, StateSet &rTodo, Idx currState, StateSet statesOnPath, string &rReport) |
void | CycleStartStates (const System &rGen, StateSet &rCycleOrigins) |
| Find all start/end states of cycles of unobservable events in a generator.
|
void | CycleStartStatesSearch (const System &rGen, StateSet &rTodo, Idx currState, StateSet statesOnPath, StateSet &rCycleOriginStates) |
| Auxiliary function for CycleStartStates().
|
bool | ExistsViolatingCyclesInGd (System &rGd, const Diagnoser &rGobs, map< pair< Idx, Idx >, Idx > &rReverseCompositionMap, const string &rFailureType, string &rReportString) |
void | ComputeGobs (const System &rOrigGen, const string &rFailureType, const EventSet &rFailureEvents, Diagnoser &rGobs) |
void | ComputeGobs (const System &rOrigGen, const AttributeFailureTypeMap &rAttrFTMap, Diagnoser &rGobs) |
| Compute G_o for a given generator with a given failure partition (according to Jiang).
|
void | ComputeGd (const Diagnoser &rGobs, map< pair< Idx, Idx >, Idx > &rReverseCompositionMap, System &rGd) |
void | TrimNonIndicatorTracesOfGd (System &rGd, const Diagnoser &rGobs, const Idx rFailureType, const EventSet &rIndicatorEvents, const map< pair< Idx, Idx >, Idx > &rReverseCompositionMap) |
void | TrimNonIndicatorTracesOfGdRecursive (System &rGd, const Diagnoser &rGobs, const Idx rFailureType, const EventSet &rIndicatorEvents, map< Idx, pair< Idx, Idx > > &rCompositionMap, Idx state, StateSet &rStatesDone) |
void | ComputeReachability (const System &rGen, const EventSet &rUnobsEvents, const EventSet &rFailures, Idx State, const AttributeFailureTypeMap &rAttrFTMap, map< Idx, multimap< Idx, DiagLabelSet > > &rReachabilityMap) |
void | ComputeReachabilityRecursive (const System &rGen, const EventSet &rUnobsEvents, const EventSet &rFailures, Idx State, const AttributeFailureTypeMap &rAttrFTMap, map< Idx, multimap< Idx, DiagLabelSet > > &rReachabilityMap, const DiagLabelSet FToccurred) |
TransSet | ActiveBackwardTransSet (const System &rGen, Idx state) |
| Obtain all transitions from other states into a given state of a generator.
|
void | EventDiagnoser (const System &rOrigGen, const map< string, EventSet > &rFailureTypeMap, Diagnoser &rDiagGen) |
void | LabelPropagation (const DiagLabelSet &lastLabel, const DiagLabelSet &failureTypes, DiagLabelSet &newLabel) |
| Generate a new label.
|
void | LabelCorrection (const multimap< Idx, DiagLabelSet > &mm, AttributeDiagnoserState &attr) |
void | ConvertParallelCompositionMap (const std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, std::map< Idx, std::pair< Idx, Idx > > &rCompositionMap) |
| Convert the reverse composition map of Parallel() by switching first and second entry.
|
bool | IsLive (const System &rGen, std::string &rReport) |
| Test if a generator is live.
|
bool | CycleOfUnobsEvents (const System &rGen, std::string &rReport) |
| Test if there exist any cycles of unobservable events in a generator.
|
bool | FailuresUnobservable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, std::string &rReport) |
| Check if all failure events are unobservable events in a generator's alphabet.
|
bool | ExistsCycle (const System &rGen, std::string &rReport) |
| Test if there exist any cycles in a generator.
|
bool | ExistsCycleSearch (const System &rGen, StateSet &rTodo, Idx currState, StateSet statesOnPath, std::string &rReport) |
| Auxiliary function for ExistsCycle(const System&, std::string&).
|
bool | ExistsViolatingCyclesInGd (System &rGd, const Diagnoser &rGobs, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, const std::string &rFailureType, std::string &rReportString) |
| Remove states with same failure labels from rGd and from rReverseCompositionMap and perform cycle detection.
|
void | ComputeGobs (const System &rOrigGen, const std::string &rFailureType, const EventSet &rFailureEvents, Diagnoser &rGobs) |
| Compute G_o for a single failure type of a generator.
|
void | ComputeGd (const Diagnoser &rGobs, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, System &rGd) |
| Compute the diagnosability testing generator G_d as a parallel composition of G_o with itself (according to Jiang).
|
void | TrimNonIndicatorTracesOfGd (System &rGd, const Diagnoser &rGobs, const Idx rFailureType, const EventSet &rIndicatorEvents, const std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap) |
| Extract all traces of a generator G_d that start with an indicator event that follows a failure event of a certain failure type.
|
void | TrimNonIndicatorTracesOfGdRecursive (System &rGd, const Diagnoser &rGobs, const Idx rFailureType, const EventSet &rIndicatorEvents, std::map< Idx, std::pair< Idx, Idx > > &rCompositionMap, Idx state, StateSet &rStatesDone) |
| Auxiliary function for TrimNonIndicatorTracesOfGd().
|
void | ComputeReachability (const System &rGen, const EventSet &rUnobsEvents, const EventSet &rFailures, Idx State, const AttributeFailureTypeMap &rAttrFTMap, std::map< Idx, std::multimap< Idx, DiagLabelSet > > &rReachabilityMap) |
| Compute the reachability from a given generator state through a trace that consists of arbitrarily many unobservable events followed by one observable event.
|
void | ComputeReachabilityRecursive (const System &rGen, const EventSet &rUnobsEvents, const EventSet &rFailures, Idx State, const AttributeFailureTypeMap &rAttrFTMap, std::map< Idx, std::multimap< Idx, DiagLabelSet > > &rReachabilityMap, const DiagLabelSet FToccurred) |
| Auxiliary function for ComputeReachability(const System&, const EventSet&, const EventSet&, Idx, const AttributeFailureTypeMap&, std::map<Idx,std::multimap<Idx,DiagLabelSet>>&).
|
void | EventDiagnoser (const System &rOrigGen, const std::map< std::string, EventSet > &rFailureTypeMap, Diagnoser &rDiagGen) |
| Compute a standard diagnoser from an input generator and a failure partition.
|
void | LabelCorrection (const std::multimap< Idx, DiagLabelSet > &mm, AttributeDiagnoserState &attr) |
| Perform label correction on propagated failure type labels.
|
bool | IsLanguageDiagnosable (const System &rGen, const System &rSpec) |
| Function definition for run-time interface.
|
void | ComputeGobs (const System &rGenMarkedNonSpecBehaviour, Diagnoser &rGobs) |
| Compute G_o for a generator that marks the faulty behaviour of a plant.
|
void | ComputeReachability (const System &rGen, const EventSet &rUnobsEvents, Idx State, map< Idx, multimap< Idx, DiagLabelSet > > &rReachabilityMap) |
void | ComputeReachabilityRecursive (const System &rGen, const EventSet &rUnobsEvents, Idx State, StateSet done, map< Idx, multimap< Idx, DiagLabelSet > > &rReachabilityMap) |
bool | IsLanguageDiagnosable (const System &rGen, const System rSpec, std::string &rReportString) |
| Test function to verify language-diagnosability.
|
bool | rec_ComputeLoopPreservingObserver (const System &rGen, const EventSet &rInitialHighAlph, EventSet &rHighAlph, const std::vector< Idx > &rDdffVector, Idx numberEvents, Idx currentNumberEvents, Idx currentLocation, EventSet chosenEvents) |
| rec_ComputeLoopPreservingObserver(rGen, rInitialHighAlph, rHighAlph, rDdffVector, numberEvents, currentNumberEvents, currentLocation, hosenEvents)
|
void | ComputeReachability (const System &rGen, const EventSet &rUnobsEvents, Idx State, std::map< Idx, std::multimap< Idx, DiagLabelSet > > &rReachabilityMap) |
| Compute the reachability from a state of a generator that marks its faulty behaviour.
|
void | ComputeReachabilityRecursive (const System &rGen, const EventSet &rUnobsEvents, Idx State, StateSet done, std::map< Idx, std::multimap< Idx, DiagLabelSet > > &rReachabilityMap) |
| Auxiliary function for ComputeReachability(const System&, const EventSet&, Idx State, std::map<Idx,std::multimap< Idx,DiagLabelSet> >&).
|
bool | IsModularDiagnosable (const SystemVector &rGsubs, const GeneratorVector &rKsubs, string &rReportString) |
bool | IsModularDiagnosable (const vector< const System * > &rGSubs, const vector< const Generator * > &rKSubs, std::string &rReportString) |
bool | ModularDiagnoser (const SystemVector &rGsubs, const GeneratorVector &rKsubs, GeneratorVector &rDiagSubs, string &rReportString) |
bool | ModularDiagnoser (const std::vector< const System * > &rGsubs, const std::vector< const Generator * > &rKsubs, std::vector< Diagnoser * > &rDiagsubs, std::string &rReportString) |
| Checks modular diagnosability for a system G (which consists of the subsystems rGsubs) with respect to the specification K (consisting of local specifications rKsubs) and the local abstraction alphabets rHighAlphSubs.
|
bool | IsModularDiagnosable (const SystemVector &rGsubs, const GeneratorVector &rKsubs) |
| Function definition for run-time interface.
|
bool | ModularDiagnoser (const SystemVector &rGsubs, const GeneratorVector &rKsubs, GeneratorVector &rDiagsubs) |
| Function definition for run-time interface.
|
void | cParallel (const vector< System > &rGens, System &rResGen) |
bool | IsModularDiagnosable (const std::vector< const System * > &rGsubs, const std::vector< const Generator * > &rKsubs, std::string &rReportString) |
| Checks modular diagnosability for a system G (which consists of the subsystems rGsubs) with respect to the specification K (consisting of local specifications rKsubs) and the local abstraction alphabets rHighAlphSubs.
|
void | cParallel (const std::vector< System > &rGens, System &rResGen) |
| Parallel composition of multiple generators.
|
bool | IsHioConstraintForm (HioConstraint &rHioConstraint, StateSet &rQY, StateSet &rQU, EventSet &rErrEvSet, TransSet &rErrTrSet, StateSet &rErrStSet, std::string &rReportStr) |
| IsHioConstraintForm: check if rHioConstraint is in I/O-constraint form and assign state attributes.
|
bool | IsHioConstraintForm (HioConstraint &rHioConstraint, std::string &rReportStr) |
| IsHioConstraintForm: check if rHioConstraint is in I/O-constraint form and assign state attributes.
|
bool | IsHioConstraintForm (HioConstraint &rHioConstraint) |
| IsHioConstraintForm: check if rHioConstraint is in I/O-constraint form and assign state attributes.
|
void | HioStatePartition (HioConstraint &rConstraint) |
| Function definition for run-time interface.
|
bool | IsHioControllerForm (HioController &rHioController, StateSet &rQUc, StateSet &rQYP, StateSet &rQUp, StateSet &rQYcUp, EventSet &rErrEvSet, TransSet &rErrTrSet, StateSet &rErrStSet, std::string &rReportStr) |
| IsHioControllerForm: check if rHioController is in I/O-controller form and assign state attributes.
|
bool | IsHioControllerForm (HioController &rHioController, std::string &rReportStr) |
| IsHioControllerForm: check if rHioController is in I/O-controller form and assign state attributes.
|
bool | IsHioControllerForm (HioController &rHioController) |
| IsHioControllerForm: check if rHioController is in I/O-controller form and assign state attributes.
|
void | HioStatePartition (HioController &rController) |
| Function definition for run-time interface.
|
bool | IsHioEnvironmentForm (HioEnvironment &rHioEnvironment, StateSet &rQYe, StateSet &rQUe, StateSet &rQUl, StateSet &rQYlUe, EventSet &rErrEvSet, TransSet &rErrTrSet, StateSet &rErrStSet, std::string &rReportStr) |
| IsHioEnvironmentForm: check if rHioEnvironment is in I/O-environment form and assign state attributes.
|
bool | IsHioEnvironmentForm (HioEnvironment &rHioEnvironment, std::string &rReportStr) |
| IsHioEnvironmentForm: check if rHioEnvironment is in I/O-environment form and assign state attributes.
|
bool | IsHioEnvironmentForm (HioEnvironment &rHioEnvironment) |
| IsHioEnvironmentForm: check if rHioEnvironment is in I/O-environment form and assign state attributes.
|
void | HioStatePartition (HioEnvironment &rEnvironment) |
| Function definition for run-time interface.
|
bool | SupNormSP (Generator &rL, const EventSet &rOAlph, const Generator &rK, Generator &rResult) |
bool | CompleteSynth (const Generator &rPlant, const EventSet rCAlph, const Generator &rSpec, Generator &rClosedLoop) |
| CompleteSynth: compute supremal complete and controllable (and closed) sublanguage.
|
bool | NormalCompleteSynth (Generator &rPlant, const EventSet &rCAlph, const EventSet &rOAlph, const Generator &rSpec, Generator &rClosedLoop) |
| NormalCompleteSynth: compute normal, complete and controllable (and closed) sublanguage.
|
bool | NormalCompleteSynthNB (Generator &rPlant, const EventSet &rCAlph, const EventSet &rOAlph, const Generator &rSpec, Generator &rClosedLoop) |
| NormalCompleteSynthNB: compute normal, complete, controllable and nonblocking sublanguage.
|
Generator | HioSortCL (const EventSet &rYc, const EventSet &rUc, const EventSet &rYp, const EventSet &rUp, const EventSet &rYe, const EventSet &rUe) |
| IoSortCL: returns IO-sorting structure required for closed loops.
|
void | HioFreeInput (const Generator &rGen, const EventSet &rInput, const EventSet &rOutput, Generator &rResGen, const std::string &rErrState1, const std::string &rErrState2, Idx &rErrState1Idx, Idx &rErrState2Idx) |
| HioFreeInput: extend generator by obviously missing input transitions.
|
void | HioFreeInput (const Generator &rGen, const EventSet &rInput, const EventSet &rOutput, Generator &rResGen, const std::string &rErrState1, const std::string &rErrState2) |
| HioFreeInput: extend generator by obviously missing input transitions.
|
void | HioFreeInput (const Generator &rGen, const EventSet &rInput, const EventSet &rOutput, Generator &rResGen) |
| HioFreeInput: extend generator by obviously missing input transitions.
|
void | HioFreeInput (const HioPlant &rPlant, HioPlant &rResPlant) |
| HioFreeInput: extend HioPlant by obviously missing input transitions.
|
void | HioFreeInput (const HioController &rController, HioController &rResController) |
| HioFreeInput: extend HioController by obviously missing input transitions.
|
void | HioFreeInput (const HioEnvironment &rEnvironment, HioEnvironment &rResEnvironment) |
| HioFreeInput: extend HioEnvironment by obviously missing input transitions.
|
void | HioFreeInput (const HioConstraint &rConstraint, HioConstraint &rResConstraint) |
| HioFreeInput: extend HioConstraint by obviously missing input transitions.
|
void | HioFreeInput (HioPlant &rPlant) |
| HioFreeInput: convenience interface to faudes::HioFreeInput(const HioPlant&, HioPlant).
|
void | HioFreeInput (HioController &rController) |
| HioFreeInput: convenience interface to faudes::HioFreeInput(const HioController&, HioController).
|
void | HioFreeInput (HioEnvironment &rEnvironment) |
| HioFreeInput: convenience interface to faudes::HioFreeInput(const HioEnvironment&, HioEnvironment).
|
void | HioFreeInput (HioConstraint &rConstraint) |
| HioFreeInput: convenience interface to faudes::HioFreeInput(const HioConstraint&, HioConstraint).
|
void | MarkHioShuffle (const Generator &rGen1, const Generator &rGen2, const std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, Generator &rShuffle) |
| MarkHioShuffle: marking rule for HioShuffle() in case of marked parameters rGen1 and rGen2 - UNDER CONSTRUCTION.
|
void | MarkAlternationAB (const EventSet rAset, const EventSet rBset, Generator &rAltAB) |
| MarkAlternationAB: returns Generator marking the alternation of Aset-transitions with Bset-transitions.
|
void | HioShuffleUnchecked (const Generator &rPlantA, const Generator &rPlantB, const EventSet &rYp, const EventSet &rUp, const EventSet &rYe, const EventSet &rUe, Generator &rIOShuffAB) |
| HioShuffleUnchecked: IO-shuffle of rPlantA and rPlantB according to definition, no parameter check.
|
void | HioShuffle (const Generator &rPlantA, const Generator &rPlantB, const EventSet &rYp, const EventSet &rUp, const EventSet &rYe, const EventSet &rUe, Generator &rIOShuffAB) |
| HioShuffle: IO-shuffle of rPlantA and rPlantB according to definition.
|
void | HioShuffle (const HioPlant &rPlantA, const HioPlant &rPlantB, HioPlant &rIOShuffAB) |
| HioShuffle: IO-shuffle of rPlantA and rPlantB according to definition.
|
void | CheapAltAnB (const EventSet rAset, const EventSet rBset, const int Depth, Generator &rAltAnB) |
| CheapAltAnB: returns Generator of the following specification: "After a maximum of n (=depth) pairs of
A-transitions, a B-transition has to occur!".
|
void | CheapAltAB (const EventSet rAset, const EventSet rBset, const int Depth, Generator &rAltAB) |
| CheapAltAB: returns Generator of the following specification: "After a maximum of n (=depth) pairs of
A-transitions, a B-transition has to occur and vice-versa!".
|
void | HioShuffleTU (const Generator &rPlantA, const Generator &rPlantB, const EventSet &rYp, const EventSet &rUp, const EventSet &rYe, const EventSet &rUe, const int Depth, Generator &rIOShuffAB) |
| HioShuffleTU: IO-shuffle of rPlantA and rPlantB according to definition with additional forced alternation of depth Depth (see CheapAltAB()) between A- and B-events.
|
void | SearchYclessScc (const Idx state, int &rcount,const Generator &rGen, const EventSet &rYc, const bool UnMarkedOnly, StateSet &rNewStates, std::stack< Idx > &rSTACK, StateSet &rStackStates, std::map< const Idx, int > &rDFN, std::map< const Idx, int > &rLOWLINK, std::set< StateSet > &rSccSet, StateSet &rRoots) |
| SearchYclessSCC: Search for strongly connected ycless components (YC-less SCC's).
|
bool | YclessScc (const Generator &rGen, const EventSet &rYc, std::set< StateSet > &rSccSet, StateSet &rRoots) |
| YclessSCC: Search for strongly connected ycless components (YC-less SCC's) - convenience api.
|
bool | YclessUnmarkedScc (const Generator &rGen, const EventSet &rYc, std::set< StateSet > &rSccSet, StateSet &rRoots) |
| YclessUnmarkedSCC: Search for strongly connected ycless components (YC-less SCC's) consisting of unmarked states only.
|
bool | YclessScc (const Generator &rGen, const EventSet &rYc, std::set< StateSet > &rSccSet) |
bool | IsYcLive (const Generator &rGen, const EventSet &rYc) |
| IsYcLive: This function checks if generator is Yc-live.
|
void | WriteStateSets (const std::set< StateSet > &rStateSets) |
| WriteStateSets: Write set of StateSet's to console (indeces).
|
void | WriteStateSets (const Generator &rGen, const std::set< StateSet > &rStateSets) |
| WriteStateSets: Write set of StateSet's to console (symbolic state names taken from rGen).
|
void | SccEntries (const Generator &rGen, const std::set< StateSet > &rSccSet, StateSet &rEntryStates, TransSetX2EvX1 &rEntryTransSet) |
| SCCEntries: figure entry states and entry transitions of strongly connected components rSccSet of rGen.
|
void | CloneScc (Generator &rGen, const StateSet &rScc, std::set< StateSet > &rSccSet, const Idx EntryState, StateSet &rEntryStates, TransSetX2EvX1 &rEntryTransSet) |
| cloneSCC: makes a copy (clone) of strongly connected component (rSCC) of the generator and moves all transitions leading to some entry state EntryState of this SCC to the copy of EntryState.
|
void | CloneUnMarkedScc (Generator &rGen, const StateSet &rScc, const Idx EntryState, const StateSet &rEntryStates, TransSetX2EvX1 &rEntryTransSet) |
| CloneUnMarkedSCC: makes a copy (clone) of strongly connected unmarked component (rSCC) of rGen.
|
void | YcAcyclic (const Generator &rGen, const EventSet &rYc, Generator &rResGen) |
| YcAcyclic: Computes the supremal(?) Yc-acyclic sublanguage of L(Gen).
|
void | ConstrSynth_Beta (Generator &rPlant, const EventSet &rYp, const EventSet &rUp, const Generator &rLocConstr, Generator &rOpConstraint) |
| ConstrSynth_Beta: compute operator constraint Sp for plant under environment constraint Sl such that plant is complete & Yp-live wrt both constraints - Beta Version.
|
void | HioSynthUnchecked (const Generator &rPlant, const Generator &rSpec, const Generator &rConstr, const Generator &rLocConstr, const EventSet &rYc, const EventSet &rUc, const EventSet &rYp, const EventSet &rUp, const EventSet &rYel, const EventSet &rUel, Generator &rController) |
| HioSynthUnchecked: I/O controller synthesis procedure, no parameter check.
|
void | HioSynth (const Generator &rPlant, const Generator &rSpec, const Generator &rConstr, const Generator &rLocConstr, const EventSet &rYc, const EventSet &rUc, const EventSet &rYp, const EventSet &rUp, const EventSet &rYel, const EventSet &rUel, Generator &rController) |
| HioSynthUnchecked: I/O controller synthesis procedure.
|
void | HioSynthMonolithic (const HioPlant &rPlant, const HioPlant &rSpec, const HioConstraint &rSc, const HioConstraint &rSp, const HioConstraint &rSe, HioController &rController) |
| HioSynthMonolithic: I/O controller synthesis procedure for monolithic plant.
|
void | HioSynthHierarchical (const HioPlant &rHioShuffle, const HioEnvironment &rEnvironment, const HioPlant &rSpec, const Generator &rIntConstr, const HioConstraint &rSc, const HioConstraint &rSl, HioController &rController) |
| HioSynthHierarchical: I/O controller synthesis procedure for I/O-shuffle of i plants and their interaction via an I/O environment.
|
void | HioShuffle_Musunoi (const HioPlant &rPlantA, const HioPlant &rPlantB, int depth, Generator &rIOShuffAB) |
void | HioSynth_Musunoi (const Generator &rPlant, const HioPlant &rSpec, const Generator &rConstr, const Generator &rLocConstr, const EventSet &rYp, const EventSet &rUp, Generator &rController) |
bool | YclessSCC (const Generator &rGen, const EventSet &rYc, std::set< StateSet > &rSccSet) |
| YclessSCC: Search for strongly connected ycless components (YC-less SCC's) - convenience api.
|
void | AdjustHioController (const HioController &rHioController, const HioModule *rHioModule1, const HioModule *rHioModule2, HioController &rResEnv) |
void | GroupHioModules (const std::vector< HioModule * > &rChildren, HioModule &rParentModule) |
| GroupHioModules: This function groups two or more HioModules to a new HioModule.
|
void | CreateSpec (int mType[5], HioPlant &rHioSpec, Generator &constrP, Generator &constrE) |
| This function creates new specification given by the type ("xxxxx") Note: The core of this function is a template specification model (SpecCB12.gen).
|
void | CreateConstraint (int mType[5], Generator &constrP, Generator &constrE) |
| This function creates constraints which describe the condition of completeness and Yp-liveness of a Specification.
|
bool | IsHioPlantForm (HioPlant &rHioPlant, StateSet &rQYpYe, StateSet &rQUp, StateSet &rQUe, EventSet &rErrEvSet, TransSet &rErrTrSet, StateSet &rErrStSet, std::string &rReportStr) |
| IsHioPlantForm: check if rHioPlant is in I/O-plant form and assign state attributes.
|
bool | IsHioPlantForm (HioPlant &rHioPlant, std::string &rReportStr) |
| IsHioPlantForm: check if rHioPlant is in I/O-plant form and assign state attributes.
|
bool | IsHioPlantForm (HioPlant &rHioPlant) |
| IsHioPlantForm: check if rHioPlant is in I/O-plant form and assign state attributes.
|
void | HioStatePartition (HioPlant &rPlant) |
| Function definition for run-time interface.
|
bool | IsIoSystem (const IoSystem &rIoSystem, StateSet &rQU, StateSet &rQY, StateSet &rQErr) |
| Test whether the system satisfies basic I/O conditions.
|
bool | IsIoSystem (IoSystem &rIoSystem) |
| Test whether the system satisfies the IO conditions.
|
void | IoStatePartition (IoSystem &rIoSystem) |
| Construct io state partition.
|
bool | IsInputLocallyFree (IoSystem &rIoSystem) |
| Test whether the system has a locally free input.
|
bool | IsInputLocallyFree (const IoSystem &rIoSystem, StateSet &rQErr) |
| Test whether the system has a locally free input.
|
bool | IsInputOmegaFree (IoSystem &rIoSystem) |
| Test whether the system behaviour has exhibits a free input.
|
bool | IsInputOmegaFree (const IoSystem &rIoSystem, StateSet &rQErr) |
| Test whether the system behaviour exhibits a free input.
|
void | IoFreeInput (IoSystem &rIoSystem) |
| Enable all input events for each input state.
|
void | IoFreeInput (Generator &rIoSystem, const EventSet &rUAlph) |
| Enable all input events for each input state.
|
void | RemoveIoDummyStates (IoSystem &rIoSystem) |
| Remove dummy states.
|
void | IoSynthesisNB (const IoSystem &rPlant, const Generator &rSpec, IoSystem &rSup) |
| IO system synthesis.
|
void | IoSynthesis (const IoSystem &rPlant, const Generator &rSpec, IoSystem &rSup) |
| IO system synthesis.
|
bool | IsStronglyCoaccessible (const MtcSystem &rGen) |
| RTI wrapper function.
|
bool | IsStronglyTrim (const MtcSystem &rGen) |
| RTI wrapper function.
|
void | StronglyCoaccessible (MtcSystem &rGen) |
| RTI wrapper function.
|
void | StronglyCoaccessible (const MtcSystem &rGen, MtcSystem &rRes) |
| RTI wrapper function.
|
void | StronglyTrim (MtcSystem &rGen) |
| RTI wrapper function.
|
void | StronglyTrim (const MtcSystem &rGen, MtcSystem &rRes) |
| RTI wrapper function.
|
Idx | calcNaturalObserver (const MtcSystem &rGen, EventSet &rHighAlph) |
| Calculate a colored natural observer by extending a given high-level alphabet.
|
void | calcAbstAlphObs (MtcSystem &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents) |
| Lm-observer computation.
|
void | calcAbstAlphObs (MtcSystem &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents) |
| Lm-observer computation.
|
void | calcAbstAlphObs (MtcSystem &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans) |
| Lm-observer computation.
|
void | calculateDynamicSystemObs (const MtcSystem &rGen, EventSet &rHighAlph, Generator &rGenDyn) |
| Computation of the dynamic system for an Lm-observer.
|
bool | IsMtcObs (const MtcSystem &rLowGen, const EventSet &rHighAlph) |
| Verification of the observer property.
|
void | mtcParallel (const MtcSystem &rGen1, const MtcSystem &rGen2, MtcSystem &rResGen) |
| Parallel composition of two colored marking generators, controllability status is observed.
|
void | mtcParallel (const MtcSystem &rGen1, const MtcSystem &rGen2, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, MtcSystem &rResGen) |
| Parallel composition of two MtcSystems.
|
void | ComposedColorSet (const MtcSystem &rGen1, const Idx stdidx1, ColorSet &colors1, const MtcSystem &rGen2, const Idx stdidx2, ColorSet &colors2, ColorSet &composedSet) |
| Compose the color set for a state combined from two states in two distinct automata.
|
void | mtcUniqueInit (MtcSystem &rGen) |
void | mtcDeterministic (const MtcSystem &rGen, MtcSystem &rResGen) |
| Make generator deterministic.
|
void | mtcDeterministic (const MtcSystem &rGen, std::map< Idx, StateSet > &rEntryStatesMap, MtcSystem &rResGen) |
| Make generator deterministic.
|
void | mtcDeterministic (const MtcSystem &rGen, std::vector< StateSet > &rPowerStates, std::vector< Idx > &rDetStates, MtcSystem &rResGen) |
| Make generator deterministic.
|
void | mtcProjectNonDet (MtcSystem &rGen, const EventSet &rProjectAlphabet) |
| Project generator to alphabet rProjectAlphabet.
|
void | mtcProjectNonDet (const MtcSystem &rGen, const EventSet &rProjectAlphabet, MtcSystem &rResGen) |
| Project generator to alphabet rProjectAlphabet.
|
void | mtcProject (const MtcSystem &rGen, const EventSet &rProjectAlphabet, MtcSystem &rResGen) |
| Minimized Deterministic projection.
|
void | mtcProject (const MtcSystem &rGen, const EventSet &rProjectAlphabet, std::map< Idx, StateSet > &rEntryStatesMap, MtcSystem &rResGen) |
| Minimized Deterministic projection.
|
void | mtcInvProject (MtcSystem &rGen, const EventSet &rProjectAlphabet) |
| Inverse projection.
|
void | mtcInvProject (const MtcSystem &rGen, const EventSet &rProjectAlphabet, MtcSystem &rResGen) |
| RTI wrapper.
|
void | SearchScc (const Idx state, int &rCount, const Generator &rGen, StateSet &rNewStates, std::stack< Idx > &rSTACK, StateSet &rStackStates, std::map< const Idx, int > &rDFN, std::map< const Idx, int > &rLOWLINK, std::set< StateSet > &rSccSet, StateSet &rRoots) |
| Search for strongly connected components (SCC)*** This function partitions the stateset of a generator into equivalence classes such that states x1 and x2 are equivalent iff there is a path from x1 to x2 AND a path from x2 to x1.
|
bool | ComputeSCC (const Generator &rGen, std::set< StateSet > &rSccSet, StateSet &rRoots) |
| Computes the strongly connected components (SCCs) of an automaton.
|
void | ColoredSCC (MtcSystem &rGen, ColorSet &rColors, std::set< StateSet > &rColoredSCCs) |
| Compute all strongly connected components (SCCs) in a colored marking generator (CMG) that are marked with a given set of colors.
|
bool | CheckRedundantColor (MtcSystem rGen, Idx redundantColor) |
| Check if a color in a colored marking generator is redundant for the supervisor synthesis.
|
void | OptimalColorSet (const MtcSystem &rGen, ColorSet &rOptimalColors, EventSet &rHighAlph) |
| Compute an optimal subset of the colors that should be removed.
|
void | rec_OptimalColorSet (const MtcSystem &rGen, const vector< Idx > &rColorVector, Idx colorNumber, ColorSet &rOptimalColors, Idx &rOptimalNumberStates, Idx &rOptimalNumberColors, const EventSet &rHighAlph, EventSet &rOptimalHighAlph) |
| Recursively find an optimal set of colors to be removed.
|
void | mtcStateMin (MtcSystem &rGen, MtcSystem &rResGen) |
| State Minimization This function implements the (n*log n) set partitioning algorithm by John E.
|
void | mtcStateMin (MtcSystem &rGen, MtcSystem &rResGen, std::vector< StateSet > &rSubsets, std::vector< Idx > &rNewIndices) |
| State Minimization This function implements the (n*log n) set partitioning algorithm by John E.
|
void | mtcStateMin (const MtcSystem &rGen, MtcSystem &rResGen) |
| RTI wrapper.
|
void | mtcSupConNB (const MtcSystem &rPlantGen, const MtcSystem &rSpecGen, MtcSystem &rResGen) |
| Nonblocking Supremal Controllable Sublanguage (wrapper function).
|
void | mtcSupConNB (const MtcSystem &rPlantGen, const MtcSystem &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, MtcSystem &rResGen) |
| Nonblocking Supremal Controllable Sublanguage.
|
void | mtcSupCon (const MtcSystem &rPlantGen, const MtcSystem &rSpecGen, MtcSystem &rResGen) |
| Supremal Controllable Sublanguage (wrapper function).
|
void | mtcSupCon (const MtcSystem &rPlantGen, const MtcSystem &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, MtcSystem &rResGen) |
| Supremal Controllable Sublanguage.
|
void | mtcSupConParallel (const MtcSystem &rPlantGen, const MtcSystem &rSpecGen, const EventSet &rUAlph, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, MtcSystem &rResGen) |
| Fast parallel composition for computation for the mtcSupConNB.
|
void | mtcSupConUnchecked (const MtcSystem &rPlantGen, const EventSet &rCAlph, MtcSystem &rSupGen) |
| Supremal Controllable Sublangauge (Real SupCon function; unchecked).
|
bool | ccTrim (const Generator &gen, Generator &trimGen) |
| A more efficient Trim() operation.
|
bool | IsConditionalClosed (const GeneratorVector &specVect, const Generator &pk, const GeneratorVector &genVect, const Generator &gk) |
| Conditionalclosedness Checking Algorithm.
|
bool | IsConditionalControllable (const GeneratorVector &specVect, const Generator &pk, const GeneratorVector &genVect, const Generator &gk, const EventSet &ACntrl) |
| Conditionalcontrollability Checking Algorithm.
|
bool | IsConditionalDecomposable (const Generator &gen, const EventSetVector &rAlphabets, const EventSet &ek, Generator &proof) |
| Conditionaldecomposability Checking Algorithm.
|
template<class GlobalAttr1 , class StateAttr1 , class EventAttr1 , class TransAttr1 , class GlobalAttr2 , class StateAttr2 , class EventAttr2 , class TransAttr2 , class GlobalAttrR , class StateAttrR , class EventAttrR , class TransAttrR > |
void | TParallel (const TGEN1 &rGen1, const TGEN2 &rGen2, TGENR &rResGen) |
| Parallel composition of timed generators.
|
template<class GlobalAttr1 , class StateAttr1 , class EventAttr1 , class TransAttr1 , class GlobalAttr2 , class StateAttr2 , class EventAttr2 , class TransAttr2 , class GlobalAttrR , class StateAttrR , class EventAttrR , class TransAttrR > |
void | TParallel (const TGEN1 &rGen1, const TGEN2 &rGen2, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, TGENR &rResGen) |
| Parallel composition of timed generators.
|
void | ran_plant_seeds (long x) |
| Use this function to set the state of all the random number generator streams by "planting" a sequence of states (seeds), one per stream, with all states dictated by the state of the default stream.
|
void | ran_put_seed (long seed) |
| Put a seed.
|
void | ran_select_stream (int index) |
| Use this function to set the current random number generator stream -- that stream from which the next random number will come.
|
void | ran_init (long seed) |
| Initialize random generator.
|
double | ran (void) |
| Run random generator Random Number Generator (for more details see "Random Number Generators: Good Ones Are Hard To Find" Steve Park and Keith Miller Communications of the ACM, October 1988).
|
double | ran_uniform (double a, double b) |
| Sample a random variable uniformly on interval [a;b) Distribution: f(t) dt= {1/(b-a)} dt for t, a <=t< b, else 0.
|
long | ran_uniform_int (long a, long b) |
| Sample a discrete random variable uniformly on interval [a;b) Distribution: p(n) = 1/(b-a-1).
|
double | ran_exponential (double mu) |
| Sample a random variable exponentially Distribution: f(t) dt = 1/mu exp(-t/mu) dt for t>=0.
|
double | ran_exponential (double mu, tpTime::Type tossLB, tpTime::Type tossUB) |
| Sample a random variable exponentially on a restricted interval Distribution: f(t) dt = 1/mu exp(-t/mu) dt for t>=0.
|
double | ran_gauss (double mu, double sigma, tpTime::Type tossLB, tpTime::Type tossUB) |
| Sample a random variable gaussian distributed on a restricted interval Distribution: f(t) = 1 / sqrt(2 pi sigma^2) * exp( -1/2 ((t-mu)/sigma)^2) for t>=0.
|
double | ran_gaussian_cdf_P (double x) |
| Help function: calculate gaussian CDF using an approximation from Abromowitz and Stegun: Handbook of Mathematical Functions.
|
void * | SDeviceSynchro (void *arg) |
int | syncSend (int dest, const char *data, int len, int flag) |
void * | NDeviceListen (void *arg) |
void * | NDeviceReply (void *arg) |
void * | NDeviceServer (void *) |
void * | SwigCastPtr (void *ptr, swig_type_info *from, swig_type_info *ty) |
swig_lua_userdata * | SwigUserData (lua_State *L, int index) |
std::string | MangleString (const std::string &str) |
static bool | luafaudes_rl_valididentifier (const std::string &str) |
static void | luafaudes_rl_dmadd (std::list< std::string > &mlist, const std::string &prefix, const std::string &str, const std::string &suffix) |
static int | luafaudes_rl_getmetaindex (lua_State *L) |
static void | luafaudes_rl_getmetafn (lua_State *L) |
static void | luafaudes_rl_getmetaget (lua_State *L) |
static int | luafaudes_rl_getmeta (lua_State *L, bool has_colon) |
static int | luafaudes_rl_getfield (lua_State *L, const char *s, size_t n) |
static std::list< std::string > | luafaudes_rl_complete (lua_State *L, const std::string &word) |
|
|
void | DecentralizedModularDiagnoser (const std::vector< const System * > &rGens, const Generator &rSpec, std::vector< Diagnoser * > &rDiags, std::string &rReportString) |
| Function that computes decentralized diagnosers for the respective subsystems of a composed (modular) system.
|
bool | ModularDiagnoser (const SystemVector &rGsubs, const GeneratorVector &rKsubs, GeneratorVector &rDiagSubs, std::string &rReportString) |
| Function that computes diagnosers for the respective subsystems of a composed system.
|
|
|
bool | IsCoDiagnosable (const System &rGen, const Generator &rSpec, const std::vector< const EventSet * > &rAlphabets, std::string &rReportString) |
| Checks co-diagnosability for a system G with respect to the specification K and the local observation alphabets rAlphabets.
|
|
|
void | EventDiagnoser (const System &rOrigGen, const AttributeFailureTypeMap &rAttrFTMap, Diagnoser &rDiagGen) |
| Compute a standard diagnoser from an input generator and a failure partition.
|
void | LanguageDiagnoser (const System &rGen, const System &rSpec, Diagnoser &rDiagGen) |
| Compute a standard diagnoser from an input generator and a specification.
|
|
|
bool | IsEventDiagnosable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, std::string &rReportString) |
| Test a system's diagnosability with respect to a given failure partition.
|
bool | IsIndicatorEventDiagnosable (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, std::string &rReportString) |
| Test a system's I-diagnosability with respect to a given failure partition.
|
bool | MeetsDiagnosabilityAssumptions (const System &rGen, const AttributeFailureTypeMap &rFailureTypeMap, std::string &rReportString) |
| Check if a generator meets the general assumptions of diagnosability as required by IsDiagnosable(const System&, const AttributeFailureTypeMap&, std::string&) and IsIndicatorDiagnosable(const System&, const AttributeFailureTypeMap&, std::string&).
|
|
|
bool | IsLoopPreservingObserver (const System &rGen, const EventSet &rHighAlph) |
| Verifies a loop-preserving observer.
|
void | LoopPreservingObserver (const System &rGen, const EventSet &rInitialHighAlph, EventSet &rHighAlph) |
| Computes a loop-preserving observer with minimal state size of the abstraction.
|
|
|
bool | IsLanguageDiagnosableX (const System &rGen, const System &rSpec, std::string &rReportString) |
| Tests a system's diagnosability with respect to a given specification.
|
|
|
bool | IsModularDiagnosable (const SystemVector &rGsubs, const GeneratorVector &rKsubs, std::string &rReportString) |
| Checks modular diagnosability for a system G (which consists of the subsystems rGsubs) with respect to the specification K (consisting of local specifications rKsubs) and the local abstraction alphabets rHighAlphSubs.
|
Variables |
TokenWriter * | gTestProtocolTw = NULL |
std::string | gTestProtocolFr |
static bool(* | gBreakFnct )(void)=0 |
static long | ran_seed [STREAMS] = {DEFAULT} |
static int | ran_stream = 0 |
static int | ran_initialized = 0 |
AutoRegisterType< TaNameSet
< AttributeSignalEvent > > | gRti1RegisterSignalDeviceEventSet ("SignalDeviceEventSet") |
AutoRegisterXElementTag
< TaNameSet
< AttributeSignalEvent > > | gRti1XElementTagSignalDeviceEventSet ("SignalDeviceEventSet","Event") |
AutoRegisterType< nDevice > | gRtiRegisterSimplenetDevice ("SimplenetDevice") |
AutoRegisterType< xDevice > | gRtiRegisterDeviceContainer ("DeviceContainer") |
static const char *const | luafaudes_rl_keywords [] |
Detailed Description
libFAUDES resides within the namespace faudes.
Plug-Ins may use the same namespace.
Typedef Documentation
Convenience typedef for std TimedGenerator.
Definition at line 801 of file tp_tgenerator.h.
Dummy typedef in the absence of the IO Device plugin.
Definition at line 29 of file sp_dplpexecutor.h.
Enumeration Type Documentation
Function Documentation
TransSet faudes::ActiveBackwardTransSet |
( |
const System & |
rGen, |
|
|
Idx |
state | |
|
) |
| | |
Obtain all transitions from other states into a given state of a generator.
- Parameters:
-
| rGen | A generator. |
| state | A state from the generators state set. |
- Returns:
- A transition set.
void faudes::AdjustHioController |
( |
const HioController & |
rHioController, |
|
|
const HioModule * |
rHioModule1, |
|
|
const HioModule * |
rHioModule2, |
|
|
HioController & |
rResEnv | |
|
) |
| | |
void faudes::aParallel |
( |
const GeneratorVector & |
rGenVec, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Parallel composition.
See also aParallel(const Generator&, const Generator&, Generator&). This version takes a vector of generators as argument to perform a synchronous composition of multiple generators. The implementation calls the std aParallel multiple times, future implementations may explore the overall reachable state set.
- Parameters:
-
| rGenVec | Vector of input generators |
| rResGen | Reference to resulting composition generator |
void faudes::backwardReachabilityObsOCC |
( |
const TransSetX2EvX1 & |
rTransSetX2EvX1, |
|
|
const EventSet & |
rControllableEvents, |
|
|
const EventSet & |
rHighAlph, |
|
|
Idx |
exitState, |
|
|
Idx |
currentState, |
|
|
bool |
controllablePath, |
|
|
map< Idx, map< Idx, bool > > & |
rExitLocalStatesMap, |
|
|
StateSet & |
rDoneStates | |
|
) |
| | |
void faudes::backwardVerificationLCC |
( |
const TransSetX2EvX1 & |
rTransSetX2EvX1, |
|
|
const EventSet & |
rControllableEvents, |
|
|
const EventSet & |
rHighAlph, |
|
|
Idx |
exitState, |
|
|
Idx |
currentState, |
|
|
bool |
controllablePath, |
|
|
std::map< Idx, bool > & |
rLocalStatesMap, |
|
|
StateSet & |
rDoneStates | |
|
) |
| | |
Function that supports the verification of local control consistency (LCC).
This function performs a recursive backward reachability to find if from a state where an uncontrollable high-level event is possible, another state is only reachable by local strings that contaion at least one controllable event. If this is the case, LCC is violated.
- Parameters:
-
| rTransSetX2EvX1 | reverse transition relation of the input generator |
| rControllableEvents | set of controllable events |
| rHighAlph | High level alphabet |
| exitState | start state for backward reachability |
| currentState | current state for backward reachability |
| controllablePath | false if at least one uncontrollable path to the currentState exists |
| rLocalStatesMap | map for states and their controllability property |
| rDoneStates | states that have already been visited |
void faudes::backwardVerificationLCC |
( |
const TransSetX2EvX1 & |
rTransSetX2EvX1, |
|
|
const EventSet & |
rControllableEvents, |
|
|
const EventSet & |
rHighAlph, |
|
|
Idx |
exitState, |
|
|
Idx |
currentState, |
|
|
bool |
controllablePath, |
|
|
map< Idx, bool > & |
rLocalStatesMap, |
|
|
StateSet & |
rDoneStates | |
|
) |
| | |
bool faudes::backwardVerificationOCC |
( |
const Generator & |
rLowGen, |
|
|
const EventSet & |
rControllableEvents, |
|
|
const EventSet & |
rHighAlph, |
|
|
Idx |
currentState | |
|
) |
| | |
Function that supports the verification of output control consistency (OCC).
This function performs a backward reachability to find if an uncontrollable high-level event is preemted by an uncontrollable low-level event. If this is the case, OCC is violated.
- Parameters:
-
| rLowGen | Input generator |
| rControllableEvents | set of controllable events |
| rHighAlph | High level alphabet |
| currentState | start state for backward reachability |
- Returns:
- true if no controllable low-level event has been found
void faudes::calcAbstAlphClosed |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
std::map< Transition, Idx > & |
rMapChangedTrans | |
|
) |
| | |
L(G)-observer computation.
This function is called by void calcAbstAlphClosed(Generator& rGenObs, EventSet& rControllableEvents, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx, set<Idx> >& rMapRelabeledEvents). It modifies a given generator and an associated natural projection such that the resulting natural projection is an Lm-observer for the prefix-closed language of the resulting generator. This function evaluates the observer algorithm as described in K. C. Wong and W. M. Wonham, "On the Computation of Observers in Discrete Event Systems," Discrete Event Dynamic Systems, vol. 14, no. 1, pp. 55-107, 2004.
The alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenObs. rGenObs must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGenObs | Low-level generator. It is modified by the algorithm by relabeling transitions and events |
| rControllableEvents | Set of controllable events |
| rHighAlph | Initial abstraction alphabet |
| rNewHighAlph | Modified abstraction alphabet such that the abstraction is an Lm-observer |
| rMapChangedTrans | Maps the original relabeled transitions to the new events |
void faudes::calcAbstAlphClosed |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
std::map< Idx, std::set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
L(G)-observer computation.
This function is called by calcAbstAlphClosed(System& rGenObs, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx, set<Idx> >& rMapRelabeledEvents). It modifies a given generator and an associated natural projection such that the resulting natural projection is an L(G)-observer for the prefix-closed language of the resulting generator. This function evaluates the observer algorithm as described in K. C. Wong and W. M. Wonham, "On the Computation of Observers in Discrete Event Systems," Discrete Event Dynamic Systems, vol. 14, no. 1, pp. 55-107, 2004.
the alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenObs rGenObs must be a deterministic generator no further restrictions on parameters.
- Parameters:
-
| rGenObs | Low-level generator. It is modified by the algorithm by relabeling transitions and events |
| rControllableEvents | Set of controllable events |
| rHighAlph | Initial abstraction alphabet |
| rNewHighAlph | Modified abstraction alphabet such that the abstraction is an Lm-observer |
| rMapRelabeledEvents | Maps the original events to sets of newly introduced events (accumulatoive, call clear before) |
void faudes::calcAbstAlphClosed |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Transition, Idx > & |
rMapChangedTrans | |
|
) |
| | |
void faudes::calcAbstAlphClosed |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Idx, set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::calcAbstAlphClosed |
( |
System & |
rGenObs, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Idx, set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::calcAbstAlphMSA |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
std::map< Transition, Idx > & |
rMapChangedTrans | |
|
) |
| | |
MSA-observer computation.
This function is called by void calcAbstAlphMSA(Generator& rGenObs, EventSet& rControllableEvents, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx, set<Idx> >& rMapRelabeledEvents). It modifies a given generator and an associated natural projection such that the resulting natural projection is an MSA-observer for the language marked by the resulting generator. This function evaluates the observer algorithm as described in K. Schmidt and Th. Moor, "Marked String Accepting Observers for the Hierarchical and Decentralized Control of Discrete Event Systems," Workshop on Discrete Event Systems, 2006.
The alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenObs. rGenObs must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGenObs | Low-level generator. It is modified by the algorithm by relabeling transitions and events |
| rControllableEvents | Set of controllable events |
| rHighAlph | Initial abstraction alphabet |
| rNewHighAlph | Modified abstraction alphabet such that the abstraction is an Lm-observer |
| rMapChangedTrans | Maps the original relabeled transitions to the new events |
void faudes::calcAbstAlphMSA |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
std::map< Idx, std::set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
MSA-observer computation.
This function is called by calcAbstAlphMSA(System& rGenObs, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx, set<Idx> >& rMapRelabeledEvents). It modifies a given generator and an associated natural projection such that the resulting natural projection is an MSA-observer for the language marked by the resulting generator. This function evaluates the observer algorithm as described in K. Schmidt and Th. Moor, "Marked String Accepting Observers for the Hierarchical and Decentralized Control of Discrete Event Systems," Workshop on Discrete Event Systems, 2006.
the alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenObs rGenObs must be a deterministic generator no further restrictions on parameters.
- Parameters:
-
| rGenObs | Low-level generator. It is modified by the algorithm by relabeling transitions and events |
| rControllableEvents | Set of controllable events |
| rHighAlph | Initial abstraction alphabet |
| rNewHighAlph | Modified abstraction alphabet such that the abstraction is an Lm-observer |
| rMapRelabeledEvents | Maps the original events to sets of newly introduced events (accumulatoive, call clear before) |
void faudes::calcAbstAlphMSA |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Transition, Idx > & |
rMapChangedTrans | |
|
) |
| | |
void faudes::calcAbstAlphMSA |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Idx, set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::calcAbstAlphMSA |
( |
System & |
rGenObs, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Idx, set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::calcAbstAlphMSALCC |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
std::map< Transition, Idx > & |
rMapChangedTrans | |
|
) |
| | |
MSA-observer computation including local control consistency (LCC).
This function is called by calcAbstAlphMSALCC(System& rGenObs, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx,set<Idx > > & rMapRelabeledEvents). It modifies a given generator and an associated natural projection such that the resulting natural projection is an MSA-observer for the language marked by the resulting generator and at the same time fulfills the local control consistency condition (LCC). This function evaluates the observer algorithm as described in K. Schmidt and C. Breindl, "On Maximal Permissiveness of Hierarchical and Modular Supervisory Control Approaches for Discrete Event Systems, Workshop on Discrete Event Systems, 2008. with an extension to LCC as indicated in K. Schmidt and C. Breindl, "On Maximal Permissiveness of Hierarchical and Modular Supervisory
Control Approaches for Discrete Event Systems," Workshop on Discrete Event Systems, 2008.
The alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenObs. rGenObs must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGenObs | Low-level generator. It is modified by the algorithm by relabeling transitions and events |
| rControllableEvents | Set of controllable events |
| rHighAlph | Initial abstraction alphabet |
| rNewHighAlph | Modified abstraction alphabet such that the abstraction is an Lm-observer |
| rMapChangedTrans | Maps the original relabeled transitions to the new events |
void faudes::calcAbstAlphMSALCC |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Transition, Idx > & |
rMapChangedTrans | |
|
) |
| | |
void faudes::calcAbstAlphMSALCC |
( |
System & |
rGenObs, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Idx, set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
Lm-observer computation.
This function is called by void calcAbstAlphObs(Generator& rGenObs, EventSet& rControllableEvents, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx, set<Idx> >& rMapRelabeledEvents). It modifies a given generator and an associated natural projection such that the resulting natural projection is an Lm-observer for the language marked by the resulting generator. This function evaluates the observer algorithm as described in K. C. Wong and W. M. Wonham, "On the Computation of Observers in Discrete Event Systems," Discrete Event Dynamic Systems, vol. 14, no. 1, pp. 55-107, 2004.
The alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenObs. rGenObs must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGenObs | Low-level generator. It is modified by the algorithm by relabeling transitions and events |
| rControllableEvents | Set of controllable events |
| rHighAlph | Initial abstraction alphabet |
| rNewHighAlph | Modified abstraction alphabet such that the abstraction is an Lm-observer |
| rMapChangedTrans | Maps the original relabeled transitions to the new events |
void faudes::calcAbstAlphObs |
( |
MtcSystem & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Idx, set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
Lm-observer computation.
This function is called by calcAbstAlphObs(System& rGenObs, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx, set<Idx> >& rMapRelabeledEvents). It modifies a given generator and an associated natural projection such that the resulting natural projection is an Lm-observer for the language marked by the resulting generator. This function evaluates the observer algorithm as described in K. C. Wong and W. M. Wonham, "On the Computation of Observers in Discrete Event Systems," Discrete Event Dynamic Systems, vol. 14, no. 1, pp. 55-107, 2004.
the alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenObs rGenObs must be a deterministic generator no further restrictions on parameters.
- Parameters:
-
| rGenObs | Low-level generator. It is modified by the algorithm by relabeling transitions and events |
| rControllableEvents | Set of controllable events |
| rHighAlph | Initial abstraction alphabet |
| rNewHighAlph | Modified abstraction alphabet such that the abstraction is an Lm-observer |
| rMapRelabeledEvents | Maps the original events to sets of newly introduced events (accumulatoive, call clear before) |
void faudes::calcAbstAlphObs |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
std::map< Transition, Idx > & |
rMapChangedTrans | |
|
) |
| | |
Lm-observer computation.
This function is called by void calcAbstAlphObs(Generator& rGenObs, EventSet& rControllableEvents, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx, set<Idx> >& rMapRelabeledEvents). It modifies a given generator and an associated natural projection such that the resulting natural projection is an Lm-observer for the language marked by the resulting generator. This function evaluates the observer algorithm as described in K. C. Wong and W. M. Wonham, "On the Computation of Observers in Discrete Event Systems," Discrete Event Dynamic Systems, vol. 14, no. 1, pp. 55-107, 2004.
The alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenObs. rGenObs must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGenObs | Low-level generator. It is modified by the algorithm by relabeling transitions and events |
| rControllableEvents | Set of controllable events |
| rHighAlph | Initial abstraction alphabet |
| rNewHighAlph | Modified abstraction alphabet such that the abstraction is an Lm-observer |
| rMapChangedTrans | Maps the original relabeled transitions to the new events |
void faudes::calcAbstAlphObs |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
std::map< Idx, std::set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
Lm-observer computation.
This function is called by calcAbstAlphObs(System& rGenObs, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx, set<Idx> >& rMapRelabeledEvents). It modifies a given generator and an associated natural projection such that the resulting natural projection is an Lm-observer for the language marked by the resulting generator. This function evaluates the observer algorithm as described in K. C. Wong and W. M. Wonham, "On the Computation of Observers in Discrete Event Systems," Discrete Event Dynamic Systems, vol. 14, no. 1, pp. 55-107, 2004.
the alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenObs rGenObs must be a deterministic generator no further restrictions on parameters.
- Parameters:
-
| rGenObs | Low-level generator. It is modified by the algorithm by relabeling transitions and events |
| rControllableEvents | Set of controllable events |
| rHighAlph | Initial abstraction alphabet |
| rNewHighAlph | Modified abstraction alphabet such that the abstraction is an Lm-observer |
| rMapRelabeledEvents | Maps the original events to sets of newly introduced events (accumulatoive, call clear before) |
void faudes::calcAbstAlphObs |
( |
System & |
rGenObs, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
EventRelabelMap & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::calcAbstAlphObs |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Transition, Idx > & |
rMapChangedTrans | |
|
) |
| | |
void faudes::calcAbstAlphObs |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Idx, set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::calcAbstAlphObs |
( |
System & |
rGenObs, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Idx, set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::calcAbstAlphObsLCC |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
std::map< Transition, Idx > & |
rMapChangedTrans | |
|
) |
| | |
Lm-observer computation including local control consistency (LCC).
This function is called by calcAbstAlphObsLCC(System& rGenObs, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx,set<Idx > > & rMapRelabeledEvents). It modifies a given generator and an associated natural projection such that the resulting natural projection is an Lm-observer for the language marked by the resulting generator and at the same time fulfills the local control consistency condition (LCC). This function evaluates the observer algorithm as described in K. C. Wong and W. M. Wonham, "On the Computation of Observers in Discrete Event Systems," Discrete Event Dynamic Systems, vol. 14, no. 1, pp. 55-107, 2004. with an extension to LCC as indicated in K. Schmidt and C. Breindl, "On Maximal Permissiveness of Hierarchical and Modular Supervisory
Control Approaches for Discrete Event Systems," Workshop on Discrete Event Systems, 2008.
The alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenObs. rGenObs must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGenObs | Low-level generator. It is modified by the algorithm by relabeling transitions and events |
| rControllableEvents | Set of controllable events |
| rHighAlph | Initial abstraction alphabet |
| rNewHighAlph | Modified abstraction alphabet such that the abstraction is an Lm-observer |
| rMapChangedTrans | Maps the original relabeled transitions to the new events |
void faudes::calcAbstAlphObsLCC |
( |
Generator & |
rGenObs, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Transition, Idx > & |
rMapChangedTrans | |
|
) |
| | |
void faudes::calcAbstAlphObsLCC |
( |
System & |
rGenObs, |
|
|
EventSet & |
rHighAlph, |
|
|
EventSet & |
rNewHighAlph, |
|
|
map< Idx, set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::calcBisimulation |
( |
Generator & |
rGenOrig, |
|
|
map< Idx, Idx > & |
rMapStateToPartition, |
|
|
vector< Idx > & |
rNewPartitions | |
|
) |
| | |
void faudes::calcBisimulation |
( |
Generator & |
rGenOrig, |
|
|
map< Idx, Idx > & |
rMapStateToPartition, |
|
|
Generator & |
rGenPart, |
|
|
vector< Idx > & |
rNewPartitions | |
|
) |
| | |
void faudes::calculateDynamicSystemClosedObs |
( |
const Generator & |
rGen, |
|
|
EventSet & |
rHighAlph, |
|
|
Generator & |
rGenDyn | |
|
) |
| | |
Computation of the dynamic system for Delta_sigma (reachable states after the occurrence of one high-level event).
This function computes the part of the dynamic system that is needed for evaluating the observer algorithm for closed languages.
The alphabet rHighAlph has to be a subset of the alphabet of rGen. rGen must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGen | Generator for which the dynamic system is computed |
| rHighAlph | Abstraction alphabet |
| rGenDyn | Generator representing the dynamic system |
void faudes::calculateDynamicSystemLCC |
( |
const Generator & |
rGen, |
|
|
const EventSet & |
rControllableEvents, |
|
|
const EventSet & |
rHighAlph, |
|
|
Generator & |
rGenDyn | |
|
) |
| | |
Computation of the dynamic system for Delta_lcc (fulfillment of the local control consistency property).
This function computes the part of the dynamic system that is needed for evaluating the observer algorithm for local control consistency
The alphabet rHighAlph has to be a subset of the alphabet of rGen. rGen must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGen | Generator for which the dynamic system is computed |
| rControllableEvents | Set of controllable events |
| rHighAlph | Abstraction alphabet |
| rGenDyn | Generator representing the dynamic system |
void faudes::calculateDynamicSystemMSA |
( |
const Generator & |
rGen, |
|
|
EventSet & |
rHighAlph, |
|
|
Generator & |
rGenDyn | |
|
) |
| | |
Computation of the dynamic system for Delta_msa (local fulfillment of the msa-observer property).
This function computes the part of the dynamic system that is needed for evaluating the observer algorithm for msa-observers.
The alphabet rHighAlph has to be a subset of the alphabet of rGen. rGen must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGen | Generator for which the dynamic system is computed |
| rHighAlph | Abstraction alphabet |
| rGenDyn | Generator representing the dynamic system |
Computation of the dynamic system for an Lm-observer.
This function computes the dynamic system that is needed for evaluating the observer algorithm.
The alphabet rHighAlph has to be a subset of the alphabet of rGen. rGen must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGen | Generator for which the dynamic system is computed |
| rHighAlph | Abstraction alphabet |
| rGenDyn | Generator representing the dynamic system |
void faudes::calculateDynamicSystemObs |
( |
const Generator & |
rGen, |
|
|
EventSet & |
rHighAlph, |
|
|
Generator & |
rGenDyn | |
|
) |
| | |
Computation of the dynamic system for Delta_obs (local reachability of a marked state).
This function computes the part of the dynamic system that is needed for evaluating the observer algorithm for marked languages.
The alphabet rHighAlph has to be a subset of the alphabet of rGen. rGen must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGen | Generator for which the dynamic system is computed |
| rHighAlph | Abstraction alphabet |
| rGenDyn | Generator representing the dynamic system |
bool faudes::CheckMergibility |
( |
Idx |
stateI, |
|
|
Idx |
stateJ, |
|
|
std::vector< std::set< Idx > > & |
rWaitList, |
|
|
Idx |
cNode, |
|
|
const System & |
rSupGen, |
|
|
const std::map< Idx, ReductionStateInfo > & |
rSupStateInfo, |
|
|
const std::map< Idx, Idx > & |
rState2Class, |
|
|
const std::vector< StateSet > & |
rClass2States | |
|
) |
| | |
Supervisor Reduction mergibility algorithm.
This recursive algorithm determines if two supervisor states can be merged to the same coset. It is called by the main procedure SupReduce.
- Parameters:
-
| stateI | First state to be checked |
| stateJ | second state to be checked |
| rWaitList | list of waiting state pairs |
| cNode | remembers first state to be checked |
| rSupGen | constant reference to supervisor |
| rSupStateInfo | constant reference to state info data structure |
| rState2Class | constant reference to data structure that maps states to their coset |
| rClass2State | constant reference to data structure that maps cosets to their states |
- Returns:
- True if the classes of statep and stateq can be merged
bool faudes::CheckSplit |
( |
const Generator & |
rGenObs, |
|
|
const EventSet & |
rSplitAlphabet, |
|
|
const std::vector< std::pair< StateSet, Idx > > & |
rNondeterministicStates, |
|
|
Idx |
entryState | |
|
) |
| | |
Check if the current alphabet splits all local automata with nondeterminims or unobservable transitions.
This algorithm verifies if nondetermisisms or unobservable transitions are resolved if the given events in are added to the high-level alphabet. The function is called by ExtendHighAlphabet,
The alphabet rHighAlph has to be a subset of the alphabet of rGenObs. rGenObs must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGenObs | Low-level generator. It is modified by the algorithm by relabeling transitions and events |
| rSplitAlphabet | Reference to the current alphabet for splitting verification |
| rNondeterministicStates | vector with states where nondeterminism has to be resolved and the related event |
| entryState | current state that is investigated |
bool faudes::CheckSplit |
( |
const Generator & |
rGen, |
|
|
const EventSet & |
rSplitAlphabet, |
|
|
const vector< pair< StateSet, Idx > > & |
rNondeterministicStates, |
|
|
Idx |
entryState | |
|
) |
| | |
std::string faudes::CollapsString |
( |
const std::string & |
rString, |
|
|
unsigned int |
len = FD_MAXCONTAINERNAME | |
|
) |
| | |
Limit length of string, return head and tail of string.
- Parameters:
-
| rString | string |
| len | Maximum number of charakters in string (approx) |
- Returns:
- Collapsed string
void faudes::ComposedColorSet |
( |
const MtcSystem & |
rGen1, |
|
|
const Idx |
stdidx1, |
|
|
ColorSet & |
colors1, |
|
|
const MtcSystem & |
rGen2, |
|
|
const Idx |
stdidx2, |
|
|
ColorSet & |
colors2, |
|
|
ColorSet & |
composedSet | |
|
) |
| | |
Compose the color set for a state combined from two states in two distinct automata.
- Parameters:
-
| rGen1 | First MtcSystem for parallel composition |
| stdidx1 | Index to first MtcSystem's current state |
| colors1 | Color set of first MtcSystem |
| rGen2 | Second MtcSystem for parallel composition |
| stdidx2 | Index to second MtcSystem's current state |
| colors2 | Color set of second MtcSystem |
| composedSet | Color set where composition colors will be inserted |
- Exceptions:
-
| Exception |
- Index not member of set (id 200)
- Index not found in set (id 201)
|
void faudes::CompositionMap1 |
( |
const std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
std::map< Idx, Idx > & |
rCompositionMap | |
|
) |
| | |
void faudes::CompositionMap2 |
( |
const std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
std::map< Idx, Idx > & |
rCompositionMap | |
|
) |
| | |
void faudes::ComputeGd |
( |
const Diagnoser & |
rGobs, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
System & |
rGd | |
|
) |
| | |
Compute the diagnosability testing generator G_d as a parallel composition of G_o with itself (according to Jiang).
- Parameters:
-
| rGobs | Input diagnoser G_o. |
| rReverseCompositionMap | Output variable containing the mapping of G_o states and G_d states (generated by Parallel()). |
| rGd | Output variable for G_d. |
void faudes::ComputeGd |
( |
const Diagnoser & |
rGobs, |
|
|
map< pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
System & |
rGd | |
|
) |
| | |
void faudes::ComputeGobs |
( |
const System & |
rGenMarkedNonSpecBehaviour, |
|
|
Diagnoser & |
rGobs | |
|
) |
| | |
Compute G_o for a generator that marks the faulty behaviour of a plant.
Every specification violation will be labelled with label "F".
- Parameters:
-
| rGenMarkedNonSpecBehaviour | Input generator that specifies specification violations by marked states. |
| rGobs | Output variable for G_o. |
void faudes::ComputeGobs |
( |
const System & |
rOrigGen, |
|
|
const std::string & |
rFailureType, |
|
|
const EventSet & |
rFailureEvents, |
|
|
Diagnoser & |
rGobs | |
|
) |
| | |
Compute G_o for a single failure type of a generator.
- Parameters:
-
| rOrigGen | Input generator, which is a model of the original plant containing the relevant failures events. |
| rFailureType | Failure type name. |
| rFailureEvents | Failure events belonging to the failure type. |
| rGobs | Output variable for G_o. |
void faudes::ComputeGobs |
( |
const System & |
rOrigGen, |
|
|
const AttributeFailureTypeMap & |
rAttrFTMap, |
|
|
Diagnoser & |
rGobs | |
|
) |
| | |
Compute G_o for a given generator with a given failure partition (according to Jiang).
- Parameters:
-
| rOrigGen | Input generator, which is a model of the original plant containing the relevant failures events. |
| rAttrFTMap | Failure partition. |
| rGobs | Output variable for G_o. |
- Exceptions:
-
| Exception |
- Input generator has no unique initial state (id 301).
|
void faudes::ComputeGobs |
( |
const System & |
rOrigGen, |
|
|
const string & |
rFailureType, |
|
|
const EventSet & |
rFailureEvents, |
|
|
Diagnoser & |
rGobs | |
|
) |
| | |
void faudes::ComputeReachability |
( |
const System & |
rGen, |
|
|
const EventSet & |
rUnobsEvents, |
|
|
Idx |
State, |
|
|
std::map< Idx, std::multimap< Idx, DiagLabelSet > > & |
rReachabilityMap | |
|
) |
| | |
Compute the reachability from a state of a generator that marks its faulty behaviour.
States are said to be reachable if they can be reached through a trace that consists of arbitrarily many unobservable events followed by one observable event.
- Parameters:
-
| rGen | Input generator. |
| rUnobsEvents | Unobservable events in the generators alphabet. |
| State | A state of the generators state set. |
| rReachabilityMap | Output variable for the reachability. Maps occurring observable events to the reachable generator states and a label that contains information about specification violations. |
void faudes::ComputeReachability |
( |
const System & |
rGen, |
|
|
const EventSet & |
rUnobsEvents, |
|
|
Idx |
State, |
|
|
map< Idx, multimap< Idx, DiagLabelSet > > & |
rReachabilityMap | |
|
) |
| | |
void faudes::ComputeReachability |
( |
const System & |
rGen, |
|
|
const EventSet & |
rUnobsEvents, |
|
|
const EventSet & |
rFailures, |
|
|
Idx |
State, |
|
|
const AttributeFailureTypeMap & |
rAttrFTMap, |
|
|
std::map< Idx, std::multimap< Idx, DiagLabelSet > > & |
rReachabilityMap | |
|
) |
| | |
Compute the reachability from a given generator state through a trace that consists of arbitrarily many unobservable events followed by one observable event.
- Parameters:
-
| rGen | Input generator. |
| rUnobsEvents | Unobservable events in the generators alphabet. |
| rFailures | Unobservable failure events in the generators alphabet. |
| State | A state of the generators state set. |
| rAttrFTMap | Failure partition. |
| rReachabilityMap | Output variable for the reachability. Maps occurring observable events to the reachable generator states and the corresponding failure types that occurred within the unobservable part of the trace. |
void faudes::ComputeReachability |
( |
const System & |
rGen, |
|
|
const EventSet & |
rUnobsEvents, |
|
|
const EventSet & |
rFailures, |
|
|
Idx |
State, |
|
|
const AttributeFailureTypeMap & |
rAttrFTMap, |
|
|
map< Idx, multimap< Idx, DiagLabelSet > > & |
rReachabilityMap | |
|
) |
| | |
void faudes::ComputeReachabilityRecursive |
( |
const System & |
rGen, |
|
|
const EventSet & |
rUnobsEvents, |
|
|
Idx |
State, |
|
|
StateSet |
done, |
|
|
std::map< Idx, std::multimap< Idx, DiagLabelSet > > & |
rReachabilityMap | |
|
) |
| | |
Auxiliary function for ComputeReachability(const System&, const EventSet&, Idx State, std::map<Idx,std::multimap< Idx,DiagLabelSet> >&).
Is recursively called for every occurring state on the trace (that consists of arbitrarily many unobservable events followed by one observable event).
- Parameters:
-
| rGen | Input generator. |
| rUnobsEvents | Unobservable events in the generators alphabet. |
| State | The current state within the trace. |
| done | Progress. |
| rReachabilityMap | Output variable for the reachability. Maps occurring observable events to the reachable generator states and a label that contains information about specification violations. |
void faudes::ComputeReachabilityRecursive |
( |
const System & |
rGen, |
|
|
const EventSet & |
rUnobsEvents, |
|
|
Idx |
State, |
|
|
StateSet |
done, |
|
|
map< Idx, multimap< Idx, DiagLabelSet > > & |
rReachabilityMap | |
|
) |
| | |
void faudes::ComputeReachabilityRecursive |
( |
const System & |
rGen, |
|
|
const EventSet & |
rUnobsEvents, |
|
|
const EventSet & |
rFailures, |
|
|
Idx |
State, |
|
|
const AttributeFailureTypeMap & |
rAttrFTMap, |
|
|
std::map< Idx, std::multimap< Idx, DiagLabelSet > > & |
rReachabilityMap, |
|
|
const DiagLabelSet |
FToccurred | |
|
) |
| | |
Auxiliary function for ComputeReachability(const System&, const EventSet&, const EventSet&, Idx, const AttributeFailureTypeMap&, std::map<Idx,std::multimap<Idx,DiagLabelSet>>&).
Is recursively called for every occurring state on the trace (that consists of arbitrarily many unobservable events followed by one observable event).
- Parameters:
-
| rGen | Input generator. |
| rUnobsEvents | Unobservable events in the generators alphabet. |
| rFailures | Unobservable failure events in the generators alphabet. |
| State | The current state within the trace. |
| rAttrFTMap | Failure partition. |
| rReachabilityMap | Output variable for the reachability. Maps occurring observable events to the reachable generator states and the coresponing failure types that occurred within the unobservable part of the trace. |
| FToccurred | Collects occurring failure types. |
void faudes::ComputeReachabilityRecursive |
( |
const System & |
rGen, |
|
|
const EventSet & |
rUnobsEvents, |
|
|
const EventSet & |
rFailures, |
|
|
Idx |
State, |
|
|
const AttributeFailureTypeMap & |
rAttrFTMap, |
|
|
map< Idx, multimap< Idx, DiagLabelSet > > & |
rReachabilityMap, |
|
|
const DiagLabelSet |
FToccurred | |
|
) |
| | |
void faudes::ConcatenateFullLanguage |
( |
Generator & |
rGen |
) |
|
ConcatenateFullLanguage: concatenate Sigma* to language marked by rGen.
Less expensive than using LanguageConcatenate() to concatenate Sigma*, as no additional nondeterminism is caused. Used in SupNorm(). Method: Transitions starting from marked states are erased. Remaining accessible marked states are provided with Sigma-selfloops. Determinism: Result can only become nondeterministic when a parameter is nondeterministic.
- Parameters:
-
| rGen | generator marking the language to be concatenated with Sigma* |
void faudes::ControlProblemConsistencyCheck |
( |
const Generator & |
rPlantGen, |
|
|
const EventSet & |
rCAlph, |
|
|
const Generator & |
rSpecGen | |
|
) |
| | |
Consistency check for controlproblem input data.
Tests whether alphabets match and generators are deterministic.
- Parameters:
-
| rPlantGen | Plant generator |
| rCAlph | Controllable events |
| rSpecGen | Specification generator |
- Exceptions:
-
| Exception |
- lphabets of generators don't match (id 100)
- plant generator nondeterministic (id 201)
- specification generator nondeterministic (id 203)
- plant and spec generator nondeterministic (id 204)
|
void faudes::ConvertParallelCompositionMap |
( |
const std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
std::map< Idx, std::pair< Idx, Idx > > & |
rCompositionMap | |
|
) |
| | |
Convert the reverse composition map of Parallel() by switching first and second entry.
- Parameters:
-
| rReverseCompositionMap | Input map as generated by Parallel(). |
| rCompositionMap | Converted map. |
void faudes::ConvertParallelCompositionMap |
( |
const map< pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
map< Idx, pair< Idx, Idx > > & |
rCompositionMap | |
|
) |
| | |
void faudes::cParallel |
( |
const std::vector< System > & |
rGens, |
|
|
System & |
rResGen | |
|
) |
| | |
Parallel composition of multiple generators.
- Parameters:
-
| rGens | STL-vector of generators. |
| rResGen | Output variable for the resulting product generator. |
void faudes::cParallel |
( |
const vector< System > & |
rGens, |
|
|
System & |
rResGen | |
|
) |
| | |
void faudes::cParallel |
( |
const std::vector< const System * > & |
rGens, |
|
|
System & |
rResGen | |
|
) |
| | |
Parallel composition of multiple generators.
- Parameters:
-
| rGens | STL-vector of generators. |
| rResGen | Output variable for the resulting product generator. |
void faudes::CreateConstraint |
( |
int |
mType[5], |
|
|
Generator & |
constrP, |
|
|
Generator & |
constrE | |
|
) |
| | |
This function creates constraints which describe the condition of completeness and Yp-liveness of a Specification.
The implementation follows the same algorithm as the CreateSpec() function, and has the same limitation: it is only for use with a specific model
- Parameters:
-
| mType | By the type we specify type of the specification to build constraint for |
| constrP | Generator to the resulting operator constraint for the specification |
| constrE | Generator to the resulting environment constraint for the specification |
void faudes::CreateEntryStatesMap |
( |
const std::map< StateSet, Idx > & |
rRevEntryStatesMap, |
|
|
std::map< Idx, StateSet > & |
rEntryStatesMap | |
|
) |
| | |
void faudes::CreateSpec |
( |
int |
mType[5], |
|
|
HioPlant & |
rHioSpec, |
|
|
Generator & |
constrP, |
|
|
Generator & |
constrE | |
|
) |
| | |
This function creates new specification given by the type ("xxxxx") Note: The core of this function is a template specification model (SpecCB12.gen).
Based on this model are the specifications created, by simply adding corresponding states and transitions. Hence, for different models, this function can not be used directly, but can serve as an example.
- Parameters:
-
| mType | By the type we specify the desired behaviour we want to model |
| rHioSpec | HioPlant reference to the resulting specification (result) |
| constrP | Generator to the resulting operator constraint for the specification |
| constrE | Generator to the resulting environment constraint for the specification |
std::string faudes::CreateTempFile |
( |
void |
|
) |
|
Create a temp file, length 0.
- Returns:
- Name of temp file
bool faudes::CycleOfUnobsEvents |
( |
const System & |
rGen, |
|
|
std::string & |
rReport | |
|
) |
| | |
Test if there exist any cycles of unobservable events in a generator.
- Parameters:
-
| rGen | Input generator. |
| rReport | User-readable information of violating condition (in case of positive test result). |
- Returns:
- True if there exists a cycle of unobservable events.
bool faudes::CycleOfUnobsEvents |
( |
const System & |
rGen, |
|
|
string & |
rReport | |
|
) |
| | |
void faudes::CycleStartStates |
( |
const System & |
rGen, |
|
|
StateSet & |
rCycleOrigins | |
|
) |
| | |
Find all start/end states of cycles of unobservable events in a generator.
- Parameters:
-
| rGen | Input generator. |
| rCycleOrigins | Output variable for the states that have been found. |
void faudes::CycleStartStatesSearch |
( |
const System & |
rGen, |
|
|
StateSet & |
rTodo, |
|
|
Idx |
currState, |
|
|
StateSet |
statesOnPath, |
|
|
StateSet & |
rCycleOriginStates | |
|
) |
| | |
Auxiliary function for CycleStartStates().
Parses through the active event set of the current state and checks whether any of the successor states already occurred on the path to current state (then a cycle is found).
- Parameters:
-
| rGen | Input generator. |
| rTodo | States that remain to be processed. |
| currState | The current state. |
| statesOnPath | States that occurred on the path. |
| rCycleOriginStates | Output variable for the states that have been found. |
bool faudes::DecentralizedDiagnoser |
( |
const System & |
rGen, |
|
|
const Generator & |
rSpec, |
|
|
const EventSetVector & |
rAlphabets, |
|
|
GeneratorVector & |
rDiags | |
|
) |
| | |
Function definition for run-time interface.
void faudes::DecentralizedModularDiagnoser |
( |
const SystemVector & |
rGens, |
|
|
const Generator & |
rSpec, |
|
|
GeneratorVector & |
rDiags | |
|
) |
| | |
Function definition for run-time interface.
void faudes::Deterministic |
( |
const Generator & |
rGen, |
|
|
std::vector< StateSet > & |
rPowerStates, |
|
|
std::vector< Idx > & |
rDetStates, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Make generator deterministic.
Constructs a deterministic generator while preserving the generated and marked languages. See Deterministic(const Generator&,Generator& rResGen) for the intended api. This version provides as second and third parameters the correspondence betwwen new states and the original state sets. in vectors
- Parameters:
-
| rGen | Reference to generator |
| rPowerStates | Vector that holds the power states |
| rDetStates | Vector that holds the corresponding deterministic states |
| rResGen | Reference to resulting deterministic generator |
void faudes::Deterministic |
( |
const Generator & |
rGen, |
|
|
std::map< Idx, StateSet > & |
rEntryStatesMap, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Make generator deterministic.
Constructs a deterministic generator while preserving the generated and marked languages. See Deterministic(const Generator&,Generator& rResGen) for the intended api. This version provides as a second parameter the resulting map from new states to their respective original state set. It is used as a so called "entry state map" for deterministic projected generators.
- Parameters:
-
| rGen | Reference to generator |
| rEntryStatesMap | Entry state map |
| rResGen | Reference to resulting deterministic generator |
const std::string & faudes::DirSeparator |
( |
void |
|
) |
|
Std dir-separator.
- Returns:
- Separator as one-char string
void faudes::EventDiagnoser |
( |
const System & |
rOrigGen, |
|
|
const std::map< std::string, EventSet > & |
rFailureTypeMap, |
|
|
Diagnoser & |
rDiagGen | |
|
) |
| | |
Compute a standard diagnoser from an input generator and a failure partition.
- Parameters:
-
| rOrigGen | Input plant including failure events. |
| rFailureTypeMap | Failure partition: maps failure type names to failure events. |
| rDiagGen | Diagnoser generator for output. |
void faudes::EventDiagnoser |
( |
const System & |
rOrigGen, |
|
|
const map< string, EventSet > & |
rFailureTypeMap, |
|
|
Diagnoser & |
rDiagGen | |
|
) |
| | |
bool faudes::ExistsCycle |
( |
const System & |
rGen, |
|
|
std::string & |
rReport | |
|
) |
| | |
Test if there exist any cycles in a generator.
- Parameters:
-
| rGen | Input generator. |
| rReport | User-readable information of violating condition (in case of positive test result). |
- Returns:
- True if there exists a cycle.
bool faudes::ExistsCycle |
( |
const System & |
rGen, |
|
|
string & |
rReport | |
|
) |
| | |
bool faudes::ExistsCycleSearch |
( |
const System & |
rGen, |
|
|
StateSet & |
rTodo, |
|
|
Idx |
currState, |
|
|
StateSet |
statesOnPath, |
|
|
std::string & |
rReport | |
|
) |
| | |
Auxiliary function for ExistsCycle(const System&, std::string&).
Starting from a state currState, this function makes a depth-first-search through the generator rGen.
- Parameters:
-
| rGen | Input generator. |
| rTodo | States to process. |
| currState | Current state. |
| statesOnPath | States that occurred on the way to current state. |
| rReport | User-readable information of violating condition (in case of negative test result). |
- Returns:
- True if a cycle is found.
bool faudes::ExistsCycleSearch |
( |
const System & |
rGen, |
|
|
StateSet & |
rTodo, |
|
|
Idx |
currState, |
|
|
StateSet |
statesOnPath, |
|
|
string & |
rReport | |
|
) |
| | |
bool faudes::ExistsViolatingCyclesInGd |
( |
System & |
rGd, |
|
|
const Diagnoser & |
rGobs, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
const std::string & |
rFailureType, |
|
|
std::string & |
rReportString | |
|
) |
| | |
Remove states with same failure labels from rGd and from rReverseCompositionMap and perform cycle detection.
- Parameters:
-
| rGd | Input diagnoser generator. |
| rGobs | Generator G_o to look up failure labels. |
| rReverseCompositionMap | Mapping of G_d states with G_o states. |
| rFailureType | The considered failure type. |
| rReportString | User-readable information of violating condition (in case of negative test result). |
- Returns:
- True if violating cycles exist.
bool faudes::ExistsViolatingCyclesInGd |
( |
System & |
rGd, |
|
|
const Diagnoser & |
rGobs, |
|
|
map< pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
const string & |
rFailureType, |
|
|
string & |
rReportString | |
|
) |
| | |
void faudes::ExitFunction |
( |
void |
|
) |
|
std::string faudes::ExpandString |
( |
const std::string & |
rString, |
|
|
unsigned int |
len | |
|
) |
| | |
Fill string with spaces up to a given length if length of the string is smaller than given length parameter.
- Parameters:
-
| rString | string |
| len | Minimum number of charakters in string |
- Returns:
- Expanded string
void faudes::ExtendHighAlphabet |
( |
const Generator & |
rGen, |
|
|
EventSet & |
rHighAlph, |
|
|
map< Idx, Idx > & |
rMapStateToPartition | |
|
) |
| | |
std::string faudes::ExtractBasename |
( |
const std::string & |
rFullName |
) |
|
Extract file name from full path.
This version also remove the last suffix.
- Parameters:
-
| rFullName | Full path of file eg "/home/friend/data/generator.gen" |
- Returns:
- Filename "generator"
std::string faudes::ExtractDirectory |
( |
const std::string & |
rFullPath |
) |
|
Extract directory from full path.
- Parameters:
-
| rFullPath | Full name of file eg "/home/friend/data/generator.gen" |
- Returns:
- Directory eg "/home/friend/data"
std::string faudes::ExtractExtension |
( |
const std::string & |
rFullName |
) |
|
Extract file name from full path.
This version also remove the last suffix.
- Parameters:
-
| rFullName | Full path of file eg "/home/friend/data/generator.gen" |
- Returns:
- Extension "gen"
std::string faudes::ExtractFilename |
( |
const std::string & |
rFullName |
) |
|
Extract file name from full path.
- Parameters:
-
| rFullName | Full path of file eg "/home/friend/data/generator.gen" |
- Returns:
- Filename "generator.gen"
bool faudes::FailuresUnobservable |
( |
const System & |
rGen, |
|
|
const AttributeFailureTypeMap & |
rFailureTypeMap, |
|
|
std::string & |
rReport | |
|
) |
| | |
Check if all failure events are unobservable events in a generator's alphabet.
- Parameters:
-
| rGen | Input generator, is a model of the original plant containing the relevant failures events. |
| rFailureTypeMap | Failure partition: maps failure type names to failure events and indicator events. |
| rReport | User-readable information of violating condition (in case of negative result). |
- Returns:
- True if all failures events are unobservable.
bool faudes::FailuresUnobservable |
( |
const System & |
rGen, |
|
|
const AttributeFailureTypeMap & |
rFailureTypeMap, |
|
|
string & |
rReport | |
|
) |
| | |
const std::string& faudes::FaudesFunctionName |
( |
const Function & |
rObject |
) |
|
std::string faudes::FDContributorsString |
( |
|
) |
|
Return contributors as std::string.
- Returns:
- std::string
std::string faudes::FDPluginsString |
( |
|
) |
|
Return FAUDES_PLUGINS as std::string.
- Returns:
- std::string with FAUDES_VERSION
std::string faudes::FDVersionString |
( |
|
) |
|
Return FAUDES_VERSION as std::string.
- Returns:
- std::string with FAUDES_VERSION
bool faudes::FileExists |
( |
const std::string & |
rFilename |
) |
|
Test existence of file.
- Parameters:
-
| rFilename | Name of file to test |
- Returns:
- True <> can open file for reading
void faudes::GroupHioModules |
( |
const std::vector< HioModule * > & |
rChildren, |
|
|
HioModule & |
rParentModule | |
|
) |
| | |
GroupHioModules: This function groups two or more HioModules to a new HioModule.
The new HioModule represents the uncontrolled behaviour of the composed HioModules.
- Parameters:
-
| rChildren | vector of HioModules to group |
| rParentModule | resulting HioModule |
void faudes::HioShuffle_Musunoi |
( |
const HioPlant & |
rPlantA, |
|
|
const HioPlant & |
rPlantB, |
|
|
int |
depth, |
|
|
Generator & |
rIOShuffAB | |
|
) |
| | |
void faudes::HioStatePartition |
( |
HioPlant & |
rPlant |
) |
|
Function definition for run-time interface.
- Parameters:
-
void faudes::HioStatePartition |
( |
HioEnvironment & |
rEnvironment |
) |
|
Function definition for run-time interface.
- Parameters:
-
| rEnvironment | HioEnvironment |
void faudes::HioStatePartition |
( |
HioController & |
rController |
) |
|
Function definition for run-time interface.
- Parameters:
-
| rController | HioController |
void faudes::HioStatePartition |
( |
HioConstraint & |
rConstraint |
) |
|
Function definition for run-time interface.
- Parameters:
-
| rConstraint | HioConstraint |
void faudes::HioSynth_Musunoi |
( |
const Generator & |
rPlant, |
|
|
const HioPlant & |
rSpec, |
|
|
const Generator & |
rConstr, |
|
|
const Generator & |
rLocConstr, |
|
|
const EventSet & |
rYp, |
|
|
const EventSet & |
rUp, |
|
|
Generator & |
rController | |
|
) |
| | |
void faudes::insertRelabeledEvents |
( |
Generator & |
rGenPlant, |
|
|
const std::map< Idx, std::set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::insertRelabeledEvents |
( |
System & |
rGenPlant, |
|
|
const std::map< Idx, std::set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::insertRelabeledEvents |
( |
Generator & |
rGenPlant, |
|
|
const std::map< Idx, std::set< Idx > > & |
rMapRelabeledEvents, |
|
|
EventSet & |
rNewEvents | |
|
) |
| | |
Convenience function for relabeling events in a given generator.
This function inserts new events and respective transitions given by a relableing map into a given generator.
Technical note: Recording of new events includes attributes, provided that the third parameter has a compatible attribute type.
There are no restrictions on parameters.
- Parameters:
-
| rGenPlant | Plant component automaton |
| rMapRelabeledEvents | Maps the original events to sets of newly introduced events |
| rNewEvents | Returns the newly inserted events (accumulative, call clear before) |
void faudes::insertRelabeledEvents |
( |
System & |
rGenPlant, |
|
|
const std::map< Idx, std::set< Idx > > & |
rMapRelabeledEvents, |
|
|
Alphabet & |
rNewEvents | |
|
) |
| | |
Convenience function for relabeling events in a given generator.
This function inserts new events and respective transitions given by a relableing map into a given generator. The function is used to adjust plant components to the relableing from another plant component.
Technical note: This version records newly inserted events incl. their respective controllability attribute in the third parameter. T
There are no restrictions on parameters.
- Parameters:
-
| rGenPlant | Plant component automaton |
| rMapRelabeledEvents | Maps the original events to sets of newly introduced events |
| rNewEvents | Returns the newly inserted events (accumulative, call clear before) |
void faudes::insertRelabeledEvents |
( |
Generator & |
rGenPlant, |
|
|
const EventRelabelMap & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::insertRelabeledEvents |
( |
Generator & |
rGenPlant, |
|
|
const EventRelabelMap & |
rMapRelabeledEvents, |
|
|
EventSet & |
rNewEvents | |
|
) |
| | |
void faudes::insertRelabeledEvents |
( |
Generator & |
rGenPlant, |
|
|
const map< Idx, set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::insertRelabeledEvents |
( |
System & |
rGenPlant, |
|
|
const map< Idx, set< Idx > > & |
rMapRelabeledEvents | |
|
) |
| | |
void faudes::insertRelabeledEvents |
( |
Generator & |
rGenPlant, |
|
|
const map< Idx, set< Idx > > & |
rMapRelabeledEvents, |
|
|
EventSet & |
rNewEvents | |
|
) |
| | |
void faudes::insertRelabeledEvents |
( |
System & |
rGenPlant, |
|
|
const map< Idx, set< Idx > > & |
rMapRelabeledEvents, |
|
|
Alphabet & |
rNewEvents | |
|
) |
| | |
long int faudes::IntegerSum |
( |
const IntegerVector & |
intvect |
) |
|
long int faudes::IntegerSum |
( |
const Integer & |
arg1, |
|
|
const Integer & |
arg2 | |
|
) |
| | |
void faudes::IoStatePartition |
( |
IoSystem & |
rIoSystem |
) |
|
Construct io state partition.
This is an rti wrapper for bool IsIoSystem(IoSystem&).
- Parameters:
-
| rIoSystem | Generator to test. |
void faudes::IoSynthesis |
( |
const IoSystem & |
rPlant, |
|
|
const Generator & |
rSpec, |
|
|
IoSystem & |
rSup | |
|
) |
| | |
IO system synthesis.
This method esentially is a wrapper for SupConComplete(), which implements a synthesis procedure to compute the supremal controllable and complete sublanguage for a given plant and specification. Input events are regarded controllable. marking is ignored, i.e., synthesis refers to the generated langugaes rather than the the marked languages. For a version thet refers to Buchi acceptance condition, see IoSynthesisNB(const IoSystem&, const Generator&, IoSystem&).
The resulting supervisor is an IO System with the plant input events as outputs and vice versa.
Note that this routine does not test whether the plant has a locally free input U, nor does it ensure that the resulting supervisor has a free input Y.
- Parameters:
-
| rPlant | IO-System - plant model |
| rSpec | Generator - specification |
| rSup | IO-System - supervisor |
- Exceptions:
-
| Exception |
- Any exceptions passed on from SupConComplete
|
void faudes::IoSynthesisNB |
( |
const IoSystem & |
rPlant, |
|
|
const Generator & |
rSpec, |
|
|
IoSystem & |
rSup | |
|
) |
| | |
IO system synthesis.
This method esentially is a wrapper for SupConOmegaNB(), which implements a synthesis procedure to compute the supremal omega-controllable. sublanguage for a given plant and specification. Input events are regarded controllable. In contrast to IoSynthesis(const IoSystem&, const Generator&, IoSystem&), this procedure refers to the Bucji acceptance condition and ensures a omega-nonblocking closed-loop behaviour.
The resulting supervisor is an IO System with the plant input events as outputs and vice versa.
Note that this routine does not test whether the plant has a locally free input U, nor does it ensure that the resulting supervisor has a free input Y.
- Parameters:
-
| rPlant | IO-System - plant model |
| rSpec | Generator - specification |
| rSup | IO-System - supervisor |
- Exceptions:
-
| Exception |
- Any exceptions passed on from SupConOmegaNB
|
bool faudes::IsCoDiagnosable |
( |
const System & |
rGen, |
|
|
const Generator & |
rSpec, |
|
|
const EventSetVector & |
rAlphabets | |
|
) |
| | |
Function definition for run-time interface.
bool faudes::IsCoDiagnosable |
( |
const System & |
rGen, |
|
|
const Generator & |
rSpec, |
|
|
const vector< const EventSet * > & |
rAlphabets, |
|
|
std::string & |
rReportString | |
|
) |
| | |
bool faudes::IsComplete |
( |
const vGenerator & |
rGen, |
|
|
const StateSet & |
rStateSet | |
|
) |
| | |
bool faudes::IsControllableUnchecked |
( |
const Generator & |
rPlantGen, |
|
|
const EventSet & |
rCAlph, |
|
|
const Generator & |
rSpecGen, |
|
|
StateSet & |
rCriticalStates | |
|
) |
| | |
Controllability (internal function).
Checks if language of specification h is controllable with respect to language of generator g. Only for deterministic plant + spec.
Controllable event set has to be given as parameter. Returns the set of critical states as last parameter.
- Parameters:
-
| rPlantGen | Plant generator |
| rCAlph | Controllable events |
| rSpecGen | Specification generator |
| rCriticalStates | Set of critical states |
- Exceptions:
-
| Exception |
- alphabets of generators don't match (id 100)
- plant generator nondeterministic (id 201)
- specification generator nondeterministic (id 203)
- plant & spec generator nondeterministic (id 204)
|
- Returns:
- true / false
bool faudes::IsEventDiagnosable |
( |
const System & |
rGen, |
|
|
const AttributeFailureTypeMap & |
rFailureTypeMap | |
|
) |
| | |
Function definition for run-time interface.
bool faudes::IsEventDiagnosable |
( |
const System & |
rGen, |
|
|
const AttributeFailureTypeMap & |
rFailureTypeMap, |
|
|
string & |
rReportString | |
|
) |
| | |
bool faudes::IsHioConstraintForm |
( |
HioConstraint & |
rHioConstraint |
) |
|
IsHioConstraintForm: check if rHioConstraint is in I/O-constraint form and assign state attributes.
This function tests if rHioConstraint meets the I/O-constraint form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioConstraint formally describe an I/O constraint. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QY flag is assigned to a state if its active eventset is a subset of the Y-Alphabet. The assignment of HioStateFlags is complete only if IsHioConstraintForm() returns true. Method: all conditions of the formal I/O-constraint form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.
- Parameters:
-
- Returns:
- true if rHioConstraint is in I/O-constraint form
bool faudes::IsHioConstraintForm |
( |
HioConstraint & |
rHioConstraint, |
|
|
std::string & |
rReportStr | |
|
) |
| | |
IsHioConstraintForm: check if rHioConstraint is in I/O-constraint form and assign state attributes.
This function tests if rHioConstraint meets the I/O-constraint form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioConstraint formally describe an I/O constraint. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QY flag is assigned to a state if its active eventset is a subset of the Y-Alphabet. The assignment of HioStateFlags is complete only if IsHioConstraintForm() returns true. Method: all conditions in the formal I/O-constraint form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.
- Parameters:
-
| rHioConstraint | HioConstraint to check, HioStateFlags are set |
| rReportStr | Information about test results |
- Returns:
- true if rHioConstraint is in I/O-constraint form
bool faudes::IsHioConstraintForm |
( |
HioConstraint & |
rHioConstraint, |
|
|
StateSet & |
rQY, |
|
|
StateSet & |
rQU, |
|
|
EventSet & |
rErrEvSet, |
|
|
TransSet & |
rErrTrSet, |
|
|
StateSet & |
rErrStSet, |
|
|
std::string & |
rReportStr | |
|
) |
| | |
IsHioConstraintForm: check if rHioConstraint is in I/O-constraint form and assign state attributes.
This function tests if rHioConstraint meets the I/O-constraint form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioConstraint formally describe an I/O constraint. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QY flag is assigned to a state if its active eventset is a subset of the Y-Alphabet. The assignment of HioStateFlags is complete only if IsHioConstraintForm() returns true. Method: all conditions in the formal I/O-constraint form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.
- Parameters:
-
| rHioConstraint | HioConstraint to check, HioStateFlags are set |
| rQY | State set containing all QY states |
| rQU | State set containing all QU states |
| rErrEvSet | Event set for possible 'bad' events |
| rErrTrSet | Event set for possible 'bad' transition relations |
| rErrStSet | Event set for possible 'bad' states |
| rReportStr | Information about test results |
- Returns:
- true if rHioConstraint is in I/O-constraint form
bool faudes::IsHioControllerForm |
( |
HioController & |
rHioController |
) |
|
IsHioControllerForm: check if rHioController is in I/O-controller form and assign state attributes.
This function tests if rHioController meets the I/O-controller form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioController formally describe an I/O controller. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYcUp flag is assigned to a state if its active eventset is a subset of the union of the YC- and the UP-Alphabet. The assignment of HioStateFlags is complete only if IsHioControllerForm() returns true. Method: all conditions of the formal I/O-controller form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.
- Parameters:
-
- Returns:
- true if rHioController is in I/O-controller form
bool faudes::IsHioControllerForm |
( |
HioController & |
rHioController, |
|
|
std::string & |
rReportStr | |
|
) |
| | |
IsHioControllerForm: check if rHioController is in I/O-controller form and assign state attributes.
This function tests if rHioController meets the I/O-controller form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioController formally describe an I/O controller. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYcUp flag is assigned to a state if its active eventset is a subset of the union of the YC- and the UP-Alphabet. The assignment of HioStateFlags is complete only if IsHioControllerForm() returns true. Method: all conditions in the formal I/O-controller form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.
- Parameters:
-
| rHioController | HioController to check, HioStateFlags are set |
| rReportStr | Information about test results |
- Returns:
- true if rHioController is in I/O-controller form
bool faudes::IsHioControllerForm |
( |
HioController & |
rHioController, |
|
|
StateSet & |
rQUc, |
|
|
StateSet & |
rQYP, |
|
|
StateSet & |
rQUp, |
|
|
StateSet & |
rQYcUp, |
|
|
EventSet & |
rErrEvSet, |
|
|
TransSet & |
rErrTrSet, |
|
|
StateSet & |
rErrStSet, |
|
|
std::string & |
rReportStr | |
|
) |
| | |
IsHioControllerForm: check if rHioController is in I/O-controller form and assign state attributes.
This function tests if rHioController meets the I/O-controller form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioController formally describe an I/O controller. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYcUp flag is assigned to a state if its active eventset is a subset of the union of the YC- and the UP-Alphabet. The assignment of HioStateFlags is complete only if IsHioControllerForm() returns true. Method: all conditions in the formal I/O-controller form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.
- Parameters:
-
| rHioController | HioController to check, HioStateFlags are set |
| rQUc | State set containing all QUc states |
| rQYP | State set containing all QYP states |
| rQUp | State set containing all QUp states |
| rQYcUp | State set containing all QYcUp states |
| rErrEvSet | Event set for possible 'bad' events |
| rErrTrSet | Event set for possible 'bad' transition relations |
| rErrStSet | Event set for possible 'bad' states |
| rReportStr | Information about test results |
- Returns:
- true if rHioController is in I/O-controller form
bool faudes::IsHioEnvironmentForm |
( |
HioEnvironment & |
rHioEnvironment |
) |
|
IsHioEnvironmentForm: check if rHioEnvironment is in I/O-environment form and assign state attributes.
This function tests if rHioEnvironment meets the I/O-environment form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioEnvironment formally describe an I/O environment. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYlUe flag is assigned to a state if its active eventset is a subset of the union of the YL- and the UE-Alphabet. The assignment of HioStateFlags is complete only if IsHioEnvironmentForm() returns true. Method: all conditions of the formal I/O-environment form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.
- Parameters:
-
- Returns:
- true if rHioEnvironment is in I/O-environment form
bool faudes::IsHioEnvironmentForm |
( |
HioEnvironment & |
rHioEnvironment, |
|
|
std::string & |
rReportStr | |
|
) |
| | |
IsHioEnvironmentForm: check if rHioEnvironment is in I/O-environment form and assign state attributes.
This function tests if rHioEnvironment meets the I/O-environment form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioEnvironment formally describe an I/O environment. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYlUe flag is assigned to a state if its active eventset is a subset of the union of the YL- and the UE-Alphabet. The assignment of HioStateFlags is complete only if IsHioEnvironmentForm() returns true. Method: all conditions in the formal I/O-environment form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.
- Parameters:
-
| rHioEnvironment | HioEnvironment to check, HioStateFlags are set |
| rReportStr | Information about test results |
- Returns:
- true if rHioEnvironment is in I/O-environment form
bool faudes::IsHioEnvironmentForm |
( |
HioEnvironment & |
rHioEnvironment, |
|
|
StateSet & |
rQYe, |
|
|
StateSet & |
rQUe, |
|
|
StateSet & |
rQUl, |
|
|
StateSet & |
rQYlUe, |
|
|
EventSet & |
rErrEvSet, |
|
|
TransSet & |
rErrTrSet, |
|
|
StateSet & |
rErrStSet, |
|
|
std::string & |
rReportStr | |
|
) |
| | |
IsHioEnvironmentForm: check if rHioEnvironment is in I/O-environment form and assign state attributes.
This function tests if rHioEnvironment meets the I/O-environment form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioEnvironment formally describe an I/O environment. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYlUe flag is assigned to a state if its active eventset is a subset of the union of the YL- and the UE-Alphabet. The assignment of HioStateFlags is complete only if IsHioEnvironmentForm() returns true. Method: all conditions in the formal I/O-environment form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.
- Parameters:
-
| rHioEnvironment | HioEnvironment to check, HioStateFlags are set |
| rQYe | State set containing all QYe states |
| rQUe | State set containing all QUe states |
| rQUl | State set containing all QUl states |
| rQYlUe | State set containing all QYlUe states |
| rErrEvSet | Event set for possible 'bad' events |
| rErrTrSet | Event set for possible 'bad' transition relations |
| rErrStSet | Event set for possible 'bad' states |
| rReportStr | Information about test results |
- Returns:
- true if rHioEnvironment is in I/O-environment form
bool faudes::IsHioPlantForm |
( |
HioPlant & |
rHioPlant |
) |
|
IsHioPlantForm: check if rHioPlant is in I/O-plant form and assign state attributes.
Function definition for run-time interface.
This function tests if rHioPlant meets the I/O-plant form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioPlant formally describe an I/O plant. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYpYe flag is assigned to a state if its active eventset is a subset of the union of the YP- and the YE-Alphabet. The assignment of HioStateFlags is complete only if IsHioPlantForm() returns true. Method: all conditions of the formal I/O-plant form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.
- Parameters:
-
- Returns:
- true if rHioPlant is in I/O-plant form
bool faudes::IsHioPlantForm |
( |
HioPlant & |
rHioPlant, |
|
|
std::string & |
rReportStr | |
|
) |
| | |
IsHioPlantForm: check if rHioPlant is in I/O-plant form and assign state attributes.
Function definition for run-time interface.
This function tests if rHioPlant meets the I/O-plant form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioPlant formally describe an I/O plant. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYpYe flag is assigned to a state if its active even set is a subset of the union of the YP- and the YE-Alphabet. The assignment of HioStateFlags is complete only if IsHioPlantForm() returns true. Method: all conditions in the formal I/O-plant form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.
- Parameters:
-
| rHioPlant | HioPlant to check, HioStateFlags are set |
| rReportStr | Information about test results |
- Returns:
- true if rHioPlant is in I/O-plant form
bool faudes::IsHioPlantForm |
( |
HioPlant & |
rHioPlant, |
|
|
StateSet & |
rQYpYe, |
|
|
StateSet & |
rQUp, |
|
|
StateSet & |
rQUe, |
|
|
EventSet & |
rErrEvSet, |
|
|
TransSet & |
rErrTrSet, |
|
|
StateSet & |
rErrStSet, |
|
|
std::string & |
rReportStr | |
|
) |
| | |
IsHioPlantForm: check if rHioPlant is in I/O-plant form and assign state attributes.
Function definition for run-time interface.
This function tests if rHioPlant meets the I/O-plant form that has been formally defined by S.Perk. If so, then the alphabet of and the language marked by rHioPlant formally describe an I/O plant. During the test, the HioStateFlags are set according to the active event set or the respective state, for example: The QYpYe flag is assigned to a state if its active even set is a subset of the union of the YP- and the YE-Alphabet. The assignment of HioStateFlags is complete only if IsHioPlantForm() returns true. Method: all conditions in the formal I/O-plant form definition are checked individually. If crucial conditions are violated, the test of remaining conditions is omitted.
- Parameters:
-
| rHioPlant | HioPlant to check, HioStateFlags are set |
| rQYpYe | State set containing all QYpYe states |
| rQUp | State set containing all QUp states |
| rQUe | State set containing all QUe states |
| rErrEvSet | Event set for possible 'bad' events |
| rErrTrSet | Event set for possible 'bad' transition relations |
| rErrStSet | Event set for possible 'bad' states |
| rReportStr | Information about test results |
- Returns:
- true if rHioPlant is in I/O-plant form
bool faudes::IsIndicatorEventDiagnosable |
( |
const System & |
rGen, |
|
|
const AttributeFailureTypeMap & |
rFailureTypeMap | |
|
) |
| | |
Function definition for run-time interface.
bool faudes::IsIndicatorEventDiagnosable |
( |
const System & |
rGen, |
|
|
const AttributeFailureTypeMap & |
rFailureTypeMap, |
|
|
string & |
rReportString | |
|
) |
| | |
bool faudes::IsLanguageDiagnosable |
( |
const System & |
rGen, |
|
|
const System |
rSpec, |
|
|
std::string & |
rReportString | |
|
) |
| | |
Test function to verify language-diagnosability.
bool faudes::IsLanguageDiagnosable |
( |
const System & |
rGen, |
|
|
const System & |
rSpec | |
|
) |
| | |
Function definition for run-time interface.
bool faudes::IsLCC |
( |
const Generator & |
rLowGen, |
|
|
const EventSet & |
rControllableEvents, |
|
|
const EventSet & |
rHighAlph | |
|
) |
| | |
Verification of local control consistency (LCC).
For verifying if a natural projection fulfills the local control consistency condition, a backward reachability is conducted. If starting from a state, where an uncontrollable high-level event is feasible, at least one local state cannot be reached by an uncontrollable path, LCC is violated.
- Parameters:
-
| rLowGen | Input generator |
| rControllableEvents | set of controllable events |
| rHighAlph | High level alphabet |
- Returns:
- true if LCC holds
bool faudes::IsLive |
( |
const System & |
rGen, |
|
|
std::string & |
rReport | |
|
) |
| | |
Test if a generator is live.
- Parameters:
-
| rGen | Input generator. |
| rReport | User-readable information of violating condition (in case of negative result). |
- Returns:
- True if generator is live.
bool faudes::IsLive |
( |
const System & |
rGen, |
|
|
string & |
rReport | |
|
) |
| | |
bool faudes::IsModularDiagnosable |
( |
const SystemVector & |
rGsubs, |
|
|
const GeneratorVector & |
rKsubs | |
|
) |
| | |
Function definition for run-time interface.
bool faudes::IsModularDiagnosable |
( |
const vector< const System * > & |
rGSubs, |
|
|
const vector< const Generator * > & |
rKSubs, |
|
|
std::string & |
rReportString | |
|
) |
| | |
bool faudes::IsModularDiagnosable |
( |
const SystemVector & |
rGsubs, |
|
|
const GeneratorVector & |
rKsubs, |
|
|
string & |
rReportString | |
|
) |
| | |
Verification of the observer property.
For verifying if a natural projection has the observer property, one step in the observer algorithm is evaluated. If the resulting generator equals the input generator, then the natural projection on the abstraction alphabet is an observer.
- Parameters:
-
| rLowGen | Input generator |
| rHighAlph | High level alphabet |
- Returns:
- true if the observer property holds
void faudes::IsMutuallyControllable |
( |
const System & |
rGen1, |
|
|
const System & |
rGen2, |
|
|
bool & |
rRes | |
|
) |
| | |
bool faudes::IsMutuallyControllable |
( |
const System & |
rGen1, |
|
|
const System & |
rGen2, |
|
|
StateSet & |
rForbidden1, |
|
|
StateSet & |
rForbidden2 | |
|
) |
| | |
Verification of mutual controllability.
This function checks if two generators are mutually controllable w.r.t. each other. Additionally, this function provides the states where mutual controllability fails in case the condition is violated.
- Parameters:
-
| rGen1 | Generator 1 |
| rGen2 | Generator 2 |
| rForbidden1 | Forbidden states in Generator 1 |
| rForbidden2 | Forbidden states in Generator 2 |
- Returns:
- True if mutual controllability is fulfilled
bool faudes::IsNormal |
( |
const System & |
rPlantGen, |
|
|
const Generator & |
rSupCandGen | |
|
) |
| | |
IsNormal wrapper.
Wrapper for convenient access via the run-time interface.
bool faudes::IsOCC |
( |
const Generator & |
rLowGen, |
|
|
const EventSet & |
rControllableEvents, |
|
|
const EventSet & |
rHighAlph | |
|
) |
| | |
Verification of output control consistency (OCC).
For verifying if a natural projection fulfills the output control consistency condition, a backward reachability is conducted. If starting from a state, where an uncontrollable high-level event is feasible, a controllable event can be reached on a local backward path, OCC is violated.
- Parameters:
-
| rLowGen | Input generator |
| rControllableEvents | set of controllable events |
| rHighAlph | High level alphabet |
- Returns:
- true if OCC holds
bool faudes::IsRelativelyOmegaClosedUnchecked |
( |
const Generator & |
rGenPlant, |
|
|
const Generator & |
rGenCand | |
|
) |
| | |
Test for relative closedness, omega languages.
This variant does not perform consitency tests on the parameters. Neither does it handle the special cases on empty arguments. See also IsRelativelyOmegaClosed(const Generator&, const Generator& )
- Parameters:
-
| rGenPlant | Generator GPlant |
| rGenCand | Generator GCand |
void faudes::LabelCorrection |
( |
const std::multimap< Idx, DiagLabelSet > & |
mm, |
|
|
AttributeDiagnoserState & |
attr | |
|
) |
| | |
Perform label correction on propagated failure type labels.
- Parameters:
-
| mm | Propagated absolute failure type labels for a diagnoser state. |
| attr | Output variable for the diagnoser state attribute. |
void faudes::LabelCorrection |
( |
const multimap< Idx, DiagLabelSet > & |
mm, |
|
|
AttributeDiagnoserState & |
attr | |
|
) |
| | |
void faudes::LabelPropagation |
( |
const DiagLabelSet & |
lastLabel, |
|
|
const DiagLabelSet & |
failureTypes, |
|
|
DiagLabelSet & |
newLabel | |
|
) |
| | |
Generate a new label.
From the last label and the failure types that occurred on the way, the new label is generated.
- Parameters:
-
| lastLabel | Diagnoser label of state estimate. |
| failureTypes | Failure types that occurred. |
| newLabel | Output variable for the new label. |
void faudes::LanguageIntersection |
( |
const GeneratorVector & |
rGenVec, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Language intersection.
See also LanguageUnion(const Generator&, const Generator&, Generator&); This version takes a vector of generators as argument to perform the intersection for multiple languages. The implementation calls the std intersection multiple times, future implementations may do better.
- Parameters:
-
| rGenVec | Vector of input generators |
| rResGen | Reference to resulting generator |
void faudes::LanguageUnion |
( |
const GeneratorVector & |
rGenVec, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Language union.
See also LanguageUnion(const Generator&, const Generator&, Generator&); This version takes a vector of generators as argument to perform the union for multiple languages. The implementation calls the std union multiple times, future implementations may do better.
- Parameters:
-
| rGenVec | Vector of input generators |
| rResGen | Reference to resulting generator |
void faudes::LocalAccessibleReach |
( |
const Generator & |
rLowGen, |
|
|
const EventSet & |
rHighAlph, |
|
|
Idx |
lowState, |
|
|
StateSet & |
rAccessibleReach | |
|
) |
| | |
Compute the accessible reach for a local automaton.
- Parameters:
-
| rLowGen | Low level generator |
| rHighAlph | High level alphabet |
| lowState | Low level entry state |
| rAccessibleReach | Result |
void faudes::LocalCoaccessibleReach |
( |
const TransSetX2EvX1 & |
rRevTransRel, |
|
|
const EventSet & |
rHighAlph, |
|
|
Idx |
lowState, |
|
|
StateSet & |
rCoaccessibleReach | |
|
) |
| | |
Compute the coaccessible reach for a local automaton.
- Parameters:
-
| rRevTransRel | Reverse sorted transition relation |
| rHighAlph | High level alphabet |
| lowState | Low level exit state |
| rCoaccessibleReach | Result |
bool faudes::LocalObservationConsistency |
( |
const System & |
rPlantGen, |
|
|
const System & |
rSpecGen, |
|
|
const EventSet & |
rHighAlph, |
|
|
const EventSet & |
rObsAlph | |
|
) |
| | |
Supervisor Reduction algorithm.
Computes a reduced supervisor from a given potentially non-reduced supervisor and the plant. This algorithm implements the results obtained in
R. Su and W. M. Wonham. Supervisor Reduction for Discrete-Event Systems. Discrete Event Dynamic Systems vol. 14, no. 1, January 2004.
Both, plant and supervisor MUST be deterministic and share the same alphabet!!!
- Parameters:
-
| rPlantGen | Plant generator |
| rSpecGen | Specification generator |
| rHighAlph | high-level alphabet |
| rObsAlph | observable alphabet |
- Returns:
- True if a reduction was achieved
- Exceptions:
-
| Exception |
- alphabets of generators don't match (id 100)
- plant nondeterministic (id 201)
- supervisor nondeterministic (id 203)
- plant and supervisor nondeterministic (id 204)
|
void faudes::LoopCallback |
( |
bool(*)(void) |
pBreakFnct |
) |
|
Algorithm loop callback.
Set a callback function for libFAUDES algorithms. Applications are meant to use this interface to terminate an algorithm on user request. libFAUDES algorithms are meant to throw an execption when the callback function returns true. See also void LoopCallback(void).
- Parameters:
-
void faudes::LoopCallback |
( |
void |
|
) |
|
Algorithm loop callback.
Calls the loop callback function and throws an exception if it returns true.
- Exceptions:
-
| Break | on appliation request (id 110) |
void faudes::LoopCallback |
( |
bool |
pBreakvoid |
) |
|
void faudes::LowExitStates |
( |
const EventSet & |
rHighAlph, |
|
|
const std::map< Idx, StateSet > & |
rEntryStatesMap, |
|
|
const TransSetX2EvX1 & |
rLowRevTransRel, |
|
|
Idx |
highState, |
|
|
StateSet & |
rLowExitStates | |
|
) |
| | |
LowExitStates call-by-reference function:
Compute the low level exit states for a corresponding hi level state
- Parameters:
-
| rHighAlph | High level events |
| rEntryStatesMap | Entry states map (see CreateEntryStatesMap(resmap)) |
| rLowRevTransRel | Reverse sorted low level transition relation |
| highState | Hi level state for which to compute low level exit states |
| rLowExitStates | Reference to StateSet for low level exit states (result) |
- Exceptions:
-
| Exception | Hi level state not found in entry states map (with FAUDES_CHECKED) |
StateSet faudes::LowExitStates |
( |
const Generator & |
rLowGen, |
|
|
const EventSet & |
rHighAlph, |
|
|
const std::map< Idx, StateSet > & |
rEntryStatesMap, |
|
|
const TransSetX2EvX1 & |
rLowRevTransRel, |
|
|
Idx |
highState | |
|
) |
| | |
LowExitStates return-copy function:
Wrapper for the corresponding call-by-reference function. Creates new StateSet, calls function and returns StateSet containing low level exit states.
- Parameters:
-
| rLowGen | Low level generator (just needed for determining statetable) |
| rHighAlph | High level events |
| rEntryStatesMap | Entry states map (see CreateEntryStatesMap(resmap)) |
| rLowRevTransRel | Reverse sorted low level transition relation |
| highState | Hi level state for which to compute low level exit states |
- Exceptions:
-
| Exception | Hi level state not found in entry states map (with FAUDES_CHECKED) (id 502) |
static std::list< std::string > faudes::luafaudes_rl_complete |
( |
lua_State * |
L, |
|
|
const std::string & |
word | |
|
) |
| | [static] |
static void faudes::luafaudes_rl_dmadd |
( |
std::list< std::string > & |
mlist, |
|
|
const std::string & |
prefix, |
|
|
const std::string & |
str, |
|
|
const std::string & |
suffix | |
|
) |
| | [static] |
static int faudes::luafaudes_rl_getfield |
( |
lua_State * |
L, |
|
|
const char * |
s, |
|
|
size_t |
n | |
|
) |
| | [static] |
static int faudes::luafaudes_rl_getmeta |
( |
lua_State * |
L, |
|
|
bool |
has_colon | |
|
) |
| | [static] |
static void faudes::luafaudes_rl_getmetafn |
( |
lua_State * |
L |
) |
[static] |
static void faudes::luafaudes_rl_getmetaget |
( |
lua_State * |
L |
) |
[static] |
static int faudes::luafaudes_rl_getmetaindex |
( |
lua_State * |
L |
) |
[static] |
static bool faudes::luafaudes_rl_valididentifier |
( |
const std::string & |
str |
) |
[static] |
std::string faudes::MangleString |
( |
const std::string & |
str |
) |
|
bool faudes::MeetsDiagnosabilityAssumptions |
( |
const System & |
rGen, |
|
|
const AttributeFailureTypeMap & |
rFailureTypeMap, |
|
|
string & |
rReportString | |
|
) |
| | |
bool faudes::ModularDiagnoser |
( |
const SystemVector & |
rGsubs, |
|
|
const GeneratorVector & |
rKsubs, |
|
|
GeneratorVector & |
rDiagsubs | |
|
) |
| | |
Function definition for run-time interface.
bool faudes::ModularDiagnoser |
( |
const SystemVector & |
rGsubs, |
|
|
const GeneratorVector & |
rKsubs, |
|
|
GeneratorVector & |
rDiagSubs, |
|
|
string & |
rReportString | |
|
) |
| | |
void faudes::mtcDeterministic |
( |
const MtcSystem & |
rGen, |
|
|
std::vector< StateSet > & |
rPowerStates, |
|
|
std::vector< Idx > & |
rDetStates, |
|
|
MtcSystem & |
rResGen | |
|
) |
| | |
Make generator deterministic.
(real function)
Second and third parameter hold the subsets + deterministic states in vectors
The multiway merge algorithm is based on a propsal in "Ted Leslie, Efficient Approaches to Subset Construction,
Computer Science, University of Waterloo, 1995"
- Parameters:
-
| rGen | Reference to generator |
| rPowerStates | Vector that holds the power states |
| rDetStates | Vector that holds the corresponding deterministic states |
| rResGen | Reference to resulting deterministic generator |
void faudes::mtcDeterministic |
( |
const MtcSystem & |
rGen, |
|
|
std::map< Idx, StateSet > & |
rEntryStatesMap, |
|
|
MtcSystem & |
rResGen | |
|
) |
| | |
Make generator deterministic.
(function wrapper)
The second parameter is an empty std::map<Idx,StateSet> which holds all the pairs of new states and their respective power states set. This is used as a so called "entry state map" for deterministic projected generators.
- Parameters:
-
| rGen | Reference to generator |
| rEntryStatesMap | Entry state map |
| rResGen | Reference to resulting deterministic generator |
void faudes::mtcInvProject |
( |
const MtcSystem & |
rGen, |
|
|
const EventSet & |
rProjectAlphabet, |
|
|
MtcSystem & |
rResGen | |
|
) |
| | |
void faudes::mtcParallel |
( |
const MtcSystem & |
rGen1, |
|
|
const MtcSystem & |
rGen2, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
MtcSystem & |
rResGen | |
|
) |
| | |
Parallel composition of two MtcSystems.
- Parameters:
-
| rGen1 | First MtcSystem for parallel composition |
| rGen2 | Second MtcSystem for parallel composition |
| rReverseCompositionMap | |
| rResGen | Generator in which the result of the parallel composition is saved |
void faudes::mtcProject |
( |
const MtcSystem & |
rGen, |
|
|
const EventSet & |
rProjectAlphabet, |
|
|
std::map< Idx, StateSet > & |
rEntryStatesMap, |
|
|
MtcSystem & |
rResGen | |
|
) |
| | |
Minimized Deterministic projection.
Does not modify generator. Calls project, determine and statemin. See functions for details.
- Parameters:
-
| rGen | Reference to generator |
| rProjectAlphabet | Projection alphabet |
| rEntryStatesMap | Reference to entry states map, see Deterministic(..) (result) |
| rResGen | Reference to resulting deterministic generator (result) |
void faudes::mtcStateMin |
( |
const MtcSystem & |
rGen, |
|
|
MtcSystem & |
rResGen | |
|
) |
| | |
void faudes::mtcStateMin |
( |
MtcSystem & |
rGen, |
|
|
MtcSystem & |
rResGen, |
|
|
std::vector< StateSet > & |
rSubsets, |
|
|
std::vector< Idx > & |
rNewIndices | |
|
) |
| | |
State Minimization This function implements the (n*log n) set partitioning algorithm by John E.
Hopcroft extended to colored marking. Given generator will be made accessible before computing minimized generator.
- Parameters:
-
| rGen | MtcSystem |
| rResGen | Minimized MtcSystem (result) |
| rSubsets | Vector of subsets that will be constructed during running the algorithm (optional parameter) |
| rNewIndices | Vector of new state indices corresponding to the subsets (optional parameter) |
- Exceptions:
-
| Exception |
- Input automaton nondeterministic (id 505)
|
void faudes::mtcStateMin |
( |
MtcSystem & |
rGen, |
|
|
MtcSystem & |
rResGen | |
|
) |
| | |
State Minimization This function implements the (n*log n) set partitioning algorithm by John E.
Hopcroft extended to colored marking. Given generator will be made accessible before computing minimized generator.
- Parameters:
-
| rGen | MtcSystem |
| rResGen | Minimized MtcSystem (result) |
- Exceptions:
-
| Exception |
- Input automaton nondeterministic (id 505)
|
void faudes::mtcSupCon |
( |
const MtcSystem & |
rPlantGen, |
|
|
const MtcSystem & |
rSpecGen, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
MtcSystem & |
rResGen | |
|
) |
| | |
Supremal Controllable Sublanguage.
Only for deterministic plant + spec. Throws exception if plant or spec is nondeterministic.
Real mtcSupCon function
Finds the "largest" sublanguage of h for that language of g is controllable with respect to h. Differing from theory the marked language of h may not be a sublanguage of g but both must share the same alphabet.
See "C.G CASSANDRAS AND S. LAFORTUNE. Introduction to Discrete Event
Systems. Kluwer, 1999." for base algorithm.
This version creates a "reverse composition map" given as reference parameter.
- Parameters:
-
| rPlantGen | Plant MtcSystem |
| rSpecGen | Specification MtcSystem |
| rReverseCompositionMap | std::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function |
| rResGen | Reference to resulting MtcSystem, the minimal restrictive supervisor |
- Exceptions:
-
| Exception |
- Alphabets of generators don't match (id 500)
- plant nondeterministic (id 501)
- spec nondeterministic (id 503)
- plant and spec nondeterministic (id 504)
|
void faudes::mtcSupConNB |
( |
const MtcSystem & |
rPlantGen, |
|
|
const MtcSystem & |
rSpecGen, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
MtcSystem & |
rResGen | |
|
) |
| | |
Nonblocking Supremal Controllable Sublanguage.
Only for deterministic plant + spec. Throws exception if plant or spec is nondeterministic.
Real mtcSupConNB function
Finds the "largest" sublanguage of h for that language of g is controllable with respect to h. Differing from theory the marked language of h may not be a sublanguage of g but both must share the same alphabet.
See "C.G CASSANDRAS AND S. LAFORTUNE. Introduction to Discrete Event
Systems. Kluwer, 1999." for base algorithm.
This version creates a "reverse composition map" given as reference parameter.
- Parameters:
-
| rPlantGen | Plant MtcSystem |
| rSpecGen | Specification MtcSystem |
| rReverseCompositionMap | std::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function |
| rResGen | Reference to resulting MtcSystem, the minimal restrictive nonblocking supervisor |
- Exceptions:
-
| Exception |
- Alphabets of generators don't match (id 500)
- plant nondeterministic (id 501)
- spec nondeterministic (id 503)
- plant and spec nondeterministic (id 504)
|
void faudes::mtcSupConParallel |
( |
const MtcSystem & |
rPlantGen, |
|
|
const MtcSystem & |
rSpecGen, |
|
|
const EventSet & |
rUAlph, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
MtcSystem & |
rResGen | |
|
) |
| | |
Fast parallel composition for computation for the mtcSupConNB.
Composition stops at transition paths that leave the specification by uncontrollable events in plant.
- Parameters:
-
| rPlantGen | Plant MtcSystem |
| rSpecGen | Specification MtcSystem |
| rUAlph | Uncontrollable Events |
| rReverseCompositionMap | std::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function |
| rResGen | Reference to resulting MtcSystem, the less restrictive supervisor |
void faudes::mtcSupConUnchecked |
( |
const MtcSystem & |
rPlantGen, |
|
|
const EventSet & |
rCAlph, |
|
|
MtcSystem & |
rSupGen | |
|
) |
| | |
Supremal Controllable Sublangauge (Real SupCon function; unchecked).
Both, plant and spec MUST be deterministic and share the same alphabet!!!
Most likely will result in blocking states.
- Parameters:
-
| rPlantGen | Plant generator |
| rCAlph | Controllable events |
| rSupGen | Specification generator |
- Exceptions:
-
| Exception |
- Alphabets of generators don't match (id 500)
- Plant generator nondeterministic (id 501)
- Specification generator nondeterministic (id 503)
- Plant & Spec generator nondeterministic (id 504)
|
void faudes::mtcUniqueInit |
( |
MtcSystem & |
rGen |
) |
|
void * faudes::NDeviceListen |
( |
void * |
arg |
) |
|
void * faudes::NDeviceReply |
( |
void * |
arg |
) |
|
void* faudes::NDeviceServer |
( |
void * |
|
) |
|
void faudes::NormalityConsistencyCheck |
( |
const Generator & |
rL, |
|
|
const EventSet & |
rOAlph, |
|
|
const Generator & |
rK | |
|
) |
| | |
NormalityConsistencyCheck: Consistency check for normality input data.
Used e.g. in IsNormal(), and SupNorm(). See exceptions.
- Parameters:
-
| rL | generator of language L |
| rOAlph | observable alphabet |
| rK | generator of language K |
- Exceptions:
-
| Exception |
- nondeterministic parameter(s) (id: 101)
- rOAlph not subset of rL.Alphabet() (id: 100)
- Alphabets of generators don't match (id: 100)
- K is not subset of L (id 0)
|
bool faudes::OmegaControlledLiveness |
( |
Generator & |
rSupCandGen, |
|
|
const EventSet & |
rCAlph, |
|
|
StateSet & |
rMarkedPlantStates, |
|
|
StateSet & |
rMarkedSpecStates | |
|
) |
| | |
void faudes::OmegaSupConNBUnchecked |
( |
const Generator & |
rPlantGen, |
|
|
const EventSet & |
rCAlph, |
|
|
const Generator & |
rSpecGen, |
|
|
std::map< OPSState, Idx > & |
rReverseCompositionMap, |
|
|
Generator & |
rResGen | |
|
) |
| | |
void faudes::OmegaSupconParallel |
( |
const Generator & |
rPlantGen, |
|
|
const EventSet & |
rCAlph, |
|
|
const Generator & |
rSpecGen, |
|
|
std::map< OPSState, Idx > & |
rReverseCompositionMap, |
|
|
StateSet & |
rMarkedPlantStates, |
|
|
StateSet & |
rMarkedSpecStates, |
|
|
Generator & |
rResGen | |
|
) |
| | |
void faudes::Parallel |
( |
const Generator & |
rGen1, |
|
|
const Generator & |
rGen2, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Parallel composition.
See Parallel(const Generator&, const Generator&, Generator&). This version fills a reverse composition map to map pairs of old states to new states.
- Parameters:
-
| rGen1 | First generator |
| rGen2 | Second generator |
| rReverseCompositionMap | Reverse composition map (map< pair<Idx,Idx>, Idx>) |
| rResGen | Reference to resulting parallel composition generator |
void faudes::Parallel |
( |
const Generator & |
rGen1, |
|
|
const Generator & |
rGen2, |
|
|
ProductCompositionMap & |
rCompositionMap, |
|
|
StateSet & |
rMark1, |
|
|
StateSet & |
rMark2, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Parallel composition.
See Parallel(const Generator&, const Generator&, Generator&). This version fills a reverse composition map to map pairs of old states to new states. It also returns the sets of states marked w.r.t. the argument generators.
- Parameters:
-
| rGen1 | First generator |
| rGen2 | Second generator |
| rCompositionMap | Reverse composition map (map< pair<Idx,Idx>, Idx>) |
| rMark2 | States maked in first generator |
| rMark1 | States maked in second generator |
| rResGen | Reference to resulting parallel composition generator |
std::string faudes::PrependDirectory |
( |
const std::string & |
rDirectory, |
|
|
const std::string & |
rFileName | |
|
) |
| | |
Construct full path from directory and filename.
- Parameters:
-
| rDirectory | Directory eg "/home/friend/data" |
| rFileName | File eg "generator.gen" |
- Returns:
- Path eg "/home/friend/data/generator.gen"
void faudes::ProcessDot |
( |
const std::string & |
rDotFile, |
|
|
const std::string & |
rOutFile, |
|
|
const std::string & |
rOutFormat = "" , |
|
|
const std::string & |
rDotExec = "dot" | |
|
) |
| | |
Convenience function: process dot file to graphics output.
If no output format is given, try to guess from filename extension.
- Parameters:
-
| rDotFile | name of dot file |
| rOutFile | name of graphics file |
| rOutFormat | graphics format eg "png", "jpg" |
| rDotExec | path/name of executable |
- Exceptions:
-
| Exception |
- error in systemcall (id 3)
- unkown format (id 3)
|
void faudes::Product |
( |
const Generator & |
rGen1, |
|
|
const Generator & |
rGen2, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Product composition.
See Product(const Generator&, const Generator&, Generator&). This version fills given reverse composition map to map pairs of old states to new states.
- Parameters:
-
| rGen1 | First generator |
| rGen2 | Second generator |
| rReverseCompositionMap | Reverse composition map (map< pair<Idx,Idx>, Idx>) |
| rResGen | Reference to resulting product composition generator |
void faudes::Product |
( |
const Generator & |
rGen1, |
|
|
const Generator & |
rGen2, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
StateSet & |
rMark1, |
|
|
StateSet & |
rMark2, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Product composition.
See Product(const Generator&, const Generator&, Generator&). This version fills given reverse composition map to map pairs of old states to new states. It also returns the sets of states marked w.r.t. the argument generators.
- Parameters:
-
| rGen1 | First generator |
| rGen2 | Second generator |
| rReverseCompositionMap | Reverse composition map (map< pair<Idx,Idx>, Idx>) |
| rMark2 | States maked in first generator |
| rMark1 | States maked in second generator |
| rResGen | Reference to resulting product composition generator |
void faudes::Project |
( |
const Generator & |
rGen, |
|
|
const EventSet & |
rProjectAlphabet, |
|
|
std::map< Idx, StateSet > & |
rEntryStatesMap, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Minimized Deterministic projection.
Projects the generated and marked languages to a subalphabet of the original alphabet, and subsequently calls Deterministic and StateMin to construct a deterministic minimal realisation of the result. The input generator does not need to be deterministic.
- Parameters:
-
| rGen | Reference to generator |
| rProjectAlphabet | Projection alphabet |
| rEntryStatesMap | Reference to entry states map, see Deterministic(..) (result) |
| rResGen | Reference to resulting deterministic generator (result) |
void faudes::ReachableEvents |
( |
const Generator & |
rLowGen, |
|
|
const EventSet & |
rHighAlph, |
|
|
Idx |
lowState, |
|
|
EventSet & |
rReachableEvents | |
|
) |
| | |
ReachableEvents call-by-reference function:
Compute the set of hi level events which can be reached from a low level state. Resulting set will be cleared first.
- Parameters:
-
| rLowGen | Low level generator |
| rHighAlph | High level alphabet |
| lowState | Low level state |
| rReachableEvents | Reference to EventSet which will contain the reachable high level events (result) |
EventSet faudes::ReachableEvents |
( |
const Generator & |
rLowGen, |
|
|
const EventSet & |
rHighAlph, |
|
|
Idx |
lowState | |
|
) |
| | |
ReachableEvents return-copy function:
Wrapper for the corresponding call-by-reference function. Creates new EventSet, calls function and returns EventSet containing the reachable hi level events.
- Parameters:
-
| rLowGen | Low level generator |
| rHighAlph | High level alphabet |
| lowState | Low level state |
std::set< std::string > faudes::ReadDirectory |
( |
const std::string & |
rDirectory |
) |
|
Read the contents of the specified directors.
- Parameters:
-
| rDirectory | Directory eg "/home/friend/data" |
- Returns:
- List of files, e.g. "gen1.gen gen2.gen data subdir"
bool faudes::rec_ComputeLoopPreservingObserver |
( |
const System & |
rGen, |
|
|
const EventSet & |
rInitialHighAlph, |
|
|
EventSet & |
rHighAlph, |
|
|
const std::vector< Idx > & |
rDiffVector, |
|
|
Idx |
numberEvents, |
|
|
Idx |
currentNumberEvents, |
|
|
Idx |
currentLocation, |
|
|
EventSet |
chosenEvents | |
|
) |
| | |
rec_ComputeLoopPreservingObserver(rGen, rInitialHighAlph, rHighAlph, rDdffVector, numberEvents, currentNumberEvents, currentLocation, hosenEvents)
void faudes::rec_OptimalColorSet |
( |
const MtcSystem & |
rGen, |
|
|
const vector< Idx > & |
rColorVector, |
|
|
Idx |
colorNumber, |
|
|
ColorSet & |
rOptimalColors, |
|
|
Idx & |
rOptimalNumberStates, |
|
|
Idx & |
rOptimalNumberColors, |
|
|
const EventSet & |
rHighAlph, |
|
|
EventSet & |
rOptimalHighAlph | |
|
) |
| | |
Recursively find an optimal set of colors to be removed.
This function recursively enumerates all possible subsets of colors that can be removed without affecting supervisor synthesis and remembers the color set that leads to the smallest hierarchical abstraction. It is called by the function OptimalColorSet.
- Parameters:
-
| rGen | input colored marking generator |
| rColorVector | set of colors of the generator (ordered!) |
| colorNumber | number of colors currently removed |
| rOptimalColors | current optimal set of colors |
| rOptimalNumberStates | current optimal number of states |
| rOptimalNumberColors | size of the optimal color set |
| rHighAlph | initial high-level alphabet |
| rOptimalHighAlph | optimal high-level alphabet |
void faudes::recursiveCheckLCC |
( |
const TransSetX2EvX1 & |
rRevTransSet, |
|
|
const EventSet & |
rControllableEvents, |
|
|
const EventSet & |
rHighAlph, |
|
|
Idx |
currentState, |
|
|
StateSet & |
rDoneStates | |
|
) |
| | |
Find states that fulfill the lcc condition.
This function performs a backward reachability computation to determine states where the lcc condition is fulfilled
The alphabet rHighAlph has to be a subset of the alphabet of rGen. rGen must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rRevTransSet | Reversely ordered transition relation |
| rControllableEvents | Set of controllable events |
| rHighAlph | Abstraction alphabet |
| currentState | Index of the start state of the backward reachability computation |
| rDoneStates | Set of already investigated states |
- Returns:
- True if the condition is fulfilled, false otherwise
bool faudes::recursiveCheckMSABackward |
( |
const Generator & |
rGen, |
|
|
const TransSetX2EvX1 & |
rRevTransSet, |
|
|
const EventSet & |
rHighAlph, |
|
|
Idx |
currentState, |
|
|
StateSet & |
rDoneStates | |
|
) |
| | |
Check if the msa-observer conditions is fulfilled for a given state.
This function performs a backward reachability computation to determine if the msa-observer condition is fulfilled for a given state.
The alphabet rHighAlph has to be a subset of the alphabet of rGen. rGen must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGen | Generator for which the dynamic system is computed |
| rRevTransSet | Reversely ordered transition relation |
| rHighAlph | Abstraction alphabet |
| currentState | Index of the state to be checked |
| rDoneStates | Set of already investigated states |
- Returns:
- True if the condition is fulfilled, false otherwise
bool faudes::recursiveCheckMSAForward |
( |
const Generator & |
rGen, |
|
|
const EventSet & |
rHighAlph, |
|
|
Idx |
currentState, |
|
|
StateSet & |
rDoneStates | |
|
) |
| | |
Check if the msa-observer conditions is fulfilled for a given state.
This function performs a forward reachability computation to determine if the msa-observer condition is fulfilled for a given state.
The alphabet rHighAlph has to be a subset of the alphabet of rGen. rGen must be a deterministic generator. There are no further restrictions on parameters.
- Parameters:
-
| rGen | Generator for which the dynamic system is computed |
| rHighAlph | Abstraction alphabet |
| currentState | Index of the state to be checked |
| rDoneStates | Set of already investigated states |
- Returns:
- True if the condition is fulfilled, false otherwise
bool faudes::relabel |
( |
Generator & |
rGenRelabel, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
std::vector< Idx > & |
rNewPartitions, |
|
|
std::map< Idx, Idx > & |
rMapStateToPartition, |
|
|
std::map< Transition, Transition > & |
rMapChangedTransReverse, |
|
|
std::map< Transition, Idx > & |
rMapChangedTrans, |
|
|
std::map< Idx, EventSet > & |
rMapRelabeledEvents | |
|
) |
| | |
Relabeling algorithm for the computation of an Lm-observer.
This function checks the termination criterion of the observer algorithm. If required, transitions of the input generator are relabeled.
The alphabets rHighAlph and rControllableEvents have to be subsets of the alphabet of rGenRelabel. There are no further restrictions on parameters.
- Parameters:
-
| rGenRelabel | Generator whose transitions are modified |
| rControllableEvents | Set of controllable events |
| rHighAlph | Abstraction alphabet |
| rNewPartitions | Vector containing the indices of the equivalence classes that partition the state space of rGenRelabel |
| rMapStateToPartition | Maps each state of rGenRelabel to an equivalence class that must also be contained in rNewPartitions |
| rMapChangedTransReverse | Maps the relabeled transitions to the original transitions |
| rMapChangedTrans | Maps the the modified original transitions to its new events |
| rMapRelabeledEvents | Maps the original events to the set of new events they were relabeled with |
bool faudes::relabel |
( |
Generator & |
rGenRelabel, |
|
|
EventSet & |
rControllableEvents, |
|
|
EventSet & |
rHighAlph, |
|
|
vector< Idx > & |
rNewPartitions, |
|
|
map< Idx, Idx > & |
rMapStateToPartition, |
|
|
map< Transition, Transition > & |
rMapChangedTransReverse, |
|
|
map< Transition, Idx > & |
rMapChangedTrans, |
|
|
map< Idx, EventSet > & |
rMapRelabeledEvents | |
|
) |
| | |
bool faudes::RemoveFile |
( |
const std::string & |
rFileName |
) |
|
Delete a file.
- Parameters:
-
| rFileName | Name of file to delete |
void * faudes::SDeviceSynchro |
( |
void * |
arg |
) |
|
void faudes::SearchScc |
( |
const Idx |
state, |
|
|
int & |
rCount, |
|
|
const Generator & |
rGen, |
|
|
StateSet & |
rNewStates, |
|
|
std::stack< Idx > & |
rSTACK, |
|
|
StateSet & |
rStackStates, |
|
|
std::map< const Idx, int > & |
rDFN, |
|
|
std::map< const Idx, int > & |
rLOWLINK, |
|
|
std::set< StateSet > & |
rSccSet, |
|
|
StateSet & |
rRoots | |
|
) |
| | |
Search for strongly connected components (SCC)*** This function partitions the stateset of a generator into equivalence classes such that states x1 and x2 are equivalent iff there is a path from x1 to x2 AND a path from x2 to x1.
This function implements the algorithm based on a depth first search presented in: -Aho, Hopcroft, Ullman: The Design and Analysis of Computer Algorithms-
Most of the comments in this function have been literally taken from this book!
- Parameters:
-
| state | State, from which the current recursion is started. |
| rCount | denotes the current depth of the recursion. |
| rGen | Generator under investigation |
| rNewStates | Set of states that up to now were not found by the depth first search |
| rSTACK | stack of state indices |
| rStackStates | set of states whose indices are on STACK. |
| rDFN | map assigning to each state its Depth-First Number |
| rLOWLINK | map assigning to each state its LOWLINK Number |
| rSccSet | result - the set of strongly connected components |
| rRoots,: | result - the set of states that each are root of some SCC. |
void faudes::SearchScc |
( |
const Idx |
vState, |
|
|
int & |
vRcount, |
|
|
const Generator & |
rGen, |
|
|
const SccFilter & |
rFilter, |
|
|
StateSet & |
rTodo, |
|
|
std::stack< Idx > & |
rStack, |
|
|
StateSet & |
rStackStates, |
|
|
std::map< const Idx, int > & |
rDfn, |
|
|
std::map< const Idx, int > & |
rLowLnk, |
|
|
std::list< StateSet > & |
rSccList, |
|
|
StateSet & |
rRoots | |
|
) |
| | |
Search for strongly connected components (SCC).
This function partitions the stateset of a generator into equivalent classes such that states x1 and x2 are equivalent iff there is a path from x1 to x2 AND a path from x2 to x1.
This function implements the algorithm based on a depth first search presented in:
-- Aho, Hopcroft, Ullman: The Design and Analysis of Computer Algorithms --
While the original algorithm works on a directed graph, this implementation adds some features that refer to transition systems and allow to filter SCCs on the run. The filter condition is specified by the SccFilter parameter rFilter.
Note: this version is derived from earlier implementations used in various plug-ins; in due course, this version will replace earlier versions; filter conditions are not thouroughly tested.
- Parameters:
-
| vState | State, from which the current recursion is started. |
| vRcount | Denotes the current depth of the recursion. |
| rGen | Transition system to investigate |
| rFilter | Filter out specified transitions |
| rTodo | Set of states that up to now were not found by the depth first search. |
| rStack | Stack of states to represent current path. |
| rStackStates | Set of states that are in rStack |
| rDfn | Map assigning to each state idx its Depth-First Number. |
| rLowLnk | Map assigning to each state its LOWLINK Number. |
| rSccList | Set SCCs (accumulative result). |
| rRoots | Set of states that each are root of some SCC (accumulative result). |
void faudes::SetComposedStateNames |
( |
const Generator & |
rGen1, |
|
|
const Generator & |
rGen2, |
|
|
const std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
Generator & |
rGen12 | |
|
) |
| | |
Helper: uses reverse composition map to track state names in a paralell composition.
Purely cosmetic.
- Parameters:
-
| rGen1 | First generator |
| rGen2 | Second generator |
| rReverseCompositionMap | Reverse composition map (map< pair<Idx,Idx>, Idx>) |
| rGen12 | Reference to resulting parallel composition generator |
void faudes::SetDifference |
( |
const vGenerator & |
rGenA, |
|
|
const vGenerator & |
rGenB, |
|
|
EventSet & |
rRes | |
|
) |
| | |
RTI convenience function.
void faudes::SetIntersection |
( |
const vGenerator & |
rGenA, |
|
|
const vGenerator & |
rGenB, |
|
|
EventSet & |
rRes | |
|
) |
| | |
RTI convenience function.
void faudes::SetUnion |
( |
const vGenerator & |
rGenA, |
|
|
const vGenerator & |
rGenB, |
|
|
EventSet & |
rRes | |
|
) |
| | |
RTI convenience function.
void faudes::StateMin |
( |
Generator & |
rGen, |
|
|
Generator & |
rResGen, |
|
|
std::vector< StateSet > & |
rSubsets, |
|
|
std::vector< Idx > & |
rNewIndices | |
|
) |
| | |
State set minimization.
This function implements the (n*log n) set partitioning algorithm by John E. Hopcroft. Given generator will be made accessible before computing minimized generator. See also StateMin(Generator&,Generator&).
- Parameters:
-
| rGen | Generator |
| rResGen | Minimized generator (result) |
| rSubsets | Vector of subsets that will be constructed during running the algorithm (optional parameter) |
| rNewIndices | Vector of new state indices corresponding to the subsets (optional parameter) |
- Exceptions:
-
| Exception | Input automaton nondeterministic (id 101) |
void faudes::StateMin |
( |
Generator & |
rGen, |
|
|
Generator & |
rResGen | |
|
) |
| | |
State set minimization.
Constructs a generator with minimal stateset while preserving the generated und marked languages. This function implements the (n*log n) set partitioning algorithm by John E. Hopcroft. The given generator will be made accessible before computing minimized generator. See also StateMin(Generator&,Generator&,std::vector<StateSet>&,std::vector<Idx>&).
- Parameters:
-
| rGen | Generator |
| rResGen | Minimized generator (result) |
- Exceptions:
-
| Exception | Input automaton nondeterministic (id 101) |
std::string faudes::StringSubstitute |
( |
const std::string & |
rString, |
|
|
const std::string & |
rFrom, |
|
|
const std::string & |
rTo | |
|
) |
| | |
Substitute in string.
- Parameters:
-
| rString | Source string to substitute |
| rFrom | String to match |
| rTo | Replacement to fill in |
- Returns:
- Result string
void faudes::SupCon |
( |
const Generator & |
rPlantGen, |
|
|
const EventSet & |
rCAlph, |
|
|
const Generator & |
rSpecGen, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Supremal Controllable Sublanguage.
Only for deterministic plant + spec. Throws exception if plant or spec is nondeterministic.
Real SupCon function
Finds the "largest" sublanguage of h for that language of g is controllable with respect to h. Note that the language of h is not rtequired to be a a sublanguage of g, but both languages must share the same alphabet.
See "C.G CASSANDRAS AND S. LAFORTUNE. Introduction to Discrete Event
Systems. Kluwer, 1999." for base algorithm.
This version creates a "reverse composition map" given as reference parameter.
- Parameters:
-
| rPlantGen | Plant Generator |
| rCAlph | Controllable events |
| rSpecGen | Specification Generator |
| rReverseCompositionMap | std::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function |
| rResGen | Reference to resulting Generator, the minimal restrictive supervisor |
- Exceptions:
-
| Exception |
- alphabets of generators don't match (id 100)
- plant nondeterministic (id 201)
- spec nondeterministic (id 203)
- plant and spec nondeterministic (id 204)
|
void faudes::SupConNBNonDet |
( |
const Generator & |
rPlantGen, |
|
|
const EventSet & |
rCAlph, |
|
|
const Generator & |
rSpecGen, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
Generator |
rDetPlantGen, |
|
|
Generator |
rDetSpecGen, |
|
|
std::map< Idx, StateSet > & |
rPowerStatesPlant, |
|
|
std::map< Idx, StateSet > & |
rPowerStatesSpec, |
|
|
bool & |
rDetPlantBool, |
|
|
bool & |
rDetSpecBool, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Nonblocking Supremal Controllable Sublanguage.
For deterministic and nondeterministic plant or spec.
- If rPlantGen is deterministic, rDetPlantGen will be unchanged. rDetPlantBool will be set to false.
- If rSpecGen is deterministic, rDetSpecGen will be unchanged rDetSpecBool will be set to false
- If rPlantGen is nondeterministic, rDetPlantGen will contain deterministic plant generator. rDetPlantBool will be set to true. rPowerStatesPlant will contain the mapping of deterministic states to subsets of nondeterministic states
- If rSpecGen is nondeterministic, rDetPlantGen will contain deterministic spec generator. rDetSpecBool will be set to true. rPowerStatesSpec will contain the mapping of deterministic states to subsets of nondeterministic states
Finds the "largest" sublanguage of h for that language of g is controllable with respect to h. Differing from theory the marked language of h may not be a sublanguage of g but both must share the same alphabet.
See "C.G CASSANDRAS AND S. LAFORTUNE. Introduction to Discrete Event
Systems. Kluwer, 1999." for base algorithm.
This version creates a "reverse composition map" given as reference parameter.
- Parameters:
-
| rPlantGen | Plant Generator |
| rCAlph | Controllable events |
| rSpecGen | Specification Generator |
| rReverseCompositionMap | std::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function |
| rDetPlantGen | Deterministic plant generator (if rPlantGen is nondeterministic) |
| rDetSpecGen | Deterministic spec generator (if rSpecGen is nondeterministic) |
| rPowerStatesPlant | Mapping of deterministic states to set of nondeterministic states |
| rPowerStatesSpec | Mapping of deterministic states to set of nondeterministic states |
| rDetPlantBool | true if rPlantGen is deterministic, false if not |
| rDetSpecBool | true if rSpecGen is deterministic, false if not |
| rResGen | Reference to resulting Generator, the minimal restrictive nonblocking supervisor |
- Exceptions:
-
| Exception | Alphabets of generators don't match (id 500) |
void faudes::SupConNBUnchecked |
( |
const Generator & |
rPlantGen, |
|
|
const EventSet & |
rCAlph, |
|
|
const Generator & |
rSpecGen, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Nonblocking Supremal Controllable Sublanguage (internal function).
This version of SupConNB creates a "reverse composition map" given as reference parameter. It is used by the user function to set up descriptive state names of the supervisor.
- Parameters:
-
| rPlantGen | Plant Generator |
| rCAlph | Controllable events |
| rSpecGen | Specification Generator |
| rReverseCompositionMap | std::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function |
| rResGen | Reference to resulting System, the minimal restrictive nonblocking supervisor |
- Exceptions:
-
| Exception |
- alphabets of generators don't match (id 100)
- plant nondeterministic (id 201)
- spec nondeterministic (id 203)
- plant and spec nondeterministic (id 204)
|
void faudes::SupConNorm |
( |
const System & |
rPlantGen, |
|
|
const Generator & |
rSpecGen, |
|
|
Generator & |
rResGen | |
|
) |
| | |
void faudes::SupConNormNB |
( |
const System & |
rPlantGen, |
|
|
const Generator & |
rSpecGen, |
|
|
Generator & |
rResGen | |
|
) |
| | |
void faudes::SupconParallel |
( |
const Generator & |
rPlantGen, |
|
|
const EventSet & |
rCAlph, |
|
|
const Generator & |
rSpecGen, |
|
|
std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap, |
|
|
Generator & |
rResGen | |
|
) |
| | |
Parallel composition optimized for the purpose of SupCon (internal function).
Composition stops at transition paths that violate the specification by uncontrollable plant transitions.
- Parameters:
-
| rPlantGen | Plant Generator |
| rCAlph | Uncontrollable Events |
| rSpecGen | Specification Generator |
| rReverseCompositionMap | std::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function |
| rResGen | Reference to resulting Generator, the less restrictive supervisor |
void faudes::SupConUnchecked |
( |
const Generator & |
rPlantGen, |
|
|
const EventSet & |
rCAlph, |
|
|
Generator & |
rSupCandGen | |
|
) |
| | |
Supremal Controllable Sublangauge (internal function).
Indetifies and deletes "critical" states in the supervisor candidate, in order to achieve controllability.
In general, the result is blocking.
- Parameters:
-
| rPlantGen | Plant generator |
| rCAlph | Controllable events |
| rSupCandGen | Supervisor candidate generator |
void faudes::SupNorm |
( |
const System & |
rPlantGen, |
|
|
const Generator & |
rSpecGen, |
|
|
Generator & |
rResGen | |
|
) |
| | |
void faudes::SupNormClosed |
( |
const System & |
rPlantGen, |
|
|
const Generator & |
rSpecGen, |
|
|
Generator & |
rResGen | |
|
) |
| | |
bool faudes::SupNormSP |
( |
Generator & |
rL, |
|
|
const EventSet & |
rOAlph, |
|
|
const Generator & |
rK, |
|
|
Generator & |
rResult | |
|
) |
| | |
bool faudes::SupPrefixClosed |
( |
const Generator & |
rK, |
|
|
Generator & |
rResult | |
|
) |
| | |
SupPrefixClosed: supremal closed sublanguage of K by cancelling all tranistions leading to a non-marked state.
Returns false on empty result. todo: implement test routines, verify correctness
- Parameters:
-
| rK | marks the (not necessarily closed) language K=Lm(rK) |
| rResult | generates and marks the supremal closed sublanguage, where L(rResult)=Lm(rResult) |
- Returns:
- true for nonempty result
- Exceptions:
-
void* faudes::SwigCastPtr |
( |
void * |
ptr, |
|
|
swig_type_info * |
from, |
|
|
swig_type_info * |
ty | |
|
) |
| | |
int faudes::syncSend |
( |
int |
dest, |
|
|
const char * |
data, |
|
|
int |
len, |
|
|
int |
flag | |
|
) |
| | |
bool faudes::TestProtocol |
( |
void |
|
) |
|
Test Protocol.
Perform a comparison of the recent protocol file and the corresponding reference. Returns true if the test passes.
Note: this function closes the current protocol.
- Returns:
- True <=> test past
void faudes::TestProtocol |
( |
const std::string & |
rMessage, |
|
|
const std::string & |
data | |
|
) |
| | |
void faudes::TestProtocol |
( |
const std::string & |
rMessage, |
|
|
long int |
data | |
|
) |
| | |
void faudes::TestProtocol |
( |
const std::string & |
rMessage, |
|
|
bool |
data | |
|
) |
| | |
void faudes::TestProtocol |
( |
const std::string & |
rMessage, |
|
|
const Type & |
rData, |
|
|
bool |
core = false | |
|
) |
| | |
Test Protocol.
This function dumps the specified data to the protocol file for the purpose of later comparison with a refernce value. If the protocol file has not been set up, this function does nothing; see also TestProtocol(const std::string&.
- Parameters:
-
| rMessage | Informal identifyer of the test |
| rData | Formal result of the test case |
| core | Whether to record full token io or statistics only. |
std::string faudes::TestProtocol |
( |
const std::string & |
rSource |
) |
|
Test Protocol.
Sets the filename for the test protocol by
- removing any path specififucation,
- replacing "." by "_",
- appending ".prot", and finaly
- prepending "tmp_". The function returns the filename except for the "tmp_" prefix. The latter is considered the nominal protocol output (aka reference protocol).
Note: only the first invocation of this functions actually sets the protocol file. Further invocations are ignored, but can be used to query the reference protocol.
- Parameters:
-
| rSource | Source file to protocol |
- Returns:
- Filename with nominal protocol.
Idx faudes::ToIdx |
( |
const std::string & |
rString |
) |
|
Convert a string to Idx.
- Parameters:
-
| rString | string to convert |
- Returns:
- Idx
- Exceptions:
-
std::string faudes::ToStringFloat |
( |
double |
number |
) |
|
float to string
- Parameters:
-
- Returns:
- string
std::string faudes::ToStringInteger |
( |
long int |
number |
) |
|
integer to string
- Parameters:
-
- Returns:
- string
std::string faudes::ToStringInteger16 |
( |
long int |
number |
) |
|
integer to string base 16
- Parameters:
-
- Returns:
- string
void faudes::TraverseUncontrollableBackwards |
( |
const EventSet & |
rCAlph, |
|
|
TransSetX2EvX1 & |
rtransrel, |
|
|
StateSet & |
rCriticalStates, |
|
|
Idx |
current | |
|
) |
| | |
Helper function for IsControllable.
The state given as "current" is considered critical. Itself and all uncontrollable predecessor states are added to the set "rCriticalStates".
- Parameters:
-
| rCAlph | Set of controllable events |
| rtransrel | Reverse sorted transition relation |
| rCriticalStates | Set of critical states in composition generator |
| current | Current state |
void faudes::TrimNonIndicatorTracesOfGd |
( |
System & |
rGd, |
|
|
const Diagnoser & |
rGobs, |
|
|
const Idx |
rFailureType, |
|
|
const EventSet & |
rIndicatorEvents, |
|
|
const std::map< std::pair< Idx, Idx >, Idx > & |
rReverseCompositionMap | |
|
) |
| | |
Extract all traces of a generator G_d that start with an indicator event that follows a failure event of a certain failure type.
- Parameters:
-
| rGd | Input generator G_d which will be prunded. |
| rGobs | Generator G_o (containing failure label information). |
| rFailureType | Failure type index. |
| rIndicatorEvents | Set of indicator events. |
| rReverseCompositionMap | Mapping of G_d states with G_o states. |
void faudes::TrimNonIndicatorTracesOfGd |
( |
System & |
rGd, |
|
|
const Diagnoser & |
rGobs, |
|
|
const Idx |
rFailureType, |
|
|
const EventSet & |
rIndicatorEvents, |
|
|
const map< pair< Idx, Idx >, Idx > & |
rReverseCompositionMap | |
|
) |
| | |
void faudes::TrimNonIndicatorTracesOfGdRecursive |
( |
System & |
rGd, |
|
|
const Diagnoser & |
rGobs, |
|
|
const Idx |
rFailureType, |
|
|
const EventSet & |
rIndicatorEvents, |
|
|
std::map< Idx, std::pair< Idx, Idx > > & |
rCompositionMap, |
|
|
Idx |
state, |
|
|
StateSet & |
rStatesDone | |
|
) |
| | |
Auxiliary function for TrimNonIndicatorTracesOfGd().
Parse through active transition set of the current state and delete transitions if occurring event is not an indicator event or there did not occur a failure before the indicator.
- Parameters:
-
| rGd | Input generator G_d which will be pruned. |
| rGobs | Generator G_o (containing failure label information). |
| rFailureType | Failure type index. |
| rIndicatorEvents | Set of indicator events. |
| rCompositionMap | Inverted mapping of G_d states with G_o states. |
| state | Current state. |
| rStatesDone | States that have been processed already. |
void faudes::TrimNonIndicatorTracesOfGdRecursive |
( |
System & |
rGd, |
|
|
const Diagnoser & |
rGobs, |
|
|
const Idx |
rFailureType, |
|
|
const EventSet & |
rIndicatorEvents, |
|
|
map< Idx, pair< Idx, Idx > > & |
rCompositionMap, |
|
|
Idx |
state, |
|
|
StateSet & |
rStatesDone | |
|
) |
| | |
bool faudes::YclessScc |
( |
const Generator & |
rGen, |
|
|
const EventSet & |
rYc, |
|
|
std::set< StateSet > & |
rSccSet | |
|
) |
| | |
Variable Documentation
Initial value: {
"and", "break", "do", "else", "elseif", "end", "false",
"for", "function", "if", "in", "local", "nil", "not", "or",
"repeat", "return", "then", "true", "until", "while", NULL
}
Definition at line 32 of file lbp_function.cpp.
|