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
 Generator with controllability attributes. 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  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...
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  TIoSystem
 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  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 tGenerators. 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 FaunctionDefinition to defines a faudes-function to be a luafaudes script. More...
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
cEventSet
 EventSet with controllablity properties.
typedef TcGenerator
< AttributeVoid, AttributeVoid,
AttributeCFlags, AttributeVoid
cGenerator
 Convenience typedef for std cGenerator.
typedef TBaseVector< cGeneratorcGeneratorVector
 Convenience typedef for generator vectors.
typedef TBaseVector< cEventSetcEventSetVector
typedef long unsigned int Idx
 Type definition for index type.
typedef long int SignedIdx
 Type definition for signed index type.
typedef TBaseVector< IntegerIntegerVector
typedef vGenerator Generator
 Plain generator, api typedef for generator with no attributes.
typedef TBaseVector< GeneratorGeneratorVector
 Convenience typedef for generator vectors.
typedef IndexSet StateSet
typedef NameSet EventSet
typedef TBaseVector< EventSetEventSetVector
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
diagGenerator
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 TIoSystem
< AttributeVoid,
AttributeIosState,
AttributeIosEvent,
AttributeVoid
IoSystem
typedef TmtcGenerator
< AttributeVoid,
AttributeColoredState,
AttributeCFlags, AttributeVoid
mtcGenerator
typedef TtGenerator
< AttributeTimedGlobal,
AttributeTimedState,
AttributeCFlags,
AttributeTimedTrans
tGenerator
 Convenience typedef for std tGenerator.
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.
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 PrependDirectory (const std::string &rDirectory, const std::string &rFileName)
 Construct full path from directory and filename.
void ExitFunction (void)
void TestProtocol (const std::string &rSource)
 Test Protocol.
void TestProtocol (const std::string &rSource, const std::string &rMessage, const Type &rData, bool core)
void TestProtocol (const std::string &rSource, const std::string &rMessage, bool data)
void TestProtocol (const std::string &rSource, const std::string &rMessage, long int data)
void TestProtocol (const std::string &rSource, const std::string &rMessage, const std::string &rData)
void LoopCallback (bool pBreak(void))
void LoopCallback (void)
 Algorithm loop callback.
void LoopCallback (bool(*pBreakFnct)(void))
 Algorithm loop callback.
StateSet LowExitStates (const vGenerator &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 vGenerator &rLowGen, const EventSet &rHighAlph, Idx lowState)
 ReachableEvents return-copy function:
void ReachableEvents (const vGenerator &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 vGenerator &rLowGen, const EventSet &rHighAlph, Idx lowState, StateSet &rAccessibleReach)
 Compute the accessible reach for a local automaton.
void aOmegaParallel (const vGenerator &rGen1, const vGenerator &rGen2, vGenerator &rResGen)
 Parallel composition with relaxed acceptance condition.
void OmegaParallel (const vGenerator &rGen1, const vGenerator &rGen2, vGenerator &rResGen)
 Parallel composition with relaxed acceptance condition.
void OmegaClosure (vGenerator &rGen)
 Topological closure.
bool IsOmegaClosed (const vGenerator &rGen)
 Test for topologically closed omega language.
void Parallel (const vGenerator &rGen1, const vGenerator &rGen2, vGenerator &rResGen)
 Parallel composition.
void aParallel (const vGenerator &rGen1, const vGenerator &rGen2, vGenerator &rResGen)
 Parallel composition.
void aParallel (const GeneratorVector &rGenVec, vGenerator &rResGen)
 Parallel composition.
void Parallel (const vGenerator &rGen1, const vGenerator &rGen2, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, StateSet &rMark1, StateSet &rMark2, vGenerator &rResGen)
 Parallel composition.
void Parallel (const vGenerator &rGen1, const vGenerator &rGen2, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, vGenerator &rResGen)
 Parallel composition.
void Product (const vGenerator &rGen1, const vGenerator &rGen2, vGenerator &rResGen)
 Product composition.
void aProduct (const vGenerator &rGen1, const vGenerator &rGen2, vGenerator &rResGen)
 Product composition.
void Product (const vGenerator &rGen1, const vGenerator &rGen2, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, StateSet &rMark1, StateSet &rMark2, vGenerator &rResGen)
 Product composition.
void Product (const vGenerator &rGen1, const vGenerator &rGen2, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, vGenerator &rResGen)
 Product composition.
void SetComposedStateNames (const vGenerator &rGen1, const vGenerator &rGen2, const std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, vGenerator &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)
 Helper: extract composition map from reverse composition map.
void CompositionMap2 (const std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, std::map< Idx, Idx > &rCompositionMap)
 Helper: extract composition map from reverse composition map.
void UniqueInit (vGenerator &rGen)
 Make initial states unique.
void Deterministic (const vGenerator &rGen, vGenerator &rResGen)
 Make generator deterministic.
void aDeterministic (const vGenerator &rGen, vGenerator &rResGen)
 Make generator deterministic.
void Deterministic (const vGenerator &rGen, std::map< Idx, StateSet > &rEntryStatesMap, vGenerator &rResGen)
 Make generator deterministic.
void Deterministic (const vGenerator &rGen, std::vector< StateSet > &rPowerStates, std::vector< Idx > &rDetStates, vGenerator &rResGen)
 Make generator deterministic.
void ProjectNonDet (vGenerator &rGen, const EventSet &rProjectAlphabet)
 Language projection.
void aProjectNonDet (vGenerator &rGen, const EventSet &rProjectAlphabet)
 Language projection.
void Project (const vGenerator &rGen, const EventSet &rProjectAlphabet, vGenerator &rResGen)
 Minimized deterministic projection.
void aProject (const vGenerator &rGen, const EventSet &rProjectAlphabet, vGenerator &rResGen)
 Minimized deterministic projection.
void Project (const vGenerator &rGen, const EventSet &rProjectAlphabet, std::map< Idx, StateSet > &rEntryStatesMap, vGenerator &rResGen)
 Minimized Deterministic projection.
void InvProject (vGenerator &rGen, const EventSet &rProjectAlphabet)
 Inverse projection.
void aInvProject (vGenerator &rGen, const EventSet &rProjectAlphabet)
 Inverse projection.
void aInvProject (const vGenerator &rGen, const EventSet &rProjectAlphabet, vGenerator &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.
TypeNewFaudesObject (const std::string &rTypeName)
 Instantiate faudes typed objects by type name.
FunctionNewFaudesFunction (const std::string &rFunctName)
 Instantiate faudes function objects by function name.
const std::string & FaudesTypeName (const Type &rObject)
 Query type name.
const std::string & FaudesFunctionName (const Function &rObject)
const std::string & FaudesFunctionName (const Type &rObject)
 Query function name.
void LanguageUnionNonDet (const vGenerator &rGen1, const vGenerator &rGen2, vGenerator &rResGen)
 Language union, nondeterministic version.
void LanguageUnion (const vGenerator &rGen1, const vGenerator &rGen2, vGenerator &rResGen)
 Language union, deterministic version.
void LanguageUnion (const GeneratorVector &rGenVec, vGenerator &rResGen)
 Language union.
void LanguageIntersection (const vGenerator &rGen1, const vGenerator &rGen2, vGenerator &rResGen)
 Language intersection.
void LanguageIntersection (const GeneratorVector &rGenVec, vGenerator &rResGen)
 Language intersection.
bool EmptyLanguageIntersection (const vGenerator &rGen1, const vGenerator &rGen2)
 Test for empty language intersection (same as Disjoind()).
bool LanguageDisjoint (const vGenerator &rGen1, const vGenerator &rGen2)
 Test whether two languages are disjoint.
void Automaton (vGenerator &rGen, const EventSet &rAlphabet)
 Convert generator to automaton wrt specified alphabet.
void Automaton (vGenerator &rGen)
 Convert generator to automaton.
void LanguageComplement (vGenerator &rGen, const EventSet &rAlphabet)
 Language complement wrt specified alphabet.
void LanguageComplement (vGenerator &rGen)
 Language complement.
void LanguageComplement (const vGenerator &rGen, vGenerator &rRes)
 Language Complement (uniform API wrapper).
void LanguageComplement (const vGenerator &rGen, const EventSet &rSigma, vGenerator &rRes)
 Language Complement (uniform API wrapper).
void LanguageDifference (const vGenerator &rGen1, const vGenerator &rGen2, vGenerator &rResGen)
 Language difference (set-theoretic difference).
void LanguageConcatenateNonDet (const vGenerator &rGen1, const vGenerator &rGen2, vGenerator &rResGen)
 Language concatenation, nondeterministic version.
void LanguageConcatenate (const vGenerator &rGen1, const vGenerator &rGen2, vGenerator &rResGen)
 Language concatenation, deterministic version.
void FullLanguage (const EventSet &rAlphabet, vGenerator &rResGen)
 Full Language, L(G)=Lm(G)=Sigma*.
void AlphabetLanguage (const EventSet &rAlphabet, vGenerator &rResGen)
 Alphabet Language, L(G)=Lm(G)=Sigma.
void EmptyStringLanguage (const EventSet &rAlphabet, vGenerator &rResGen)
 Empty string language, L(G)=Lm(G)={epsilon}.
void EmptyLanguage (const EventSet &rAlphabet, vGenerator &rResGen)
 Empty language Lm(G)={}.
bool IsEmptyLanguage (const vGenerator &rGen)
 Test for Empty language Lm(G)=={}.
bool LanguageInclusion (const vGenerator &rGen1, const vGenerator &rGen2)
 Test language inclusion, Lm1<=Lm2.
bool LanguageEquality (const vGenerator &rGen1, const vGenerator &rGen2)
 Language equality, Lm1==Lm2.
void KleeneClosure (vGenerator &rGen)
 Kleene Closure.
void KleeneClosure (const vGenerator &rGen, vGenerator &rResGen)
 Kleene Closure.
void KleeneClosureNonDet (vGenerator &rGen)
 Kleene Closure, nondeterministic version.
void PrefixClosure (vGenerator &rGen)
 Prefix Closure.
bool IsPrefixClosed (const vGenerator &rGen)
 Test for prefix closed marked language.
bool IsNonblocking (const vGenerator &rGen)
 Test for nonblocking generator.
bool IsNonblocking (const vGenerator &rGen1, const vGenerator &rGen2)
 Test for nonblocking marked languages.
void SelfLoop (vGenerator &rGen, const EventSet &rAlphabet)
 Self-loop all states.
void SelfLoopMarkedStates (vGenerator &rGen, const EventSet &rAlphabet)
 Self-loop all marked states.
void SelfLoop (vGenerator &rGen, const EventSet &rAlphabet, const StateSet &rStates)
 Self-loop specified states.
void StateMin (const vGenerator &rGen, vGenerator &rResGen)
 State set minimization.
void aStateMin (const vGenerator &rGen, vGenerator &rResGen)
 State set minimization.
void aStateMin (vGenerator &rGen)
 State set minimization.
void StateMin (vGenerator &rGen, vGenerator &rResGen)
 State set minimization.
void StateMin (vGenerator &rGen, vGenerator &rResGen, std::vector< StateSet > &rSubsets, std::vector< Idx > &rNewIndices)
 State set minimization.
void AlternativeAccessible (vGenerator &rGen)
 Alternative accessibility algorithm.
bool IsRelativelyMarked (const vGenerator &rGenPlant, const vGenerator &rGenCand)
 Test for relative marking.
bool IsRelativelyPrefixClosed (const vGenerator &rGenPlant, const vGenerator &rGenCand)
 Test for relative prefix-closedness.
bool IsRelativelyOmegaMarked (const vGenerator &rGenPlant, const vGenerator &rGenCand)
 Test for relative marking, omega langauges.
bool IsRelativelyOmegaClosed (const vGenerator &rGenPlant, const vGenerator &rGenCand)
 Test for relative closedness, omega languages.
bool IsRelativelyOmegaClosedUnchecked (const vGenerator &rGenPlant, const vGenerator &rGenCand)
 Test for relative closedness, omega languages.
bool IsControllableUnchecked (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSpecGen, StateSet &rCriticalStates)
 Controllability (internal function).
bool SupConUnchecked (const vGenerator &rPlantGen, const EventSet &rCAlph, vGenerator &rSupCandGen)
 Supremal Controllable Sublangauge (internal function).
void SupconParallel (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, vGenerator &rResGen)
 Parallel composition optimized for the purpose of SupCon (internal function).
void SupConNBUnchecked (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, vGenerator &rResGen)
 Nonblocking Supremal Controllable Sublanguage (internal function).
void ControlProblemConsistencyCheck (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSpecGen)
 Consistency check for controlproblem input data.
bool IsControllable (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSupCandGen)
 Test controllability.
bool IsControllable (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSupCandGen, StateSet &rCriticalStates)
 Test controllability.
void SupConNB (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSpecGen, vGenerator &rResGen)
 Nonblocking Supremal Controllable Sublanguage.
void SupConNBNonDet (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &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, vGenerator &rResGen)
 Nonblocking Supremal Controllable Sublanguage.
void SupCon (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSpecGen, vGenerator &rResGen)
 Supremal Controllable Sublanguage.
void SupCon (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, vGenerator &rResGen)
 Supremal Controllable Sublanguage.
void TraverseUncontrollableBackwards (const EventSet &rCAlph, TransSetX2EvX1 &rtransrel, StateSet &rCriticalStates, Idx current)
 Helper function for IsControllable.
bool IsControllable (const cGenerator &rPlantGen, const vGenerator &rSupCandGen)
 Test controllability.
void SupConNB (const cGenerator &rPlantGen, const vGenerator &rSpecGen, vGenerator &rResGen)
 Nonblocking Supremal Controllable Sublanguage.
void SupCon (const cGenerator &rPlantGen, const vGenerator &rSpecGen, vGenerator &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 IsNormalAlt (const Generator &rL, const EventSet &rOAlph, const Generator &rK)
 IsNormalAlt: Alternative implementation of IsNormal().
bool IsNormal (const cGenerator &rPlantGen, const vGenerator &rSupCandGen)
 IsNormal wrapper.
void ConcatenateFullLanguage (vGenerator &rGen)
 ConcatenateFullLanguage: concatenate Sigma* to language marked by rGen.
bool SupNorm (Generator &rL, const EventSet &rOAlph, const Generator &rK, Generator &rResult)
 SupNorm: compute supremal normal sublanguage.
bool SupNormClosed (Generator &rL, const EventSet &rOAlph, const Generator &rK, Generator &rResult)
 SupNormClosed - compute supremal normal and closed sublanguage.
bool SupPrefixClosed (const Generator &rK, Generator &rResult)
 SupPrefixClosed: supremal closed sublanguage of K by cancelling all tranistions leading to a non-marked state.
bool SupNormAlt (Generator &rL, const EventSet &rOAlph, const Generator &rK, Generator &rResult)
 SupNormAlt: Alternative implementation of SupNorm().
void SupNorm (const vGenerator &rPlantGen, const EventSet &rOAlph, const vGenerator &rSpecGen, vGenerator &rResGen)
 rti wrapper
void SupNorm (const cGenerator &rPlantGen, const vGenerator &rSpecGen, vGenerator &rResGen)
 rti wrapper
void SupNormClosed (const vGenerator &rPlantGen, const EventSet &rOAlph, const vGenerator &rSpecGen, vGenerator &rResGen)
 rti wrapper
void SupNormClosed (const cGenerator &rPlantGen, const vGenerator &rSpecGen, vGenerator &rResGen)
 rti wrapper
bool IsOmegaControllable (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSupCandGen)
 Test omega controllability.
bool IsOmegaControllable (const cGenerator &rPlantGen, const vGenerator &rSupCandGen)
 Test omega-controllability.
void SupConComplete (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSpecGen, vGenerator &rResGen)
 Supremal controllable and complete sublanguage.
void SupConComplete (const cGenerator &rPlantGen, const vGenerator &rSpecGen, vGenerator &rResGen)
 Supremal controllable and complete sublanguage.
void SupConCompleteNB (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSpecGen, vGenerator &rResGen)
 Supremal controllable and complete sublanguage.
void SupConCompleteNB (const cGenerator &rPlantGen, const vGenerator &rSpecGen, vGenerator &rResGen)
 Supremal controllable and complete sublanguage.
bool OmegaControlledLiveness (vGenerator &rSupCandGen, const EventSet &rCAlph, StateSet &rMarkedPlantStates, StateSet &rMarkedSpecStates)
void OmegaSupconParallel (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSpecGen, std::map< OPSState, Idx > &rReverseCompositionMap, StateSet &rMarkedPlantStates, StateSet &rMarkedSpecStates, vGenerator &rResGen)
void OmegaSupConNBUnchecked (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSpecGen, std::map< OPSState, Idx > &rReverseCompositionMap, vGenerator &rResGen)
void OmegaSupConNB (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSpecGen, vGenerator &rResGen)
 Omega-synthesis (experimental).
void OmegaSupConNB (const cGenerator &rPlantGen, const vGenerator &rSpecGen, vGenerator &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 cGenerator &rGen1, const cGenerator &rGen2)
 Verification of mutual controllability.
bool IsMutuallyControllable (const cGenerator &rGen1, const cGenerator &rGen2, StateSet &rForbidden1, StateSet &rForbidden2)
 Verification of mutual controllability.
void IsMutuallyControllable (const cGenerator &rGen1, const cGenerator &rGen2, bool &rRes)
 RTI wrapper.
void calculateDynamicSystemClosedObs (const vGenerator &rGen, EventSet &rHighAlph, vGenerator &rGenDyn)
 Computation of the dynamic system for Delta_sigma (reachable states after the occurrence of one high-level event).
void calculateDynamicSystemObs (const vGenerator &rGen, EventSet &rHighAlph, vGenerator &rGenDyn)
 Computation of the dynamic system for Delta_obs (local reachability of a marked state).
void calculateDynamicSystemMSA (const vGenerator &rGen, EventSet &rHighAlph, vGenerator &rGenDyn)
 Computation of the dynamic system for Delta_msa (local fulfillment of the msa-observer property).
bool recursiveCheckMSAForward (const vGenerator &rGen, const EventSet &rHighAlph, Idx currentState, StateSet &rDoneStates)
 Check if the msa-observer conditions is fulfilled for a given state.
bool recursiveCheckMSABackward (const vGenerator &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 vGenerator &rGen, const EventSet &rControllableEvents, const EventSet &rHighAlph, vGenerator &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 vGenerator &rGenObs, EventSet &rHighAlph)
 L(G)-observer computation by adding events to the high-level alphabet.
SignedIdx calcNaturalObserver (const vGenerator &rGenObs, EventSet &rHighAlph)
 Lm(G)-observer computation by adding events to the high-level alphabet.
SignedIdx calcNaturalObserverLCC (const vGenerator &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 vGenerator &rGen, EventSet &rHighAlph)
 MSA-observer computation by adding events to the high-level alphabet.
SignedIdx calcMSAObserverLCC (const vGenerator &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 vGenerator &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 (cGenerator &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents)
void calcAbstAlphClosed (vGenerator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents)
void calcAbstAlphClosed (vGenerator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans)
void calcAbstAlphObs (cGenerator &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents)
void calcAbstAlphObs (vGenerator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents)
void calcAbstAlphObs (vGenerator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans)
void calcAbstAlphMSA (cGenerator &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents)
void calcAbstAlphMSA (vGenerator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents)
void calcAbstAlphMSA (vGenerator &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 (cGenerator &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents)
void calcAbstAlphObsLCC (vGenerator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans)
void calcAbstAlphMSALCC (cGenerator &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents)
void calcAbstAlphMSALCC (vGenerator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans)
bool relabel (vGenerator &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 (cGenerator &rGenPlant, const map< Idx, set< Idx > > &rMapRelabeledEvents, cEventSet &rNewEvents)
void insertRelabeledEvents (Generator &rGenPlant, const map< Idx, set< Idx > > &rMapRelabeledEvents, EventSet &rNewEvents)
void insertRelabeledEvents (cGenerator &rGenPlant, const map< Idx, set< Idx > > &rMapRelabeledEvents)
void insertRelabeledEvents (Generator &rGenPlant, const map< Idx, set< Idx > > &rMapRelabeledEvents)
void calcAbstAlphObs (cGenerator &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 vGenerator &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 (cGenerator &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 L(G)-observer computation.
void calcAbstAlphClosed (vGenerator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 L(G)-observer computation.
void calcAbstAlphClosed (vGenerator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans)
 L(G)-observer computation.
void calcAbstAlphObs (cGenerator &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 Lm-observer computation.
void calcAbstAlphObs (vGenerator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 Lm-observer computation.
void calcAbstAlphObs (vGenerator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans)
 Lm-observer computation.
void calcAbstAlphMSA (cGenerator &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 MSA-observer computation.
void calcAbstAlphMSA (vGenerator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 MSA-observer computation.
void calcAbstAlphMSA (vGenerator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans)
 MSA-observer computation.
void calcAbstAlphObsLCC (cGenerator &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 Lm-observer computation including output control consistency (OCC).
void calcAbstAlphObsLCC (vGenerator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans)
 Lm-observer computation including local control consistency (LCC).
void calcAbstAlphMSALCC (cGenerator &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Idx, std::set< Idx > > &rMapRelabeledEvents)
 MSA-observer computation including local control consistency (LCC).
void calcAbstAlphMSALCC (vGenerator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, std::map< Transition, Idx > &rMapChangedTrans)
 MSA-observer computation including local control consistency (LCC).
bool relabel (vGenerator &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 (cGenerator &rGenPlant, const std::map< Idx, std::set< Idx > > &rMapRelabeledEvents, cEventSet &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 (cGenerator &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 vGenerator &rLowGen, const EventSet &rHighAlph)
 Verification of the natural observer property.
bool IsMSA (const vGenerator &rLowGen, const EventSet &rHighAlph)
 Verification of the MSA observer property.
bool IsOCC (const cGenerator &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 cGenerator &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 IsCoDiagnosable (const cGenerator &rGen, const Generator &rSpec, const vector< const EventSet * > &rAlphabets, std::string &rReportString)
bool ComputeDecentralizedDiagnoser (const cGenerator &rGen, const Generator &rSpec, const std::vector< const EventSet * > &rAlphabets, std::vector< diagGenerator * > &rDiags, std::string &rReportString)
 Computes decentralized diagnosers for multiple local sites.
bool IsCoDiagnosable (const cGenerator &rGen, const Generator &rSpec, const EventSetVector &rAlphabets)
 Function definition for run-time interface.
bool ComputeDecentralizedDiagnoser (const cGenerator &rGen, const Generator &rSpec, const EventSetVector &rAlphabets, GeneratorVector &rDiags)
 Function definition for run-time interface.
void ComputeDecentralizedModularDiagnoser (const cGeneratorVector &rGens, const Generator &rSpec, GeneratorVector &rDiags)
 Function definition for run-time interface.
void cParallel (const std::vector< const cGenerator * > &rGens, cGenerator &rResGen)
 Parallel composition of multiple generators.
bool IsEventDiagnosable (const cGenerator &rGen, const AttributeFailureTypeMap &rFailureTypeMap, string &rReportString)
bool IsEventDiagnosable (const cGenerator &rGen, const AttributeFailureTypeMap &rFailureTypeMap)
 Function definition for run-time interface.
bool IsIndicatorEventDiagnosable (const cGenerator &rGen, const AttributeFailureTypeMap &rFailureTypeMap, string &rReportString)
bool IsIndicatorEventDiagnosable (const cGenerator &rGen, const AttributeFailureTypeMap &rFailureTypeMap)
 Function definition for run-time interface.
bool MeetsDiagnosabilityAssumptions (const cGenerator &rGen, const AttributeFailureTypeMap &rFailureTypeMap, string &rReportString)
void ConvertParallelCompositionMap (const map< pair< Idx, Idx >, Idx > &rReverseCompositionMap, map< Idx, pair< Idx, Idx > > &rCompositionMap)
bool IsLive (const cGenerator &rGen, string &rReport)
bool CycleOfUnobsEvents (const cGenerator &rGen, string &rReport)
bool FailuresUnobservable (const cGenerator &rGen, const AttributeFailureTypeMap &rFailureTypeMap, string &rReport)
bool ExistsCycle (const cGenerator &rGen, string &rReport)
bool ExistsCycleSearch (const cGenerator &rGen, StateSet &rTodo, Idx currState, StateSet statesOnPath, string &rReport)
void CycleStartStates (const cGenerator &rGen, StateSet &rCycleOrigins)
 Find all start/end states of cycles of unobservable events in a generator.
void CycleStartStatesSearch (const cGenerator &rGen, StateSet &rTodo, Idx currState, StateSet statesOnPath, StateSet &rCycleOriginStates)
 Auxiliary function for CycleStartStates().
bool ExistsViolatingCyclesInGd (cGenerator &rGd, const diagGenerator &rGobs, map< pair< Idx, Idx >, Idx > &rReverseCompositionMap, const string &rFailureType, string &rReportString)
void ComputeGobs (const cGenerator &rOrigGen, const string &rFailureType, const EventSet &rFailureEvents, diagGenerator &rGobs)
void ComputeGobs (const cGenerator &rOrigGen, const AttributeFailureTypeMap &rAttrFTMap, diagGenerator &rGobs)
 Compute G_o for a given generator with a given failure partition (according to Jiang).
void ComputeGd (const diagGenerator &rGobs, map< pair< Idx, Idx >, Idx > &rReverseCompositionMap, cGenerator &rGd)
void TrimNonIndicatorTracesOfGd (cGenerator &rGd, const diagGenerator &rGobs, const Idx rFailureType, const EventSet &rIndicatorEvents, const map< pair< Idx, Idx >, Idx > &rReverseCompositionMap)
void TrimNonIndicatorTracesOfGdRecursive (cGenerator &rGd, const diagGenerator &rGobs, const Idx rFailureType, const EventSet &rIndicatorEvents, map< Idx, pair< Idx, Idx > > &rCompositionMap, Idx state, StateSet &rStatesDone)
void ComputeReachability (const cGenerator &rGen, const EventSet &rUnobsEvents, const EventSet &rFailures, Idx State, const AttributeFailureTypeMap &rAttrFTMap, map< Idx, multimap< Idx, DiagLabelSet > > &rReachabilityMap)
void ComputeReachabilityRecursive (const cGenerator &rGen, const EventSet &rUnobsEvents, const EventSet &rFailures, Idx State, const AttributeFailureTypeMap &rAttrFTMap, map< Idx, multimap< Idx, DiagLabelSet > > &rReachabilityMap, const DiagLabelSet FToccurred)
TransSet ActiveBackwardTransSet (const cGenerator &rGen, Idx state)
 Obtain all transitions from other states into a given state of a generator.
void ComputeEventDiagnoser (const cGenerator &rOrigGen, const map< string, EventSet > &rFailureTypeMap, diagGenerator &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 cGenerator &rGen, std::string &rReport)
 Test if a generator is live.
bool CycleOfUnobsEvents (const cGenerator &rGen, std::string &rReport)
 Test if there exist any cycles of unobservable events in a generator.
bool FailuresUnobservable (const cGenerator &rGen, const AttributeFailureTypeMap &rFailureTypeMap, std::string &rReport)
 Check if all failure events are unobservable events in a generator's alphabet.
bool ExistsCycle (const cGenerator &rGen, std::string &rReport)
 Test if there exist any cycles in a generator.
bool ExistsCycleSearch (const cGenerator &rGen, StateSet &rTodo, Idx currState, StateSet statesOnPath, std::string &rReport)
 Auxiliary function for ExistsCycle(const cGenerator&, std::string&).
bool ExistsViolatingCyclesInGd (cGenerator &rGd, const diagGenerator &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 cGenerator &rOrigGen, const std::string &rFailureType, const EventSet &rFailureEvents, diagGenerator &rGobs)
 Compute G_o for a single failure type of a generator.
void ComputeGd (const diagGenerator &rGobs, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, cGenerator &rGd)
 Compute the diagnosability testing generator G_d as a parallel composition of G_o with itself (according to Jiang).
void TrimNonIndicatorTracesOfGd (cGenerator &rGd, const diagGenerator &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 (cGenerator &rGd, const diagGenerator &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 cGenerator &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 cGenerator &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 cGenerator&, const EventSet&, const EventSet&, Idx, const AttributeFailureTypeMap&, std::map<Idx,std::multimap<Idx,DiagLabelSet>>&).
void ComputeEventDiagnoser (const cGenerator &rOrigGen, const std::map< std::string, EventSet > &rFailureTypeMap, diagGenerator &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 cGenerator &rGen, const cGenerator &rSpec)
 Function definition for run-time interface.
void ComputeGobs (const cGenerator &rGenMarkedNonSpecBehaviour, diagGenerator &rGobs)
 Compute G_o for a generator that marks the faulty behaviour of a plant.
void ComputeReachability (const cGenerator &rGen, const EventSet &rUnobsEvents, Idx State, map< Idx, multimap< Idx, DiagLabelSet > > &rReachabilityMap)
void ComputeReachabilityRecursive (const cGenerator &rGen, const EventSet &rUnobsEvents, Idx State, StateSet done, map< Idx, multimap< Idx, DiagLabelSet > > &rReachabilityMap)
bool IsLanguageDiagnosable (const cGenerator &rGen, const cGenerator rSpec, std::string &rReportString)
 Test function to verify language-diagnosability.
bool rec_ComputeLoopPreservingObserver (const cGenerator &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 cGenerator &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 cGenerator &rGen, const EventSet &rUnobsEvents, Idx State, StateSet done, std::map< Idx, std::multimap< Idx, DiagLabelSet > > &rReachabilityMap)
 Auxiliary function for ComputeReachability(const cGenerator&, const EventSet&, Idx State, std::map<Idx,std::multimap< Idx,DiagLabelSet> >&).
bool IsModularDiagnosable (const cGeneratorVector &rGsubs, const GeneratorVector &rKsubs, string &rReportString)
bool IsModularDiagnosable (const vector< const cGenerator * > &rGSubs, const vector< const Generator * > &rKSubs, std::string &rReportString)
bool ComputeModularDiagnoser (const cGeneratorVector &rGsubs, const GeneratorVector &rKsubs, GeneratorVector &rDiagSubs, string &rReportString)
bool ComputeModularDiagnoser (const std::vector< const cGenerator * > &rGsubs, const std::vector< const Generator * > &rKsubs, std::vector< diagGenerator * > &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 cGeneratorVector &rGsubs, const GeneratorVector &rKsubs)
 Function definition for run-time interface.
bool ComputeModularDiagnoser (const cGeneratorVector &rGsubs, const GeneratorVector &rKsubs, GeneratorVector &rDiagsubs)
 Function definition for run-time interface.
void cParallel (const vector< cGenerator > &rGens, cGenerator &rResGen)
bool IsModularDiagnosable (const std::vector< const cGenerator * > &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< cGenerator > &rGens, cGenerator &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 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 vGenerator &rGen1, const vGenerator &rGen2, const std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, vGenerator &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 mtcGenerator &rGen)
 RTI wrapper function.
bool IsStronglyTrim (const mtcGenerator &rGen)
 RTI wrapper function.
void StronglyCoaccessible (mtcGenerator &rGen)
 RTI wrapper function.
void StronglyCoaccessible (const mtcGenerator &rGen, mtcGenerator &rRes)
 RTI wrapper function.
void StronglyTrim (mtcGenerator &rGen)
 RTI wrapper function.
void StronglyTrim (const mtcGenerator &rGen, mtcGenerator &rRes)
 RTI wrapper function.
Idx calcNaturalObserver (const mtcGenerator &rGen, EventSet &rHighAlph)
 Calculate a colored natural observer by extending a given high-level alphabet.
void calcAbstAlphObs (mtcGenerator &rGenObs, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents)
 Lm-observer computation.
void calcAbstAlphObs (mtcGenerator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Idx, set< Idx > > &rMapRelabeledEvents)
 Lm-observer computation.
void calcAbstAlphObs (mtcGenerator &rGenObs, EventSet &rControllableEvents, EventSet &rHighAlph, EventSet &rNewHighAlph, map< Transition, Idx > &rMapChangedTrans)
 Lm-observer computation.
void calculateDynamicSystemObs (const mtcGenerator &rGen, EventSet &rHighAlph, vGenerator &rGenDyn)
 Computation of the dynamic system for an Lm-observer.
bool IsMtcObs (const mtcGenerator &rLowGen, const EventSet &rHighAlph)
 Verification of the observer property.
void mtcParallel (const mtcGenerator &rGen1, const mtcGenerator &rGen2, mtcGenerator &rResGen)
 Parallel composition of two colored marking generators, controllability status is observed.
void mtcParallel (const mtcGenerator &rGen1, const mtcGenerator &rGen2, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, mtcGenerator &rResGen)
 Parallel composition of two mtcGenerators.
void ComposedColorSet (const mtcGenerator &rGen1, const Idx stdidx1, ColorSet &colors1, const mtcGenerator &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 (mtcGenerator &rGen)
void mtcDeterministic (const mtcGenerator &rGen, mtcGenerator &rResGen)
 Make generator deterministic.
void mtcDeterministic (const mtcGenerator &rGen, std::map< Idx, StateSet > &rEntryStatesMap, mtcGenerator &rResGen)
 Make generator deterministic.
void mtcDeterministic (const mtcGenerator &rGen, std::vector< StateSet > &rPowerStates, std::vector< Idx > &rDetStates, mtcGenerator &rResGen)
 Make generator deterministic.
void mtcProjectNonDet (mtcGenerator &rGen, const EventSet &rProjectAlphabet)
 Project generator to alphabet rProjectAlphabet.
void mtcProjectNonDet (const mtcGenerator &rGen, const EventSet &rProjectAlphabet, mtcGenerator &rResGen)
 Project generator to alphabet rProjectAlphabet.
void mtcProject (const mtcGenerator &rGen, const EventSet &rProjectAlphabet, mtcGenerator &rResGen)
 Minimized Deterministic projection.
void mtcProject (const mtcGenerator &rGen, const EventSet &rProjectAlphabet, std::map< Idx, StateSet > &rEntryStatesMap, mtcGenerator &rResGen)
 Minimized Deterministic projection.
void mtcInvProject (mtcGenerator &rGen, const EventSet &rProjectAlphabet)
 Inverse projection.
void mtcInvProject (const mtcGenerator &rGen, const EventSet &rProjectAlphabet, mtcGenerator &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 (mtcGenerator &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 (mtcGenerator rGen, Idx redundantColor)
 Check if a color in a colored marking generator is redundant for the supervisor synthesis.
void OptimalColorSet (const mtcGenerator &rGen, ColorSet &rOptimalColors, EventSet &rHighAlph)
 Compute an optimal subset of the colors that should be removed.
void rec_OptimalColorSet (const mtcGenerator &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 (mtcGenerator &rGen, mtcGenerator &rResGen)
 State Minimization This function implements the (n*log n) set partitioning algorithm by John E.
void mtcStateMin (mtcGenerator &rGen, mtcGenerator &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 mtcGenerator &rGen, mtcGenerator &rResGen)
 RTI wrapper.
void mtcSupConNB (const mtcGenerator &rPlantGen, const mtcGenerator &rSpecGen, mtcGenerator &rResGen)
 Nonblocking Supremal Controllable Sublanguage (wrapper function).
void mtcSupConNB (const mtcGenerator &rPlantGen, const mtcGenerator &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, mtcGenerator &rResGen)
 Nonblocking Supremal Controllable Sublanguage.
void mtcSupCon (const mtcGenerator &rPlantGen, const mtcGenerator &rSpecGen, mtcGenerator &rResGen)
 Supremal Controllable Sublanguage (wrapper function).
void mtcSupCon (const mtcGenerator &rPlantGen, const mtcGenerator &rSpecGen, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, mtcGenerator &rResGen)
 Supremal Controllable Sublanguage.
void mtcSupConParallel (const mtcGenerator &rPlantGen, const mtcGenerator &rSpecGen, const EventSet &rUAlph, std::map< std::pair< Idx, Idx >, Idx > &rReverseCompositionMap, mtcGenerator &rResGen)
 Fast parallel composition for computation for the mtcSupConNB.
bool mtcSupConUnchecked (const mtcGenerator &rPlantGen, const EventSet &rCAlph, mtcGenerator &rSupGen)
 Supremal Controllable Sublangauge (Real SupCon function; unchecked).
bool IsControllableUnchecked (const mtcGenerator &rPlantGen, const mtcGenerator &rSpecGen, const EventSet &rUAlph, StateSet &forbidden)
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)
Functions (modular diagnoser computation)

void ComputeDecentralizedModularDiagnoser (const std::vector< const cGenerator * > &rGens, const Generator &rSpec, std::vector< diagGenerator * > &rDiags, std::string &rReportString)
 Function that computes decentralized diagnosers for the respective subsystems of a composed (modular) system.
bool ComputeModularDiagnoser (const cGeneratorVector &rGsubs, const GeneratorVector &rKsubs, GeneratorVector &rDiagSubs, std::string &rReportString)
 Function that computes diagnosers for the respective subsystems of a composed system.
Functions (decentralized diagnosability)

bool IsCoDiagnosable (const cGenerator &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.
Functions (diagnoser computation)

void ComputeEventDiagnoser (const cGenerator &rOrigGen, const AttributeFailureTypeMap &rAttrFTMap, diagGenerator &rDiagGen)
 Compute a standard diagnoser from an input generator and a failure partition.
void ComputeLanguageDiagnoser (const cGenerator &rGen, const cGenerator &rSpec, diagGenerator &rDiagGen)
 Compute a standard diagnoser from an input generator and a specification.
Functions (diagnosability with respect to a failure partition)

bool IsEventDiagnosable (const cGenerator &rGen, const AttributeFailureTypeMap &rFailureTypeMap, std::string &rReportString)
 Test a system's diagnosability with respect to a given failure partition.
bool IsIndicatorEventDiagnosable (const cGenerator &rGen, const AttributeFailureTypeMap &rFailureTypeMap, std::string &rReportString)
 Test a system's I-diagnosability with respect to a given failure partition.
bool MeetsDiagnosabilityAssumptions (const cGenerator &rGen, const AttributeFailureTypeMap &rFailureTypeMap, std::string &rReportString)
 Check if a generator meets the general assumptions of diagnosability as required by IsDiagnosable(const cGenerator&, const AttributeFailureTypeMap&, std::string&) and IsIndicatorDiagnosable(const cGenerator&, const AttributeFailureTypeMap&, std::string&).
Functions (verification and computation of loop-preserving observers)

bool IsLoopPreservingObserver (const cGenerator &rGen, const EventSet &rHighAlph)
 Verifies a loop-preserving observer.
void ComputeLoopPreservingObserver (const cGenerator &rGen, const EventSet &rInitialHighAlph, EventSet &rHighAlph)
 Computes a loop-preserving observer with minimal state size of the abstraction.
Functions (diagnosability with respect to a specification)

bool IsLanguageDiagnosableX (const cGenerator &rGen, const cGenerator &rSpec, std::string &rReportString)
 Tests a system's diagnosability with respect to a given specification.
Functions (modular diagnosability)

bool IsModularDiagnosable (const cGeneratorVector &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

TokenWritergTestProtocolTw = NULL
static bool(* gBreakFnct )(void)=0
ConsoleOut gConsoleOut
 Globale console out object and reference.
ConsoleOut gpConsoleOut
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< nDevicegRtiRegisterSimplenetDevice ("SimplenetDevice")
AutoRegisterType< xDevicegRtiRegisterDeviceContainer ("DeviceContainer")

Detailed Description

libFAUDES resides within the namespace faudes.

Plug-Ins may use the same namespace.


Typedef Documentation

EventSet with controllablity properties.

Definition at line 236 of file cfl_cgenerator.h.

Definition at line 884 of file cfl_cgenerator.h.

Convenience typedef for std cGenerator.

Definition at line 880 of file cfl_cgenerator.h.

Convenience typedef for generator vectors.

Definition at line 883 of file cfl_cgenerator.h.

typedef unsigned long int faudes::fType

Convenience typdef flag data.

Definition at line 164 of file cfl_attributes.h.

typedef long unsigned int faudes::Idx

Type definition for index type.

Definition at line 43 of file cfl_definitions.h.

Definition at line 218 of file cfl_elementary.h.

Definition at line 209 of file ios_attributes.h.

typedef long int faudes::SignedIdx

Type definition for signed index type.

Definition at line 46 of file cfl_definitions.h.

typedef void*(* faudes::swig_converter_func)(void *, int *)

Definition at line 279 of file lbp_function.cpp.

typedef struct swig_type_info*(* faudes::swig_dycast_func)(void **)

Definition at line 280 of file lbp_function.cpp.

Convenience typedef for std tGenerator.

Definition at line 807 of file tp_tgenerator.h.

typedef void faudes::vDevice

Dummy typedef in the absence of the IO Device plugin.

Definition at line 29 of file sp_dplpexecutor.h.


Enumeration Type Documentation

Enumerator:
NORMAL 
CONFUSED 
BLOCK 

Definition at line 88 of file diag_languagediagnosis.h.


Function Documentation

TransSet faudes::ActiveBackwardTransSet ( const cGenerator &  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 
)

Definition at line 603 of file hio_module.cpp.

void faudes::aParallel ( const GeneratorVector &  rGenVec,
vGenerator &  rResGen 
)

Parallel composition.

See also aParallel(const vGenerator&, const vGenerator&, vGenerator&). 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 
)

Definition at line 1144 of file op_observercomputation.cpp.

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 
)

Definition at line 208 of file op_obserververification.cpp.

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 ( vGenerator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
std::map< Transition, Idx > &  rMapChangedTrans 
)

L(G)-observer computation.

This function is called by void calcAbstAlphClosed(vGenerator& 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 ( vGenerator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
std::map< Idx, std::set< Idx > > &  rMapRelabeledEvents 
)

L(G)-observer computation.

This function is called by calcAbstAlphClosed(cGenerator& 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 ( vGenerator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Transition, Idx > &  rMapChangedTrans 
)

Definition at line 703 of file op_observercomputation.cpp.

void faudes::calcAbstAlphClosed ( vGenerator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Definition at line 680 of file op_observercomputation.cpp.

void faudes::calcAbstAlphClosed ( cGenerator &  rGenObs,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Definition at line 669 of file op_observercomputation.cpp.

void faudes::calcAbstAlphMSA ( vGenerator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
std::map< Transition, Idx > &  rMapChangedTrans 
)

MSA-observer computation.

This function is called by void calcAbstAlphMSA(vGenerator& 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 ( vGenerator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
std::map< Idx, std::set< Idx > > &  rMapRelabeledEvents 
)

MSA-observer computation.

This function is called by calcAbstAlphMSA(cGenerator& 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 ( vGenerator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Transition, Idx > &  rMapChangedTrans 
)

Definition at line 868 of file op_observercomputation.cpp.

void faudes::calcAbstAlphMSA ( vGenerator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Definition at line 845 of file op_observercomputation.cpp.

void faudes::calcAbstAlphMSA ( cGenerator &  rGenObs,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Definition at line 834 of file op_observercomputation.cpp.

void faudes::calcAbstAlphMSALCC ( vGenerator &  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(cGenerator& 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 ( vGenerator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Transition, Idx > &  rMapChangedTrans 
)

Definition at line 1287 of file op_observercomputation.cpp.

void faudes::calcAbstAlphMSALCC ( cGenerator &  rGenObs,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Definition at line 1260 of file op_observercomputation.cpp.

void faudes::calcAbstAlphObs ( mtcGenerator rGenObs,
EventSet rControllableEvents,
EventSet rHighAlph,
EventSet rNewHighAlph,
map< Transition, Idx > &  rMapChangedTrans 
)

Lm-observer computation.

This function is called by void calcAbstAlphObs(vGenerator& 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 ( mtcGenerator rGenObs,
EventSet rControllableEvents,
EventSet rHighAlph,
EventSet rNewHighAlph,
map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Lm-observer computation.

This function is called by calcAbstAlphObs(cGenerator& 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 ( vGenerator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
std::map< Transition, Idx > &  rMapChangedTrans 
)

Lm-observer computation.

This function is called by void calcAbstAlphObs(vGenerator& 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 ( vGenerator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
std::map< Idx, std::set< Idx > > &  rMapRelabeledEvents 
)

Lm-observer computation.

This function is called by calcAbstAlphObs(cGenerator& 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 ( cGenerator &  rGenObs,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
EventRelabelMap &  rMapRelabeledEvents 
)

Rti convenience wrapper.

void faudes::calcAbstAlphObs ( vGenerator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Transition, Idx > &  rMapChangedTrans 
)

Definition at line 785 of file op_observercomputation.cpp.

void faudes::calcAbstAlphObs ( vGenerator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Definition at line 762 of file op_observercomputation.cpp.

void faudes::calcAbstAlphObs ( cGenerator &  rGenObs,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Definition at line 751 of file op_observercomputation.cpp.

void faudes::calcAbstAlphObsLCC ( vGenerator &  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(cGenerator& 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 ( vGenerator &  rGenObs,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Transition, Idx > &  rMapChangedTrans 
)

Definition at line 1210 of file op_observercomputation.cpp.

void faudes::calcAbstAlphObsLCC ( cGenerator &  rGenObs,
EventSet &  rHighAlph,
EventSet &  rNewHighAlph,
map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Definition at line 1183 of file op_observercomputation.cpp.

void faudes::calcBisimulation ( Generator &  rGenOrig,
map< Idx, Idx > &  rMapStateToPartition,
vector< Idx > &  rNewPartitions 
)

Definition at line 53 of file op_bisimulation.cpp.

void faudes::calcBisimulation ( Generator &  rGenOrig,
map< Idx, Idx > &  rMapStateToPartition,
Generator &  rGenPart,
vector< Idx > &  rNewPartitions 
)

Definition at line 37 of file op_bisimulation.cpp.

void faudes::calculateDynamicSystemClosedObs ( const vGenerator &  rGen,
EventSet &  rHighAlph,
vGenerator &  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 vGenerator &  rGen,
const EventSet &  rControllableEvents,
const EventSet &  rHighAlph,
vGenerator &  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 vGenerator &  rGen,
EventSet &  rHighAlph,
vGenerator &  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
void faudes::calculateDynamicSystemObs ( const mtcGenerator rGen,
EventSet rHighAlph,
vGenerator rGenDyn 
)

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 vGenerator &  rGen,
EventSet &  rHighAlph,
vGenerator &  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::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 
)

Definition at line 636 of file op_observercomputation.cpp.

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 mtcGenerator &  rGen1,
const Idx  stdidx1,
ColorSet &  colors1,
const mtcGenerator &  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 mtcGenerator for parallel composition
stdidx1 Index to first mtcGenerator's current state
colors1 Color set of first mtcGenerator
rGen2 Second mtcGenerator for parallel composition
stdidx2 Index to second mtcGenerator's current state
colors2 Color set of second mtcGenerator
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 
)

Helper: extract composition map from reverse composition map.

The reverse composition map is an optional return value of functions that operate on the product state space of two component generators, e.g. Parallel. It maps pairs of component state indices to the correponding index in the product set. Occasionally, one requires a map from the product space to to one of the component indicees. This function extracts the latter from the reverse composition map. There are two versions, one for each component.

Parameters:
rReverseCompositionMap provided map from pairs of component states to states in the product space
rCompositionMap resulting map from the product space to states from the first compoent
void faudes::CompositionMap2 ( const std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
std::map< Idx, Idx > &  rCompositionMap 
)

Helper: extract composition map from reverse composition map.

See also CompositionMap1.

Parameters:
rReverseCompositionMap provided map from pairs of component states to states in the product space
rCompositionMap resulting map from the product space to states from the second component
bool faudes::ComputeDecentralizedDiagnoser ( const cGenerator &  rGen,
const Generator &  rSpec,
const EventSetVector &  rAlphabets,
GeneratorVector &  rDiags 
)

Function definition for run-time interface.

void faudes::ComputeDecentralizedModularDiagnoser ( const cGeneratorVector &  rGens,
const Generator &  rSpec,
GeneratorVector &  rDiags 
)

Function definition for run-time interface.

void faudes::ComputeEventDiagnoser ( const cGenerator &  rOrigGen,
const std::map< std::string, EventSet > &  rFailureTypeMap,
diagGenerator &  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::ComputeEventDiagnoser ( const cGenerator &  rOrigGen,
const map< string, EventSet > &  rFailureTypeMap,
diagGenerator &  rDiagGen 
)

Definition at line 816 of file diag_eventdiagnosis.cpp.

void faudes::ComputeGd ( const diagGenerator &  rGobs,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
cGenerator &  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 diagGenerator &  rGobs,
map< pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
cGenerator &  rGd 
)

Definition at line 588 of file diag_eventdiagnosis.cpp.

void faudes::ComputeGobs ( const cGenerator &  rGenMarkedNonSpecBehaviour,
diagGenerator &  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 cGenerator &  rOrigGen,
const std::string &  rFailureType,
const EventSet &  rFailureEvents,
diagGenerator &  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 cGenerator &  rOrigGen,
const AttributeFailureTypeMap &  rAttrFTMap,
diagGenerator &  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 cGenerator &  rOrigGen,
const string &  rFailureType,
const EventSet &  rFailureEvents,
diagGenerator &  rGobs 
)

Definition at line 423 of file diag_eventdiagnosis.cpp.

bool faudes::ComputeModularDiagnoser ( const cGeneratorVector &  rGsubs,
const GeneratorVector &  rKsubs,
GeneratorVector &  rDiagsubs 
)

Function definition for run-time interface.

bool faudes::ComputeModularDiagnoser ( const cGeneratorVector &  rGsubs,
const GeneratorVector &  rKsubs,
GeneratorVector &  rDiagSubs,
string &  rReportString 
)

Definition at line 128 of file diag_modulardiagnosis.cpp.

void faudes::ComputeReachability ( const cGenerator &  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 cGenerator &  rGen,
const EventSet &  rUnobsEvents,
Idx  State,
map< Idx, multimap< Idx, DiagLabelSet > > &  rReachabilityMap 
)

Definition at line 180 of file diag_languagediagnosis.cpp.

void faudes::ComputeReachability ( const cGenerator &  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 cGenerator &  rGen,
const EventSet &  rUnobsEvents,
const EventSet &  rFailures,
Idx  State,
const AttributeFailureTypeMap &  rAttrFTMap,
map< Idx, multimap< Idx, DiagLabelSet > > &  rReachabilityMap 
)

Definition at line 703 of file diag_eventdiagnosis.cpp.

void faudes::ComputeReachabilityRecursive ( const cGenerator &  rGen,
const EventSet &  rUnobsEvents,
Idx  State,
StateSet  done,
std::map< Idx, std::multimap< Idx, DiagLabelSet > > &  rReachabilityMap 
)

Auxiliary function for ComputeReachability(const cGenerator&, 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 cGenerator &  rGen,
const EventSet &  rUnobsEvents,
Idx  State,
StateSet  done,
map< Idx, multimap< Idx, DiagLabelSet > > &  rReachabilityMap 
)

Definition at line 207 of file diag_languagediagnosis.cpp.

void faudes::ComputeReachabilityRecursive ( const cGenerator &  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 cGenerator&, 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 cGenerator &  rGen,
const EventSet &  rUnobsEvents,
const EventSet &  rFailures,
Idx  State,
const AttributeFailureTypeMap &  rAttrFTMap,
map< Idx, multimap< Idx, DiagLabelSet > > &  rReachabilityMap,
const DiagLabelSet  FToccurred 
)

Definition at line 729 of file diag_eventdiagnosis.cpp.

void faudes::ConcatenateFullLanguage ( vGenerator &  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 be nondeterministic only if parameter is nondeterministic.

Parameters:
rGen generator marking the language to be concatenated with Sigma*
void faudes::ControlProblemConsistencyCheck ( const vGenerator &  rPlantGen,
const EventSet &  rCAlph,
const vGenerator &  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 
)

Definition at line 210 of file diag_eventdiagnosis.cpp.

void faudes::cParallel ( const std::vector< cGenerator > &  rGens,
cGenerator &  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< cGenerator > &  rGens,
cGenerator &  rResGen 
)

Definition at line 270 of file diag_modulardiagnosis.cpp.

void faudes::cParallel ( const std::vector< const cGenerator * > &  rGens,
cGenerator &  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 
)

Definition at line 720 of file cfl_project.cpp.

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 cGenerator &  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 cGenerator &  rGen,
string &  rReport 
)

Definition at line 241 of file diag_eventdiagnosis.cpp.

void faudes::CycleStartStates ( const cGenerator &  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 cGenerator &  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.
void faudes::Deterministic ( const vGenerator &  rGen,
std::vector< StateSet > &  rPowerStates,
std::vector< Idx > &  rDetStates,
vGenerator &  rResGen 
)

Make generator deterministic.

Constructs a deterministic generator while preserving the generated and marked languages. See Deterministic(const vGenerator&,vGenerator& 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 vGenerator &  rGen,
std::map< Idx, StateSet > &  rEntryStatesMap,
vGenerator &  rResGen 
)

Make generator deterministic.

Constructs a deterministic generator while preserving the generated and marked languages. See Deterministic(const vGenerator&,vGenerator& 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
bool faudes::ExistsCycle ( const cGenerator &  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 cGenerator &  rGen,
string &  rReport 
)

Definition at line 283 of file diag_eventdiagnosis.cpp.

bool faudes::ExistsCycleSearch ( const cGenerator &  rGen,
StateSet &  rTodo,
Idx  currState,
StateSet  statesOnPath,
std::string &  rReport 
)

Auxiliary function for ExistsCycle(const cGenerator&, 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 cGenerator &  rGen,
StateSet &  rTodo,
Idx  currState,
StateSet  statesOnPath,
string &  rReport 
)

Definition at line 306 of file diag_eventdiagnosis.cpp.

bool faudes::ExistsViolatingCyclesInGd ( cGenerator &  rGd,
const diagGenerator &  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 ( cGenerator &  rGd,
const diagGenerator &  rGobs,
map< pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
const string &  rFailureType,
string &  rReportString 
)

Definition at line 380 of file diag_eventdiagnosis.cpp.

void faudes::ExitFunction ( void   ) 

Definition at line 335 of file cfl_helper.cpp.

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 vGenerator &  rGen,
EventSet &  rHighAlph,
map< Idx, Idx > &  rMapStateToPartition 
)

Definition at line 538 of file op_observercomputation.cpp.

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::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 cGenerator &  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 cGenerator &  rGen,
const AttributeFailureTypeMap &  rFailureTypeMap,
string &  rReport 
)

Definition at line 265 of file diag_eventdiagnosis.cpp.

const std::string& faudes::FaudesFunctionName ( const Function rObject  ) 

Definition at line 670 of file cfl_registry.cpp.

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
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:
rPlant HioPlant
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 
)

Convenience function for relabeling events in a given generator.

See insertRelabeledEvents(Generator&, const std::map<Idx, std::set<Idx> >&, EventSet&)

There are no restrictions on parameters.

Parameters:
rGenPlant Plant component automaton
rMapRelabeledEvents maps the original events to sets of newly introduced events
void faudes::insertRelabeledEvents ( cGenerator &  rGenPlant,
const std::map< Idx, std::set< Idx > > &  rMapRelabeledEvents 
)

Convenience function for relabeling events in a given generator.

See insertRelabeledEvents(cGenerator&, const std::map<Idx, std::set<Idx> >&, cEventSet&)

There are no restrictions on parameters.

Parameters:
rGenPlant Plant component automaton
rMapRelabeledEvents maps the original events to sets of newly introduced events
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 ( cGenerator &  rGenPlant,
const std::map< Idx, std::set< Idx > > &  rMapRelabeledEvents,
cEventSet &  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 
)

Rti convenience wrapper.

void faudes::insertRelabeledEvents ( Generator &  rGenPlant,
const EventRelabelMap &  rMapRelabeledEvents,
EventSet &  rNewEvents 
)

Rti convenience wrapper.

void faudes::insertRelabeledEvents ( Generator &  rGenPlant,
const map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Definition at line 1921 of file op_observercomputation.cpp.

void faudes::insertRelabeledEvents ( cGenerator &  rGenPlant,
const map< Idx, set< Idx > > &  rMapRelabeledEvents 
)

Definition at line 1915 of file op_observercomputation.cpp.

void faudes::insertRelabeledEvents ( Generator &  rGenPlant,
const map< Idx, set< Idx > > &  rMapRelabeledEvents,
EventSet &  rNewEvents 
)

Definition at line 1889 of file op_observercomputation.cpp.

void faudes::insertRelabeledEvents ( cGenerator &  rGenPlant,
const map< Idx, set< Idx > > &  rMapRelabeledEvents,
cEventSet &  rNewEvents 
)

Definition at line 1866 of file op_observercomputation.cpp.

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 cGenerator &  rGen,
const Generator &  rSpec,
const EventSetVector &  rAlphabets 
)

Function definition for run-time interface.

bool faudes::IsCoDiagnosable ( const cGenerator &  rGen,
const Generator &  rSpec,
const vector< const EventSet * > &  rAlphabets,
std::string &  rReportString 
)

Definition at line 24 of file diag_decentralizeddiagnosis.cpp.

bool faudes::IsComplete ( const vGenerator &  rGen,
const StateSet &  rStateSet 
)

Definition at line 2982 of file cfl_generator.cpp.

bool faudes::IsControllableUnchecked ( const mtcGenerator &  rPlantGen,
const mtcGenerator &  rSpecGen,
const EventSet &  rUAlph,
StateSet &  forbidden 
)

Definition at line 494 of file mtc_supcon.cpp.

bool faudes::IsControllableUnchecked ( const vGenerator &  rPlantGen,
const EventSet &  rCAlph,
const vGenerator &  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 cGenerator &  rGen,
const AttributeFailureTypeMap &  rFailureTypeMap 
)

Function definition for run-time interface.

bool faudes::IsEventDiagnosable ( const cGenerator &  rGen,
const AttributeFailureTypeMap &  rFailureTypeMap,
string &  rReportString 
)

Definition at line 13 of file diag_eventdiagnosis.cpp.

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:
rHioConstraint HioConstraint to check, HioStateFlags are set
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:
rHioController HioController to check, HioStateFlags are set
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:
rHioEnvironment HioEnvironment to check, HioStateFlags are set
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:
rHioPlant HioPlant to check, HioStateFlags are set
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 cGenerator &  rGen,
const AttributeFailureTypeMap &  rFailureTypeMap 
)

Function definition for run-time interface.

bool faudes::IsIndicatorEventDiagnosable ( const cGenerator &  rGen,
const AttributeFailureTypeMap &  rFailureTypeMap,
string &  rReportString 
)

Definition at line 85 of file diag_eventdiagnosis.cpp.

bool faudes::IsLanguageDiagnosable ( const cGenerator &  rGen,
const cGenerator  rSpec,
std::string &  rReportString 
)

Test function to verify language-diagnosability.

bool faudes::IsLanguageDiagnosable ( const cGenerator &  rGen,
const cGenerator &  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 cGenerator &  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 cGenerator &  rGen,
string &  rReport 
)

Definition at line 225 of file diag_eventdiagnosis.cpp.

bool faudes::IsModularDiagnosable ( const cGeneratorVector &  rGsubs,
const GeneratorVector &  rKsubs 
)

Function definition for run-time interface.

bool faudes::IsModularDiagnosable ( const vector< const cGenerator * > &  rGSubs,
const vector< const Generator * > &  rKSubs,
std::string &  rReportString 
)

Definition at line 50 of file diag_modulardiagnosis.cpp.

bool faudes::IsModularDiagnosable ( const cGeneratorVector &  rGsubs,
const GeneratorVector &  rKsubs,
string &  rReportString 
)

Definition at line 23 of file diag_modulardiagnosis.cpp.

bool faudes::IsMtcObs ( const mtcGenerator rLowGen,
const EventSet rHighAlph 
)

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 cGenerator &  rGen1,
const cGenerator &  rGen2,
bool &  rRes 
)

RTI wrapper.

bool faudes::IsMutuallyControllable ( const cGenerator &  rGen1,
const cGenerator &  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 cGenerator &  rPlantGen,
const vGenerator &  rSupCandGen 
)

IsNormal wrapper.

Wrapper for convenient access via the run-time interface.

bool faudes::IsNormalAlt ( const Generator &  rL,
const EventSet &  rOAlph,
const Generator &  rK 
)

IsNormalAlt: Alternative implementation of IsNormal().

using parallel composition instead of invProject and set intersection. Checks normality of a language K generated by rK w.r.t. a language L generated by rL and the subset of observable events rOAlph. This is done by checking if the following equality holds: p(K) || L = K todo(?): check for efficient algorithm replacing above formula that returns false immediately after having found a non-normal string -> IsNormalFast() todo: implement test routines, verify correctness todo: compare speed with IsNormal

Parameters:
rL generator of language L
rOAlph observable alphabet
rK generator of language K
Returns:
true if K is normal w.r.t. L and the observable alphabet
Exceptions:
Exception 
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 vGenerator &  rGenPlant,
const vGenerator &  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 vGenerator&, const vGenerator& )

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 
)

Definition at line 1047 of file diag_eventdiagnosis.cpp.

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,
vGenerator &  rResGen 
)

Language intersection.

See also LanguageUnion(const vGenerator&, const vGenerator&, vGenerator&); 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,
vGenerator &  rResGen 
)

Language union.

See also LanguageUnion(const vGenerator&, const vGenerator&, vGenerator&); 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 vGenerator &  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
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:
pBreakFnct 
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  ) 

Definition at line 423 of file cfl_helper.cpp.

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 vGenerator &  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)
bool faudes::MeetsDiagnosabilityAssumptions ( const cGenerator &  rGen,
const AttributeFailureTypeMap &  rFailureTypeMap,
string &  rReportString 
)

Definition at line 160 of file diag_eventdiagnosis.cpp.

void faudes::mtcDeterministic ( const mtcGenerator &  rGen,
std::vector< StateSet > &  rPowerStates,
std::vector< Idx > &  rDetStates,
mtcGenerator &  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 mtcGenerator &  rGen,
std::map< Idx, StateSet > &  rEntryStatesMap,
mtcGenerator &  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 mtcGenerator &  rGen,
const EventSet &  rProjectAlphabet,
mtcGenerator &  rResGen 
)
void faudes::mtcParallel ( const mtcGenerator &  rGen1,
const mtcGenerator &  rGen2,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
mtcGenerator &  rResGen 
)

Parallel composition of two mtcGenerators.

Parameters:
rGen1 First mtcGenerator for parallel composition
rGen2 Second mtcGenerator for parallel composition
rReverseCompositionMap 
rResGen Generator in which the result of the parallel composition is saved
void faudes::mtcProject ( const mtcGenerator &  rGen,
const EventSet &  rProjectAlphabet,
std::map< Idx, StateSet > &  rEntryStatesMap,
mtcGenerator &  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 mtcGenerator &  rGen,
mtcGenerator &  rResGen 
)
void faudes::mtcStateMin ( mtcGenerator &  rGen,
mtcGenerator &  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 mtcGenerator
rResGen Minimized mtcGenerator (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 ( mtcGenerator &  rGen,
mtcGenerator &  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 mtcGenerator
rResGen Minimized mtcGenerator (result)
Exceptions:
Exception 
  • Input automaton nondeterministic (id 505)
void faudes::mtcSupCon ( const mtcGenerator &  rPlantGen,
const mtcGenerator &  rSpecGen,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
mtcGenerator &  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 mtcGenerator
rSpecGen Specification mtcGenerator
rReverseCompositionMap std::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function
rResGen Reference to resulting mtcGenerator, 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 mtcGenerator &  rPlantGen,
const mtcGenerator &  rSpecGen,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
mtcGenerator &  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 mtcGenerator
rSpecGen Specification mtcGenerator
rReverseCompositionMap std::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function
rResGen Reference to resulting mtcGenerator, 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 mtcGenerator &  rPlantGen,
const mtcGenerator &  rSpecGen,
const EventSet &  rUAlph,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
mtcGenerator &  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 mtcGenerator
rSpecGen Specification mtcGenerator
rUAlph Uncontrollable Events
rReverseCompositionMap std::map< std::pair<Idx,Idx>, Idx> as in the parallel composition function
rResGen Reference to resulting mtcGenerator, the less restrictive supervisor
bool faudes::mtcSupConUnchecked ( const mtcGenerator &  rPlantGen,
const EventSet &  rCAlph,
mtcGenerator &  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
Returns:
True if no state has been deleted. Otherwise false.
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 ( mtcGenerator &  rGen  ) 

Definition at line 33 of file mtc_project.cpp.

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(), IsNormalAlt() 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 ( vGenerator &  rSupCandGen,
const EventSet &  rCAlph,
StateSet &  rMarkedPlantStates,
StateSet &  rMarkedSpecStates 
)

Definition at line 298 of file syn_wsupcon.cpp.

void faudes::OmegaSupConNBUnchecked ( const vGenerator &  rPlantGen,
const EventSet &  rCAlph,
const vGenerator &  rSpecGen,
std::map< OPSState, Idx > &  rReverseCompositionMap,
vGenerator &  rResGen 
)

Definition at line 657 of file syn_wsupcon.cpp.

void faudes::OmegaSupconParallel ( const vGenerator &  rPlantGen,
const EventSet &  rCAlph,
const vGenerator &  rSpecGen,
std::map< OPSState, Idx > &  rReverseCompositionMap,
StateSet &  rMarkedPlantStates,
StateSet &  rMarkedSpecStates,
vGenerator &  rResGen 
)

Definition at line 461 of file syn_wsupcon.cpp.

void faudes::Parallel ( const vGenerator &  rGen1,
const vGenerator &  rGen2,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
vGenerator &  rResGen 
)

Parallel composition.

See Parallel(const vGenerator&, const vGenerator&, vGenerator&). This version fills given 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 vGenerator &  rGen1,
const vGenerator &  rGen2,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
StateSet &  rMark1,
StateSet &  rMark2,
vGenerator &  rResGen 
)

Parallel composition.

See Parallel(const vGenerator&, const vGenerator&, vGenerator&). This version fills given 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
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 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 vGenerator &  rGen1,
const vGenerator &  rGen2,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
vGenerator &  rResGen 
)

Product composition.

See Product(const vGenerator&, const vGenerator&, vGenerator&). 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 vGenerator &  rGen1,
const vGenerator &  rGen2,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
StateSet &  rMark1,
StateSet &  rMark2,
vGenerator &  rResGen 
)

Product composition.

See Product(const vGenerator&, const vGenerator&, vGenerator&). 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 vGenerator &  rGen,
const EventSet &  rProjectAlphabet,
std::map< Idx, StateSet > &  rEntryStatesMap,
vGenerator &  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 vGenerator &  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 vGenerator &  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
bool faudes::rec_ComputeLoopPreservingObserver ( const cGenerator &  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 mtcGenerator 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 vGenerator &  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 vGenerator &  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 ( vGenerator &  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 ( vGenerator &  rGenRelabel,
EventSet &  rControllableEvents,
EventSet &  rHighAlph,
vector< Idx > &  rNewPartitions,
map< Idx, Idx > &  rMapStateToPartition,
map< Transition, Transition > &  rMapChangedTransReverse,
map< Transition, Idx > &  rMapChangedTrans,
map< Idx, EventSet > &  rMapRelabeledEvents 
)

Definition at line 1481 of file op_observercomputation.cpp.

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 vGenerator &  rGen1,
const vGenerator &  rGen2,
const std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
vGenerator &  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 ( vGenerator &  rGen,
vGenerator &  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(vGenerator&,vGenerator&).

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 ( vGenerator &  rGen,
vGenerator &  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(vGenerator&,vGenerator&,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 vGenerator &  rPlantGen,
const EventSet &  rCAlph,
const vGenerator &  rSpecGen,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
vGenerator &  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 vGenerator &  rPlantGen,
const EventSet &  rCAlph,
const vGenerator &  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,
vGenerator &  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 vGenerator &  rPlantGen,
const EventSet &  rCAlph,
const vGenerator &  rSpecGen,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
vGenerator &  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 cGenerator, 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::SupconParallel ( const vGenerator &  rPlantGen,
const EventSet &  rCAlph,
const vGenerator &  rSpecGen,
std::map< std::pair< Idx, Idx >, Idx > &  rReverseCompositionMap,
vGenerator &  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
bool faudes::SupConUnchecked ( const vGenerator &  rPlantGen,
const EventSet &  rCAlph,
vGenerator &  rSupCandGen 
)

Supremal Controllable Sublangauge (internal function).

Calls IsControllable to indetify "critical" states in the supervisor candidate. Then deletes critical states from the candidate supervisor in order to achieve controllability.

In general, the result is blocking.

Parameters:
rPlantGen Plant generator
rCAlph Controllable events
rSupCandGen Supervisor candidate generator
Returns:
True if no state has been deleted. Else false.
void faudes::SupNorm ( const cGenerator &  rPlantGen,
const vGenerator &  rSpecGen,
vGenerator &  rResGen 
)

rti wrapper

rti wrapper (caution: args swap)

void faudes::SupNorm ( const vGenerator &  rPlantGen,
const EventSet &  rOAlph,
const vGenerator &  rSpecGen,
vGenerator &  rResGen 
)

rti wrapper

rti wrapper (caution: args swap)

bool faudes::SupNormAlt ( Generator &  rL,
const EventSet &  rOAlph,
const Generator &  rK,
Generator &  rResult 
)

SupNormAlt: Alternative implementation of SupNorm().

using SupPrefixClosed() instead of concatenating Sigma*. SupNormAlt calculates the supremal sublanguage of the closed language K (language generated by rK) that is normal w.r.t. the closed language L (language generated by rL) and the set of observable events: SupNormClosedAlt(K)wrt(L)=SupClosed(K-Pinv[P(L-K)])

SupNormAlt returns false on empty result. todo: implement test routines, verify correctness todo: check for efficient algorithm replacing above formula

Parameters:
rL generates the closed language L=L(rL)
rOAlph observable alphabet
rK generates the closed language K=L(rK)
rResult generates the supremal normal and closed sublanguage, where Lm(rResult) is intersection of L(rResult) and Lm(rL) (marking consistent to rL)
Returns:
true for nonempty result
Exceptions:
Exception 
  • Alphabets of generators don't match (id 500)
  • rOAlph not subset of rL.Alphabet() (id 506)
  • K is not subset of L. (id 0)
void faudes::SupNormClosed ( const cGenerator &  rPlantGen,
const vGenerator &  rSpecGen,
vGenerator &  rResGen 
)

rti wrapper

rti wrapper (caution: args swap)

void faudes::SupNormClosed ( const vGenerator &  rPlantGen,
const EventSet &  rOAlph,
const vGenerator &  rSpecGen,
vGenerator &  rResGen 
)

rti wrapper

rti wrapper (caution: args swap)

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:
Exception 
  • todo: check determinism of rK
void* faudes::SwigCastPtr ( void *  ptr,
swig_type_info *  from,
swig_type_info *  ty 
)

Definition at line 306 of file lbp_function.cpp.

int faudes::syncSend ( int  dest,
const char *  data,
int  len,
int  flag 
)

Definition at line 266 of file iop_simplenet.cpp.

void faudes::TestProtocol ( const std::string &  rSource,
const std::string &  rMessage,
const std::string &  rData 
)
void faudes::TestProtocol ( const std::string &  rSource,
const std::string &  rMessage,
long int  data 
)
void faudes::TestProtocol ( const std::string &  rSource,
const std::string &  rMessage,
bool  data 
)
void faudes::TestProtocol ( const std::string &  rSource,
const std::string &  rMessage,
const Type &  rData,
bool  core 
)
void faudes::TestProtocol ( const std::string &  rSource  ) 

Test Protocol.

Sets the filename for the test protocol.

Parameters:
rSource Source file to protocol
Idx faudes::ToIdx ( const std::string &  rString  ) 

Convert a string to Idx.

Parameters:
rString string to convert
Returns:
Idx
Exceptions:
Idx overflow (id 600)
std::string faudes::ToStringFloat ( double  number  ) 

float to string

Parameters:
number double
Returns:
string
std::string faudes::ToStringInteger ( long int  number  ) 

integer to string

Parameters:
number integer
Returns:
string
std::string faudes::ToStringInteger16 ( long int  number  ) 

integer to string base 16

Parameters:
number integer
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 ( cGenerator &  rGd,
const diagGenerator &  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 ( cGenerator &  rGd,
const diagGenerator &  rGobs,
const Idx  rFailureType,
const EventSet &  rIndicatorEvents,
const map< pair< Idx, Idx >, Idx > &  rReverseCompositionMap 
)

Definition at line 606 of file diag_eventdiagnosis.cpp.

void faudes::TrimNonIndicatorTracesOfGdRecursive ( cGenerator &  rGd,
const diagGenerator &  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 ( cGenerator &  rGd,
const diagGenerator &  rGobs,
const Idx  rFailureType,
const EventSet &  rIndicatorEvents,
map< Idx, pair< Idx, Idx > > &  rCompositionMap,
Idx  state,
StateSet &  rStatesDone 
)

Definition at line 618 of file diag_eventdiagnosis.cpp.

bool faudes::YclessScc ( const Generator &  rGen,
const EventSet &  rYc,
std::set< StateSet > &  rSccSet 
)

Definition at line 1723 of file hio_functions.cpp.


Variable Documentation

bool(* faudes::gBreakFnct)(void)=0 [static]

Definition at line 420 of file cfl_helper.cpp.

Globale console out object and reference.

Definition at line 372 of file cfl_helper.cpp.

int faudes::ran_initialized = 0 [static]

Definition at line 30 of file sp_random.cpp.

long faudes::ran_seed[STREAMS] = {DEFAULT} [static]

Definition at line 28 of file sp_random.cpp.

int faudes::ran_stream = 0 [static]

Definition at line 29 of file sp_random.cpp.

libFAUDES 2.18b --- 2010-12-17 --- c++ source docu by doxygen 1.6.3