Simulate.cc

Go to the documentation of this file.

#include<thread>
#include<cstdlib>
#include<iostream>
#include<fstream>
#include<regex>
#include<unordered_map>
#include<random>
#include<chrono>
#include<boost/program_options.hpp>
#include<diades/automata/experimental/AutFile.hh>
#include<diades/automata/experimental/DdAutFile.hh>
#include<diades/automata/experimental/DdAutFileDescriptor.hh>
#include<diades/automata/experimental/Io.hh>
#include"../AutomataInterface.hh"
#include"../CmdInterface.hh"

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

namespace Poptions = boost::program_options;



const string program("dd-sim");
const string briefcomment(": dd-sim simulates a model. Given a ddaut file, dd-sim computes some runs of the model");
const string detailedcomment=R"(
dd-sim simulates a model. Given a ddaut file, dd-sim computes some runs of the model

Example 1:


dd-sim file.ddaut --seed=30 --size=100 --through='.*o\.p=ko.*' 
       --format='@s -> @t [@e]' --format='@o' --timer=10 
       --observable=observable.txt 
       --controllable=controllable.txt -o result.run


In Example 1. dd-sim computes a random run (seed of the random generator is 30), the size 
of the run is 100, and the run must go through a state with a label containing 'o.p=ko'.
The run must be found within 10 seconds, if not the simulator stops. 
The resulting run will be written in the file result1.run following the format: 

@s -> @t [@e]

That is 'sourcestate -> targetstate [event]':  
   - @s  stands for source state,  
   - @t  stands for target state,  
   - @e  stands for event. 

Other possible tags are:
  - @o stands for observable event,
  - @c stands for controllable event. 

@o and @c are respectively defined in observable.txt and controllable.txt. For a given 
event  @e, the observable parts are the substring of  @e that are in observable.txt, 
the controllable parts are the substring of @e that are in controllable.txt.

A second file  result2.run contains the sequence of observable events of the same run 
following the format 

@o

)";

/*
 * File suffixes
 */
FileSuffixes suffixes({"ddaut"});

void
initialiseOptions(int argc, char * argv[],
                  Poptions::options_description & desc,
                  Poptions::variables_map & vm)
{
  desc.add_options()
    ("help,h", "produce help message")
    ("file,f", Poptions::value< string >(), "file that contains the model to simulate (.ddaut format)")
    ("output,o", Poptions::value< string >(),
     R"(template name for the generated output files: 
Suppose the template name is 'output.run' then, depending on the number of requested simulations,
the generated files will named as follows: output_1.run, output_2.run, ...)")
    ("seed",Poptions::value< unsigned int >(),
     R"(seed used by the random generator: if no seed is given, take as seed the starting time of the process.)")
    ("size", Poptions::value< unsigned int >(),
     R"(size is the size (number of transitions) of the run to simulate. If the simulator cannot find
such a requested run, it will simplify give up. (default value is 100))")
    ("through", Poptions::value< string >(),
     R"(This parameter requests a regular expression as defined at the following address:

http://www.cplusplus.com/reference/regex/ECMAScript/

This parameter states that the simulator must look for a run that must go at least once through one state 
whose label matches the given regular expression.)")
    ("format", Poptions::value< std::vector<string> >(),
     R"(format of the result. The expression given in the format will be used as a template to write the simulation 
in the output file. @s stands for source state, @t for target state, @e for transition event, @o observable part of 
the event, @c controllable part of the event. Many formats are allowed, one format generates one output file.)")
    ("timer", Poptions::value< unsigned int >(),
     R"(simulation timer. Does not allow the simulator to look for one run after the time set (in seconds) 
by the timer is reached. If no timer is set, the program may not end if no run is found.)")
    ("observable", Poptions::value< string >(),
     R"(set the file that defines the observable events of the model. An event of the model is considered as observable
if at least one of its substring matches an event contained in the given file. If the option observable is not set,
no event of the model is considered as observable (@o will keep return the empty string).)")
    ("controllable", Poptions::value< string >(),
     R"(set the file that defines the controllable events of the model. An event of the model is considered as controllable
if at least one of its substring matches an event contained in the given file. If the option controlable is not set,
no event of the model is considered as controlable (@o will keep return the empty string).)")
    ;
  Poptions::positional_options_description p;
  // 1 that The command line can accept 1 file name as positional option
  p.add("file", 1);
  Poptions::store(Poptions::command_line_parser(argc, argv).options(desc).positional(p).run(), vm);
  Poptions::notify(vm);
}


using Diades::Automata::Experimental::DdAutFsm;
using Diades::Automata::Experimental::DdAutFA;
using Diades::Automata::Experimental::DdAutEventManager;
using Diades::Automata::Experimental::DdAutStateManager;
using namespace Diades::CmdInterface;

struct DdSimOptions
{
  unsigned int seed;
  unsigned int size = 100;
  unsigned int timer = 0;
  std::string fileName;
  std::string output;
  std::string observable;
  std::string controllable;
  std::string through;
  std::vector<std::string> formats;
};


size_t setOptions(int argc, char** argv, DdSimOptions & options)
{
  try
    {
     
      Poptions::options_description desc("Options");
      Poptions::variables_map vm;
      initialiseOptions(argc, argv, desc, vm);
      if(vm.count("help"))
        {
          return printUsage(program + briefcomment + detailedcomment, desc);
        }
      if(vm.count("file"))
        {
          options.fileName = vm["file"].as<std::string> ();
        }
      if(vm.count("observable"))
        {
          options.observable = vm["observable"].as<std::string> ();
        }
      if(vm.count("controllable"))
        {
          options.controllable = vm["controllable"].as<std::string> ();
        }
      if(vm.count("output"))
        {
          options.output = vm["output"].as<std::string>();
        }
      if(vm.count("seed"))
        {
          options.seed = vm["seed"].as<unsigned int>();
        }
      if(vm.count("size"))
        {
          options.size = vm["size"].as<unsigned int>();
        }
      if(vm.count("timer"))
        {
          options.timer = vm["timer"].as<unsigned int>();
        }
      if(vm.count("through"))
        {
          options.through = vm["through"].as<std::string>();
        }
      if(vm.count("format"))
        {
          options.formats = vm["format"].as<std::vector<std::string>>();
        }
    }
  catch(Poptions::required_option & e)
    {
      return printCommandLineError(e.what());
    }
  catch(Poptions::error & e)
    {
      return printCommandLineError(e.what());
    }
  return SUCCESS;
}

bool isThroughState(const ConstManagedDdAutFsm & mfsm,
                    State state,
                    const std::regex & regularExpression,
                    CstStMap<char> & throughStates)
{
  if(throughStates[state] == 1) { return true; }
  if(throughStates[state] == 2) { return false; }
  bool result = false;
  if(std::regex_match(mfsm.sMgr.getStateProperty(mfsm.fsm.getStatePropertyId(state)),regularExpression))
    {
      throughStates[state] = 1;
      result = true;
    }
  else
    {
      throughStates[state] = 2;
    }
  return result;
}                   

size_t prepareSimulation(const DdSimOptions & options)
{
  DdAutFsm fsm;
  DdAutStateManager sManager;
  DdAutEventManager eManager;
  auto result =  loadFiniteStateMachine(options.fileName,{fsm,sManager,eManager});
  StMap<char> throughStates(fsm.behaviour(),fsm.numberOfStates(),0);
  return SUCCESS;
}






int
main(int argc, char** argv)
{
  auto now = std::chrono::system_clock::now(); // now is a system_clock::time_point
  DdSimOptions options;
  options.seed = std::chrono::system_clock::to_time_t(now); // convert to time_t to initialise the seed
                      setOptions(argc, argv, options);
                      auto result = checkDdAutFile(options.fileName);
                      if(result!=SUCCESS) { return result; }
                      if(!options.observable.empty())
                        {
                          result = isOpenableFile(options.observable);
                          if(result!=SUCCESS) { return result; }
                        }
                      if(!options.controllable.empty())
                        {
                          result = isOpenableFile(options.controllable);
                          if(result!=SUCCESS) { return result; }
                        }
    
                      return prepareSimulation(options);
                    }