Fault Diagnosis Plug-In
[PlugIns]

Classes

class  faudes::AttributeDiagnoserState
 Implements state estimates for the current status of the generator. More...
class  faudes::AttributeFailureEvents
 Stores the failure and indicator events for a particular failure type. More...
class  faudes::AttributeFailureTypeMap
 Partitions the failure and indicator events. More...
class  faudes::DiagLabelSet
 Implements the label representation for state estimates. More...
class  faudes::TdiagGenerator< GlobalAttr, StateAttr, EventAttr, TransAttr >
 Provides the structure and methods to build and handle diagnosers. More...

Functions

bool faudes::DecentralizedDiagnoser (const System &rGen, const Generator &rSpec, const std::vector< const EventSet * > &rAlphabets, std::vector< Diagnoser * > &rDiags, std::string &rReportString)
 Computes decentralized diagnosers for multiple local sites.
bool faudes::IsModularDiagnosable (const std::vector< const System * > &rGsubs, const std::vector< const Generator * > &rKsubs, std::string &rReportString)
 Checks modular diagnosability for a system G (which consists of the subsystems rGsubs) with respect to the specification K (consisting of local specifications rKsubs) and the local abstraction alphabets rHighAlphSubs.
bool faudes::ModularDiagnoser (const std::vector< const System * > &rGsubs, const std::vector< const Generator * > &rKsubs, std::vector< Diagnoser * > &rDiagsubs, std::string &rReportString)
 Checks modular diagnosability for a system G (which consists of the subsystems rGsubs) with respect to the specification K (consisting of local specifications rKsubs) and the local abstraction alphabets rHighAlphSubs.

Functions (decentralized diagnosability)



bool faudes::IsCoDiagnosable (const System &rGen, const Generator &rSpec, const std::vector< const EventSet * > &rAlphabets, std::string &rReportString)
 Checks co-diagnosability for a system G with respect to the specification K and the local observation alphabets rAlphabets.

Functions (modular diagnoser computation)



void faudes::DecentralizedModularDiagnoser (const std::vector< const System * > &rGens, const Generator &rSpec, std::vector< Diagnoser * > &rDiags, std::string &rReportString)
 Function that computes decentralized diagnosers for the respective subsystems of a composed (modular) system.
bool faudes::ModularDiagnoser (const SystemVector &rGsubs, const GeneratorVector &rKsubs, GeneratorVector &rDiagSubs, std::string &rReportString)
 Function that computes diagnosers for the respective subsystems of a composed system.

Functions (diagnosability with respect to a failure partition)



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

Functions (diagnoser computation)



void faudes::EventDiagnoser (const System &rOrigGen, const AttributeFailureTypeMap &rAttrFTMap, Diagnoser &rDiagGen)
 Compute a standard diagnoser from an input generator and a failure partition.
void faudes::LanguageDiagnoser (const System &rGen, const System &rSpec, Diagnoser &rDiagGen)
 Compute a standard diagnoser from an input generator and a specification.

Functions (diagnosability with respect to a specification)



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

Functions (verification and computation of loop-preserving observers)



bool faudes::IsLoopPreservingObserver (const System &rGen, const EventSet &rHighAlph)
 Verifies a loop-preserving observer.
void faudes::LoopPreservingObserver (const System &rGen, const EventSet &rInitialHighAlph, EventSet &rHighAlph)
 Computes a loop-preserving observer with minimal state size of the abstraction.

Functions (modular diagnosability)



bool faudes::IsModularDiagnosable (const SystemVector &rGsubs, const GeneratorVector &rKsubs, std::string &rReportString)
 Checks modular diagnosability for a system G (which consists of the subsystems rGsubs) with respect to the specification K (consisting of local specifications rKsubs) and the local abstraction alphabets rHighAlphSubs.

Detailed Description

Overview

This plug-in implements failure diagnosis for discrete-event systems in libFAUDES.

Failures are assumed to be unobservable events in DES that might lead to an undesired or unpredictable behaviour of the system. In order to be able to react to occurring failures, fault detection and isolation became an active area of research since the 1990s. In [1], Sampath et al. introduced the notion of diagnosability and diagnosers which observe the on-line behaviour of the system under investigation.

Diagnoser automata are FSMs that estimate the occurrence of certain failure events by tracking the observable events triggered by the plant under observation.

Diagnosability is a system property that states a system to be diagnosable with respect to a failure partition or specification, if the occurrence of a failure or violation of the specification can be determined within a bounded number of transitions.

The basic structure and handling of diagnoser automata is realized in faudes::TdiagGenerator according to [1] and a diagnoser can be computed from the failure-based model of the observed plant using the function ComputeDiagnoser().

Additionally, several functions are provided to determine the diagnosability of a system with respect to a given failure partition or specification:

  • The test for standard diagnosability with respect to a failure partition is implemented in IsDiagnosable(const System&, const AttributeFailureTypeMap&, std::string&) according to [2].
  • Testing I-diagnosability (which is a special case of diagnosability where failures only have to be detected after the occurrence of associated indicator events) is done by IsIdiagnosable(const System&, const AttributeFailureTypeMap&, std::string&) that is an enhancement of the algorithm presented in [2].
  • Diagnosability with respect to a specification (which we also refer to as language diagnosability) is tested by IsDiagnosable(const System&, const System&, std::string&) by attributing it to the known diagnosability problem in [2].
  • Decentralized diagnosability is handled by the function IsDecentralizedDiagnosable(const std::vector<System>&, const std::vector<System>&, const std::vector<EventSet>&, std::string&) that tests a modular system's diagnosability from the models of its local subsystems and specifications as presented in [3].

[1] "Diagnosability of discrete-event systems" by Sampath, M. and Sengupta, R. and Lafortune, S. and Sinnamohideen, K. and Teneketzis, D. Automatic Control, IEEE Transactions on, 40(9):1555-1575, Sep 1995.
[2] "A polynomial algorithm for testing diagnosability of discrete-event systems" by Jiang, S. and Huang, Z. Chandra, V. and Kumar, R. Automatic Control, IEEE Transactions on, 46(8):1318-1321, Aug 2001.
[3] "Hierarchical Fault Diagnosis for Discrete Event Systems: Theoretical Development and Application" by Tobias Barthel, Lehrstuhl für Regelungstechnik, Universität Erlangen-Nürnberg, 2009 (associated diploma thesis).

License

The initial implementation of this plug-in was part of Tobias Barthel's diploma thesis [3], supervised by Klaus Schmidt. The code is distributed with libFAUDES and under the terms of the LGPL.


Copyright (c) 2009, Tobias Barthel, Klaus Schmidt, Thomas Moor.
Copyright (c) 2009, Klaus Schmidt, Thomas Moor.


Function Documentation

bool faudes::DecentralizedDiagnoser ( const System &  rGen,
const Generator &  rSpec,
const std::vector< const EventSet * > &  rAlphabets,
std::vector< Diagnoser * > &  rDiags,
std::string &  rReportString 
)

Computes decentralized diagnosers for multiple local sites.

Parameters:
rGen Plant automaton.
rSpec Specification automaton.
rAlphabets Observable events of the local sites.
rDiags Decentralized diagnosers
rReportString User-readable information of violating condition (in case of negative test result).
Exceptions:
Exception 
  • Number of alphabets does not equal number of local sites (id 305).
Returns:
True if system G is co-diagnosable. The result is allocated on the heap, ownership is with the calling function.
void faudes::DecentralizedModularDiagnoser ( const std::vector< const System * > &  rGens,
const Generator &  rSpec,
std::vector< Diagnoser * > &  rDiags,
std::string &  rReportString 
)

Function that computes decentralized diagnosers for the respective subsystems of a composed (modular) system.

doxygen group

Parameters:
rGens Local subsystem automata
rSpec Specification automaton.
rDiags Decentralized diagnosers
rReportString User-readable information of violating condition (in case of negative test result).
Exceptions:
Exception 
  • Number of modular components does not equal number of decentralized diagnosers (id 306).
void faudes::EventDiagnoser ( const System &  rOrigGen,
const AttributeFailureTypeMap &  rAttrFTMap,
Diagnoser &  rDiagGen 
)

Compute a standard diagnoser from an input generator and a failure partition.

doxygen group

Parameters:
rOrigGen Input plant including failure events.
rAttrFTMap Failure type map of plant.
rDiagGen Diagnoser generator for output.
Exceptions:
Exception 
  • Input generator has no unique initial state (id 301).
bool faudes::IsCoDiagnosable ( const System &  rGen,
const Generator &  rSpec,
const std::vector< const EventSet * > &  rAlphabets,
std::string &  rReportString 
)

Checks co-diagnosability for a system G with respect to the specification K and the local observation alphabets rAlphabets.

doxygen group

Parameters:
rGen Plant automaton.
rSpec Specification automaton.
rAlphabets Local observation alphabets (for decentralized diagnosis)
rReportString User-readable information of violating condition (in case of negative test result).
Returns:
True if system G is co-diagnosable.
bool faudes::IsEventDiagnosable ( const System &  rGen,
const AttributeFailureTypeMap &  rFailureTypeMap,
std::string &  rReportString 
)

Test a system's diagnosability with respect to a given failure partition.

doxygen group Standard diagnosability of a plant is validated with respect to a given failure partition. According to: "A Polynomial Algorithm for Testing Diagnosability of Discrete Event Systems" by Shengbing Jiang, Zhongdong Huang, Vigyan Chandra, and Ratnesh Kumar.

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.
rReportString User-readable information of violating condition (in case of negative test result).
bool faudes::IsIndicatorEventDiagnosable ( const System &  rGen,
const AttributeFailureTypeMap &  rFailureTypeMap,
std::string &  rReportString 
)

Test a system's I-diagnosability with respect to a given failure partition.

Validates I-Diagnosability with respect to a given failure and indicator partition. The algorithm is a modification of IsDiagnosable().

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.
rReportString User-readable information of violating condition (in case of negative test result).
bool faudes::IsLanguageDiagnosableX ( const System &  rGen,
const System &  rSpec,
std::string &  rReportString 
)

Tests a system's diagnosability with respect to a given specification.

doxygen group

Parameters:
rGen Input generator.
rSpec Specification automaton.
rReportString User-readable information of violating condition (in case of negative test result).
Returns:
True if input generator is diagnosable.
bool faudes::IsLoopPreservingObserver ( const System &  rGen,
const EventSet &  rHighAlph 
)

Verifies a loop-preserving observer.

doxygen group

Parameters:
rGen Original generator.
rHighAlph Abstraction alphabet.
Returns:
True if natural projection is a loop-preserving observer
bool faudes::IsModularDiagnosable ( const std::vector< const System * > &  rGsubs,
const std::vector< const Generator * > &  rKsubs,
std::string &  rReportString 
)

Checks modular diagnosability for a system G (which consists of the subsystems rGsubs) with respect to the specification K (consisting of local specifications rKsubs) and the local abstraction alphabets rHighAlphSubs.

Parameters:
rGsubs Local subsystem automata.
rKsubs Local specification automata of the subsystems.
rReportString User-readable information of violating condition (in case of negative test result).
Exceptions:
Exception 
  • Number of specifications does not equal number of subsystems (id 304).
Returns:
True if system G is modular diagnosable.
bool faudes::IsModularDiagnosable ( const SystemVector &  rGsubs,
const GeneratorVector &  rKsubs,
std::string &  rReportString 
)

Checks modular diagnosability for a system G (which consists of the subsystems rGsubs) with respect to the specification K (consisting of local specifications rKsubs) and the local abstraction alphabets rHighAlphSubs.

doxygen group

Parameters:
rGsubs Local subsystem automata.
rKsubs Local specification automata of the subsystems.
rReportString User-readable information of violating condition (in case of negative test result).
Exceptions:
Exception 
  • Number of specifications does not equal number of subsystems (id 304).
Returns:
True if system G is modular diagnosable.
void faudes::LanguageDiagnoser ( const System &  rGen,
const System &  rSpec,
Diagnoser &  rDiagGen 
)

Compute a standard diagnoser from an input generator and a specification.

doxygen group

Parameters:
rGen Input plant
rSpec Specification generator.
rDiagGen Diagnoser generator for output.
void faudes::LoopPreservingObserver ( const System &  rGen,
const EventSet &  rInitialHighAlph,
EventSet &  rHighAlph 
)

Computes a loop-preserving observer with minimal state size of the abstraction.

Parameters:
rGen Original generator
rInitialHighAlph % Initial abstraction alphabet
rHighAlph Resulting abstraction alphabet
bool faudes::MeetsDiagnosabilityAssumptions ( const System &  rGen,
const AttributeFailureTypeMap &  rFailureTypeMap,
std::string &  rReportString 
)

Check if a generator meets the general assumptions of diagnosability as required by IsDiagnosable(const System&, const AttributeFailureTypeMap&, std::string&) and IsIndicatorDiagnosable(const System&, const AttributeFailureTypeMap&, std::string&).

It is examined if the following assumptions hold:

  1. The failure and indicator events are part of the generator's alphabet.
  2. The generator is live.
  3. There do not exist any cycles of unobservable events.
  4. All failure events are unobservable.
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.
rReportString User-readable information of violationg condition (in case of negative result).
Returns:
True if all assumptions are met.
Exceptions:
Exception 
  • A failure event does not form part of the alphabet of the generator (id 302).
  • A indicator event does not form part of the alphabet of the generator (id 303).
bool faudes::ModularDiagnoser ( const SystemVector &  rGsubs,
const GeneratorVector &  rKsubs,
GeneratorVector &  rDiagSubs,
std::string &  rReportString 
)

Function that computes diagnosers for the respective subsystems of a composed system.

doxygen group

Parameters:
rGsubs Local subsystem automata
rKsubs Local specification automata of the subsystems.
rDiagSubs Modular diagnosers
rReportString User-readable information of violating condition (in case of negative test result).
Exceptions:
Exception 
  • Number of specifications does not equal number of subsystems (id 304).
Returns:
True if system G is modular diagnosable.
bool faudes::ModularDiagnoser ( const std::vector< const System * > &  rGsubs,
const std::vector< const Generator * > &  rKsubs,
std::vector< Diagnoser * > &  rDiagsubs,
std::string &  rReportString 
)

Checks modular diagnosability for a system G (which consists of the subsystems rGsubs) with respect to the specification K (consisting of local specifications rKsubs) and the local abstraction alphabets rHighAlphSubs.

Parameters:
rGsubs Local subsystem automata.
rKsubs Local specification automata of the subsystems.
rDiagsubs Modular diagnosers
rReportString User-readable information of violating condition (in case of negative test result).
Exceptions:
Exception 
  • Number of specifications does not equal number of subsystems (id 304).
Returns:
True if system G is modular diagnosable. The result is allocated on the heap, ownership is with the calling function.

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