History.hh

Go to the documentation of this file.

#ifndef __DIADES__AUTOMATA__HISTORY__HH__
#define __DIADES__AUTOMATA__HISTORY__HH__

#include<set>
#include<map>


#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/date_time/posix_time/time_serialize.hpp>
#include "ObservableComponent.hh"
#include "Diagnosis.hh"


using namespace boost::posix_time;
using namespace Diades::Utils;

namespace Diades
{
  namespace Automata
  {
        class History
        {
        public:
          typedef const Diagnosis* DiagPtr;
          typedef pair<ptime,Event> Observation;
          typedef map<ptime,Event>::const_iterator ObservationIterator;

          typedef set<ptime>::const_iterator TimeIterator;
        private:
          ptime _initialTimePoint;
          vector<ptime> _timePoints;
          vector<Diagnosis>    _diags;
          map<ptime,Event> _obs;
          set<ptime>  _hist;
          Diagnosis _nullDiagnosis;
          
        public:
          History():_initialTimePoint(microsec_clock::local_time()),_timePoints(),_diags(),_obs(),_hist(),_nullDiagnosis(){
                _hist.insert(_initialTimePoint);
          }

          typedef Candidate::StateId StateId;
          typedef vector < unordered_map<StateId,unordered_set<StateId> > > Dict;

          History(const History & hist,
                          const Dict & dict);


          
          void publishObservation(ptime t, const Event & e)
          {
                _obs[t] = e;
                _hist.insert(t);
          }

          
          void publishDiagnosis(ptime t, const Diagnosis & d)
          {
                _timePoints.push_back(t);
                _diags.push_back(d);
                _hist.insert(t);
          }
          ptime initialTimePoint() const
          {
                return _initialTimePoint;
          }
          ptime lastTimePoint() const
          {
                return *(_hist.rbegin());
          }

          TimeIterator begin(ptime t) const
          {
                TimeIterator it = _hist.begin();
                while((it!=_hist.end()) && (t > *it))
                  {
                        ++it;
                  }
                return it;
          }
          TimeIterator end(ptime t) const
          {
                TimeIterator it = _hist.begin();
                while((it!=_hist.end()) && (t >= *it))
                  {
                        ++it;
                  }
                return it;
          }
          const Diagnosis & getDiagnosis(ptime t) const;

          ObservationIterator obsBegin(ptime t) const
          {
                ObservationIterator it = _obs.begin();
                while((it != _obs.end()) && (it->first < t))
                  {
                        ++it;
                  }
                return it;
          }

          ObservationIterator obsEnd(ptime t) const
          {
                ObservationIterator it = _obs.begin();
                while((it != _obs.end()) && (it->first <= t))
                  {
                        ++it;
                  }
                return it;
          }
          
          friend ostream & operator<<(ostream & os, const History & history);
        
        
        private:        
          friend class boost::serialization::access;
          
          template<class Archive>
          void serialize(Archive & ar, const unsigned int version)
          {
                ar & _initialTimePoint;
                ar & _timePoints;
                ar & _diags;
                ar & _obs;
                ar & _hist;
                ar & _nullDiagnosis;
          }
        };



        template<typename DiagnosisComparisonFunctor>
        void historyCompare(const History & history1, const History & history2, DiagnosisComparisonFunctor compare,
                                                list< pair<ptime,typename DiagnosisComparisonFunctor::ValueType> > & result)
        {
          // offset between histories, I synchronise on the history 1
          //ptime initialTime = history1.initialTimePoint(); 
          time_duration offset = history2.initialTimePoint() - history1.initialTimePoint();
          History::TimeIterator it1  = history1.begin(history1.initialTimePoint());
          History::TimeIterator it2 = history2.begin(history2.initialTimePoint());
          bool commonTemporalWindow = true;
          //cout << "initial it1 = " << *it1 << endl;
          //cout << "initial it2 = " << *it2 << endl;
          //cout << "initial it1 + offset = " << (*it1+offset) << endl;
          //cout << "initial it2 - offset = " << (*it2-offset) << endl;
          while(commonTemporalWindow && (it1 != history1.end(history1.lastTimePoint()))
                        &&
                        (it2 != history2.end(history2.lastTimePoint())))
                {
                  //cout << "it1 = " << *it1 << endl;
                  //cout << "it2 = " << *it2 << endl;
                  //cout << "it1 + offset = " << (*it1+offset) << endl;
                  //cout << "it2 - offset = " << (*it2-offset) << endl;
                  //cout << "history1.lastTimePoint() = " << history1.lastTimePoint() << endl;
                  //cout << "history2.lastTimePoint() = " << history2.lastTimePoint() << endl;

                  
                  
                
                  if(commonTemporalWindow)
                        {
                          if(*it1 < (*it2 - offset))
                                {
                                  //cout << "*it is earlier than *it2 with regards to the synchronisation" << endl;
                                  // *it is earlier than *it2 with regards to the synchronisation
                                  commonTemporalWindow =  ((*it1 + offset) <= history2.lastTimePoint());
                                  if(commonTemporalWindow)
                                        {
                                          typename DiagnosisComparisonFunctor::ValueType res = compare(history1.getDiagnosis(*it1), history2.getDiagnosis(*it1 + offset));
                                          result.push_back(make_pair(*it1,res));
                                          ++it1;
                                        }
                                }
                          else
                                {
                                  // *it2 is either *it1 or an earlier time point with regards to the synchronisation
                                  //cout << "*it2 is either *it1 or an earlier time point with regards to the synchronisation" << endl;
                                  if(*it1 == (*it2 - offset))
                                        {
                                          commonTemporalWindow = (*it1 + offset) <= history2.lastTimePoint() && (*it2 -offset <= history1.lastTimePoint());
                                        }
                                  else
                                        {
                                          commonTemporalWindow = (*it2 -offset <= history1.lastTimePoint());
                                        }         
                                  if(commonTemporalWindow)
                                        {                                       
                                          typename DiagnosisComparisonFunctor::ValueType res = compare(history1.getDiagnosis(*it2 - offset), history2.getDiagnosis(*it2));
                                          result.push_back(make_pair(*it2-offset,res));
                                        }
                                  if(*it1 == (*it2 - offset))
                                        {
                                          //cout << "*it1 == (*it2 - offset)" << endl;
                                          ++it1;
                                          ++it2;
                                        }
                                  else
                                        {
                                          //cout << "*it1 != (*it2 - offset)" << endl;
                                          ++it2;
                                        }
                                }
                        }
                  //cout << "commonTemporalWindow ? " << commonTemporalWindow << endl;
                }
        }       
          
        template<typename  DiagnosisComparisonFunctor>
        void historyCompareWithTimeStep(const History & history1, const History & history2,
                                                                        DiagnosisComparisonFunctor compare,
                                                                        time_duration timeStep,
                                                                        list< pair<ptime,int> > & result)
        {
          // offset between histories, I synchronise on the history 1
          ptime initialTime = history1.initialTimePoint(); 
          time_duration offset = history2.initialTimePoint() - history1.initialTimePoint();
          bool commonTemporalWindow = true;
          while(commonTemporalWindow && (initialTime <= history1.lastTimePoint()))
                {
                  commonTemporalWindow = (initialTime + offset) < history2.lastTimePoint();
                  if(commonTemporalWindow)
                        {
                          int res = compare(history1.getDiagnosis(initialTime), history2.getDiagnosis(initialTime + offset));
                          result.push_back(make_pair(initialTime,res));
                        }
                  initialTime += timeStep;
                }
        }       
                
  }; 
};


#endif