FaultDiagnosis.hh

Go to the documentation of this file.

#ifndef __DIADES__AUTOMATA__FAULTDIAGNOSIS_HH_
#define __DIADES__AUTOMATA__FAULTDIAGNOSIS_HH_

#include <unordered_map>
#include <diades/utils/Exceptions.hh>
#include <diades/automata/ObservableComponent.hh>
#include <diades/automata/ClassicalDiagnoser.hh>
#include <diades/automata/SynchronisationRules.hh>
#include <diades/automata/ComposableModel.hh>
#include <diades/automata/Diagnosis.hh>



namespace Diades
{
  namespace Automata
  {

        class FaultDiagnosis {

        public:
          static string typeName() { return "Automata::FaultDiagnosis"; }
          typedef Diades::Utils::Exception<FaultDiagnosis> Exception;
  
        public:
          typedef enum{Unknown,Comp,Global,Abstract,Diagnoser} AlgoType;
          
        private:
          AlgoType _type;
          set<Event> _faultEvents; // set of faulty events to diagnose
          const ObservableComponent * _globalModel;   // the global model if available
          ClassicalDiagnoser * _diagnoser; // the classical diagnoser if available
          vector<const ComposableModel *> _models; // the components if available
          ComposableModel * _globalComposableModel; // the composable model if available 
          const SynchronisationRules * _rules; // the synchronisation rules if available
          
          list< vector<State> > * _currentState; // current diagnosis (state-part)
          list< set<Event> > * _currentFaults; // current diagnosis (fault-part)
          set<State> _currentGlobalStates; // currentGlobalStates if availaible
           
          list<Event> _observations; // sequence of observed events
          
          

        
        
        private:

          void componentDiagnose(const Event & obs);
         
          void globalModelDiagnose(const Event & obs);


          void diagnoserDiagnose(const Event & obs);

          
          
          /*
           * 
           */
          bool createTransition(State stateToSynchronise,
                                                        const vector<Transition> & nextTransition, 
                                                        const vector<State> & nextState, 
                                                        State & targetState,
                                                        Graph::Graph & synchronisation, 
                                                        NodeMap< vector<State> > & states, 
                                                        EdgeMap< vector<Transition> > & transitions, 
                                                        EdgeMap< set<int> > & supportedTransition);

          
          /*
           *
           */ 
          bool createState(Graph::Graph & synchronisation,const vector<State> & nextState, 
                                           NodeMap< vector<State> > & states, State & s) const;
          
          /*
           * 
           */                            
          bool nextConfiguration(const list< list<Transition> > & candidateTransitions, 
                                                         list< list<Transition>::const_iterator > & configuration) const;
                                         
        public:
          FaultDiagnosis(const vector<const ObservableComponent *> models,
                                         const SynchronisationRules & rules,
                                         const set<Event> & faults);
          
          FaultDiagnosis(const ObservableComponent & globalModel, const set<Event> & faults);
          
          FaultDiagnosis(ClassicalDiagnoser & diagnoser);
        
          void diagnose(const Event & obs);
                
        
          void getDiagnosis(Diagnosis & diagnosis);
          
          
          
        };
  };
};



#endif /*FAULTDIAGNOSIS_HH_*/