ClassicalDiagnoser.hh

Go to the documentation of this file.

#ifndef __DIADES__AUTOMATA__CLASSICALDIAGNOSER__HH
#define __DIADES__AUTOMATA__CLASSICALDIAGNOSER__HH


#include <fstream>
#include <list>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <boost/dynamic_bitset.hpp>
#include <diades/graph/Graph.hh>
#include <diades/graph/NodeMap.hh>
#include <diades/graph/ConstNodeMap.hh>
#include <diades/graph/EdgeMap.hh>
#include <diades/automata/ObservableComponent.hh>
#include <diades/automata/Diagnosis.hh>

using namespace Diades::Graph;

namespace boost
{
  namespace serialization
  {
        typedef boost::dynamic_bitset<> FaultSet;
        
        template<class Archive>
        void load(Archive & ar, FaultSet & bset, const unsigned int version)
        {
          std::string s;
          ar & s;
          bset.resize(s.length(),false);
          for(unsigned i = 0; i < s.length();++i)
                {
                  bset.set(bset.size() - 1 - i, (s[i]=='1'));
                }
        }

        
        template<class Archive>
        void save(Archive & ar, const FaultSet & bset, const unsigned int version)
        {
          std::string s;
          to_string(bset,s);
          ar & s; 
        }
        

  }
}
  
BOOST_SERIALIZATION_SPLIT_FREE(boost::dynamic_bitset<>)




namespace Diades {
  namespace Automata {

        class ClassicalDiagnoser : public ObservableComponent {


        public:
          typedef enum {Diagnosed, Observable} EventType;
          typedef enum {Safe,Sure,Ambiguous}   FaultStatus;

        public:
          static string typeName() { return "Automata::ClassicalDiagnoser"; }
          typedef Diades::Utils::Exception<ClassicalDiagnoser> Exception;

          
        private:

          // Mappings
          unordered_set<Event> _diagnosedEvents; 
          typedef int ModelState;
          typedef boost::dynamic_bitset<> FaultSet;
          vector<FaultSet::size_type> faultToIndex; 
          vector<Event> indexToFault;              
          typedef pair< ModelState, FaultSet> DiagnosisHypothesis;
          typedef multimap<ModelState,  FaultSet > DiagnoserInfoState;
        
          NodeMap< DiagnoserInfoState >  stateInfo;

          State currentDiagnoserState; 
          typedef unordered_map< Event, unordered_multimap< State, FaultSet > > ReachableInfo;


          vector<string> labelStates;
        
        protected:
 


          virtual void computeDiagnoser(const ObservableComponent & model,
                                                                        const unordered_set<Event> & faults, bool silentClosure);
        

        
        private:


          void computeSilentClosure(const ObservableComponent & model, State source, const unordered_set<Event> & faults,
                                                                unordered_multimap< State, FaultSet > & result);


          
          void initModelStatesLabels(const ObservableComponent & model, vector<State> & modelStateOf,
                                                                 ConstNodeMap<int> & valueOf);





          void computeReachableStates(const ObservableComponent & model,
                                                                  ConstNodeMap< ReachableInfo > & reachables,
                                                                  bool silentClosure,
                                                                  ConstNodeMap< unordered_multimap< State, FaultSet > > & silent);



          void computeNonDeterministicDiagnoser(const ObservableComponent & model,
                                                                                        const unordered_set<Event> & faults,
                                                                                        Graph::Graph & nonDeterministicDiagnoser,
                                                                                        NodeMap< pair<int, FaultSet > > & stateInfoNonDet,
                                                                                        EdgeMap< Event > & transInfoNonDet,
                                                                                        unordered_set<State> & initialStateNonDetState,
                                                                                        bool silentClosure);
        public:
          ClassicalDiagnoser():ObservableComponent(){}


          ClassicalDiagnoser(const ObservableComponent & model,  const unordered_set<Event> & faults, bool silentClosure=false);



          FaultStatus getFaultStatus(State diagnoserState, const Event & fault) const;


          //   /**
          //      *  Load constructor
          //      *  @param fileName name of the file to load
          //      **/
          //     ClassicalDiagnoser(const string & fileName):ObservableComponent()
          //     {
          //       ifstream file(fileName.c_str());
          //       file >> *this;
          //       file.close();
          //     }


          virtual ~ClassicalDiagnoser() {
                clear();
          }


  


          unordered_set<Event>::const_iterator beginOfDiagnosedEvents() const {
                return _diagnosedEvents.begin();
          }

          unordered_set<Event>::const_iterator endOfDiagnosedEvents() const {
                return _diagnosedEvents.end();
          }

          unsigned numberOfDiagnosedEvents() const
          {
                return _diagnosedEvents.size();
          }
          
    


          State initialState() const { if(_initial.empty()) { return State(); } return *(_initial.begin()); }


        
          bool initialize() {  currentDiagnoserState = initialState(); return currentDiagnoserState.valid();  }

          void getDiagnosis(Diagnosis & diagnosis) const;

          void diagnose(const Event & obs);

          bool isConsistent(const Event & obs) const;

          //int memoryUsage() const;

        
          bool diagnoser2dot(const string & fileName, string & log) const;
          
          bool diagnoser2hd(const string & fileName, string & log) const;



        

          //  /** output stream operator (saving) */
          //     friend ostream& operator<<(ostream& os, const ClassicalDiagnoser & d);

          //     /** input stream operator (loading) */
          //     friend istream& operator>>(istream& is, ClassicalDiagnoser & d);

        public:
          
          template<class Archive>
          void serialize(Archive & ar, const unsigned int version)
          {
                //  serialize base class information
                ar & boost::serialization::base_object<ObservableComponent>(*this);
                ar & _diagnosedEvents;
                ar & faultToIndex;
                ar & indexToFault;
                ar & stateInfo;
                ar & currentDiagnoserState;
                ar & labelStates;
          }
        
          
        };


  };
};


#endif