Diagnoser.cc

Go to the documentation of this file.

#include <fstream>
#include <sstream>
#include <unordered_set>

#include <diades/automata/Event.hh>
#include <diades/automata/ClassicalDiagnoser.hh>
#include <diades/automata/CppGenerator.hh>

#include "CmdInterface.hh"
using namespace std;
using namespace Diades::Automata;
using namespace Diades::CmdInterface;

typedef enum { NOFAILURES=0, FAILURES=1, OBSERVABLES=2, HDFILE=3, DOTFILE=4, CPPFILE=5, WITHSILENTCLOSURE =6, HELP=7 } Option;

unsigned numberOfOptions = 8;
unsigned numberOfFileExtensions = 1;


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

string description="DiaDes: Diagnoser computation\nLAAS-CNRS, 2006-2012, 7 avenue du Colonel Roche, Toulouse, France\nContact: yannick.pencole@laas.fr\n\nUsage: diagnoser\n\t [--with-silent-closure]\n\t [--no-failures | --failures evt1 [evt2 ...]]\n\t [--observables obs1 [obs2 ...]]\n\t [--hd filename1]\n\t [--dot filename2]\n\tinfile.des_comp \n\n\nCompute an explicit representation of the diagnoser from the model \ninfile.des_comp and saves it into modelName.diagnoser (diades format). \nThe diagnoser can be extended with the silent closure or not. \nIf --no-failures is set, it returns a state observer. If --observables \n(resp. --failures) is set, then only the listed events are considered as observable \n(resp. faulty). The tag --hd exports the diagnoser is HyDiag format, the tag --dot \nexports the diagnoser in graphviz format, the tag --cpp exports the diagnoser \nin standalone and compilable C++ file. The option --help displays this message";


void initialiseOptions()
{
  options[NOFAILURES]  = "--no-failures";
  options[FAILURES]    = "--failures";
  options[OBSERVABLES] = "--observables";
  options[HDFILE] = "--hd";
  options[DOTFILE] = "--dot";
  options[CPPFILE] = "--cpp";
  options[WITHSILENTCLOSURE] = "--with-silent-closure";
  options[HELP] = "--help";
  fileExtensions[0]      = "des_comp";
}

bool getFailuresFromFileModel(const string & infileName, unordered_set<Event> & failures, string & log);



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

int main(int argc, char * argv[])
{
  verbose<VbOutput>("DiaDes: Diagnoser computation\n");
  verbose<VbOutput>("LAAS-CNRS, 2006-2012, 7 avenue du Colonel Roche, Toulouse, France\n");
  verbose<VbOutput>("Contact: yannick.pencole@laas.fr\n");
  initialiseOptions();
  vector<unsigned> values(numberOfOptions);
  vector< set<string> > events(numberOfOptions);
  string infileName;
  string dotfileName;
  string hdfileName;
  string cppfileName;
  int index = 1;
  unordered_set<Event> failures;
  unordered_set<Event> observables;
  
  if(argc < 2)
    {
          printCommandLineError(description);
    }
  else
    {
          while(index < argc)
                {
                  Option currentOption;
                  if(getOption<Option>(argv[index],options,currentOption))
                        {
                          if(isSet[currentOption])
                                {
                                  printCommandLineError("The option '" + options[currentOption] + "' occurs at least twice.");
                                }
                          else
                                {
                                  isSet[currentOption] = true;
                                }
                          

                          switch(currentOption)
                                {
                                case NOFAILURES:
                                  {
                                        ++index;
                                        if(isSet[FAILURES])
                                          {
                                                 printCommandLineError("The options failures/no-failures are incompatible with each other.");
                                          }
                                        break;
                                  }
                                case FAILURES:
                                  {
                                        ++index;
                                        if(isSet[NOFAILURES])
                                          {
                                                 printCommandLineError("The options failures/no-failures are incompatible with each other.");
                                          }
                                        else
                                          {
                                                getParameterList<string>(argc,argv,options,fileExtensions,
                                                                                                 index,events[currentOption]);
                                                if(events[currentOption].empty())
                                                  {
                                                        printCommandLineError("No parameter after the option " + options[currentOption]);
                                                  }
                                                else
                                                  {
                                                        for(const string & obs : events[currentOption])
                                                          {                                                                                             
                                                                failures.insert(EventFactory::factory()->getEvent(obs));
                                                          }
                                                  }
                                          }
                                        break;
                                  }
                                case OBSERVABLES:
                                  {
                                        ++index;
                                        
                                        getParameterList<string>(argc,argv,options,fileExtensions,
                                                                                         index,events[currentOption]);
                                        if(events[currentOption].empty())
                                          {
                                                printCommandLineError("No parameter after the option " + options[currentOption]);
                                          }
                                        else
                                          {
                                                for(const string & obs : events[currentOption])
                                                  {                                                                                             
                                                        observables.insert(EventFactory::factory()->getEvent(obs));
                                                  }
                                          }
                                        break;
                                  }
                                case HDFILE:
                                  {
                                        ++index;
                                        set<string> files;
                                        getParameterList<string>(argc,argv,options,fileExtensions,
                                                                                         index,files);
                                        if(files.size() != 1)
                                          {
                                                printCommandLineError("One and only one argument was expected after option --hd.");
                                          }
                                        hdfileName=*(files.begin());
                                        break;
                                  }
                                case DOTFILE:
                                  {
                                        ++index;
                                        set<string> files;
                                        getParameterList<string>(argc,argv,options,fileExtensions,
                                                                                         index,files);
                                        if(files.size() != 1)
                                          {
                                                printCommandLineError("One and only one argument was expected after option --dot.");
                                          }
                                        dotfileName=*(files.begin());
                                        break;
                                  }
                                case CPPFILE:
                                  {
                                        ++index;
                                        set<string> files;
                                        getParameterList<string>(argc,argv,options,fileExtensions,
                                                                                         index,files);
                                        if(files.size() != 1)
                                          {
                                                printCommandLineError("One and only one argument was expected after option --cpp.");
                                          }
                                        cppfileName=*(files.begin());
                                        break;
                                  }
                                case WITHSILENTCLOSURE:
                                  {
                                        ++index;
                                        break;
                                  }
                                case HELP:
                                  {
                                        ++index;
                                        printUsage(description);
                                        break;
                                  }
                                default:
                                  {
                                        printCommandLineError("Unrecognized option: " + string(argv[index]));
                                        break;
                                  }
                                }
                        }
                  else
                        {
                          // then it should be the model file
                          if(infileName.empty())
                                {
                                  getParameter<string>(argc,argv,index,infileName);
                                  if(!fileSuffixOk(infileName,"des_comp"))
                                        {
                                          printCommandLineError("The model file is not a component model file.");
                                        }
                                }
                          else
                                {
                                  printCommandLineError("It seems that there are more than one model file as a argument.");
                                }
                        }
                }
                          

          if(infileName.empty())
                {
                  printCommandLineError("No model, so no computation.");
                }

          verbose<VbOutput>("Model loading... ");
          ObservableComponent * modl = new ObservableComponent();
          try
                {
                  if(!modl->importDesCompModel(infileName))
                        {
                          throw(Failure("main"));
                        }
                }
          catch(exception & e)
                {
                  log<LgProcess>("The main function caught the following exception: \n\t%1%") % e.what();
                  saveLog(cerr);
                  printCommandLineError("Load of the file " + infileName + " has failed. See log above.");
                }

          { verbose<VbOutput>("%1% success.\n") % modl->name(); }

          if(!isSet[NOFAILURES] && !isSet[FAILURES])
                {
                  // the option noFailure is off and the no failure is declared as a parameter
                  // this is the default -> take the failures declared in the lafmodel
                  // @todo change this as I do not want to maintain lafmodel anymore
                  string log;
                  getFailuresFromFileModel(infileName, failures,log);
                }

         
          if(isSet[OBSERVABLES])
                {
                  // the observable mask of the component must be changed as it is probably not the default one
                  ObservableMask newMask;
                  for(unordered_set<Event>::const_iterator obsIt = observables.begin();
                          obsIt != observables.end(); ++obsIt)
                        {
                          newMask.addMask(*obsIt,*obsIt);
                        }
                  modl->setMask(newMask);
                }

          verbose<VbOutput>("Computation of the diagnoser with the following parameters: \n");
        

          for (unordered_set<Event>::const_iterator i=failures.begin(); i!=failures.end(); ++i)
                {
                  verbose<VbOutput>("Failure: %1%\n") % *i;
                }
          for (ObservableMask::ObservableEventIterator  i= modl->mask().observableBegin();
                   i!=modl->mask().observableEnd();
                   ++i)
                {
                  verbose<VbOutput>("Observable: %1%\n") % *i;
                }
                  
          //create a deterministic diagnoser
          {
                verbose<VbOutput>("Processing, please wait...");
          }
          ClassicalDiagnoser * diag = new ClassicalDiagnoser(*modl,failures,isSet[WITHSILENTCLOSURE]);
          {
                verbose<VbOutput>("Done.\n");  
                verbose<VbOutput>("Number of states: %1%\nNumber of transitions: %2%")
                  % diag->numberOfStates()
                  % diag->numberOfTransitions();
          }

          if(isSet[HDFILE])
                {
                  verbose<VbOutput>("Export in Hydiag format: ");
                  string exportHdLog; 
                  if(!diag->diagnoser2hd(hdfileName,exportHdLog))
                        {
                          string msg = exportHdLog + "\nExport failure";
                          printCommandLineError(msg);
                        }
                  verbose<VbOutput>("%1% Done.\n") % hdfileName;
                }



          if(isSet[DOTFILE])
                {
                  verbose<VbOutput>("Export in dot format: ");
                  string exportDotLog; 
                  if(!diag->diagnoser2dot(dotfileName,exportDotLog))
                        {
                          string msg = exportDotLog + "\nExport failure";
                          printCommandLineError(msg);
                        }
                  verbose<VbOutput>("%1% Done.\n") % hdfileName;
                }

          if(isSet[CPPFILE])
                {
                  {
                        verbose<VbOutput>("Export in c++ format: %1%.hh and %1%.cc") % cppfileName;
                  }
                  generateCppCode(*diag,cppfileName);
                  verbose<VbOutput>("Done.\n");
                }
          {
                verbose<VbOutput>("Save the diagnoser in %1%.diagnoser.\n") % diag->name();
          }
                

          delete diag;
          delete modl;
        }
}


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


bool getFailuresFromFileModel(const string & infileName, unordered_set<Event> & failures, string & log)
{
  bool result = true;
  string goodSuffix = fileExtensions[0];
  stringstream logStream;
  if(infileName.size() <= goodSuffix.size())
        {
          logStream << "Error: incorrect input file name, it should be something like 'filename" << fileExtensions[0] << "' but it is " << infileName << ".";
          result =false;
        }
  else
        {
          string suffix = infileName.substr(infileName.size()-goodSuffix.size(),infileName.size()-1);
          if(suffix != goodSuffix)
                {
                  logStream << "Error: incorrect input file name, it should be something like 'filename" << fileExtensions[0] << "' but it is " << infileName << ".";
                  result =false;
                }
          else
                {
                  ifstream file(infileName.c_str());
                  if(!file)
                        {
                          result =false;
                          logStream << "Error: the file '" << infileName << "' does not exist.";
                        }
                  
                  if(result)
                        {
                          string fakeName;
                          getline(file,fakeName);
                          result = !file.eof();
                          if(!result)
                                {
                                  logStream << "Error: the file '" << infileName << "' seems to be empty.";
                                }
                          else
                                {
                                  unsigned number;
                                  file >> number;
                                  if(file.eof())
                                        {
                                          logStream << "Error: Impossible to get the number of states in the file '"<< infileName << "'.";
                                        }
                                  result = !file.eof();
                                  unsigned i = 0;
                                  while(result && (i < number))
                                        {
                                          string label;
                                          file >> label;
                                          if(file.eof())
                                                {
                                                  logStream << "Error:  Impossible to get state number " << i << " in file '" << infileName << "'.";
                                                }
                                          result = !file.eof();
                                          ++i;
                                        }
                                
                                  if(result)
                                        {
                                          file >> number;
                                          result = !file.eof();
                                          if(!result)
                                                {
                                                  logStream << "Error: Impossible to get the number of fault events in file '" << infileName << "'.";
                                                }
                                          i = 0;
                                          while(result && (i < number))
                                                {
                                                  string label;
                                                  file >> label;
                                                  if(file.eof())
                                                        {                                                       
                                                          logStream << "Error: Impossible to get fault event number " << i << "in file '" << infileName << "'.";
                                                        }
                                                  failures.insert(EventFactory::factory()->getEvent(fakeName + "." + label));
                                                  result = !file.eof();
                                                  ++i;
                                                }
                                        }
                                }
                        }
                  file.close();
                }
        }
  if(!result)
        {
          log = "In getFailuresFromFileModel method, \n" + logStream.str();
        }
  return result;
}