FaultGenerate.cc

Go to the documentation of this file.

#include<iostream>
#include<sstream>
#include<fstream>
#include<string>
#include<map>
#include<list>
#include <cmath>
#include<utils/Random.hh>
#include<utils/Verbose.hh>
#include<utils/Log.hh>
#include<utils/CmdInterface.hh>
#include<automata/ObservableComponent.hh>


using namespace std;
using namespace Diades::Utils;
using namespace Diades::Automata;


typedef enum { FAULTMAX=0, SEED=1, HELP=2 } Option;
typedef enum { DESCOMP=0 } FileExtension;

unsigned numberOfOptions = 3;
unsigned numberOfFileExtensions = 1; 

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


string description="Usage:  dd-fault-generate\n\t --help |\n\t [--seed randomSeed] [--faultMax nbFaultMax] [file1.des_comp ...] \n\n\t Generate randomly a set of fault events out of the models. If no model file is\n\t provided as argument, read the input standard. The set of chosen faults\n\t is printed on the standard output.";


void initialiseOptions()
{
  options[FAULTMAX]         = "--faultMax";
  options[SEED] = "--seed";
  options[HELP] = "--help";
  fileExtensions[DESCOMP] = "des_comp";
}

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

int main(int argc, char ** argv)
{
  initialiseOptions();
  int index = 1;
  unsigned faultMax = 0;
  unsigned seed = Diades::Utils::initialiseSeed();
  list<string> modelFiles;
  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 FAULTMAX:
                          {
                                ++index;
                                getParameter<unsigned>(argc,argv,index,faultMax);
                                break;
                          }
                        case SEED:
                          {
                                ++index;
                                getParameter<unsigned>(argc, argv, index, seed);
                                break;
                          }
                        default:
                          {
                                printUsage(description);
                                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;
                  switch(extension)
                        {
                        case DESCOMP:
                          {
                                modelFiles.push_back(string(argv[index]));
                                break;
                          }
                        }
                  ++index;
                } 
        }
  vector<Event> unobservables;
  if(modelFiles.empty())
        {
          try
                {
                  while(cin)
                        {
                          ObservableComponent component;
                          component.importDesCompModel(cin);
                          for(ObservableComponent::EventIterator it = component.eventBegin();
                                  it != component.eventEnd();
                                  ++it)
                                {
                                  if(component.mask().isUnobservable(*it))
                                        {
                                          unobservables.push_back(*it);
                                        }
                                }
                        }
                }
          catch(exception & e)
                {
                  // nothing to do, just stop.
                }
        }
  else
        {
          for(const string & filename : modelFiles)
                {

                  ObservableComponent component;
                  ifstream file(filename.c_str());
                  component.importDesCompModel(file);
                  file.close();
                  for(ObservableComponent::EventIterator it = component.eventBegin();
                          it != component.eventEnd();
                          ++it)
                        {
                          if(component.mask().isUnobservable(*it))
                                {
                                  unobservables.push_back(*it);
                                }
                        }
                }
        }
  initialiseRandomGenerator(seed);
  long faultNb = 0;
  if(faultMax==0)
        {
          faultNb = Diades::Utils::generateRandomValue(0,unobservables.size());
        }
  else
        {
          if(faultMax < unobservables.size())
                {
                  faultNb = Diades::Utils::generateRandomValue(0,faultMax);
                }
          else
                {
                  faultNb = Diades::Utils::generateRandomValue(0,unobservables.size());
                }
        }
  set<unsigned> indexes;
  Diades::Utils::selectNValues(0,unobservables.size()-1,faultNb,indexes);
  for(const unsigned & index : indexes)
        {
          cout << unobservables[index] << " ";
        }  
}