run.cc

Go to the documentation of this file.

#include<fstream>
#include<string>
#include<vector>
#include<list>
#include<map>
#include<boost/date_time/posix_time/posix_time.hpp>
#include<boost/archive/text_oarchive.hpp>
#include<utils/Random.hh>
#include<utils/CmdInterface.hh>
#include<automata/SynchronisationRules.hh>
#include<automata/ObservableComponent.hh>
#include<automata/FaultDiagProblem.hh>
#include<automata/FBFS.hh>
#include<automata/FDFS.hh>
#include<automata/FGFS.hh>
#include<io/xml/automata/Simulation.hh>
#include<automata/Diagnose.hh>
#include<automata/SyncRulesLoad.hh>


using Diades::Automata::ObservableComponent;
using Diades::Automata::SynchronisationRules;
using Diades::Automata::Event;
using Diades::Automata::Diagnosis;
using Diades::Automata::EventFactory;
using Diades::Automata::FaultDiagProblem;
using Diades::Automata::Diagnose;
using Diades::Automata::FBFS;
using Diades::Automata::FGFS;
using Diades::Automata::FDFS;
using Diades::Automata::EventOccurrence;
using Diades::Automata::ParametrizedSynchronisation;
typedef enum { FAULTS = 0, ALGORITHMS = 1 } Option;
typedef enum { DESCOMP=0, RULES=1, XML=2} FileExtension;
unsigned numberOfOptions = 2;
unsigned numberOfFileExtensions = 3;

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

string description="Usage:\t dd-run --algorithms ALG1 [ALG2...] --faults evt1 [evt2 ...] file1.des_comp [file2.des_comp  file3.des_comp... sync.rules] scenario.xml\n\t Diagnose the sequence of observations given in the scenarios with the set of available algorithms.  Write the diagnostic history in\n\t a file 'histALG.archv' for each algorithm ALG and the perfect diagnosis in 'perfect_history.archv'.\n\t The implemented algorithms are: FBFS, FDFS, FGFS, AFBFS.";

void initialiseOptions()
{
  options[FAULTS]             = "--faults";
  options[ALGORITHMS]         = "--algorithms";
  fileExtensions[DESCOMP]     = "des_comp";
  fileExtensions[RULES]       = "rules";
  fileExtensions[XML]         = "xml";
}

void readScenario(const string & filename,
                                  vector< EventOccurrence > & simulation,
                                  vector< EventOccurrence > & observations);

void readParameters(int argc, char * argv[],
                                        list<string> & modelFiles,
                                        set<string> & algos,
                                        unordered_set<Event> & faults,
                                        string & ruleFiles,
                                        string & scenarioFile);


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

int main(int argc, char ** argv)
{
  Diades::Utils::initialiseRandomGenerator(Diades::Utils::initialiseSeed());
  list<string> modelFiles;
  set<string> algos;
  unordered_set<Event> faults;
  string ruleFile;
  string scenarioFile;
  initialiseOptions();
  readParameters(argc,argv,modelFiles,algos,faults,ruleFile,scenarioFile);

  // model loading
  vector<ObservableComponent *> components;
  vector<ObservableComponent::CRef> comps;
  ParametrizedSynchronisation::ComponentVector vectorComp;
  for(const string & filename : modelFiles)
        {
          components.push_back(new ObservableComponent());
          components.back()->importDesCompModel(filename);
          vectorComp.push_back(components.back());
          comps.push_back(cref(*components.back()));
        }

  // synchronisation rules loading
  ParametrizedSynchronisation rules;
  if(!ruleFile.empty())
    {                                                                                   
      loadSynchronisationRules(vectorComp,ruleFile,rules);
    }
  set<Event> synchronisedEvents;
  for(SynchronisationRules::SynchronisationIterator sit = rules.beginOfSynchronisedEvents();
          sit != rules.endOfSynchronisedEvents();
          ++sit)
        {
          for(Diades::Automata::SynchronisationEvent::ComponentIterator cit = sit->beginOfSupport();
                  cit != sit->endOfSupport();
                  ++cit)
                {
                  synchronisedEvents.insert(sit->getAssociatedEvent(cit));
                }
        }

  // scenario loading
  vector< EventOccurrence > observations;
  vector< EventOccurrence > simulation;
  readScenario(scenarioFile,simulation,observations);

  std::cout << "Scenario:" << std::endl;
  for(const EventOccurrence & evo: observations)
        {
          std::cout << "(" << evo.first << "," << evo.second << ") ";
        }
  std::cout << std::endl;
  
  
 

  list<Diagnosis> results;
  string histFile = "hist.archv";
  for(const string & algo: algos)
        {
          if(algo == "FBFS")
                {
                  FaultDiagProblem problem(comps, faults, rules, observations);
                  cout << "FBFS starting.." << endl;
                  Diagnose<FBFS> d1(problem);
                  std::ofstream ofs1( "FBFS" + histFile);
                  boost::archive::text_oarchive oa1(ofs1);
                  oa1 << d1.history();
                  results.push_back(d1.history().getDiagnosis(d1.history().lastTimePoint()));
                }
          if(algo == "FDFS")
                {
                  FaultDiagProblem problem(comps, faults, rules, observations);
                  cout << "FDFS starting.." << endl;
                  Diagnose<FDFS> d2(problem);
                  std::ofstream ofs2( "FDFS" + histFile);
                  boost::archive::text_oarchive oa2(ofs2);
                  oa2 << d2.history();
                  results.push_back(d2.history().getDiagnosis(d2.history().lastTimePoint()));
                }
          if(algo == "FGFS")
                {
                  FaultDiagProblem problem(comps, faults, rules, observations);
                  cout << "FGFS starting.." << endl;
                  Diagnose<FGFS> d3(problem);
                  std::ofstream ofs3( "FGFS" + histFile);
                  boost::archive::text_oarchive oa3(ofs3);
                  oa3 << d3.history();
                  results.push_back(d3.history().getDiagnosis(d3.history().lastTimePoint()));
                }
          if(algo == "AFBFS")
                {
                  cout << "pre-ABFS starting" << endl;
                  // model abstracting
                  typedef  unordered_map<Diades::Automata::State,unordered_set<Diades::Automata::State> > Dict;
                  vector<Dict> dictionary;
                  vector<ObservableComponent *> absComponents;
                  vector<ObservableComponent::CRef> abscomps;
                  ParametrizedSynchronisation::ComponentVector vectorAbsComp;
                  for(const ObservableComponent & comp : comps)
                        {
                          absComponents.push_back(new ObservableComponent());
                          set<Event> projectedEvents;
                          for(ObservableComponent::EventIterator evtIt = comp.eventBegin();
                                  evtIt != comp.eventEnd();
                                  ++evtIt)
                                {
                                  if(synchronisedEvents.find(*evtIt) != synchronisedEvents.end())
                                        {
                                          projectedEvents.insert(*evtIt);
                                        }
                                  if(comp.mask().isObservable(*evtIt))
                                        {
                                          projectedEvents.insert(*evtIt);
                                        }
                                  if(faults.find(*evtIt) != faults.end())
                                        {
                                          projectedEvents.insert(*evtIt);
                                        }
                                }
                          dictionary.push_back(Dict());
                          absComponents.back()->project(&comp,projectedEvents,dictionary.back());
                          absComponents.back()->setName(comp.name());
                          abscomps.push_back(cref(*absComponents.back()));
                          vectorAbsComp.push_back(absComponents.back());
                        }
                  // synchronisation rules loading
                  ParametrizedSynchronisation absrules;
                  if(!ruleFile.empty())
                        {                                                                                       
                          loadSynchronisationRules(vectorAbsComp,ruleFile,absrules);
                        }
                  FaultDiagProblem problem( abscomps, faults,  absrules, observations);
                  cout << "AFBFS starting.." << endl;
                  Diagnose<FBFS> d4(problem);
                  cout << "Done" << endl;
                  std::ofstream ofs4( "AFBFS" + histFile);
                  boost::archive::text_oarchive oa4(ofs4);
                  typedef  unordered_map<Diades::Automata::Candidate::StateId,unordered_set<Diades::Automata::Candidate::StateId> > DictId;
                  vector<DictId> dictionaryId(dictionary.size());
                  for(unsigned i = 0; i < dictionary.size(); ++i)
                        {
                          for(Dict::const_iterator it1 = dictionary[i].begin();
                                  it1 != dictionary[i].end();
                                  ++it1)
                                {
                                  for(unordered_set<Diades::Automata::State>::const_iterator it2 = it1->second.begin();
                                          it2 != it1->second.end();
                                          ++it2)
                                        {
                                          dictionaryId[i][it1->first.id()].insert(it2->id());
                                        }
                                }
                        }
                  Diades::Automata::History nonAbsHist(d4.history(),dictionaryId);cout << "here8" << endl;
                  oa4 << nonAbsHist;
                  results.push_back(nonAbsHist.getDiagnosis(d4.history().lastTimePoint()));
                }
        }
  cout << "Result: ";
  list<Diagnosis>::const_iterator rit = results.begin();
  for(set<string>::const_iterator it = algos.begin();
          it != algos.end();
          ++it)
        {
          set<string>::const_iterator it2 = it;
          list<Diagnosis>::const_iterator rit2 = rit;
          ++it2;
          ++rit2;
          for(; it2 != algos.end(); ++it2)
                {
                  cout << *it << "/" << *it2 << " ? " << (*rit == *rit2 ) << endl; 
                  ++rit2;
                }
        }
}




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

void readParameters(int argc, char * argv[],
                                        list<string> & modelFiles,
                                        set<string> & algos,
                                        unordered_set<Event> & faults,
                                        string & ruleFile, string & scenarioFile)
{
  list<string>::size_type nbModel = 0;
  if(argc < 3)
        {
          printUsage(description);
        }
  int index = 1;
  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 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;
                          }
                        case ALGORITHMS:
                          {
                                ++index;

                                getParameterList<string>(argc,argv,options,fileExtensions,
                                                                                 index,algos);
                                if(algos.empty())
                                  {
                                        printError("No parameter after the option " + options[currentOption]);
                                  }
                                break;
                          }
                        }
                }
          else
                {
                  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]));
                        }
                  FileExtension extension = DESCOMP;
                  if(*it==fileExtensions[RULES]) { extension = RULES; }
                  if(*it==fileExtensions[XML]) { extension = XML; }
                  switch(extension)
                        {
                        case DESCOMP:
                          {
                                if(find(modelFiles.begin(),modelFiles.end(),string(argv[index])) == modelFiles.end())
                                  {
                                        ++nbModel;
                                        modelFiles.push_back(string(argv[index]));
                                  }
                                break;
                          }
                        case RULES:
                          {
                                if(!ruleFile.empty())
                                  {
                                        printError("The dreamap command does not accept two synchronisation files at the same time.");
                                  }
                                ruleFile = string(argv[index]);
                                break;
                          }
                        case XML:
                          {
                                if(!scenarioFile.empty())
                                  {
                                        printError("The dreamap command does not accept two scenarios at the same time.");
                                  }
                                scenarioFile =  string(argv[index]);
                                break;
                          }
                        }
                  ++index;
                }
        }
  if(faults.empty())
        {
          printError("No fault found.");
        }
  if(scenarioFile.empty())
        {
          printError("No scenario file found.");
        }
  if((nbModel > 1) && (ruleFile.empty()))
        {
          printError("No rule file found.");
        }
  if((nbModel == 1) && (!ruleFile.empty()))
        {
          printError("Only one component found so no rule file is needed.");
        }
  if(modelFiles.empty())
        {
          printError("No model found");
        }
}

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


void readScenario(const string & filename,
                                  vector< EventOccurrence > & simulation,
                                  vector< EventOccurrence > & observations)
{
  list<EventOccurrence> tmp1;
  list<EventOccurrence> tmp2;
  
  back_insert_iterator< list< EventOccurrence > > simIt(tmp1);
  back_insert_iterator< list< EventOccurrence > > obsIt(tmp2);
  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());
        }

  for(const EventOccurrence & evo : tmp1)
        {
          simulation.push_back(evo);
        }
  
  for(const EventOccurrence & evo : tmp2)
        {
          observations.push_back(evo);
        }
  
  
}

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