Simulate.cc

Go to the documentation of this file.

#include<iostream>
#include<fstream>
#include<vector>
#include<string>
#include<set>
#include<list>
#include<boost/date_time/posix_time/posix_time.hpp>
#include<diades/utils/Random.hh>
#include<diades/utils/Verbose.hh>

#include<diades/automata/ComposableModel.hh>
//#include<diades/io/xml/automata/Simulation.hh>
#include<diades/automata/SyncRulesLoad.hh>
#include"CmdInterface.hh"
#include"Simulator.hh"

using namespace std;
using namespace boost::posix_time;

typedef enum {
    OBSMIN = 0, OBSMAX = 1, TIMEMIN = 2, TIMEMAX = 3, NOEVT = 4, SEED = 5, XML = 6, GENERATEFAULTS = 7, HELP = 8, INTERACTIVE = 9, PTALOG = 10, NBSIM = 11
} Option;

typedef enum {
    DESCOMP = 0, RULES = 1
} FileExtension;
unsigned numberOfOptions = 12;
unsigned numberOfFileExtensions = 2;


vector<string> fileExtensions(numberOfFileExtensions);
vector<string> options(numberOfOptions);
vector<bool> isSet(numberOfOptions, false);
string description = "Usage:  dd-simulate\n\t --help |\n\t model1.des_comp [model2.des_comp ... sync.rules]\n\t [--seed randomSeed]\n\t [--noevent e3 e4 ....]\n\t [--obsMin nbObsMin]\n\t [--obsMax nbObsMax]\n\t [--timeMin minSeconds]\n\t [--timeMax maxSeconds]\n\t [--generateFaults]\n\t [--xml simulation.xml]\n\t [--interactive]\n\t [--ptalog output.pta_log]\n\t [--nbSim number]\n\n\n Write an observable scenario on the standard output based on \n the model that contains at least one occurrence of the event e1, e2 \n and that does not contain the events e3 e4. The generated scenario \n contains [nbObsMin,nbObsMax] observations. If set, the delay between\n two event occurrences is in [minSeconds,maxSeconds]. Optionnaly, a xml\n file can be generated with option --xml. \n The option --generateFaults randomly selects  unobservable events in\n the model that will be considered as fault in the generated scenario.\n --interactive is the interactive mode, invalidate any other simulation\n option. --ptalog write the observable simulation in a pta_log file.\n --nbSim defines the number of simulations (default is 1)";

void initialiseOptions() {
    options[TIMEMIN] = "--timeMin";
    options[TIMEMAX] = "--timeMax";
    options[OBSMIN] = "--obsMin";
    options[OBSMAX] = "--obsMax";
    options[NOEVT] = "--noevent";
    options[SEED] = "--seed";
    options[GENERATEFAULTS] = "--generateFaults";
    options[XML] = "--xml";
    options[HELP] = "--help";
    options[INTERACTIVE] = "--interactive";
    options[PTALOG] = "--ptalog";
    options[NBSIM] = "--nbSim";
    fileExtensions[DESCOMP] = "des_comp";
    fileExtensions[RULES] = "rules";
}



using namespace Diades::Utils;
using namespace Diades::CmdInterface;

void clean(vector<Diades::Automata::ObservableComponent *> & components) {
    for (vector<Diades::Automata::ObservableComponent *>::size_type i = 0; i < components.size();
            ++i) {
        if (components[i] != nullptr) {
            delete components[i];
            components[i] = nullptr;
        }
    }
    components.clear();
    Diades::Automata::EventFactory::destroy();
    Diades::Utils::LoggerFactory::destroy();
}

bool readParameters(int argc, char ** argv,
        vector<unsigned> & values,
        vector< set<string> > & noevents,
        set<string> & modelFiles,
        string & ruleFile,
        string & xmlFile,
        string & ptaLogFile,
        bool & faultGeneration,
        bool & interactiveMode) {
    if (argc == 1) {
        printCommandLineError("dd-simulate requires parameters. Try dd-simulate --help for details");
        return false;
    }
    int index = 1;
    while (index < argc) {
        Option currentOption;
        if (getOption<Option>(argv[index], options, currentOption)) {
            if (isSet[currentOption]) {
                printCommandLineError("The option '" + options[currentOption] + "' occurs at least twice.");
                return false;
            } else {
                isSet[currentOption] = true;
            }

            switch (currentOption) {
                case INTERACTIVE:
                {
                    ++index;
                    interactiveMode = true;
                    break;
                }
                case HELP:
                {
                    if ((index != 1) || (argc != 2)) {
                        printCommandLineError("Incorrect use of option --help.");
                        return false;
                    } else {
                        printUsage(description);
                        return 0;
                    }
                }
                case OBSMIN:
                case OBSMAX:
                case TIMEMIN:
                case TIMEMAX:
                case SEED:
                case NBSIM:
                {
                    ++index;
                    getParameter<unsigned>(argc, argv, index, values[currentOption]);
                    break;
                }
                case GENERATEFAULTS:
                {
                    ++index;
                    faultGeneration = true;
                    break;
                }
                case NOEVT:
                {
                    ++index;
                    getParameterList<string>(argc, argv, options, fileExtensions,
                            index, noevents[currentOption]);
                    if (noevents[currentOption].empty()) {
                        printCommandLineError("No parameter after the option " + options[currentOption]);
                        return false;
                    }
                    break;
                }
                case XML:
                {
                    ++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 --xml.");
                        return false;
                    }
                    xmlFile = *(files.begin());
                    break;
                }
                case PTALOG:
                {
                    ++index;
                    set<string> files;
                    getParameterList<string>(argc, argv, options, fileExtensions,
                            index, files);
                    cout << files.size() << endl;
                    if (files.size() != 1) {
                        printCommandLineError("One and only one argument was expected after option --ptalog.");
                        return false;
                    }
                    ptaLogFile = *(files.begin());
                    break;
                }
                default:
                {
                    printCommandLineError("Unrecognized option: " + string(argv[index]));
                    return false;
                    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()) {
                printCommandLineError("Unrecognized file extension in file name: " + string(argv[index]));

                return false;

            }


            FileExtension extension = DESCOMP;
            if (*it == fileExtensions[RULES]) {
                extension = RULES;
            }
            switch (extension) {
                case DESCOMP:
                {
                    modelFiles.insert(string(argv[index]));
                    break;
                }
                case RULES:
                {
                    if (!ruleFile.empty()) {
                        printCommandLineError("It seems that there are more than one synchronization rules file as a argument.");

                        return false;

                    }
                    ruleFile = string(argv[index]);
                    break;
                }
            }
            ++index;
        }
    }
    if (modelFiles.empty()) {
        printCommandLineError("No model, so no simulation.");
        return false;
    }
    if ((modelFiles.size() == 1) && (!ruleFile.empty())) {
        printCommandLineError("There is one synchronization rule file but no more than one component.");
        return false;
    }
    if ((modelFiles.size() > 1) && (ruleFile.empty())) {
        printCommandLineError("There is no synchronization rule file but it is required as there is more than one component in the model.");
        return false;
    }
    if ((modelFiles.size() == 1) && (!ruleFile.empty())) {
        printCommandLineError("There is one synchronization rule file but no more than one component.");
    }
    if ((modelFiles.size() > 1) && (ruleFile.empty())) {
        printCommandLineError("There is no synchronization rule file but it is required as there is more than one component in the model.");
    }
    if (isSet[TIMEMAX] && !isSet[TIMEMIN]) {
        printCommandLineError("--timeMax is set so --timeMin must be set.");
        return false;
    }
    if (isSet[TIMEMIN] && !isSet[TIMEMAX]) {
        printCommandLineError("--timeMin is set so --timeMax must be set.");
        return false;
    }
    if (values[TIMEMIN] > values[TIMEMAX]) {
        printCommandLineError("--timeMin is greater than --timeMax.");
        return false;
    }
    return true;
}

bool readModels
(const set<string> & modelFiles,
        const string & ruleFile,
        vector<Diades::Automata::ObservableComponent *> & components,
        Diades::Automata::ParametrizedSynchronisation & rules) {
    Diades::Automata::ParametrizedSynchronisation::ComponentVector vectorComp;
    try {
        unsigned i = 0;
        for (const string & name : modelFiles) {
            components[i] = new Diades::Automata::ObservableComponent();
            if (!components[i]->importDesCompModel(name)) {
                throw (FunctionException("readModels", Diades::Utils::Msg("Cannot load the model file '%1%'") % name));
            }
            vectorComp.push_back(components[i]);
            ++i;
        }
        if (!ruleFile.empty()) {
            loadSynchronisationRules(vectorComp, ruleFile, rules);
        }
    } catch (exception & e) {
        log<LgProcess>("The readModels function caught the following exception: \n\t%1%") % e.what();
        saveLog(cerr);
        clean(components);
        printCommandLineError("Load of the files has failed. See log above.");
        return false;
    }
    return true;
}

void generateFaults(unsigned seed,
        const vector<Diades::Automata::ObservableComponent *> components,
        list<Diades::Automata::Event> & faults) {
    initialiseRandomGenerator(seed);
    for (unsigned i = 0; i < components.size(); ++i) {
        for (auto & event : components[i]->events()) {
            components[i]->setNormal(event);
        }
    }



    for (unsigned i = 0; i < components.size(); ++i) {
        vector<Diades::Automata::Event> candidates;
        for (Diades::Automata::ObservableComponent::EventIterator it = components[i]->eventBegin();
                it != components[i]->eventEnd();
                ++it) {
            // any event except the identifiable ones are candidates
            if (!components[i]->mask().isIdentifiable(*it)) {
                candidates.push_back(*it);
            }
        }
        long faultNb = Diades::Utils::generateRandomValue(0, candidates.size());
        set<unsigned> indexes;
        Diades::Utils::selectNValues(0, candidates.size() - 1, faultNb, indexes);
        for (const unsigned & index : indexes) {
            faults.push_back(candidates[index]);
            components[i]->setFaulty(candidates[index]);
        }
    }
}

void writeTimedSimulation(const list<Diades::Automata::Event> & simulation,
        const Diades::Automata::ObservableMask & mask,
        set<Diades::Automata::Event> & observables,
        set<Diades::Automata::Event> & nonObservables,
        unsigned timeMin,
        unsigned timeMax,
        unsigned & nbObs) {
    nbObs = 0;
    list< pair<time_duration, Diades::Automata::Event> > timedSimulation;
    back_insert_iterator<list< pair<time_duration, Diades::Automata::Event> > > ii(timedSimulation);
    timeStamp(simulation.begin(), simulation.end(), seconds(timeMin), seconds(timeMax), ii);
    VerboseLevel level = VbOutput;
    setVerboseLevel(level);
    cout << "TIMED SIMULATION:" << endl;
    cout << "{ ";
    list< pair<time_duration, Diades::Automata::Event> > observableTimedSimulation;
    for (const pair<time_duration, Diades::Automata::Event> & occurrence : timedSimulation) {
        if (mask.isObservable(occurrence.second)) {
            observableTimedSimulation.push_back(make_pair(occurrence.first, occurrence.second));
            observables.insert(occurrence.second);
            ++nbObs;
        } else {
            nonObservables.insert(occurrence.second);
        }
        cout << occurrence.second << " " << occurrence.first.total_seconds() << " ";
    }
    cout << "}" << endl << endl;
    cout << "OBSERVABLE PART OF TIMED SIMULATION:" << endl;
    cout << "{ ";
    for (const pair<time_duration, Diades::Automata::Event> & occurrence : observableTimedSimulation) {
        cout << occurrence.second << " " << occurrence.first.total_seconds() << " ";
    }
    cout << "}";
    if (isSet[XML]) {
        cout << "not implemented yet" << endl;
        //        try {
        //
        //            cout << "not implemented yet" << endl;
        //            // Diades::Io::Xml::saveXmlSimulation(faults.begin(),faults.end(),timedSimulation.begin(),timedSimulation.end(),observableTimedSimulation.begin(),observableTimedSimulation.end(),xmlFile);
        //            // list< pair<time_duration,Diades::Automata::Event> > timedSimulation2;
        //            // list< pair<time_duration,Diades::Automata::Event> > observableTimedSimulation2;
        //            // list< Event > faults2;
        //            // loadXmlSimulation(xmlFile,back_insert_iterator< list< Diades::Automata::Event> > >(faults2), back_insert_iterator< list< pair<time_duration,Diades::Automata::Event> > >(timedSimulation2)
        //            //                                        back_insert_iterator< list< pair<time_duration,Diades::Automata::Event> > >(observableTimedSimulation2));
        //        } catch (exception & e) {
        //            string msg = "An exception has been caught when saving the simulation to xml file.";
        //            msg += e.what();
        //            clean(components);
        //            printCommandLineError(msg);
        //            return 1;
        //        }
    }
}

void writeUntimedSimulation(const list<Diades::Automata::Event> & simulation,
        const Diades::Automata::ObservableMask & mask,
        set<Diades::Automata::Event> & observables,
        set<Diades::Automata::Event> & nonObservables,
        unsigned & nbObs) {

    nbObs = 0;
    list< Diades::Automata::Event> observations;
    VerboseLevel level = VbOutput;
    setVerboseLevel(level);
    cout << "SIMULATION:" << endl;
    cout << toStream(simulation.begin(), simulation.end()) << endl << endl;
    cout << "OBSERVABLE PART OF SIMULATION:" << endl;
    for (const Diades::Automata::Event & e : simulation) {
        if (mask.isObservable(e)) {
            observations.push_back(e);
            observables.insert(e);
            ++nbObs;
        } else {
            nonObservables.insert(e);
        }
    }
    cout << toStream(observations.begin(), observations.end());
    if (isSet[XML]) {
        //        try {
        cout << "not implemented yet" << endl;
        //Diades::Io::Xml::saveXmlSimulation(faults.begin(),faults.end(),simulation.begin(),simulation.end(),observations.begin(),observations.end(),xmlFile);
        //        } catch (exception & e) {
        //            string msg = "An exception has been caught when saving the simulation to xml file.";
        //            msg += e.what();
        //            clean(components);
        //            printCommandLineError(msg);
        //            return 1;
        //        }
    }
}

void writeFinalPartOfSimulation(
        const list<Diades::Automata::Event> & simulation,
        bool faultGeneration,
        const list<Diades::Automata::Event> & faults,
        const set<Diades::Automata::Event> & identifiables,
        const set<Diades::Automata::Event> & nonIdentifiables,
        unsigned nbObs,
        const set<Diades::Automata::Event> & events,
        const Diades::Automata::ObservableMask & mask) {
    cout << endl << endl << "Size of the scenario: " << simulation.size() << endl;
    if (faultGeneration) {
        cout << "Number of faults in the model: " << faults.size() << endl;
        cout << "Faults: " << toStream(faults.begin(), faults.end()) << endl;
    }
    cout << "Size of the observable scenario: " << nbObs << endl;
    cout << "Non-identifiable events in this scenario: " << toStream(nonIdentifiables.begin(), nonIdentifiables.end()) << endl;
    cout << "Identifiable events in this scenario: " << toStream(identifiables.begin(), identifiables.end()) << endl;


    cout << "Non-identifiable events that did not occur in this scenario: "
            << toStream(events.begin(), events.end(),
            unaryAnd(Diades::Utils::isNotIn(nonIdentifiables.begin(), nonIdentifiables.end()),
            Diades::Automata::IsNonIdentifiable(mask))) << endl;
    cout << "Identifiable events that did not occur in this scenario: "
            << toStream(mask.observableBegin(), mask.observableEnd(),
            Diades::Utils::isNotIn(identifiables.begin(), identifiables.end())) << endl;
}

void writeSimulation(const list<Diades::Automata::Event> & simulation,
        vector<unsigned> & values,
        bool faultGeneration,
        const list<Diades::Automata::Event> & faults,
        const set<Diades::Automata::Event> & events,
        const Diades::Automata::ObservableMask & mask) {
    set<Diades::Automata::Event> observables;
    set<Diades::Automata::Event> nonObservables;
    unsigned nbObs = 0;
    if (isSet[TIMEMIN]) {
        writeTimedSimulation(simulation, mask, observables, nonObservables,
                values[TIMEMIN], values[TIMEMAX], nbObs);
    } else {
        writeUntimedSimulation(simulation, mask, observables, nonObservables, nbObs);
    }
    writeFinalPartOfSimulation(simulation, faultGeneration, faults, observables,
            nonObservables, nbObs, events, mask);
}

bool startInteractiveSimulation(
        const vector<Diades::Automata::ObservableComponent *> components,
        const Diades::Automata::ParametrizedSynchronisation & rules,
        Diades::Automata::ObservableMask & mask,
        set<Diades::Automata::Event> & events,
        list<Diades::Automata::Event> & simulation) {
    bool result = true;
    if (components.size() == 1) {
        mask = components[0]->mask();
        events = components[0]->events();
        if (!Diades::Automata::interactiveSimulation(*components[0],
                simulation)) {
            cout << "Failed SIMULATION:" << endl;
            cout << toStream(simulation.begin(), simulation.end());
            log<LgProcess>("The simulation has failed. See the log above.");
            saveLog(cerr);
            return false;
        }
    } else {
        Diades::Automata::ComposableModel * model = nullptr;
        vector<Diades::Automata::ComposableModel::ConstPointer> comps;
        vector<const Diades::Automata::ObservableComponent *> comps2;
        for (unsigned i = 0; i < components.size(); ++i) {
            comps.push_back(new Diades::Automata::ComposableModel(*components[i], rules));
            comps2.push_back(components[i]);
        }

        model = new Diades::Automata::ComposableModel(comps, rules, true);
        events = model->component().events();
        Diades::Automata::ObservableMask synchronisedMask(rules, comps2);
        mask = synchronisedMask;
        if (!Diades::Automata::interactiveSimulation(*model,
                mask,
                simulation)) {
            cout << "Failed SIMULATION:" << endl;
            cout << toStream(simulation.begin(), simulation.end());
            log<LgProcess>("The simulation has failed. See the log above.");
            saveLog(cerr);
            result = false;
        }
        if (model != nullptr) {
            delete model;
        }
        for (unsigned i = 0; i < components.size(); ++i) {
            delete comps[i];
        }
        comps.clear();
    }
    return result;
}

bool startNonInteractiveSimulation(
        const vector<Diades::Automata::ObservableComponent *> components,
        const Diades::Automata::ParametrizedSynchronisation & rules,
        const vector<unsigned> & values,
        const vector< set<string> > & noevents,
        Diades::Automata::ObservableMask & mask,
        set<Diades::Automata::Event> & events,
        list<Diades::Automata::Event> & simulation,
        unsigned simNb) {
    bool result = true;
    if (components.size() == 1) {
        mask = components[0]->mask();
        events = components[0]->events();
        if (!Diades::Automata::simulate(*components[0],
                noevents[NOEVT],
                values[OBSMIN],
                values[OBSMAX],
                values[SEED] + simNb, simulation)) {
            cout << "Failed SIMULATION:" << endl;
            cout << toStream(simulation.begin(), simulation.end());
            log<LgProcess>("The simulation has failed. See the log above.");
            saveLog(cerr);
            return false;
        }
    } else {
        Diades::Automata::ComposableModel * model = nullptr;
        vector<Diades::Automata::ComposableModel::ConstPointer> comps;
        vector<const Diades::Automata::ObservableComponent *> comps2;
        for (unsigned i = 0; i < components.size(); ++i) {
            comps.push_back(new Diades::Automata::ComposableModel(*components[i], rules));
            comps2.push_back(components[i]);
        }

        model = new Diades::Automata::ComposableModel(comps, rules, true);
        events = model->component().events();
        Diades::Automata::ObservableMask synchronisedMask(rules, comps2);
        mask = synchronisedMask;
        if (!Diades::Automata::simulate(*model,
                mask,
                noevents[NOEVT],
                values[OBSMIN],
                values[OBSMAX],
                values[SEED]+simNb,
                simulation)) {
            cout << "Failed SIMULATION:" << endl;
            cout << toStream(simulation.begin(), simulation.end());
            log<LgProcess>("The simulation has failed. See the log above.");
            saveLog(cerr);
            result = false;
        }
        if (model != nullptr) {
            delete model;
        }
        for (unsigned i = 0; i < components.size(); ++i) {
            delete comps[i];
        }
        comps.clear();
    }
    return result;
}

void exportLogIntoPtaLogFile(const vector<Diades::Automata::ObservableComponent *> & components,
        const Diades::Automata::ParametrizedSynchronisation & rules,
        const list<Diades::Automata::Event> & simulation,
        const Diades::Automata::ObservableMask & mask,
        ostream & file) {

    // first pass, look for the faulty events
    set<Diades::Automata::Event> faults;
    for (auto & event : simulation) {
        auto it = rules.beginOfSynchronisedEvents();
        bool found = false;
        while ((!found) && (it != rules.endOfSynchronisedEvents())) {
            found = (event == it->synchronisedEvent());
            if (!found) {
                ++it;
            }
        }
        bool isFaulty = false;
        auto it2 = it->beginOfSupport();
        while (!isFaulty && (it2 != it->endOfSupport())) {
            isFaulty = it2->isFaulty(it->getAssociatedEvent(it2));
            ++it2;
        }
        if (isFaulty) {
            faults.insert(event);
        }
    }
    if (faults.empty()) {
        file << "N ";
    } else {
        for (auto & event : faults) {
            file << event;
        }
        file << " ";
    }
    // second pass, look for the observable events
    for (auto & event : simulation) {
        if (!mask.isUnobservable(event)) {
            Diades::Automata::Event obs = *mask.observableBegin(event);
            if (obs == mask.noEvent()) {
                obs = *(++mask.observableBegin(event));
            }
            file << obs << " ";
        }
    }
    file << endl;
}

int main(int argc, char ** argv) {
    verbose<VbOutput>("DiaDes: Discrete Event System Simulator\n");
    verbose<VbOutput>("LAAS-CNRS, 2006-2017, 7 avenue du Colonel Roche, Toulouse, France\n");
    verbose<VbOutput>("Contact: yannick.pencole@laas.fr\n");
    initialiseOptions();
    vector<unsigned> values(numberOfOptions);
    values[SEED] = initialiseSeed();
    values[NBSIM] = 1;
    vector< set<string> > noevents(numberOfOptions);
    set<string> modelFiles;
    string ruleFile;
    string xmlFile;
    string ptaLogFile;
    bool faultGeneration = false;
    bool interactiveMode = false;

    // Parameter readings
    if (!readParameters(argc, argv, values, noevents, modelFiles,
            ruleFile, xmlFile, ptaLogFile, faultGeneration, interactiveMode)) {
        return 1;
    }

    // Model loading
    vector<Diades::Automata::ObservableComponent *> components(modelFiles.size(), nullptr);
    Diades::Automata::ParametrizedSynchronisation rules;
    if (!readModels(modelFiles, ruleFile, components, rules)) {
        return 1;
    }

    ofstream file;
    if (!ptaLogFile.empty()) {
        file.open(ptaLogFile);
    }
    
    // fault generation
    list<Diades::Automata::Event> faults;
    if (faultGeneration) {
        generateFaults(values[SEED], components, faults);
    }
    
    
    for (unsigned i = 0; i < values[NBSIM]; ++i) {
        

        list<Diades::Automata::Event> simulation;
        set<Diades::Automata::Event> events;

        Diades::Automata::ObservableMask mask;
        if (interactiveMode) {
            if (!startInteractiveSimulation(components, rules, mask, events, simulation)) {
                clean(components);
                return 1;
            }
        } else {

            if (!startNonInteractiveSimulation(components, rules, values, noevents,
                    mask, events, simulation,i)) {
                clean(components);
                return 1;
            }

        }



        // simulation writing on the standard output
        writeSimulation(simulation, values, faultGeneration,
                faults, events, mask);

        if (!ptaLogFile.empty()) {
            exportLogIntoPtaLogFile(components, rules, simulation, mask, file);
        }
    }
    if (!ptaLogFile.empty()) {
        file.close();
    }

    clean(components);
    return 0;
}