Diagnose.cc

Go to the documentation of this file.

#include<iostream>
#include<fstream>
#include<list>
#include<string>
#include<set>
#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics/stats.hpp>
#include <boost/accumulators/statistics/min.hpp>
#include <boost/accumulators/statistics/max.hpp>
#include <boost/accumulators/statistics/mean.hpp>
#include <boost/accumulators/statistics/variance.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <utils/CmdInterface.hh>
#include<automata/Event.hh>
#include<automata/ObservableComponent.hh>
#include<automata/ClassicalDiagnoser.hh>
#include<automata/SyncRulesLoad.hh>
#include<automata/Diagnosis.hh>
#include<automata/History.hh>
#include<FaultDiagnosis.hh>
#include<io/xml/automata/Simulation.hh>


using std::vector;
using std::string;
using namespace boost::posix_time;
using namespace Diades::Automata;
using namespace boost::accumulators;
using boost::accumulators::extract::max;
using boost::accumulators::extract::min;


typedef enum { STATISTICS=0 , HELP =1, FAULTS = 2 } Option;
typedef enum { DESCOMP=0, RULES=1, XML=2, ABSTRACTION = 3, DIAGNOSER = 4} FileExtension;
unsigned numberOfOptions = 3;
unsigned numberOfFileExtensions = 5;

vector<string> fileExtensions(numberOfFileExtensions);
vector<string> options(numberOfOptions);
vector<bool> isSet(numberOfOptions,false);

string description="Usage:\t diagnose --help\n\t diagnose [--statistics]  [--faults evt1 evt2]  file1.des_comp file2.des_comp  [file3.des_comp...] sync.rules scenario.xml\n\t diagnose [--statistics]  [--faults evt1 evt2]  file1.des_comp  scenario.xml\n\t diagnose [--statistics]  [--faults evt1 evt2]  file.des_comp file.abstraction scenario.xml\n\t diagnose [--statistics]  [--faults evt1 evt2]  file.diagnoser scenario.xml\n\n\n\t Diagnose the sequence of observations given in the scenarios. Print on the\n\t standard output the final diagnosis. Write the diagnostic history in\n\t a file 'history.archv' and the perfect diagnosis in 'perfect_history.archv'.\n\t The events listed after the --faults option are considered as faults.\n\n\t If the input models are a set of models, 'diagnose' uses a component-based\n\t algorithm. If the input model is a global one, 'diagnose' uses a global \n\t model algorithm. If the input model is a diagnoser, 'diagnose' uses a diagnoser\n\t algorithm.\n\t Options: --statistics write some statistics in a file 'output.statistics'.";

void initialiseOptions()
{
  options[STATISTICS]         = "--statistics";
  options[HELP]               = "--help";
  options[FAULTS]             = "--faults";
  fileExtensions[DESCOMP]     = "des_comp";
  fileExtensions[RULES]       = "rules";
  fileExtensions[XML]         = "xml";
  fileExtensions[ABSTRACTION] = "abstraction";
  fileExtensions[DIAGNOSER]   = "diagnoser";
}


  
/************************************************************************************/

typedef pair<time_duration,Event> EventOccurrence;

typedef enum {Unknown, Comp,Model,Abstract,Diagnoser} Algotype;
void readParameters(int argc, char * argv[],
                                        Algotype & type,
                                        list<string> & modelFiles,set<Event> & faults);
void readScenario(const string & filename,
                                  list< EventOccurrence > & simulation,
                                  list< EventOccurrence > & observations);
void runDiagnosis(FaultDiagnosis & faultDiagnosis, const list< EventOccurrence >  & observations,bool statistics);

/************************************************************************************/

int main(int argc, char * argv[])
{
  setVerboseLevel(VbOutput);
  initialiseOptions();
  Algotype type = Unknown;
  list<string> modelFiles;
  set<Event> faults;
  readParameters(argc,argv,type,modelFiles,faults);
  list< EventOccurrence >  simulation;
  list< EventOccurrence >  observations;
  
  FaultDiagnosis * faultDiagnosis = 0;
  ObservableComponent globalModel;
  ClassicalDiagnoser diagnoser;
  vector<const ObservableComponent *> components;
  { verbose<VbOutput>("Loading the models..."); }
  switch(type)
        {
        case Comp:
          {
                ParametrizedSynchronisation::ComponentVector vectorComp;
                unsigned nbModel = modelFiles.size() - 2;
                while(nbModel != 0)
                  {
                        ObservableComponent * component = new ObservableComponent();
                        component->importDesCompModel(modelFiles.front());
                        
                        components.push_back(component);
                        vectorComp.push_back(component);
                        modelFiles.pop_front();
                        --nbModel;
                  }
                ParametrizedSynchronisation rules;
                loadSynchronisationRules(vectorComp,modelFiles.front(),rules);
                modelFiles.pop_front();
                faultDiagnosis = new FaultDiagnosis(components,rules,faults);
                break;
          }
        case Model:
          {
                
                globalModel.importDesCompModel(modelFiles.front());
                modelFiles.pop_front();
                faultDiagnosis = new FaultDiagnosis(globalModel,faults);
                break;
          }
        case Diagnoser:
          {
                std::ifstream ifs(modelFiles.front().c_str());
        boost::archive::text_iarchive ia(ifs);
                ia >> diagnoser;
                string log;
                diagnoser.sanityCheck(log);
                modelFiles.pop_front();
                faultDiagnosis = new FaultDiagnosis(diagnoser,faults);
                break;
          }
        default:
          {
                cout << "ALGORITHM NOT IMPLEMENTED YET. SORRY MATE." << endl;
                exit(1);
          }
        }
  { verbose<VbOutput>("Done.\n"); }
  { verbose<VbOutput>("Loading the scenario..."); }
  readScenario(modelFiles.front(),simulation,observations);
  { verbose<VbOutput>("Done.\n"); }
  { verbose<VbOutput>("Starting the diagnosis...\n"); }
  runDiagnosis(*faultDiagnosis,observations,isSet[STATISTICS]);
}


/*************************************************************************************/

void readParameters(int argc, char * argv[],
                                        Algotype & type,
                                        list<string> & modelFiles,
                                        set<Event> & faults)
{
  if(argc < 2)
        {
          printUsage(description);
        }
  int index = 1;
  string param;
  int nbModel = 0;
  string abstractionFile;
  string ruleFile;
  string xmlFile;
  while( index < argc )
        {
          Option currentOption;
          if(getOption<Option>(argv[index],options,currentOption))
                {
                  if(isSet[currentOption])
                        {
                          printError("The option '" + options[currentOption] + "' occurs at least twice.");
                        }
                  else
                        {
                          isSet[currentOption] = true;
                        }
                  switch(currentOption)
                        {
                        case HELP:
                          {
                                if((index!=1) || (argc !=2))
                                  {
                                        printError("Incorrect use of option --help.");
                                  }
                                else
                                  {
                                        printUsage(description);
                                  }
                                break;
                          }
                        case STATISTICS:
                          {
                                ++index;
                                break;
                          }
                        case FAULTS:
                          {
                                ++index;
                                set<string> faultstring;
                                getParameterList<string>(argc,argv,options,fileExtensions,
                                                                                 index,faultstring);
                                if(faultstring.empty())
                                  {
                                        printError("No parameter after the option " + options[currentOption]);
                                  }
                                else
                                  {
                                        for(const string & s : faultstring)
                                          {
                                                faults.insert(EventFactory::factory()->getEvent(s));
                                          }
                                  }
                                break;
                          }
                        default:
                          {
                                printError("Unrecognized option: " + string(argv[index]));
                                break;
                          } 
                        }
                }
          else
                {
                  // then it should be the name of a file
                  vector<string>::const_iterator it =
                        getFileExtension(string(argv[index]),fileExtensions.begin(),fileExtensions.end());

                  if(it == fileExtensions.end())
                        {
                          printError("Unrecognized file extension in file name: " + string(argv[index]));
                        }

                  // not beautiful here but i want to use a switch afterwards, so...
                  FileExtension extension = DESCOMP;
                  if(*it==fileExtensions[RULES]) { extension = RULES; }
                  if(*it==fileExtensions[XML]) { extension = XML; }
                  if(*it==fileExtensions[ABSTRACTION]) {  extension = ABSTRACTION; }
                  if(*it==fileExtensions[DIAGNOSER]) {  extension = DIAGNOSER;  }
                  switch(extension)
                        {
                        case DIAGNOSER:
                          {
                                if(nbModel!=0)
                                  {
                                        printError("The Diagnose command does not accept a diagnoser and a model file at the same time.");
                                  }
                                if(type == Abstract)
                                  {
                                        printError("The Diagnose command does not accept a diagnoser and an abstraction file at the same time.");
                                  }
                                if(type == Comp)
                                  {
                                        printError("The Diagnose command does not accept a diagnoser and a model file at the same time.");
                                  }
                                type = Diagnoser;
                                modelFiles.push_back(string(argv[index]));
                                break;
                          }
                        case DESCOMP:
                          {
                                if(type==Diagnoser)
                                  {
                                        printError("The Diagnose command does not accept a diagnoser and a model file at the same time.");
                                  }
                                if((type==Abstract) && (nbModel==1))
                                  {
                                        printError("The Diagnose command does not accept several model files and an abstraction file at the same time.");
                                  }
                                ++nbModel;
                                modelFiles.push_back(string(argv[index]));
                                break;
                          }
                        case ABSTRACTION:
                          {
                                if(type==Diagnoser)
                                  {
                                        printError("The Diagnose command does not accept a diagnoser and an abstraction file at the same time.");
                                  }
                                if(nbModel>1 ||  (type==Comp) )
                                  {
                                        printError("The Diagnose command does not accept several model files and an abstraction file at the same time.");
                                  }
                                abstractionFile = string(argv[index]);
                                type = Abstract;
                                break;
                          }
                        case RULES:
                          {
                                if(type==Diagnoser)
                                  {
                                        printError("The Diagnose command does not accept a diagnoser and an synchronisation file at the same time.");
                                  }
                                if(type==Abstract)
                                  {
                                        printError("The Diagnose command does not accept a diagnoser and a synchronisation file at the same time.");

                                  }
                                if(!ruleFile.empty())
                                  {
                                        printError("The Diagnose command does not accept two synchronisation files at the same time.");
                                  }
                                ruleFile = string(argv[index]);
                                type= Comp;
                                break;
                          }
                        case XML:
                          {
                                if(!xmlFile.empty())
                                  {
                                        printError("The Diagnose command does not accept two scenarios at the same time.");
                                  }
                                xmlFile =  string(argv[index]);
                                break;
                          }
                        }
                  ++index;
                }
        }
  if(type==Unknown && nbModel !=1)
        {
          printError("A synchronisation file is required.");
        }
  if(nbModel==1 && type==Unknown)
        {
          type=Model;
        }
  if(type==Unknown)
        {
          printError("Sorry mate, certainly a bug but impossible to correctly interpret your command.");
        }
  if(type==Comp)
        {
          modelFiles.push_back(ruleFile);
        }
  if(type==Abstract)
        {
          modelFiles.push_back(abstractionFile);
        }
  if(xmlFile.empty())
        {
          printError("No scenario file found.");
        }
  modelFiles.push_back(xmlFile); 
}
        



/***********************************************************************************/


void readScenario(const string & filename,
                                  list< EventOccurrence > & simulation,
                                  list< EventOccurrence > & observations)
{
  back_insert_iterator< list< EventOccurrence > > simIt(simulation);
  back_insert_iterator< list< EventOccurrence > > obsIt(observations);
  try
        {
          Diades::Io::Xml::loadXmlSimulation(filename, simIt,obsIt);
        }
  catch(exception & e)
        {
          printError("The function readScenario has caught an exception when loading the file " + filename + ": \n" + e.what());
        }
}

/***********************************************************************************/


void runDiagnosis(FaultDiagnosis & faultDiagnosis, const list< EventOccurrence >  & observations,
                                  bool statistics)
{
  // we need to store the produced Diagnosis somewhere, it will be here
  list<Diagnosis> diagnoses;

  // let's go and start the History
  History history;

  // let's go and start the emulated perfect History
  History perfectHistory;

  

  // now as the observable scenario is known already, it is prerecorded in the History
  for(const EventOccurrence & occurrence : observations)
        {
          history.publishObservation(history.initialTimePoint()+occurrence.first, occurrence.second);
          perfectHistory.publishObservation(perfectHistory.initialTimePoint()+occurrence.first, occurrence.second);
        }

  // let's publish the initial diagnosis, we suppose it is available at initial time point
  diagnoses.push_back(Diagnosis());
  //faultDiagnosis.getDiagnosis(diagnoses.back()); 
  history.publishDiagnosis(history.initialTimePoint(),diagnoses.back());
  perfectHistory.publishDiagnosis(perfectHistory.initialTimePoint(),diagnoses.back());

        
  // algorithm clock, initialised at the initial time point of the history
  time_duration algorithmClock = seconds(0);

  // for some statistics if needed
  ofstream file;
  accumulator_set< long, stats< tag::min, tag::max, tag::mean, tag::variance(lazy) > > stats;
  if(statistics)
        {
          file.open("output.statistics");
        }
  

  // the described algorithms being not anytime at all, here there is only
  // one published diagnosis after each observation. Off course,
  // for an anytime diagnosis, several diagnosis can be published
  // between the occurrence of two observations. That is actually the
  // big advantage of an anytime algorithm. But to perform diagnosis
  // publication when the diagnosis algorithm is working, it is required
  // to implement threads that are not implemented in this version. See
  // the work of PJ Meyer.
  // As the result of the diagnosis algorithm presented here is
  // always equivalent to the Samptah's diagnoser algorithm (only the duration will change)
  // the perfect history can also be built at the same time.

  int nbObs = observations.size();
  int currentObs = 0;
  for(const EventOccurrence & occurrence : observations)
        {
          {
                ++currentObs;
                verbose<VbOutput>("\nObservation: %1% at time %2% (%3%/%4%).") % occurrence.second
                  % occurrence.first % currentObs % nbObs;
          }
          boost::posix_time::ptime initialTime(boost::posix_time::microsec_clock::local_time());
          faultDiagnosis.diagnose(occurrence.second);
          diagnoses.push_back(Diagnosis());
          faultDiagnosis.getDiagnosis(diagnoses.back());
          boost::posix_time::ptime endTime(boost::posix_time::microsec_clock::local_time());
          time_duration algorithmicTime = endTime - initialTime;
          if(statistics)
                {
                  stats(algorithmicTime.total_microseconds());
                }
          if(algorithmClock < occurrence.first)
                {
                  // the algorithm was sleeping
                  algorithmClock = occurrence.first + algorithmicTime;
                }
          else
                {
                  // the algorithm is delayed
                  algorithmClock = algorithmClock + algorithmicTime;

                }
          
          // so the diagnosis provided by this algorithm for the flow from time 0 to time occurrence.first
          // is available at time algorithmClock
          history.publishDiagnosis(history.initialTimePoint() + algorithmClock, diagnoses.back());

          // now let us build the perfect history. The result obtained by the previous algorithm
          // is the most accurrate so in the perfect wolrd the same result is instantaneously available
          // at time occurrence.first
          perfectHistory.publishDiagnosis(perfectHistory.initialTimePoint()+occurrence.first,diagnoses.back());
        }

  

  
  cout << endl << "Final Diagnosis:" <<  endl;
  cout << diagnoses.back() << endl;
  cout << "History saved in " << flush; 
  std::ofstream ofs1("history.archv");
  boost::archive::text_oarchive oa1(ofs1);
  oa1 << history;
  cout << "history.archv" << endl;
  cout << "Perfect history saved in " << flush; 
  std::ofstream ofs2("perfect_history.archv");
  boost::archive::text_oarchive oa2(ofs2);
  oa2 << perfectHistory;
  cout << "perfect_history.archv" << endl;

  if(statistics)
        {
          cout << "Statistics saved in " << endl;
          file << "/* Result are in microseconds */" << endl;
          file << "Mean time:" <<  boost::accumulators::extract::mean(stats) << endl;
          file << "Max  time:" <<  boost::accumulators::extract::max(stats) << endl;
          file << "Min  time:" <<  boost::accumulators::extract::min(stats) << endl;
          file << "Variance: " <<  boost::accumulators::extract::variance(stats) << endl;
          file.close();
          cout << "output.statistics" << endl;
        }
}