Diagnosis.hh

Go to the documentation of this file.

#ifndef __DIADES__AUTOMATA__DIAGNOSIS__HH__
#define __DIADES__AUTOMATA__DIAGNOSIS__HH__

#include<set>
#include<list>
#include<vector>
#include <boost/serialization/set.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <utils/Measures.hh>
#include <utils/Exceptions.hh>
#include "Event.hh"
#include "ObservableComponent.hh"
#include "Candidate.hh"


using namespace Diades::Utils;

namespace Diades
{
  namespace Automata
  {

        class Diagnosis
        {

        public:
          static string typeName() { return "Automata::Diagnosis"; }
          typedef Diades::Utils::Exception<Diagnosis> Exception;
        public:
          typedef set<Candidate>::size_type SizeType;
          typedef set<Candidate>::const_iterator CandidateIterator;
          typedef list< vector< Candidate::StateId > >::const_iterator StateIdIterator;
          typedef set< set<Event> >::const_iterator FaultCandidateIterator;
        private:
          set<Candidate> _candidates;
          list< vector<Candidate::StateId> > _bs;
          set< set<Event> > _faults;
        public:
          Diagnosis():_candidates(),_bs(),_faults(){}
          
          Diagnosis(const Diagnosis & diagnosis):_candidates(diagnosis._candidates),_bs(diagnosis._bs),_faults(diagnosis._faults){}
          typedef Candidate::StateId StateId;
          typedef vector < unordered_map<StateId,unordered_set<StateId> > > Dict;

          Diagnosis(const Diagnosis & diagnosis,
                                const Dict & dict) throw(Exception);

          void addCandidate(const Candidate & candidate);

          void deleteCandidate(const Candidate & candidate);

          SizeType numberOfCandidates() const { return _candidates.size(); }

          CandidateIterator begin() const { return _candidates.begin(); }

          CandidateIterator end() const { return _candidates.end(); }

          SizeType bsSize() const { return _bs.size(); }

          StateIdIterator bsBegin() const { return _bs.begin(); }


          StateIdIterator bsEnd() const { return _bs.end(); }


          FaultCandidateIterator fcBegin() const { return _faults.begin(); }

          FaultCandidateIterator fcEnd() const { return _faults.end(); }

          bool operator==(const Diagnosis & diag) const
          {
                return _candidates == diag._candidates;
          }


          bool operator!=(const Diagnosis & diag) const
          {
                return !(_candidates == diag._candidates);
          }


          void clear();
          
          friend ostream & operator<<(ostream & os, const Diagnosis & diagnosis);


        private:
          friend class boost::serialization::access;
          
          template<class Archive>
          void serialize(Archive & ar, const unsigned int version)
          {
                ar & _candidates;
                ar & _bs;
                ar & _faults;
          }        
        };


        template<typename T>
        struct ReturnedType
        {
          typedef T ValueType;
        };
        
          struct Distance : public ReturnedType<int>
        {
          ReturnedType::ValueType operator()(const Diagnosis & diag1, const Diagnosis & diag2)
          {
                return orderedHamming(diag1.begin(),diag1.end(),diag2.begin(),diag2.end());
          }
        };


        struct FcDistance : public ReturnedType<int>
        {
          ReturnedType::ValueType operator()(const Diagnosis & diag1, const Diagnosis & diag2)
          {
                set<Event> faults1;
                for(Diagnosis::FaultCandidateIterator it = diag1.fcBegin();
                        it != diag1.fcEnd();
                        ++it)
                  {
                        faults1.insert(it->begin(),it->end());
                  }
                
                set<Event> faults2;
                for(Diagnosis::FaultCandidateIterator it = diag2.fcBegin();
                        it != diag2.fcEnd();
                        ++it)
                  {
                        faults2.insert(it->begin(),it->end());
                  }
                
                return orderedHamming(faults1.begin(),faults1.end(),faults2.begin(),faults2.end());
          }
        };

        struct BsDistance : public ReturnedType<int>
        {
          ReturnedType::ValueType  operator()(const Diagnosis & diag1, const Diagnosis & diag2)
          {
                set<string> bs1;
                set<string> bs2;
                for(Diagnosis::StateIdIterator it = diag1.bsBegin();
                        it != diag1.bsEnd();
                        ++it)
                  {
                        stringstream stream;
                        for(unsigned i = 0; i < it->size(); ++i)
                          {
                                stream << (*it)[i] << '_';
                          }
                        bs1.insert(stream.str());
                  }

                for(Diagnosis::StateIdIterator it = diag2.bsBegin();
                        it != diag2.bsEnd();
                        ++it)
                  {
                        stringstream stream;
                        for(unsigned i = 0; i < it->size(); ++i)
                          {
                                stream << (*it)[i] << '_';
                          }
                        bs2.insert(stream.str());
                  }
                return orderedHamming(bs1.begin(),bs1.end(),bs2.begin(),bs2.end());
          }
        };
        
        struct CommonFaults : public ReturnedType<int>
        {
          ReturnedType::ValueType  operator()(const Diagnosis & diag1, const Diagnosis & diag2)
          {
                set<Event> faults1;
                for(Diagnosis::FaultCandidateIterator it = diag1.fcBegin();
                        it != diag1.fcEnd();
                        ++it)
                  {
                        faults1.insert(it->begin(),it->end());
                  }
                
                set<Event> faults2;
                for(Diagnosis::FaultCandidateIterator it = diag2.fcBegin();
                        it != diag2.fcEnd();
                        ++it)
                  {
                        faults2.insert(it->begin(),it->end());
                  }
                
                return intersectionSize(faults1.begin(),faults1.end(),faults2.begin(),faults2.end());
          }
        };
        
        struct NonCommonFaults : public ReturnedType<int>
        {
          ReturnedType::ValueType  operator()(const Diagnosis & diag1, const Diagnosis & diag2)
          {
                set<Event> faults1;
                for(Diagnosis::FaultCandidateIterator it = diag1.fcBegin();
                        it != diag1.fcEnd();
                        ++it)
                  {
                        faults1.insert(it->begin(),it->end());
                  }
                
                set<Event> faults2;
                for(Diagnosis::FaultCandidateIterator it = diag2.fcBegin();
                        it != diag2.fcEnd();
                        ++it)
                  {
                        faults2.insert(it->begin(),it->end());
                  }
                
                return differenceSize(faults1.begin(),faults1.end(),faults2.begin(),faults2.end());
          }
        };



        struct Accuracy : public ReturnedType<double>
        {
          ReturnedType::ValueType  operator() (const Diagnosis & diag1, const Diagnosis & diag2)
          {
                double intersection = intersectionSize(diag1.begin(),diag1.end(),diag2.begin(),diag2.end());
                double unionSize = diag1.numberOfCandidates() + diag2.numberOfCandidates() - intersection;
                return intersection / unionSize;
          }

        };




        struct BsAccuracy : public ReturnedType<double>
        {
          ReturnedType::ValueType  operator() (const Diagnosis & diag1, const Diagnosis & diag2)
          {
                set<string> bs1;
                set<string> bs2;
                for(Diagnosis::StateIdIterator it = diag1.bsBegin();
                        it != diag1.bsEnd();
                        ++it)
                  {
                        stringstream stream;
                        for(unsigned i = 0; i < it->size(); ++i)
                          {
                                stream << (*it)[i] << '_';
                          }
                        bs1.insert(stream.str());
                  }

                for(Diagnosis::StateIdIterator it = diag2.bsBegin();
                        it != diag2.bsEnd();
                        ++it)
                  {
                        stringstream stream;
                        for(unsigned i = 0; i < it->size(); ++i)
                          {
                                stream << (*it)[i] << '_';
                          }
                        bs2.insert(stream.str());
                  }
                double intersection = intersectionSize(bs1.begin(),bs1.end(),bs2.begin(),bs2.end());
                double unionSize = bs1.size() + bs2.size() - intersection;
                return intersection / unionSize;
          }

        };


        struct FcAccuracy: public ReturnedType<double>
        {
          ReturnedType::ValueType  operator() (const Diagnosis & diag1, const Diagnosis & diag2)
          {
                set<Event> faults1;
                for(Diagnosis::FaultCandidateIterator it = diag1.fcBegin();
                        it != diag1.fcEnd();
                        ++it)
                  {
                        faults1.insert(it->begin(),it->end());
                  }
                
                set<Event> faults2;
                for(Diagnosis::FaultCandidateIterator it = diag2.fcBegin();
                        it != diag2.fcEnd();
                        ++it)
                  {
                        faults2.insert(it->begin(),it->end());
                  }
                double intersection = intersectionSize(faults1.begin(),faults1.end(),faults2.begin(),faults2.end());
                double unionSize = faults1.size() + faults2.size() - intersection;
                return intersection / unionSize;
          }

        };


        struct Precision: public ReturnedType<double>
        {
          ReturnedType::ValueType  operator() (const Diagnosis & diag1, const Diagnosis & diag2)
          {
                return min( (double)diag1.numberOfCandidates() / (double)diag2.numberOfCandidates(),
                                        (double)diag2.numberOfCandidates() / (double)diag1.numberOfCandidates());
          }

        };


        struct BsPrecision: public ReturnedType<double>
        {
          ReturnedType::ValueType  operator() (const Diagnosis & diag1, const Diagnosis & diag2)
          {
                set<string> bs1;
                set<string> bs2;
                for(Diagnosis::StateIdIterator it = diag1.bsBegin();
                        it != diag1.bsEnd();
                        ++it)
                  {
                        stringstream stream;
                        for(unsigned i = 0; i < it->size(); ++i)
                          {
                                stream << (*it)[i] << '_';
                          }
                        bs1.insert(stream.str());
                  }

                for(Diagnosis::StateIdIterator it = diag2.bsBegin();
                        it != diag2.bsEnd();
                        ++it)
                  {
                        stringstream stream;
                        for(unsigned i = 0; i < it->size(); ++i)
                          {
                                stream << (*it)[i] << '_';
                          }
                        bs2.insert(stream.str());
                  }
                return min( (double) bs1.size() / (double) bs2.size(), (double) bs2.size() / (double) bs1.size());
          }

        };



        struct FcPrecision: public ReturnedType<double>
        {
          ReturnedType::ValueType  operator() (const Diagnosis & diag1, const Diagnosis & diag2)
          {
                set<Event> faults1;
                for(Diagnosis::FaultCandidateIterator it = diag1.fcBegin();
                        it != diag1.fcEnd();
                        ++it)
                  {
                        faults1.insert(it->begin(),it->end());
                  }
                
                set<Event> faults2;
                for(Diagnosis::FaultCandidateIterator it = diag2.fcBegin();
                        it != diag2.fcEnd();
                        ++it)
                  {
                        faults2.insert(it->begin(),it->end());
                  }
                return min( (double) faults1.size() / (double) faults2.size(), (double) faults2.size() / (double) faults1.size());
          }

        };






        
  }; 
};


#endif