|
libFAUDES
Sections
Index
|
Synthesis Plug-In |
Functions | |
bool | faudes::IsRelativelyMarked (const vGenerator &rGenPlant, const vGenerator &rGenCand) |
Test for relative marking. | |
bool | faudes::IsRelativelyPrefixClosed (const vGenerator &rGenPlant, const vGenerator &rGenCand) |
Test for relative prefix-closedness. | |
bool | faudes::IsRelativelyOmegaMarked (const vGenerator &rGenPlant, const vGenerator &rGenCand) |
Test for relative marking, omega langauges. | |
bool | faudes::IsRelativelyOmegaClosed (const vGenerator &rGenPlant, const vGenerator &rGenCand) |
Test for relative closedness, omega languages. | |
bool | faudes::IsControllable (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSupCandGen) |
Test controllability. | |
bool | faudes::IsControllable (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSupCandGen, StateSet &rCriticalStates) |
Test controllability. | |
bool | faudes::IsControllable (const cGenerator &rPlantGen, const vGenerator &rSupCandGen) |
Test controllability. | |
void | faudes::SupConNB (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSpecGen, vGenerator &rResGen) |
Nonblocking Supremal Controllable Sublanguage. | |
void | faudes::SupConNB (const cGenerator &rPlantGen, const vGenerator &rSpecGen, vGenerator &rResGen) |
Nonblocking Supremal Controllable Sublanguage. | |
void | faudes::SupCon (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSpecGen, vGenerator &rResGen) |
Supremal Controllable Sublanguage. | |
void | faudes::SupCon (const cGenerator &rPlantGen, const vGenerator &rSpecGen, vGenerator &rResGen) |
Supremal Controllable Sublanguage. | |
bool | faudes::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 | faudes::SupNorm (Generator &rL, const EventSet &rOAlph, const Generator &rK, Generator &rResult) |
SupNorm: compute supremal normal sublanguage. | |
bool | faudes::SupNormClosed (Generator &rL, const EventSet &rOAlph, const Generator &rK, Generator &rResult) |
SupNormClosed - compute supremal normal and closed sublanguage. | |
bool | faudes::IsOmegaControllable (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSupCandGen) |
Test omega controllability. | |
bool | faudes::IsOmegaControllable (const cGenerator &rPlantGen, const vGenerator &rSupCandGen) |
Test omega-controllability. | |
void | faudes::SupConComplete (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSpecGen, vGenerator &rResGen) |
Supremal controllable and complete sublanguage. | |
void | faudes::SupConComplete (const cGenerator &rPlantGen, const vGenerator &rSpecGen, vGenerator &rResGen) |
Supremal controllable and complete sublanguage. | |
void | faudes::SupConCompleteNB (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSpecGen, vGenerator &rResGen) |
Supremal controllable and complete sublanguage. | |
void | faudes::SupConCompleteNB (const cGenerator &rPlantGen, const vGenerator &rSpecGen, vGenerator &rResGen) |
Supremal controllable and complete sublanguage. | |
void | faudes::OmegaSupConNB (const vGenerator &rPlantGen, const EventSet &rCAlph, const vGenerator &rSpecGen, vGenerator &rResGen) |
Omega-synthesis (experimental). | |
void | faudes::OmegaSupConNB (const cGenerator &rPlantGen, const vGenerator &rSpecGen, vGenerator &rResGen) |
Omega-synthesis (experimental). |
This plug-in implements functions that are related to controllability and normality, as originally proposed by W.M. Wonham et al in the 1980s. Examples are provided in the user reference, section Synthesis.
This plug-in is distributed with libFAUDES and under the terms of the LGPL.
Copyright (c) 2006, Bernd Opitz
Copyright (c) 2009, Thomas Moor, Sebastian Perk, Klaus Schmidt.
bool faudes::IsControllable | ( | const cGenerator & | rPlantGen, | |
const vGenerator & | rSupCandGen | |||
) |
Test controllability.
Tests whether the candidate supervisor h is controllable w.r.t. the plant g; this is a cGenerator wrapper for IsControllable
rPlantGen | Plant g generator | |
rSupCandGen | Supervisor candidate h generator |
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) |
bool faudes::IsControllable | ( | const vGenerator & | rPlantGen, | |
const EventSet & | rCAlph, | |||
const vGenerator & | rSupCandGen, | |||
StateSet & | rCriticalStates | |||
) |
Test controllability.
Tests whether the candidate supervisor H is controllable w.r.t. the plant G. This implementation does not require the supervisor H to represent a sublanguage of the plant G.
If the candidate fails to be controllable, this version will return a set of "critical" states of the candidate supervisor. These states are characterised by (a) being reachable in the parallel composition of plant and supervisor (b) disabeling an uncontrollable transition of the plant
Parameter restrictions: both generators must be deterministic and have the same alphabet.
rPlantGen | Plant G | |
rCAlph | Controllable events | |
rSupCandGen | Supervisor candicate H | |
rCriticalStates | Set of critical states |
Exception |
|
bool faudes::IsControllable | ( | const vGenerator & | rPlantGen, | |
const EventSet & | rCAlph, | |||
const vGenerator & | rSupCandGen | |||
) |
Test controllability.
RTI wrapper.
Tests whether the candidate supervisor H is controllable w.r.t. the plant G. This implementation does not require the supervisor H to represent a sublanguage of the plant G.
Parameter restrictions: both generators must be deterministic and have the same alphabet.
rPlantGen | Plant G | |
rCAlph | Controllable events | |
rSupCandGen | Supervisor candidate H |
Exception |
|
bool faudes::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.
This is done by checking if the following equality holds: pinv(p(K)) intersect 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 IsNormalAlt
rL | generator of language L | |
rOAlph | observable alphabet | |
rK | generator of language K |
Exception |
|
bool faudes::IsOmegaControllable | ( | const cGenerator & | rPlantGen, | |
const vGenerator & | rSupCandGen | |||
) |
Test omega-controllability.
Tests whether the candidate supervisor h is omega controllable w.r.t. the plant g; this is a cGenerator wrapper for IsOmegaControllable.
rPlantGen | Plant g generator | |
rSupCandGen | Supervisor candidate h generator |
Exception |
|
bool faudes::IsOmegaControllable | ( | const vGenerator & | rPlantGen, | |
const EventSet & | rCAlph, | |||
const vGenerator & | rSupCandGen | |||
) |
Test omega controllability.
Tests whether the candidate supervisor H is omega controllable w.r.t. the plant G. This implementation invokes IsControllable and IsRelativelyOmegaClosed. A future implementation may be more efficient.
Parameter restrictions: both generators must be deterministic, omega-trim and have the same alphabet.
rPlantGen | Plant G | |
rCAlph | Controllable events | |
rSupCandGen | Supervisor candidate H |
Exception |
|
bool faudes::IsRelativelyMarked | ( | const vGenerator & | rGenPlant, | |
const vGenerator & | rGenCand | |||
) |
Test for relative marking.
Tests whether the language Lm(GCand) is relatively marked w.r.t. the language Lm(GPlant). The formal definition of this property requires
closure(Lm(GCand)) ^ Lm(GPlant) <= Lm(GCand).
The implementation tests
L(GCand) ^ Lm(GPlant) <= Lm(GCand)
by first performing the product composition and then inspecting the marking to require
( forall accessible (qPlant,qCand) ) [ qPlant in QPlant_m implies qCand in QCand_m ].
In general, the test is only sufficient. Provided the arguments are trim and deterministic, the test is sufficient and necessary.
rGenPlant | Generator GPlant | |
rGenCand | Generator GCand |
Exception |
|
bool faudes::IsRelativelyOmegaClosed | ( | const vGenerator & | rGenPlant, | |
const vGenerator & | rGenCand | |||
) |
Test for relative closedness, omega languages.
Tests whether the omega language Bm(GCand) is relatively closed w.r.t. the omega language Bm(GPlant). The formal definition of this property requires
closure(Bm(GCand)) ^ Bm(GPlant) = Bm(GCand).
The implementation first performs the product composition of the two generators with product state space QPlant x QCand and generated language L(GPlant x GCand) = L(GPlant) ^ L(GCand). It uses the composition to test the follwing three conditions:
The arguments GCand and GPlant are required to be deterministic and omega trim.
rGenPlant | Generator GPlant | |
rGenCand | Generator GCand |
Exception |
|
bool faudes::IsRelativelyOmegaMarked | ( | const vGenerator & | rGenPlant, | |
const vGenerator & | rGenCand | |||
) |
Test for relative marking, omega langauges.
Tests whether the omega language Bm(GCand) is relatively marked w.r.t. the omega language Bm(GPlant). The formal definition of this property requires
closure(Bm(GCand)) ^ Bm(GPlant) <= Bm(GCand).
The implementation first performs the product composition of the two generators with product state space QPlant x QCand and generated language L(GPlant x GCand) = L(Plant) ^ L(Cand). It then investigates all SCCs that do not contain a state that corresponds to GCand-marking. If and only if none of the considered SCCs has a GPlant marking, the function returns true.
The arguments GCand and GPlant are required to be deterministic and omega trim.
rGenPlant | Generator GPlant | |
rGenCand | Generator GCand |
Exception |
|
bool faudes::IsRelativelyPrefixClosed | ( | const vGenerator & | rGenPlant, | |
const vGenerator & | rGenCand | |||
) |
Test for relative prefix-closedness.
Tests whether the language Lm(GCand) is relatively closed w.r.t. the language Lm(GPant). The formal definition of this property requires
closure(Lm(GCand)) ^ Lm(GPlant) = Lm(GCand).
The implementation tests
L(GCand) ^ Lm(GPland) = Lm(GCand)
by performing the product composition and by testing
In general, the test is only sufficient. Provided the arguments are trim and deterministic, the test is sufficient and necessary.
rGenPlant | Generator GPlant | |
rGenCand | Generator GCand |
Exception |
|
void faudes::OmegaSupConNB | ( | const cGenerator & | rPlantGen, | |
const vGenerator & | rSpecGen, | |||
vGenerator & | rResGen | |||
) |
Omega-synthesis (experimental).
This function is experimental and perhaps not functional. In the long term it may synthesise supervisors for omega-languages.
This is the RTI wrapper for OmegaSupConNB(const vGenerator&, const EventSet&, const vGenerator&, vGenerator&). Controllability attributes are taken from the plant argument. If the result is specified as a cGenerator, attributes will be copied from the plant argument.
rPlantGen | Plant cGenerator | |
rSpecGen | Specification Generator | |
rResGen | Reference to resulting Generator, the minimal restrictive nonblocking supervisor |
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::OmegaSupConNB | ( | const vGenerator & | rPlantGen, | |
const EventSet & | rCAlph, | |||
const vGenerator & | rSpecGen, | |||
vGenerator & | rResGen | |||
) |
Omega-synthesis (experimental).
This function is experimental and perhaps not functional. In the long term it may synthesise supervisors for omega-languages.
Parameter restrictions: both generators must be deterministic and have the same alphabet.
rPlantGen | Plant G | |
rCAlph | Controllable events | |
rSpecGen | Specification Generator E | |
rResGen | Reference to resulting Generator, the minimal restrictive nonblocking supervisor |
Exception |
|
void faudes::SupCon | ( | const cGenerator & | rPlantGen, | |
const vGenerator & | rSpecGen, | |||
vGenerator & | rResGen | |||
) |
Supremal Controllable Sublanguage.
This is the RTI wrapper for SupCon(const vGenerator&, const EventSet&, const vGenerator&, vGenerator&). Controllability attributes are taken from the plant argument. If the result is specified as a cGenerator, attributes will be copied from the plant argument.
rPlantGen | Plant cGenerator | |
rSpecGen | Specification Generator | |
rResGen | Reference to resulting Generator, the minimal restrictive supervisor |
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::SupCon | ( | const vGenerator & | rPlantGen, | |
const EventSet & | rCAlph, | |||
const vGenerator & | rSpecGen, | |||
vGenerator & | rResGen | |||
) |
Supremal Controllable Sublanguage.
Parameter restrictions: both generators must be deterministic and have the same alphabet.
rPlantGen | Plant G | |
rCAlph | Controllable events | |
rSpecGen | Specification E | |
rResGen | Reference to resulting Generator, the minimal restrictive supervisor |
Exception |
|
void faudes::SupConComplete | ( | const cGenerator & | rPlantGen, | |
const vGenerator & | rSpecGen, | |||
vGenerator & | rResGen | |||
) |
Supremal controllable and complete sublanguage.
This is the RTI wrapper for SupConComplete(const vGenerator&, const EventSet&, const vGenerator&, vGenerator&). Controllability attributes are taken from the plant argument. If the result is specified as a cGenerator, attributes will be copied from the plant argument.
rPlantGen | Plant cGenerator | |
rSpecGen | Specification Generator | |
rResGen | Reference to resulting Generator |
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::SupConComplete | ( | const vGenerator & | rPlantGen, | |
const EventSet & | rCAlph, | |||
const vGenerator & | rSpecGen, | |||
vGenerator & | rResGen | |||
) |
Supremal controllable and complete sublanguage.
Given a plant and a specification, this function computes a realisation of the supremal controllable and complete sublange. This version consideres the generated languages (ignores the marking). In particular, this implies that the result is prefix closed. It is returned as generated language.
Starting with a product composition of plant and specification, the implementation iteratively remove states that either contradict controllability or completeness. Removal of states is continued until no contradicting states are left. Thus, the result is indeed controllable and complete. The algorithm was proposed in
R. Kumar, V. Garg, and S.I. Marcus. On supervisory control of sequential behaviors. IEEE Transactions on Automatic Control, Vol. 37: pp.1978-1985, 1992.
The paper proves supremality of the result. Provided that the corresponding omega language of the specification is closed, the result of the above algorithm also realises the least restrictive closed loop behaviour of the corresponding omega language control problem.
Parameter restrictions: both generators must be deterministic and have the same alphabet. The result will be accessible and deterministic.
rPlantGen | Plant G | |
rCAlph | Controllable events | |
rSpecGen | Specification Generator E | |
rResGen | Reference to resulting Generator |
Exception |
|
void faudes::SupConCompleteNB | ( | const cGenerator & | rPlantGen, | |
const vGenerator & | rSpecGen, | |||
vGenerator & | rResGen | |||
) |
Supremal controllable and complete sublanguage.
This is the RTI wrapper for SupConCompleteNB(const vGenerator&, const EventSet&, const vGenerator&, vGenerator&). Controllability attributes are taken from the plant argument. If the result is specified as a cGenerator, attributes will be copied from the plant argument.
rPlantGen | Plant cGenerator | |
rSpecGen | Specification Generator | |
rResGen | Reference to resulting Generator |
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::SupConCompleteNB | ( | const vGenerator & | rPlantGen, | |
const EventSet & | rCAlph, | |||
const vGenerator & | rSpecGen, | |||
vGenerator & | rResGen | |||
) |
Supremal controllable and complete sublanguage.
Given a plant and a specigfication, this function computes a realisation of the supremal controllable and complete sublange. This version consideres the marked languages.
Starting with a product composition of plant and specification, the implementation iteratively remove states that contradict controllability or completeness or that are not coaccessible. Removal of states is continued until no contradicting states are left. Thus, the result is indeed controllable, complete and coaccessible.
Considering the marked languages implies that only strings that simultanuosly reach a marking can survive the above procedure. From an omega-languages perspective, this is of limited use. However, in the special situation that the specification is relatively closed w.r.t. the plant, we can replace the specification by its prefix closure befor invoking SupConComlpleteNB. In this situation we claim that the procedure returns a realisation of the the least restrictive closed loop behaviour of the corresponding omega language control problem.
rPlantGen | Plant G | |
rCAlph | Controllable events | |
rSpecGen | Specification Generator E | |
rResGen | Reference to resulting Generator |
Exception |
|
void faudes::SupConNB | ( | const cGenerator & | rPlantGen, | |
const vGenerator & | rSpecGen, | |||
vGenerator & | rResGen | |||
) |
Nonblocking Supremal Controllable Sublanguage.
This is the RTI wrapper for SupConNB(const vGenerator&, const EventSet&, const vGenerator&, vGenerator&). Controllability attributes are taken from the plant argument. If the result is specified as a cGenerator, attributes will be copied from the plant argument.
rPlantGen | Plant cGenerator | |
rSpecGen | Specification Generator | |
rResGen | Reference to resulting Generator, the minimal restrictive nonblocking supervisor |
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::SupConNB | ( | const vGenerator & | rPlantGen, | |
const EventSet & | rCAlph, | |||
const vGenerator & | rSpecGen, | |||
vGenerator & | rResGen | |||
) |
Nonblocking Supremal Controllable Sublanguage.
Computes the supremal nonblocking sublanguage of the specification E that is controllable w.r.t. the plant G. The result is given as a trim deterministic generator that may be used to supervise G in order to enforce H. This implementation does not require E to represent a sublanguage of G
See "C.G CASSANDRAS AND S. LAFORTUNE. Introduction to Discrete Event Systems. Kluwer, 1999." for base algorithm.
Parameter restrictions: both generators must be deterministic and have the same alphabet.
rPlantGen | Plant G | |
rCAlph | Controllable events | |
rSpecGen | Specification Generator E | |
rResGen | Reference to resulting Generator, the minimal restrictive nonblocking supervisor |
Exception |
|
bool faudes::SupNorm | ( | Generator & | rL, | |
const EventSet & | rOAlph, | |||
const Generator & | rK, | |||
Generator & | rResult | |||
) |
SupNorm: compute supremal normal sublanguage.
SupNorm calculates the supremal sublanguage of the closed language K (prefix closure of the language marked by rK) that is normal w.r.t. the closed language L (prefix closure of the language marked by rL) and the set of observable events.
Method: The supremal normal sublanguage is computed according to the Lin-Brandt-Formula: supnorm(K)wrt(L)=K-Pinv[P(L-K)]
SupNorm returns false on empty result.
Parameters have to be deterministic, result is deterministic.
Note: rL is not const, as the prefix closure is taken during computation. However, its original marked language is restored before return. See also SupNormClosed and supnorm_tutorial.cpp
rL | generates the closed language L=L(rL) | |
rOAlph | observable alphabet | |
rK | generates the closed language K=L(rK) | |
rResult | generates the supremal normal sublanguage, where Lm(rResult) is intersection of L(rResult) and Lm(rL) (marking consistent to rL) |
Exception |
|
bool faudes::SupNormClosed | ( | Generator & | rL, | |
const EventSet & | rOAlph, | |||
const Generator & | rK, | |||
Generator & | rResult | |||
) |
SupNormClosed - compute supremal normal and closed sublanguage.
SupNormClosed calculates the supremal sublanguage of the closed language K (prefix closure of the language marked by rK) that is closed and normal w.r.t. the closed language L (prefix closure of the language marked by rL) and the set of observable events.
Method: The supremal normal sublanguage is computed according to the Lin-Brandt-Formula: supnormclosed(K)wrt(L)=K-Pinv[P(L-K)]Sigma* The difference to supnorm lies in the concatenation of Sigma*. SupNormClosed returns false on empty result.
Parameters have to be deterministic, result is deterministic.
Note: rL is not const, as the prefix closure is taken during computation. However, its original marked language is restored before return. See also supnorm_tutorial.cpp todo: check for efficient algorithm replacing above formula
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) |
Exception |
|
libFAUDES 2.16b --- 2010-9-8 --- c++ source docu by doxygen 1.6.3