DesGenerate.cc

Go to the documentation of this file.

#include<iostream>
#include<sstream>
#include<string>
#include<map>
#include<list>
#include <cmath>
#include<diades/utils/Random.hh>
#include<diades/utils/Verbose.hh>
#include<diades/utils/Log.hh>
#include<diades/utils/Selection.hh>
#include<diades/graph/ConstNodeMap.hh>
#include<diades/automata/Event.hh>
#include<diades/automata/Topology.hh>
#include<diades/automata/TopologyMap.hh>
#include<diades/automata/ObservableComponent.hh>
#include<diades/automata/SynchronisationRules.hh>
#include<diades/automata/ComposableModel.hh>
#include<diades/automata/SyncRulesLoad.hh>
//#include<diades/petri/AutomataConversion.hh>
#include"CmdInterface.hh"

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

typedef enum {
    STATEMIN = 0, STATEMAX = 1, OBSMIN = 2, OBSMAX = 3, EVTMIN = 4, EVTMAX = 5, SEED = 6, DIRNAME = 7, LATEXFILENAME = 8,
    TOPOLOGYFILENAME = 9, OBSINTERACTIONMIN = 10, OBSINTERACTIONMAX = 11, NODEBEHAVIOUR = 12, HELP = 13,
    OUTPUTDEGREEMAX = 14, PETRINET = 15
} Option;


unsigned numberOfOptions = 16;
unsigned numberOfFileExtensions = 0; // no file extension as no file is used as an option in this interface,
// files are always the parameter of an option

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


string description = "Usage:  dd-generate\n\t --help |\n\t [--topo topologyFileName.topo]\n\t [--seed randomSeed]\n\t [--evtMin nbEvtMin]\n\t [--evtMax    nbEvtMax]\n\t [--obsMin      nbObsMin]\n\t [--obsMax    nbObsMax]\n\t [--stateMin  nbStateMin]\n\t [--stateMax  nbStateMax]\n\t [--latex  latexFileName]\n\t [--outputdir dirName]\n\t [--obsInteractionMin nbObsIntMin]\n\t [--obsInteractionMax nbObsIntMax]\n\t [--nodeBehaviour node=file.descomp ci=ej ck=el ...]]\n\t [--outputDegreeMax outDeg]\n\t [--petrinet]\n\n\n Generate a distributed discrete-event system that has the topology\n defined in the file topologyFileName.topo. The generator uses\n a random generator of number that can be initialised with the\n seed 'randomSeed'. If not provided, the seed is the starting time\n of each run of the program. As far as the behaviour of a component\n is concerned, the number of generated states is between nbStateMin\n and nbStateMax. The number of event is between nbEvtMin and nbEvtMax\n as long as it is compatible with the topology. The number of\n observable events is between nbObsMin and nbObsMax. The generated model\n consists of a set of files written in the directory 'dirName'. The\n model generator also generates a document in latex format for documentation\n purposes (if the option is set). The parameters --obsInteractionMin\n and --obsInteractionMax states the possible numbers of observable interactions.\n The --nodeBehaviour parameters states that one (and only one) of the node\n called 'node' has the predefined behaviour described in 'file.descomp'. \nConstraints like 'ci=sj' assert that the component 'node' implements the\n connection 'ci' of the topology with the iteractive event 'sj'.\n The option '--outputDegreeMax' rules the maximal number of transitions\n (i.e. events) that are the output of one state. If the --petrinet option is set, the distributed system is generated as a 1-bounded petri net. ";

void initialiseOptions() {
    options[STATEMIN] = "--stateMin";
    options[STATEMAX] = "--stateMax";
    options[OBSMIN] = "--obsMin";
    options[OBSMAX] = "--obsMax";
    options[EVTMIN] = "--evtMin";
    options[EVTMAX] = "--evtMax";
    options[SEED] = "--seed";
    options[DIRNAME] = "--outputdir";
    options[LATEXFILENAME] = "--latex";
    options[TOPOLOGYFILENAME] = "--topo";
    options[OBSINTERACTIONMIN] = "--obsInteractionMin";
    options[OBSINTERACTIONMAX] = "--obsInteractionMax";
    options[NODEBEHAVIOUR] = "--nodeBehaviour";
    options[HELP] = "--help";
    options[OUTPUTDEGREEMAX] = "--outputDegreeMax";
    //options[PETRINET] = "--petrinet";
}

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

unsigned eventNumber = 0; 

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

typedef Diades::Graph::ConstNodeMap<Event> ConnectionMap;
typedef Diades::Graph::ConstNodeMap<ObservableComponent *> ComponentNodeMap;
typedef Diades::Graph::ConstNodeMap< map<Topology::Connection, Event> > SharedEventNodeMap;

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

void makeComponentComplete(unsigned outputDegreeMax, Selection<Event> & eventSelection, ObservableComponent & result);


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

Transition getTransitionFromInteractiveCurrentState(const ObservableComponent & interaction,
        State currentInteractingState,
        const Event & eventCurrentNode,
        map<Event, Topology::Connection> & mappingCurrentSideToInteraction,
        map<Topology::Connection, Event> & mappingConnectionToInteraction,
        const set<Event> & constrainedEvents);

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

void generateTransitionSystem(const Topology & topology,
        const Node & node,
        SharedEventNodeMap & sharedEventOfNode,
        const ObservableComponent & interaction,
        set<Node>::const_iterator first,
        set<Node>::const_iterator last,
        unsigned numberOfStates,
        unsigned outputDegreeMax,
        ObservableComponent & result);


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

void defineObservableMask(unsigned obsMin, unsigned obsMax, unsigned obsInteractionMin,
        unsigned obsInteractionMax, const set<Event> & interactiveEvents,
        const set<Event> & nonInteractiveEvents,
        ObservableComponent & result);

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

void generateNonInteractiveEvents(const Topology & topology,
        Topology::Node node,
        unsigned evtMin,
        unsigned evtMax,
        unsigned obsMin,
        unsigned obsInteractionMax,
        ObservableComponent & result,
        set<Event> & nonInteractiveEvents);

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

void generateRandomComponent(const Topology & topology, const Node & node,
        SharedEventNodeMap & sharedEventOfNode,
        const ObservableComponent & interaction,
        set<Node>::const_iterator first,
        set<Node>::const_iterator last,
        unsigned stateMin,
        unsigned stateMax,
        unsigned obsMin,
        unsigned obsMax,
        unsigned evtMin,
        unsigned evtMax,
        unsigned obsInteractionMin,
        unsigned obsInteractionMax,
        unsigned outputDegreeMax,
        ObservableComponent * result);

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

void initialiseSynchronisationRules(const Topology & topology,
        set<Node>::const_iterator first,
        set<Node>::const_iterator last,
        SharedEventNodeMap & sharedEventOfNode,
        const Diades::Graph::ConstNodeMap< pair<string, ObservableComponent *> > & projection,
        ParametrizedSynchronisation & synchronisation);

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

ObservableComponent * getSynchronisedInteraction(const Topology & topology, const Node & node,
        SharedEventNodeMap & sharedEventOfNode,
        const Diades::Graph::ConstNodeMap< pair<string, ObservableComponent *> > & projection,
        set<Node>::const_iterator first,
        set<Node>::const_iterator last);

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

void getOutputProjection(const Topology & topology,
        const Node & node,
        SharedEventNodeMap & sharedEventOfNode,
        const ObservableComponent & component,
        const set<Node> & nonGeneratedNeighbours,
        pair<string, ObservableComponent *> & result);

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

void propagateConstrainedInteractions(const Topology & topology,
        Topology::Node node,
        Diades::Graph::ConstNodeMap<int> & visitedNodes,
        set<Topology::Node> & generatedNeighbours,
        set<Topology::Node> & nonGeneratedNeighbours,
        list<Topology::Node> & nodesToVisit);

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


void writeComponent(const ObservableComponent & component,
        const string & dirName);


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


bool checkEventConsistency(const Topology & topology, unsigned evtMax, unsigned obsInteractionMin);

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



//template<typename T>
//void getParameter(int argc, char ** argv,  int index, T & param, bool & alreadyRegistered);
void generateSharedEvents(const Topology & topology,
        ComponentNodeMap & componentOfNode,
        SharedEventNodeMap & sharedEventOfNode,
        Topology::Node fixedTopoNode);
void generateBehaviour(const Topology & topology,
        unsigned stateMin,
        unsigned stateMax,
        unsigned evtMin,
        unsigned evtMax,
        unsigned obsMin,
        unsigned obsMax,
        unsigned obsInteractionMin,
        unsigned obsInteractionMax,
        ComponentNodeMap & componentOfNode,
        SharedEventNodeMap & sharedEventOfNode,
        string dirName, Node fixedTopoNode,
        unsigned outputDegreeMax);
void generateLatexComponents(const Topology & topology, SharedEventNodeMap & sharedEventOfNode, const ComponentNodeMap & componentOfNode, ofstream & latexfile);
void generateLatexEventIndex(const Topology & topology, SharedEventNodeMap & sharedEventOfNode, const ComponentNodeMap & componentOfNode, ofstream & latexfile);
void generateLatexEpilog(ofstream & latexfile);
void generateLatexTopology(const Topology & topology, SharedEventNodeMap & sharedEventOfNode, ofstream & latexfile);
void generateLatexPreamble(const Topology & topology,
        unsigned stateMin,
        unsigned stateMax,
        unsigned evtMin,
        unsigned evtMax,
        unsigned obsMin,
        unsigned obsMax,
        unsigned obsInteractionMin,
        unsigned obsInteractionMax,
        unsigned seed,
        unsigned outputDegreeMax,
        const string & fixedNode,
        const string & behaviourFileName,
        map<string, string> & assignedConnections,
        const ComponentNodeMap & componentOfNode,
        SharedEventNodeMap & sharedEventOfNode,
        const string & filename,
        ofstream & latexfile);
void generateLatexFile(const Topology & topology,
        unsigned stateMin,
        unsigned stateMax,
        unsigned evtMin,
        unsigned evtMax,
        unsigned obsMin,
        unsigned obsMax,
        unsigned obsInteractionMin,
        unsigned obsInteractionMax,
        unsigned seed,
        unsigned outputDegreeMax,
        const string & fixedNode,
        const string & behaviourFileName,
        map<string, string> & assignedConnections,
        const ComponentNodeMap & componentOfNode,
        SharedEventNodeMap & sharedEventOfNode,
        const string & filename);

void exportTopologyMap(const Topology & topology,
        SharedEventNodeMap & sharedEventOfNode,
        const ComponentNodeMap & componentOfNode,
        const string & mapTopoFileNameDest);

void generateStates(ObservableComponent & result, unsigned numberOfStates,
        vector<Node> & indexState);

void generateTriggerableEvents(unsigned numberOfUnusedEventPerState,
        unsigned numberOfTrans,
        Component::EventIterator first,
        Component::EventIterator last,
        unsigned nbEvents,
        //const set<Event> & constrainedEvents,
        set<Event> & newSelection,
        set<Event> & unusedEvents);

// result is almost generated. The problem is that some transitions
// of interaction may not have their correpsondance in result yet
// (triggeredTransition[t] = 0)
// so we complete the model to have full correspondance by adding some
// transitions in the result
void makeComponentFullyConsistent(ObservableComponent & result,
        const Node & node,
        SharedEventNodeMap & sharedEventOfNode,
        const ObservableComponent & interaction,
        map<Event, Topology::Connection> & mappingInteractionToCurrentSide,
        map<Event, Topology::Connection> & mappingCurrentSideToInteraction,
        EdgeMap<int> & triggeredTransition,
        NodeMap< set<State> > & stateMapping,
        unsigned outputDegreeMax,
        Selection<Event> & eventSelection);

// Here we just inserted the fact that the state 'state' has a new corresponding
// state 'correspondingState' in the interaction model.
// This new information must be propagated to the successors of 'state'
void propagateInteractingStates(ObservableComponent & result, const Node & node,
        SharedEventNodeMap & sharedEventOfNode,
        map<Event, Topology::Connection> & mappingInteractionToCurrentSide,
        const ObservableComponent & interaction,
        State state,
        State correspondingState,
        NodeMap< set<State> > & stateMapping);

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

void printDebugStartVisit(const Topology & topology, Topology::Node node);
void printDebugProjectionOnGeneratedNeighbours(const set<Topology::Node> & generatedNeighbours,
        const Diades::Graph::NodeMap< pair<string, ObservableComponent *> > & projection);
void printDebugLaw(const ParametrizedSynchronisation & synchronisation);

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

int main(int argc, char ** argv) {
    setVerboseLevel(VbOutput);
    debug(setVerboseLevel(VbDebug););
    initialiseOptions();
    cout << "Discrete-event system generator" << endl;
    cout << "LAAS-CNRS, 2006-2017, 7 avenue du Colonel Roche, Toulouse, France" << endl;
    cout << "Contact: yannick.pencole@laas.fr" << endl;
    unsigned stateMin = 3;
    unsigned stateMax = 10;
    unsigned obsMin = 0;
    unsigned obsMax = 3;
    unsigned evtMin = 1;
    unsigned evtMax = 3;
    unsigned seed = initialiseSeed();
    string dirName = "model_generator_directory";
    string latexFileName = "generated_model_report.tex";
    string topologyFileName = "";
    unsigned obsInteractionMin = 0;
    unsigned obsInteractionMax = 3;
    unsigned outputDegreeMax = evtMax;
    string behaviourFileName = "";
    bool petrinet = false;
    map<string, string> assignedConnections;
    string fixedNode = "";
    if (argc < 2) {
        printUsage(description);
    }

    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.");
            } else {
                isSet[currentOption] = true;
            }
            switch (currentOption) {
                case HELP:
                {
                    if ((index != 1) || (argc != 2)) {
                        printCommandLineError("Incorrect use of option --help.");
                    } else {
                        printUsage(description);
                        return 0;
                    }
                    break;
                }
                case STATEMIN:
                {
                    ++index;
                    getParameter<unsigned>(argc, argv, index, stateMin);
                    log<LgDebug>("stateMin = %1%") % stateMin;
                    if (stateMin == 0) {
                        printCommandLineError("'stateMin' must be greater than 0");
                    }
                    break;
                }
                case STATEMAX:
                {
                    ++index;
                    getParameter<unsigned>(argc, argv, index, stateMax);
                    log<LgDebug>("stateMax = %1%") % stateMax;
                    if (stateMax == 0) {
                        printCommandLineError("'stateMax' must be greater than 0");
                    }
                }
                    break;
                case EVTMIN:
                {
                    ++index;
                    getParameter<unsigned>(argc, argv, index, evtMin);
                    log<LgDebug>("evtMin = %1%") % evtMin;
                    if (evtMin == 0) {
                        printCommandLineError("'evtMin' must be greater than 0.");
                    }
                    break;
                }
                case EVTMAX:
                {
                    ++index;
                    getParameter<unsigned>(argc, argv, index, evtMax);
                    log<LgDebug>("evtMax = %1%") % evtMax;
                    if (evtMax == 0) {
                        printCommandLineError("'evtMax' must be greater than 0.");
                    }
                    break;
                }
                case OBSMIN:
                {
                    ++index;
                    getParameter<unsigned>(argc, argv, index, obsMin);
                    log<LgDebug>("obsMin = %1%") % obsMin;
                    break;
                }
                case OBSMAX:
                {
                    ++index;
                    getParameter<unsigned>(argc, argv, index, obsMax);
                    log<LgDebug>("obsMax = %1%") % obsMax;
                    break;
                }

                case SEED:
                {
                    ++index;
                    getParameter<unsigned>(argc, argv, index, seed);
                    log<LgDebug>("seed = %1%") % seed;
                    break;
                }
                case DIRNAME:
                {
                    ++index;
                    getParameter<string>(argc, argv, index, dirName);
                    log<LgDebug>("dirName = %1%") % dirName;
                    break;
                }
                case LATEXFILENAME:
                {
                    ++index;
                    getParameter<string>(argc, argv, index, latexFileName);
                    log<LgDebug>("latexFileName = %1%") % latexFileName;
                    break;
                }
                case TOPOLOGYFILENAME:
                {
                    ++index;
                    getParameter<string>(argc, argv, index, topologyFileName);
                    log<LgDebug>("TololgyFileName = %1%") % topologyFileName;
                    break;
                }
                case OBSINTERACTIONMIN:
                {
                    ++index;
                    getParameter<unsigned>(argc, argv, index, obsInteractionMin);
                    log<LgDebug>(" obsInteractionMin = %1%") % obsInteractionMin;
                    break;
                }
                case OBSINTERACTIONMAX:
                {
                    ++index;
                    getParameter<unsigned>(argc, argv, index, obsInteractionMax);
                    log<LgDebug>(" obsInteractionMax = %1%") % obsInteractionMax;
                    break;
                }
                case NODEBEHAVIOUR:
                {
                    ++index;
                    set<string> parameters;
                    getParameterList<string>(argc, argv, options, fileExtensions, index, parameters);
                    if (parameters.empty()) {
                        printCommandLineError("--nodeBehaviour expects at least one parameter. Check the command line, merci.");
                    }
                    for (set<string>::const_iterator it = parameters.begin();
                            it != parameters.end();
                            ++it) {
                        string::size_type idx = it->find('=');
                        if (idx == string::npos) {
                            printCommandLineError("Expecting --nodeBehaviour node=file.des_comp ci=sj, ck=sl..., check your command line. Merci.");
                        } else {
                            assignedConnections[it->substr(0, idx)] = it->substr(idx + 1);
                            log<LgDebug>(" node behaviour = <%1%,%2%>\n")
                                    % it->substr(0, idx)
                                    % it->substr(idx + 1);
                        }
                    }
                    break;
                }
                case OUTPUTDEGREEMAX:
                {
                    ++index;
                    getParameter<unsigned>(argc, argv, index, outputDegreeMax);
                    log<LgDebug>(" outputDegreeMax = %1%") % outputDegreeMax;
                    break;
                }
                case PETRINET:
                {
                    petrinet = true;
                    ++index;
                    log<LgDebug>(" petrinet = %1%") % petrinet;
                    break;
                }
                default:
                {
                    printUsage(description);
                    break;
                }
            }
        } else {
            string msg = "Unrecognized option: ";
            msg += argv[index];
            printCommandLineError(msg);
        }
    }




    // Some consistency tests
    Topology topology;
    if (isSet[TOPOLOGYFILENAME]) {
        cout << "Loading the topology in file " << topologyFileName << flush;
        try {
            topology.import(topologyFileName);
        } catch (exception & e) {
            cerr << endl << "The following exception has been caught:" << endl << ">>> " << e.what() << "<<< " << endl;
            cerr << "The generation is aborted." << endl;
            exit(EXIT_FAILURE);
        }
        cout << "Done" << endl;
    } else {
        topology.addNode();
        obsInteractionMax = 0;
        obsInteractionMin = 0;
    }
    Topology::Node fixedTopoNode;
    if (isSet[NODEBEHAVIOUR] && !isSet[TOPOLOGYFILENAME]) {
        printCommandLineError("You attempt to generate a model containing one node but you already fixed this node, so no generation is required.");
    }
    map<Topology::Connection, string> assignedTopoConnections;
    if (isSet[NODEBEHAVIOUR]) {
        set<string> topoElements;
        set<Topology::Node> topoNodes;
        set<Topology::Connection> topoConnections;

        for (const std::pair<string, string> & p : assignedConnections) {
            if (topoElements.find(p.first) != topoElements.end()) {
                string msg = "The same connection/node '";
                msg += p.first;
                msg += "' appears more than once in the command line. Check the command line, merci.";
                printCommandLineError(msg);
            }
            topoElements.insert(p.first);
        }
        Topology::NodeIterator it = topology.nodeBegin();
        while (it != topology.nodeEnd()) {
            if (topoElements.find(topology.getNodeName(*it).str()) != topoElements.end()) {
                topoNodes.insert(*it);
                topoElements.erase(topology.getNodeName(*it).str());
            }
            ++it;
        }
        if (topoNodes.size() == 0) {
            string msg = "Impossible to find in the given topology a node that corresponds to any of the following names: { ";
            for (const string & e : topoElements) {
                msg += e;
                msg += " ";
            }
            msg += "}";
            printCommandLineError(msg);
        }
        if (topoNodes.size() > 1) {
            string msg = "Found more than one corresponding node in the given topology: { ";
            for (set<Topology::Node>::const_iterator nodeIt = topoNodes.begin();
                    nodeIt != topoNodes.end();
                    ++nodeIt) {
                msg += topology.getNodeName(*it).str();
                msg += " ";
            }
            msg += "}.  Check the command line, merci.";
            printCommandLineError(msg);
        }
        fixedTopoNode = *topoNodes.begin();
        fixedNode = topology.getNodeName(fixedTopoNode).str();
        behaviourFileName = assignedConnections[ topology.getNodeName(fixedTopoNode).str()];
        log<LgDebug>(" found topology node = %1% assigned to model in file %2%.\n")
                % topology.getNodeName(fixedTopoNode)
                % behaviourFileName;
        assignedConnections.erase(topology.getNodeName(fixedTopoNode).str());
        Topology::ConnectionIterator it2 = topology.connectionBegin();
        while (it2 != topology.connectionEnd()) {
            if (topoElements.find(topology.getConnectionLabel(*it2).str()) != topoElements.end()) {
                assignedTopoConnections[*it2] = assignedConnections[topology.getConnectionLabel(*it2).str()];
                topoElements.erase(topology.getConnectionLabel(*it2).str());
            }
            ++it2;
        }
        if (!topoElements.empty()) {
            string msg = "Unrecognized connection/nodes: {";
            for (const string & s : topoElements) {
                msg += s;
                msg += " ";
            }
            msg += "}. Check the command line. Merci.";
            printCommandLineError(msg);
        }
        set<Topology::Connection> wrongConnections;
        for (const Topology::Connection & connection : topoConnections) {
            Topology::CliqueIterator nodeIt = topology.cliqueBegin(connection);
            bool foundNode = false;
            while (!foundNode && (nodeIt != topology.cliqueEnd(connection))) {
                foundNode = (*nodeIt) == fixedTopoNode;
                ++it;
            }
            if (!foundNode) {
                wrongConnections.insert(connection);
            }
        }
        if (!wrongConnections.empty()) {
            string msg = "The following connections are not connected to the node '";
            msg += topology.getNodeName(fixedTopoNode).str();
            msg += "': {";
            for (const Topology::Connection & connection : wrongConnections) {
                msg += topology.getConnectionLabel(connection).str();
            }
            printCommandLineError(msg);
        }
    }

    if (stateMin > stateMax) {
        printCommandLineError("stateMax should be at least equal to stateMin");
    }
    if (evtMin > evtMax) {
        printCommandLineError("evtMax should be at least equal to evtMin");
    }
    if (obsMin > obsMax) {
        printCommandLineError("obsMax should be at least equal to obsMin");
    }
    if (obsMin > evtMax) {
        printCommandLineError("obsMin should be at at most equal to evtMax");
    }
    if (obsMax > evtMax) {
        printCommandLineError("obsMax should be less than  evtMax");
    }
    if (obsInteractionMax > obsMax) {
        printCommandLineError("obsInteractionMax should be at most less or equal to obsMax");
    }
    if (obsInteractionMin > obsMin) {
        printCommandLineError("obsInteractionMin should be at most less or equal to obsMin");
    }
    if (obsInteractionMin > obsInteractionMax) {
        printCommandLineError("obsInteractionMin should be at most less or equal to obsInteractionMax");
    }
    if ((isSet[OUTPUTDEGREEMAX]) && (stateMax * outputDegreeMax < evtMin)) {
        stringstream stream;
        stream << "evtMin (" << evtMin
                << ") is too important as the maximal number of events that are possible is stateMax * outputDegreeMax ("
                << stateMax * outputDegreeMax << ").";
        printCommandLineError(stream.str());

    }

    if (!checkEventConsistency(topology, evtMax, obsInteractionMin)) {
        printCommandLineError("evtMax or obsInteractionMin are incompatible with the given topology");
    }
    verbose<VbOutput>("Initialisation of the random generator with the seed %1%.\n") % seed;
    initialiseRandomGenerator(seed);
    ComponentNodeMap componentOfNode(topology.graph());
    SharedEventNodeMap sharedEventOfNode(topology.graph());

    if (isSet[NODEBEHAVIOUR]) {
        map<Event, Event> translation;
        try {
            componentOfNode[fixedTopoNode] = new ObservableComponent();
            componentOfNode[fixedTopoNode]->import(behaviourFileName);
            componentOfNode[fixedTopoNode]->setId(fixedTopoNode.id());
            componentOfNode[fixedTopoNode]->setName(topology.getNodeName(fixedTopoNode).str());
            // need also to change the absolute name of the events
            list<Event> oldEvents;
            oldEvents.insert(oldEvents.end(), componentOfNode[fixedTopoNode]->eventBegin(),
                    componentOfNode[fixedTopoNode]->eventEnd());
            // need to change the mask as well !!
            ObservableMask obsCopy(componentOfNode[fixedTopoNode]->mask());
            ObservableMask newMask;
            while (!oldEvents.empty()) {
                Event current = oldEvents.front();
                oldEvents.pop_front();
                Event newEvent = EventFactory::factory()->getEvent(componentOfNode[fixedTopoNode]->name() + "." + current.nickname());
                newEvent.setNickname(current.nickname());
                componentOfNode[fixedTopoNode]->replaceEvent(current, newEvent);
                translation[newEvent] = current;
                if (obsCopy.isIdentifiable(current)) {
                    newMask.addMask(newEvent, newEvent);
                } else {
                    newMask.addMask(newEvent, newEvent);
                }
            }
            componentOfNode[fixedTopoNode]->setMask(newMask);
        } catch (exception & e) {
            string msg = "des_generate caught the following exception when attempting to load the model file"
                    + behaviourFileName + ":\n" + e.what();
            printCommandLineError(msg);
        }

        set<Event> usedEvents;
        for (const pair<Topology::Connection, string> & p : assignedTopoConnections) {

            bool foundEvent = false;
            ObservableComponent::EventIterator eventIt = componentOfNode[fixedTopoNode]->eventBegin();
            while ((!foundEvent) && (eventIt != componentOfNode[fixedTopoNode]->eventEnd())) {
                foundEvent = (translation[*eventIt].label() == p.second) || (eventIt->nickname() == p.second);
                if (!foundEvent) {
                    ++eventIt;
                }
            }
            if (!foundEvent) {
                string msg = "The event ";
                msg += p.second;
                msg += " is not contained in the model ";
                msg += behaviourFileName;
                printCommandLineError(msg);
            }
            if (foundEvent && (usedEvents.find(*eventIt) != usedEvents.end())) {
                string msg = "The event ";
                msg += p.second;
                msg += " cannot implement two different connections.";
                printCommandLineError(msg);
            }
            bool foundNode = false;
            Topology::CliqueIterator cliqueIt = topology.cliqueBegin(p.first);
            while (!foundNode && (cliqueIt != topology.cliqueEnd(p.first))) {
                foundNode = fixedTopoNode == *cliqueIt;
                ++cliqueIt;
            }
            if (!foundNode) {

                string msg = "The connection ";
                msg += topology.getConnectionLabel(p.first).str();
                msg += " does not involve the component ";
                msg += topology.getNodeName(fixedTopoNode).str();
                msg += ".";
                printCommandLineError(msg);
            }



            usedEvents.insert(*eventIt);
            always_assertion(FunctionException, eventIt->isValid(),
                    "Main: invalid event in sharedEventOfNode");
            sharedEventOfNode[fixedTopoNode][p.first] = *eventIt;
        }
        // let assigned  the pending connections with other events

        unsigned numberOfPendingConnections = topology.connectivity(fixedTopoNode) - assignedTopoConnections.size();

        if (numberOfPendingConnections > 0) {
            vector<Event> unusedEvents;
            for (ObservableComponent::EventIterator eventIt = componentOfNode[fixedTopoNode]->eventBegin();
                    eventIt != componentOfNode[fixedTopoNode]->eventEnd();
                    ++eventIt) {
                if (usedEvents.find(*eventIt) == usedEvents.end()) {
                    unusedEvents.push_back(*eventIt);
                }
            }

            set<unsigned> selectedIndexes;
            selectNValues(0, unusedEvents.size() - 1, numberOfPendingConnections, selectedIndexes);


            for (Topology::NodeConnectionIterator connIt = topology.nodeConnectionBegin(fixedTopoNode);
                    connIt != topology.nodeConnectionEnd(fixedTopoNode);
                    ++connIt) {

                if (!sharedEventOfNode[fixedTopoNode][*connIt].isValid()) {
                    if (selectedIndexes.empty()) {
                        throw (FunctionException("main", "BUG in the selection of shared events for the fixed node."));
                    }

                    always_assertion(FunctionException, unusedEvents[*selectedIndexes.begin()].isValid(),
                            "Main: invalid event in sharedEventOfNode");
                    sharedEventOfNode[fixedTopoNode][*connIt] = unusedEvents[*selectedIndexes.begin()];
                    selectedIndexes.erase(selectedIndexes.begin());
                }
            }
        }
    }






    // prepare the outputs
    stringstream stream;
    string param = "mkdir -p " + dirName;
    system(param.c_str());
    string topoFileNameDest = dirName + "/" + "topology.topo";
    topology.save(topoFileNameDest);


    for (Topology::NodeIterator nodeIt = topology.nodeBegin();
            nodeIt != topology.nodeEnd();
            ++nodeIt) {
        if (!isSet[NODEBEHAVIOUR] || (*nodeIt != fixedTopoNode)) {
            componentOfNode[*nodeIt] = new ObservableComponent();
            componentOfNode[*nodeIt]->setId(nodeIt->id());
            componentOfNode[*nodeIt]->setName(topology.getNodeName(*nodeIt).str());
        }
    }
    // generation of the shared events consistent with the topology
    generateSharedEvents(topology, componentOfNode, sharedEventOfNode, fixedTopoNode);


    // write the synchronisation rules
    string rulesFileNameDest = dirName + "/" + "sync.rules";
    ofstream file(rulesFileNameDest.c_str());
    file << "components: ";
    for (Topology::NodeIterator nodeIt = topology.nodeBegin();
            nodeIt != topology.nodeEnd();
            ++nodeIt) {
        file << topology.getNodeName(*nodeIt);
        Topology::NodeIterator nextNodeIt = nodeIt;
        ++nextNodeIt;
        if (nextNodeIt == topology.nodeEnd()) {
            file << ";" << endl;
        } else {
            file << ", ";
        }
    }
    file << "rules:" << endl;
    for (Topology::ConnectionIterator connIt = topology.connectionBegin();
            connIt != topology.connectionEnd();
            ++connIt) {
        file << "<";
        for (Topology::CliqueIterator cliqueIt = topology.cliqueBegin(*connIt);
                cliqueIt != topology.cliqueEnd(*connIt);
                ++cliqueIt) {
            file << sharedEventOfNode[*cliqueIt][*connIt];
            Topology::CliqueIterator nextCliqueIt = cliqueIt;
            ++nextCliqueIt;
            if (nextCliqueIt == topology.cliqueEnd(*connIt)) {
                file << ">;" << endl;
            } else {
                file << ", ";
            }
        }
    }
    file.close();

    if (topology.nodeBegin() == topology.nodeEnd()) {
        verbose<VbWarning>("It seems that the current topology is empty. No generation then...Au revoir.\n");
    } else {
        // generation of the behaviours
        try {
            generateBehaviour(topology, stateMin, stateMax, evtMin, evtMax, obsMin, obsMax, obsInteractionMin, obsInteractionMax,
                    componentOfNode, sharedEventOfNode, dirName, fixedTopoNode, outputDegreeMax);
        } catch (exception & e) {
            stringstream stream;
            stream << "des_generate caught an exception when calling generateBehaviour():\n";
            stream << "\t here are the parameters of des_generate:" << endl;
            stream << "\t\tstateMin = " << stateMin << endl;
            stream << "\t\tstateMax = " << stateMax << endl;
            stream << "\t\tobsMin = " << obsMin << endl;
            stream << "\t\tobsMax = " << obsMax << endl;

            stream << "\t\tevtMin = " << evtMin << endl;
            stream << "\t\tevtMax = " << evtMax << endl;
            stream << "\t\tseed =  " << seed << endl;
            stream << "\t\tdirName =  " << dirName << endl;
            stream << "\t\tlatexFileName = " << latexFileName << endl;
            stream << "\t\ttopologyFileName =  " << topologyFileName << endl;

            stream << "\t\tobsInteractionMin = " << obsInteractionMin << endl;
            stream << "\t\tobsInteractionMax =  " << obsInteractionMax << endl;
            stream << "\t\toutputDegreeMax = " << outputDegreeMax << endl;
            stream << "\t\tbehaviourFileName= " << behaviourFileName << endl;
            stream << "\t\tfixedNode= " << fixedNode << endl;
            stream << "Here is the exception: " << endl;
            stream << e.what();
            cerr << stream.str() << endl;
            cerr << "LOGS: " << endl;
            debug(saveAllLogs(cerr));
            exit(EXIT_FAILURE);
        }



        // generation of the latex file
        string latexFileNameDest = dirName + "/" + latexFileName;
        generateLatexFile(topology, stateMin, stateMax, evtMin,
                evtMax, obsMin, obsMax, obsInteractionMin, obsInteractionMax, seed, outputDegreeMax, fixedNode, behaviourFileName, assignedConnections, componentOfNode, sharedEventOfNode, latexFileNameDest);

        // ... and finally the topology mapping
        string mapTopoFileNameDest = dirName + "/" + "topology.maptopo";
        exportTopologyMap(topology, sharedEventOfNode, componentOfNode, mapTopoFileNameDest);

        if (petrinet) {
                        cout << "Not implemented yet" << endl;
//            string rulesFileNameDest = dirName + "/" + "sync.rules";
//
//            std::vector< std::reference_wrapper<const ObservableComponent> > components;
//            Diades::Automata::SynchronisationRules::ComponentVector compVect;
//
//            for (Topology::NodeIterator nIt = topology.nodeBegin();
//                    nIt != topology.nodeEnd(); ++nIt) {
//                components.push_back(std::cref(*componentOfNode[*nIt]));
//                compVect.push_back(componentOfNode[*nIt]);
//            }
//            Diades::Automata::ParametrizedSynchronisation sync;
//            loadSynchronisationRules(compVect, rulesFileNameDest, sync);
//
//            Diades::Petri::Net net;
//            Diades::Petri::automataConversion(components.begin(), components.end(), sync, net);
//            net.setName("generated_net");
//            string netFileName = dirName + "/petrinet.net";
//            ofstream file(netFileName.c_str());
//            net.net2Tina(file);
//            cout << "Generated net: places = " << net.numberOfPlaces() << " transitions = "
//                    << net.numberOfTransitions() << endl;
//            file.close();
        }
    }

    ofstream logfile("lastlog.output");
    saveAllLogs(logfile);
    logfile.close();
    verbose<VbOutput>("Model successfully generated...\n");
    return EXIT_SUCCESS;
}


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

bool checkEventConsistency(const Topology & topology, unsigned evtMax, unsigned nbObsIntMin) {
    unsigned connectivityMax = 0;
    unsigned connectivityMin = 0;
    for (Topology::NodeIterator it = topology.nodeBegin();
            it != topology.nodeEnd();
            ++it) {
        if (connectivityMin == 0) {
            connectivityMin = topology.connectivity(*it);
        } else {
            if (connectivityMin > topology.connectivity(*it)) {
                connectivityMin = topology.connectivity(*it);
            }
        }
        if (connectivityMax < topology.connectivity(*it)) {
            connectivityMax = topology.connectivity(*it);
        }
    }
    log<LgOutput>("evtMax=%1% and max(connectivity)=%2%")
            % evtMax % connectivityMax;
    if (evtMax < connectivityMax) {
        log<LgOutput>("evtMax is smaller than the maximal connectivity of this topology");
    }
    log<LgOutput>("nbObsIntMin=%1% and min(connectivity)=%2%")
            % nbObsIntMin % connectivityMin;

    if (nbObsIntMin > connectivityMin) {
        log<LgOutput>("nbObsIntMin is strictly greater than the minimal connectivity of this topology");
    }
    return (evtMax >= connectivityMax) && (nbObsIntMin <= connectivityMin);
}


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

void generateSharedEvents(const Topology & topology, ComponentNodeMap & componentOfNode,
        SharedEventNodeMap & sharedEventOfNode, Topology::Node fixedTopoNode) {
    for (Topology::NodeIterator nodeIt = topology.nodeBegin();
            nodeIt != topology.nodeEnd();
            ++nodeIt) {
        if (!fixedTopoNode.valid() || (fixedTopoNode != *nodeIt)) {
            for (Topology::NodeConnectionIterator connIt = topology.nodeConnectionBegin(*nodeIt);
                    connIt != topology.nodeConnectionEnd(*nodeIt);
                    ++connIt) {
                stringstream stream;
                stream << topology.getNodeName(*nodeIt) << ".s" << eventNumber;
                Event evt = EventFactory::factory()->getEvent(stream.str());
                stringstream nickname;
                nickname << "s" << eventNumber;
                evt.setNickname(nickname.str());
                always_assertion(FunctionException, evt.isValid(),
                        "generateSharedEvents: invalid event in sharedEventOfNode");
                sharedEventOfNode[*nodeIt][*connIt] = evt;
                componentOfNode[*nodeIt]->insertEvent(evt);
                ++eventNumber;
            }
        }
    }

    // final check
    for (Topology::NodeIterator nodeIt = topology.nodeBegin();
            nodeIt != topology.nodeEnd();
            ++nodeIt) {


        for (Topology::NodeConnectionIterator connIt = topology.nodeConnectionBegin(*nodeIt);
                connIt != topology.nodeConnectionEnd(*nodeIt);
                ++connIt) {

            always_assertion(FunctionException, sharedEventOfNode[*nodeIt][*connIt].isValid(),
                    "generateSharedEvents: invalid event in sharedEventOfNode");


        }
    }

}

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

void generateBehaviour(const Topology & topology,
        unsigned stateMin,
        unsigned stateMax,
        unsigned evtMin,
        unsigned evtMax,
        unsigned obsMin,
        unsigned obsMax,
        unsigned obsInteractionMin,
        unsigned obsInteractionMax,
        ComponentNodeMap & componentOfNode,
        SharedEventNodeMap & sharedEventOfNode,
        string dirName,
        Node fixedTopoNode,
        unsigned outputDegreeMax) {
    list<Topology::Node> nodesToVisit;
    Diades::Graph::ConstNodeMap< pair<string, ObservableComponent *> > projection(topology.graph());
    ObservableComponent * interaction = 0;
    try {
        Diades::Graph::ConstNodeMap<int> visitedNodes(topology.graph(), 0); // 0:not visited 1:visited 2:generated
        Topology::Node initialNode;

        if (fixedTopoNode.valid()) {
            // in this case, one node has a predefined behaviour, so it is set to be already visited.
            initialNode = fixedTopoNode;
            visitedNodes[initialNode] = 2;

            // write the output immediately (to get a better debug output)
            writeComponent(*componentOfNode[initialNode], dirName);


            // now we generate the neighbours that will initiate the node generation
            // obviusly, in this case generatedNeighbours is always empty. 
            set<Topology::Node> generatedNeighbours;
            set<Topology::Node> nonGeneratedNeighbours;
            propagateConstrainedInteractions(topology,
                    initialNode,
                    visitedNodes,
                    generatedNeighbours,
                    nonGeneratedNeighbours,
                    nodesToVisit);

            // projection of the initial component on the events in
            // interaction with the set of nonGeneratedNeighbours (i.e. here all the neighbours)
            // moreover nonGeneratedNeighbours is not empty as the topology must contain
            // at least two nodes in this case.
            projection[initialNode] = make_pair("", new ObservableComponent());
            getOutputProjection(topology, initialNode, sharedEventOfNode,
                    *componentOfNode[initialNode],
                    nonGeneratedNeighbours,
                    projection[initialNode]);

        } else {
            // in this case, no node has a predefined behaviour.
            // take the first one that can be found and mark as visited but not saturated
            initialNode = *topology.nodeBegin();
            nodesToVisit.push_back(initialNode);
            visitedNodes[initialNode] = 1;
        }

        // Breadth-first search 
        while (!nodesToVisit.empty()) {
            Node node = nodesToVisit.front();
            debug(printDebugStartVisit(topology, node));
            nodesToVisit.pop_front();

            // now we generate the neighbours that will initiate the node generation
            set<Topology::Node> generatedNeighbours;
            set<Topology::Node> nonGeneratedNeighbours;
            propagateConstrainedInteractions(topology,
                    node,
                    visitedNodes,
                    generatedNeighbours,
                    nonGeneratedNeighbours,
                    nodesToVisit);
            debug(printDebugProjectionOnGeneratedNeighbours(generatedNeighbours, projection));


            if (generatedNeighbours.empty() && (node != initialNode)) {
                throw (FunctionException("generateBehaviour", "the current node has no interaction with generated neighbours. BUG.\n"));
            }

            // generation of the interactive behaviour that the current node must comply with.
            interaction = getSynchronisedInteraction(topology, node,
                    sharedEventOfNode,
                    projection,
                    generatedNeighbours.begin(),
                    generatedNeighbours.end());

            if ((node != initialNode) && (interaction->numberOfTransitions() < generatedNeighbours.size())) {
                delete interaction;
                interaction = 0;
                throw (FunctionException("generateBehaviour", "the interactions with generated neighbours are incorrect. BUG\n"));
            }

            // generation of the current node
            generateRandomComponent(topology, node,
                    sharedEventOfNode,
                    *interaction,
                    generatedNeighbours.begin(),
                    generatedNeighbours.end(),
                    stateMin,
                    stateMax,
                    obsMin,
                    obsMax,
                    evtMin,
                    evtMax,
                    obsInteractionMin,
                    obsInteractionMax,
                    outputDegreeMax,
                    componentOfNode[node]);

            // write the output immediately (to get a better debug output)
            writeComponent(*componentOfNode[node], dirName);

            if (!nonGeneratedNeighbours.empty()) {
                // compute the interactive behaviour of the current generated node for futher node generations
                projection[node] = make_pair("", new ObservableComponent());
                getOutputProjection(topology, node, sharedEventOfNode, *componentOfNode[node],
                        nonGeneratedNeighbours,
                        projection[node]);
            }
            // now this node is saturated
            visitedNodes[node] = 2;
            delete interaction;
            interaction = 0;
        }
    } catch (exception & e) {
        if (interaction != 0) {
            delete interaction;
            interaction = 0;
        }
        for (Topology::NodeIterator nodeIt = topology.nodeBegin();
                nodeIt != topology.nodeEnd();
                ++nodeIt) {
            if (projection[*nodeIt].second != 0) {
                delete projection[*nodeIt].second;
            }
        }
        throw (FunctionException("generateBehaviour", e.what()));
    }
}

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

void getOutputProjection(const Topology & topology,
        const Node & node,
        SharedEventNodeMap & sharedEventOfNode,
        const ObservableComponent & component,
        const set<Node> & nonGeneratedNeighbours,
        pair<string, ObservableComponent *> & result) {
    always_require(FunctionException, !nonGeneratedNeighbours.empty(), "getOutputProjection: empty set of non generated neighbours");
    stringstream streamP;
    streamP << "P_{";
    for (set<Node>::const_iterator outIt = nonGeneratedNeighbours.begin();
            outIt != nonGeneratedNeighbours.end(); ++outIt) {
        streamP << topology.getNodeName(*outIt) << " ";
    }
    streamP << "}(" << topology.getNodeName(node) << ")";
    result.first = streamP.str();

    set<Event> projectedEvents;
    for (Topology::NodeConnectionIterator it = topology.nodeConnectionBegin(node);
            it != topology.nodeConnectionEnd(node);
            ++it) {
        Topology::CliqueIterator it2 = topology.cliqueBegin(*it);
        bool found = false;
        while (!found && (it2 != topology.cliqueEnd(*it))) {
            found = (*it2 != node) && (nonGeneratedNeighbours.find(*it2) != nonGeneratedNeighbours.end());
            ++it2;
        }
        if (found) {
            always_require(FunctionException, sharedEventOfNode[node][*it].isValid(),
                    "getOutputProjection: invalid shared event found in sharedEventOfNode");
            projectedEvents.insert(sharedEventOfNode[node][*it]);
        }
    }
    try {
        result.second->project(&component, projectedEvents);
    } catch (exception & e) {
        stringstream msg;
        msg << "caught an exception." << endl;
        msg << "getOutputProjection called with the following parameters:" << endl;
        msg << "\t node= " << topology.getNodeName(node) << endl;
        msg << "\t non generated nodes= " << toStream(nonGeneratedNeighbours.begin(), nonGeneratedNeighbours.end()) << endl;
        msg << "Here is the caught exception:" << endl;
        msg << e.what() << endl;
        throw (FunctionException(msg.str()));
    }
    result.second->setName(result.first);
    always_ensure(FunctionException, result.second->isValid(), "getOutputProjection: invalid returned projection");
    set<Event> effectiveEvents;
    for (ObservableComponent::TransitionIterator trIt = result.second->transitionBegin();
            trIt != result.second->transitionEnd(); ++trIt) {
        effectiveEvents.insert(result.second->getEvent(*trIt));
    }
    always_ensure(FunctionException, effectiveEvents == projectedEvents, "getOutputProjection: the set of projected events is incorrect");
}

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

ObservableComponent *
getSynchronisedInteraction(const Topology & topology, const Node & node,
        SharedEventNodeMap & sharedEventOfNode,
        const Diades::Graph::ConstNodeMap< pair<string, ObservableComponent *> > & projection,
        set<Node>::const_iterator first,
        set<Node>::const_iterator last) {

    ObservableComponent * projectedInteraction = 0;
    ObservableComponent * interaction = 0;

    debug(verbose<VbDebug>("getSynchronisedInteraction on node %1%.\n") % topology.getNodeName(node).str());

    if (first == last) {
        projectedInteraction = new ObservableComponent();
        projectedInteraction->setInitial(projectedInteraction->newState());
    } else {
        vector<const ComposableModel *> composableModels;
        bool interactionToBeDestroyed = false;
        try {
            vector<const Component *> models;
            for (set<Node>::const_iterator it = first; it != last; ++it) {
                models.push_back(projection[*it].second);
            }
            if (models.size() == 1) {
                interaction = projection[*first].second;
                interactionToBeDestroyed = false;
            } else {
                // synchronisation of the input projections

                // first let us create the synchronisation law
                ParametrizedSynchronisation synchronisation(models);
                initialiseSynchronisationRules(topology, first, last,
                        sharedEventOfNode, projection, synchronisation);
                debug(printDebugLaw(synchronisation));

                // then apply the synchronsation law

                for (set<Node>::const_iterator it = first; it != last; ++it) {
                    composableModels.push_back(new ComposableModel(*projection[*it].second, synchronisation));
                }


                interaction = new ObservableComponent();
                interactionToBeDestroyed = true;

                ComposableModel composedModel(composableModels, synchronisation, false, interaction);
                for (vector<const ComposableModel *>::size_type i = 0; i < composableModels.size(); ++i) {
                    delete composableModels[i];
                }
                composableModels.clear();
            }

            // and finally project on the events in synchronisation with the node to generate
            projectedInteraction = new ObservableComponent();
            set<Event> projectedEvents;

            for (Topology::NodeConnectionIterator it = topology.nodeConnectionBegin(node);
                    it != topology.nodeConnectionEnd(node);
                    ++it) {
                for (Topology::CliqueIterator it2 = topology.cliqueBegin(*it);
                        it2 != topology.cliqueEnd(*it);
                        ++it2) {
                    if (find(first, last, *it2) != last) {
                        projectedEvents.insert(sharedEventOfNode[*it2][*it]);
                    }
                }
            }
            projectedInteraction->project(interaction, projectedEvents);
            if (interactionToBeDestroyed) {
                delete interaction;
                interaction = 0;
                interactionToBeDestroyed = false;
            }
            // let us do some checking
            // 1) first != last implies that projectedInteraction is not empty
            if ((first != last) && (projectedInteraction->numberOfTransitions() == 0)) {
                throw FunctionException("getSynchronisedInteraction", "The returned interaction is empty, BUG. Be careful it is maybe due to a fundamental problem of the whole generation algorithm. This algorithm is based on a random generator and has not been proved to always work. Sorry for any inconvenience. Try again with another seed and good luck :-) Merci for trying\n");
            }
        } catch (exception & e) {
            if (projectedInteraction != 0) {
                delete projectedInteraction;
            }
            if (interaction != 0 && interactionToBeDestroyed) {
                delete interaction;
                interaction = 0;
                interactionToBeDestroyed = false;
            }
            for (vector<const ComposableModel *>::size_type i = 0; i < composableModels.size(); ++i) {
                delete composableModels[i];
            }
            composableModels.clear();
            throw (FunctionException("getSynchronisedInteraction", e.what()));
        }
    }
    return projectedInteraction;
}

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

void generateRandomComponent(const Topology & topology, const Node & node,
        SharedEventNodeMap & sharedEventOfNode,
        const ObservableComponent & interaction,
        set<Node>::const_iterator first,
        set<Node>::const_iterator last,
        unsigned stateMin,
        unsigned stateMax,
        unsigned obsMin,
        unsigned obsMax,
        unsigned evtMin,
        unsigned evtMax,
        unsigned obsInteractionMin,
        unsigned obsInteractionMax,
        unsigned outputDegreeMax,
        ObservableComponent * result) {
    set<Event> interactiveEvents;
    for (ObservableComponent::EventIterator eventIt = result->eventBegin();
            eventIt != result->eventEnd();
            ++eventIt) {
        interactiveEvents.insert(*eventIt);
    }

    set<Event> nonInteractiveEvents;
    generateNonInteractiveEvents(topology, node, evtMin, evtMax, obsMin, obsInteractionMax, *result, nonInteractiveEvents);


    // Let define the observable mask
    defineObservableMask(obsMin, obsMax, obsInteractionMin, obsInteractionMax, interactiveEvents,
            nonInteractiveEvents, *result);

    // let's generate the number of states in this component
    always_require(FunctionException, stateMin <= stateMax, "generateRandomComponent: stateMin > stateMax");
    unsigned numberOfStates = generateRandomValue(stateMin, stateMax);
    always_assertion(FunctionException, numberOfStates <= stateMax, "generateRandomComponent: numberOfStates > stateMax.");
    always_assertion(FunctionException, numberOfStates >= stateMin, "generateRandomComponent: numberOfStates < stateMin.");


    // let's generate the transition system of the component
    generateTransitionSystem(topology, node, sharedEventOfNode, interaction, first, last, numberOfStates,
            outputDegreeMax, *result);
}


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

void generateStates(ObservableComponent & result, unsigned numberOfStates, vector<Node> & indexState) {

    indexState.resize(numberOfStates);
    for (unsigned i = 0; i < numberOfStates; ++i) {
        stringstream s;
        s << "q" << i;
        indexState[i] = result.newState(s.str());
    }
}

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

void logDetailsBeforeCallingGenerateTransitionSystem(const Topology & topology,
        const Node & node,
        SharedEventNodeMap & sharedEventOfNode,
        const ObservableComponent & interaction,
        set<Node>::const_iterator first,
        set<Node>::const_iterator last,
        unsigned numberOfStates,
        unsigned outputDegreeMax,
        ObservableComponent & result) {
    verbose<VbDebug>("Call of generateTransitionSystem on the node %1%\n") % topology.getNodeName(node);
    verbose<VbDebug>("Generation of %1% states.\n") % numberOfStates;
    verbose<VbDebug>("Shared events involved: \n[");
    for (map<Topology::Connection, Event>::const_iterator it = sharedEventOfNode[node].begin();
            it != sharedEventOfNode[node].end();
            ++it) {
        string nodeNames;
        for (Topology::CliqueIterator cliqueIt = topology.cliqueBegin(it->first);
                cliqueIt != topology.cliqueEnd(it->first);
                ++cliqueIt) {
            if (*cliqueIt != node) {
                string nodeName = topology.getNodeName(*cliqueIt).str();
                nodeNames += nodeName + " ";
            }
        }
        verbose<VbDebug>("%1%  ( in connection with %2%)\n") % it->second % nodeNames;
    }
    string logs;
    interaction.component2dot("interaction.dot");
}


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

void initConstrainedConnectionMappings(const Topology & topology,
        const Node & node,
        SharedEventNodeMap & sharedEventOfNode,
        set<Node>::const_iterator first,
        set<Node>::const_iterator last,
        map<Event, Topology::Connection> & mappingInteractionToCurrentSide,
        map<Topology::Connection, Event> & mappingConnectionToInteraction,
        map<Event, Topology::Connection> & mappingCurrentSideToInteraction,
        set<Event>& constrainedEvents) {
    for (Topology::NodeConnectionIterator it = topology.nodeConnectionBegin(node);
            it != topology.nodeConnectionEnd(node);
            ++it) {
        for (Topology::CliqueIterator it2 = topology.cliqueBegin(*it);
                it2 != topology.cliqueEnd(*it);
                ++it2) {
            if (find(first, last, *it2) != last) {
                mappingCurrentSideToInteraction[sharedEventOfNode[node][*it]] = *it;
                mappingInteractionToCurrentSide[sharedEventOfNode[*it2][*it]] = *it;
                constrainedEvents.insert(sharedEventOfNode[node][*it]);
                mappingConnectionToInteraction[*it] = sharedEventOfNode[*it2][*it];
            }
        }
    }
}


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

unsigned getNumberOfTransitions(const Selection<Event> & eventSelection,
        const set<Event> & constrainedEvents,
        const set<Event> & constrainedTriggerableEvents,
        unsigned numberOfAdmissibleEvents,
        unsigned numberOfStatesToVisit,
        unsigned outputDegreeMax,
        bool & mustUseNewEvent) {
    always_require(FunctionException, numberOfAdmissibleEvents > 0, "getNumberOfTransitions: there is no admissible event");
    always_require(FunctionException, outputDegreeMax > 0, "getNumberOfTransitions: outputDegreeMax is null.");
    unsigned result = 0;
    mustUseNewEvent = false;
    unsigned numberOfNonInsertedAndTriggerableEvents =
            count_if(eventSelection.nonSelectedBegin(),
            eventSelection.nonSelectedEnd(),
            unaryOr(isNotIn(constrainedEvents.begin(), constrainedEvents.end()),
            isIn(constrainedTriggerableEvents.begin(), constrainedTriggerableEvents.end())));

    if (numberOfNonInsertedAndTriggerableEvents != 0) {
        double probablilityOfCertainlyUsingSomeNewEventInThisState = 1;
        if (numberOfStatesToVisit > 0) {
            probablilityOfCertainlyUsingSomeNewEventInThisState =
                    min((double) 1, ((double) eventSelection.numberOfNonSelectedItems()) / ((double) numberOfStatesToVisit));
        }
        double value = generateRandomDouble(0, 1);
        mustUseNewEvent = value <= probablilityOfCertainlyUsingSomeNewEventInThisState;
    }

    unsigned minimalNumberOfTrans = 1;
    unsigned maximalNumberOfTrans = min(numberOfAdmissibleEvents, outputDegreeMax);
    result = generateRandomValue(minimalNumberOfTrans, maximalNumberOfTrans);
    ensure(FunctionException, result > 0, "getNumberOfTransitions: null result.");
    ensure(FunctionException, result <= outputDegreeMax, "getNumberOfTransitions: result greater than outputDegreeMax.");
    ensure(FunctionException, result <= numberOfAdmissibleEvents, "getNumberOfTransitions: result greater than the number of admissible events");
    return result;
}
/************************************************************************************************/

void generateTriggerableEvents(unsigned nbTransitions,
        Selection<Event> & eventSelection,
        const vector<unsigned> & admissibleEventIndexes,
        unsigned numberOfNonPreviouslySelectedButAdmissibleEvents,
        bool mustUseNewEvent,
        set<Event> & selectedEvents) {
    always_require(FunctionException, (!mustUseNewEvent) || (numberOfNonPreviouslySelectedButAdmissibleEvents != 0),
            "generateTriggerableEvents: BUG the parameters mustUseNewEvent and numberOfNonPreviouslySelectedButAdmissibleEvents are incompatible.");
    always_require(FunctionException, nbTransitions > 0, "generateTriggerableEvents: BUG nbTransitions is null");
    always_require(FunctionException, eventSelection.numberOfItems() >= admissibleEventIndexes.size(),
            "generateTriggerableEvents: BUG the set of admissible events is greater than the number of events.");
    always_require(FunctionException, numberOfNonPreviouslySelectedButAdmissibleEvents <= admissibleEventIndexes.size(),
            "generateTriggerableEvents: BUG there are more unselected admissible events than admissible events.");
    always_require(FunctionException, numberOfNonPreviouslySelectedButAdmissibleEvents <= eventSelection.numberOfNonSelectedItems(),
            "generateTriggerableEvents: BUG there are more unselected admissible events than unselected events.");
    // in order to be as random as possible, first we try to get directly nbTransitions
    // from the admissibleEventIndexes independently from the fact a new event
    // must be selected or not.
    set<unsigned> randomResult;
    try {
        selectNValues(0, admissibleEventIndexes.size() - 1, nbTransitions, randomResult);
    } catch (exception & e) {
        stringstream stream;
        stream << "Exception caught: parameters of generateTriggerableEvents:\n nbTransitions = " << nbTransitions
                << "\n eventSelection.numberOfItems() = " << eventSelection.numberOfItems()
                << "\n admissibleEventIndexes.size() = " << admissibleEventIndexes.size()
                << "\n numberOfNonPreviouslySelectedButAdmissibleEvents = " << numberOfNonPreviouslySelectedButAdmissibleEvents
                << "\n mustUseNewEvent = " << mustUseNewEvent
                << "selectedEvents.size() = " << selectedEvents.size()
                << endl;
        throw (FunctionException(stream.str(), e.what()));
    }
    // now we check the first index, if it is greater than  numberOfNonPreviouslySelectedButAdmissibleEvents
    // we know that the selection does not contain any new event
    if ((mustUseNewEvent) && (*(randomResult.begin()) >= numberOfNonPreviouslySelectedButAdmissibleEvents)) {
        // bad luck, let us force a bit the destiny
        // selection of an event never selected.
        unsigned selectionIndex = generateRandomValue(0, numberOfNonPreviouslySelectedButAdmissibleEvents);
        randomResult.erase(randomResult.begin());
        randomResult.insert(selectionIndex);
    }

    // now randomResult context the index of events included in eventSelection
    // some have never been selected, it is time to notice this fact.
    for (const unsigned & index : randomResult) {
        selectedEvents.insert(eventSelection.getItem(admissibleEventIndexes[index]));
        if (!eventSelection.hasBeenAlreadySelectedOnce(admissibleEventIndexes[index])) {
            eventSelection.select(admissibleEventIndexes[index]);
        }
    }

    always_ensure(FunctionException, selectedEvents.size() == nbTransitions,
            "generateTriggerableEvents: BUG wrong number of selected events");

}



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

void getSelectedEvents(const ObservableComponent & interaction,
        State currentInteractingState,
        map<Event, Topology::Connection> & mappingInteractionToCurrentSide,
        map<Event, Topology::Connection> & mappingCurrentSideToInteraction,
        map<Topology::Connection, Event> & mappingConnectionToInteraction,
        Selection<Event> & eventSelection,
        const set<Event> & constrainedEvents,
        const set<Topology::Connection> & constrainedConnections,
        unsigned numberOfVisitedStates,
        ObservableComponent & result,
        unsigned outputDegreeMax,
        set<Event> & selectedEvents) {
    set<Event> constrainedTriggerableEvents;
    for (const Event & e : constrainedEvents) {
        if (constrainedConnections.find(mappingCurrentSideToInteraction[e])
                != constrainedConnections.end()) {
            // ok event e is involved with a constrainedConnection
            // let us see whether the associated event can be triggered by
            //  currentInteractingState
            Event associatedEvent = mappingConnectionToInteraction[mappingCurrentSideToInteraction[e]];
            if (interaction.outputEventTransitionBegin(currentInteractingState,
                    associatedEvent)
                    != interaction.outputEventTransitionEnd(currentInteractingState,
                    associatedEvent)
                    ) {
                //yes
                constrainedTriggerableEvents.insert(e);

            }
        }
    }


    vector<unsigned> admissibleEventIndexes;
    always_require(FunctionException, result.numberOfEvents() > 0,
            "getSelectedEvents: there is no event in the component to be generated.");

    always_require(FunctionException, eventSelection.numberOfItems() > 0,
            "getSelectedEvents: there is no event of the component in the eventSelection object.");


    always_require(FunctionException, eventSelection.numberOfItems() == result.numberOfEvents(),
            "getSelectedEvents: eventSelection.numberOfItems() != result.numberOfEvents().");

    admissibleEventIndexes.reserve(result.numberOfEvents());

    // an event is admissible iff it is not a constrained event or, if it is,
    // its corresponding event in the interaction model can be triggered
    // in the state currentInteractingState
    // In order to be more efficient when generating the selection of events,
    // we explore first the events that are still not in the model and then the one that
    // are in the model already.

    for (Selection<Event>::IndexIterator indexIt = eventSelection.nonSelectedIndexBegin();
            indexIt != eventSelection.nonSelectedIndexEnd();
            ++indexIt) {

        if (constrainedEvents.find(eventSelection.getItem(*indexIt)) == constrainedEvents.end()) {
            admissibleEventIndexes.push_back(*indexIt);
        } else {
            if (constrainedTriggerableEvents.find(eventSelection.getItem(*indexIt)) != constrainedTriggerableEvents.end()) {
                admissibleEventIndexes.push_back(*indexIt);
            }
        }
    }

    unsigned numberOfNonPreviouslySelectedButAdmissibleEvents = admissibleEventIndexes.size();
    for (Selection<Event>::IndexIterator indexIt = eventSelection.selectedIndexBegin();
            indexIt != eventSelection.selectedIndexEnd();
            ++indexIt) {

        if (constrainedEvents.find(eventSelection.getItem(*indexIt)) == constrainedEvents.end()) {
            admissibleEventIndexes.push_back(*indexIt);
        } else {
            if (constrainedTriggerableEvents.find(eventSelection.getItem(*indexIt)) != constrainedTriggerableEvents.end()) {
                admissibleEventIndexes.push_back(*indexIt);
            }
        }
    }

    // Generation of the number of output transitions for the current state.
    // From a state, the behaviour is deterministic so the number of transitions
    // is at most the number of admissible events. Since the state of the component
    // is live, I also suppose that there exists at least one transition
    // but I also need to take care about the fact that every event is at least used
    // once in the model.

    bool mustUseNewEvent = false;
    unsigned nbTransitions = getNumberOfTransitions(eventSelection,
            constrainedEvents,
            constrainedTriggerableEvents,
            admissibleEventIndexes.size(),
            result.numberOfStates() - numberOfVisitedStates,
            outputDegreeMax, mustUseNewEvent);

    generateTriggerableEvents(nbTransitions,
            eventSelection,
            admissibleEventIndexes,
            numberOfNonPreviouslySelectedButAdmissibleEvents,
            mustUseNewEvent,
            selectedEvents);


    always_ensure(FunctionException, !selectedEvents.empty(),
            "getSelectedEvents: the returned set of events is empty. BUG.");
}


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

void generateTransitionSystem(const Topology & topology,
        const Node & node,
        SharedEventNodeMap & sharedEventOfNode,
        const ObservableComponent & interaction,
        set<Node>::const_iterator first,
        set<Node>::const_iterator last,
        unsigned numberOfStates,
        unsigned outputDegreeMax,
        ObservableComponent & result) {
    debug(logDetailsBeforeCallingGenerateTransitionSystem(topology, node,
            sharedEventOfNode,
            interaction,
            first,
            last,
            numberOfStates,
            outputDegreeMax,
            result););


    // state generation
    vector<State> indexedState; // at each index, there is a state
    generateStates(result, numberOfStates, indexedState);
    Selection<State> stateSelection(indexedState);

    // the component is deterministic but not minimal
    // I also need to take care about the fact that every event is at least used
    // once in the model and every transition in interaction must be triggered once.
    // Moreover no transition with a code shared with interaction is independent from
    // interaction. 

    // here are the connections that are contrained by interaction
    map<Event, Topology::Connection> mappingInteractionToCurrentSide;
    map<Topology::Connection, Event> mappingConnectionToInteraction;
    map<Event, Topology::Connection> mappingCurrentSideToInteraction;
    set<Event> constrainedEvents;
    initConstrainedConnectionMappings(topology, node, sharedEventOfNode, first,
            last, mappingInteractionToCurrentSide,
            mappingConnectionToInteraction,
            mappingCurrentSideToInteraction,
            constrainedEvents);


    // will state whether a transition of the interaction model
    // is taken into account into the generated model
    // (must be true for every transition in the end)
    Graph behaviour = interaction.behaviour();
    EdgeMap<int> triggeredTransition(behaviour);

    // contains a mapping between the state of the generated model
    // and some corresponding states in the interaction model.
    // structure mainly used to complete the model in the end
    NodeMap< set<State> > stateMapping(result.behaviour());


    // for guaranteeing that any event type will be used at least once.
    vector<Event> events;
    events.reserve(result.numberOfEvents());
    copy(result.eventBegin(), result.eventEnd(), inserter(events, events.end()));
    Selection<Event> eventSelection(events);


    // common structures for visiting the state of the generated model
    // in parallel with the interaction model
    // here we suppose that the transition system has one initial state only
    list<State> stateToVisit; // BFS from the initial state
    list<State> interactingStateToVisit; // parallel exploration of the interactive model
    NodeMap<bool> inThePool(result.behaviour(), false);
    unsigned numberOfVisitedStates = 0;

    // let us start with the first state of indexState. It will
    // be the initial state of the component
    unsigned selectedIndex = stateSelection.newSelection();
    result.setInitial(indexedState[selectedIndex]);
    stateToVisit.push_back(indexedState[selectedIndex]);
    inThePool[indexedState[selectedIndex]] = true;
    stateMapping[indexedState[selectedIndex]].insert(*interaction.initialStateBegin());
    interactingStateToVisit.push_back(*interaction.initialStateBegin());

    // if outputDegreeMax is not set, let make it maximal
    if (!isSet[OUTPUTDEGREEMAX]) {
        outputDegreeMax = result.numberOfEvents();
    }

    // if outputDegreeMax is set but greater than the number of events
    // set it it to this number of events
    if (isSet[OUTPUTDEGREEMAX] && (outputDegreeMax > result.numberOfEvents())) {
        outputDegreeMax = result.numberOfEvents();
    }


    // start the transition generation
    while (!stateToVisit.empty()) {
        // current state in the model under construction
        State currentState = stateToVisit.front();
        stateToVisit.pop_front();

        // current state in the interaction model
        State currentInteractingState = interactingStateToVisit.front();
        interactingStateToVisit.pop_front();

        set<Topology::Connection> constrainedConnections;
        for (ObservableComponent::OutputTransitionIterator it = interaction.outputTransitionBegin(currentInteractingState);
                it != interaction.outputTransitionEnd(currentInteractingState);
                ++it) {
            constrainedConnections.insert(mappingInteractionToCurrentSide[interaction.getEvent(*it)]);
        }



        set<Event> selectedEvents;

        getSelectedEvents(interaction, currentInteractingState,
                mappingInteractionToCurrentSide,
                mappingCurrentSideToInteraction,
                mappingConnectionToInteraction,
                eventSelection,
                constrainedEvents,
                constrainedConnections,
                numberOfVisitedStates,
                result,
                outputDegreeMax,
                selectedEvents);

        // before creating transitions I check whether there are still unreached states.
        // If there are, I select one  as a target of a transition with the current
        // state. It is a way to be sure that every state is at least reachable from
        // the initial state by at least one transition since the current state is
        // reachable from the initial state.
        State unreachedState;
        int numberOfIterationsBefore = 0;
        if (!stateSelection.allSelected()) {
            unreachedState = indexedState[stateSelection.newSelection()];
            numberOfIterationsBefore = generateRandomValue(0, selectedEvents.size() - 1);
        }


        // generation of the target states and the transitions

        int counter = 0;
        set<Event>::const_iterator eventIt = selectedEvents.begin();
        for (unsigned i = 0; i < selectedEvents.size(); ++i) {
            State nextState;
            if ((unreachedState.valid()) &&
                    (counter == numberOfIterationsBefore)) {
                // here this is the case where the transition is created
                // to a reach a unreached state as we selected before
                nextState = unreachedState;
            } else {
                // here, this is the normal case, we choose the target state randomly
                // (between the reached and unreached ones)
                unsigned targetId = 0;
                targetId = generateRandomValue(0, numberOfStates - 1);
                // is the selected target state reached or not ?
                if (!stateSelection.hasBeenAlreadySelectedOnce(targetId)) {
                    // no it was a unreached state, make it reached now
                    stateSelection.select(targetId);
                }
                nextState = indexedState[targetId];
            }

            result.newTransition(currentState, nextState, *eventIt);

            // it is possible that this state has been already inserted as a reached state
            // in a previous iteration of this loop, in this case nothing to be done
            if (!inThePool[nextState]) {
                stateToVisit.push_back(nextState);
                inThePool[nextState] = true;

                Transition correspondingInteractionTransition =
                        getTransitionFromInteractiveCurrentState(interaction, currentInteractingState,
                        *eventIt,
                        mappingCurrentSideToInteraction,
                        mappingConnectionToInteraction,
                        constrainedEvents);
                if (correspondingInteractionTransition.valid()) {
                    // the interaction state is changing
                    interactingStateToVisit.push_back(correspondingInteractionTransition.target());
                    triggeredTransition[correspondingInteractionTransition] = 1;
                    stateMapping[nextState].insert(correspondingInteractionTransition.target());
                } else {
                    // the interaction state is not changing
                    interactingStateToVisit.push_back(currentInteractingState);
                    stateMapping[nextState].insert(currentInteractingState);
                }
            }
            ++eventIt;
            ++counter;
        }
        ++numberOfVisitedStates;
    }
    // end of the transition generation



    // Now we may have a problem. Some transitions from the interaction model may not be taken into account
    // we have to complete the generated model to make it fully consistent with the interaction model
    makeComponentFullyConsistent(result, node, sharedEventOfNode, interaction, mappingInteractionToCurrentSide,
            mappingCurrentSideToInteraction, triggeredTransition, stateMapping, outputDegreeMax, eventSelection);

    // And finally, in the worst case some events during the generation of the component did not occur
    makeComponentComplete(outputDegreeMax, eventSelection, result);
}

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

void makeComponentFullyConsistent(ObservableComponent & result,
        const Node & node,
        SharedEventNodeMap & sharedEventOfNode,
        const ObservableComponent & interaction,
        map<Event, Topology::Connection> & mappingInteractionToCurrentSide,
        map<Event, Topology::Connection> & mappingCurrentSideToInteraction,
        EdgeMap<int> & triggeredTransition,
        NodeMap< set<State> > & stateMapping,
        unsigned outputDegreeMax,
        Selection<Event> & eventSelection) {

    list<Transition> unmatchedTransitions;
    for (ObservableComponent::TransitionIterator it = interaction.transitionBegin();
            it != interaction.transitionEnd();
            ++it) {

        if (triggeredTransition[*it] == 0) {
            unmatchedTransitions.push_back(*it);
        }
    }

    while (!unmatchedTransitions.empty()) {

        Transition currentTrans = unmatchedTransitions.front();
        unmatchedTransitions.pop_front();

        // looking for a source/target states:
        list<State> potentialSourceStates;
        State possibleSource;
        State possibleTarget;
        bool stop = false;
        ObservableComponent::StateIterator stateIt = result.stateBegin();
        while (!stop && (stateIt != result.stateEnd())) {
            if (stateMapping[*stateIt].find(currentTrans.source()) != stateMapping[*stateIt].end()) {
                potentialSourceStates.push_back(*stateIt);
                // looking whether there is a possible target state for this source
                Diades::Graph::OutEdgeIterator outTransIt = stateIt->outEdgeBegin();
                bool found = false;
                while (!found && (outTransIt != stateIt->outEdgeEnd())) {

                    found = mappingCurrentSideToInteraction[result.getEvent(*outTransIt)] ==
                            mappingInteractionToCurrentSide[interaction.getEvent(currentTrans)];
                    if (found) {
                        possibleTarget = outTransIt->target();
                    }
                    ++outTransIt;
                }
                stop = found;
                if (stop) {
                    possibleSource = potentialSourceStates.back();
                }
            }
            ++stateIt;
        }
        if (stop) {
            // we found a transition in the model that matches currentEdge      
            triggeredTransition[currentTrans] = 1;
            if (stateMapping[possibleTarget].find(currentTrans.target()) == stateMapping[possibleTarget].end()) {
                stateMapping[possibleTarget].insert(currentTrans.target());
                propagateInteractingStates(result,
                        node,
                        sharedEventOfNode,
                        mappingInteractionToCurrentSide,
                        interaction, possibleTarget,
                        currentTrans.target(),
                        stateMapping);
            }
        } else {
            // we haven't found a transition we need to create a new one                        
            if (potentialSourceStates.empty()) {
                // we cannot do anything at this stage so we must push the current transition back to the
                // list and wait that a source state will appear (it will!).
                unmatchedTransitions.push_back(currentTrans);
            } else {
                // we are lucky, we found some sources
                // I just select one of them randomly and then I select a target state randomly. 
                // Since the generation is already very randomized, I just consider a deterministic
                // procedure for the rest. It can be randomized. The code would be longer and a bit
                // more complex.

                // but first we need to eliminate the source that already have the maximal output degree
                list<State> potentialSourceStatesWithCompatibleOutDeg;
                for (const State & s : potentialSourceStates) {
                    if (s.outDeg() < outputDegreeMax) {
                        potentialSourceStatesWithCompatibleOutDeg.push_back(s);
                    }
                }
                State source;
                unsigned counter = 0;
                if (potentialSourceStatesWithCompatibleOutDeg.empty()) {
                    // we are in big trouble, unsolvable problem now I emit a warning
                    cout << "WARNING: the outputDegreeMax option cannot be respected in the component " << result.name() << ",  the problem looks unsolvable to me. Te constraint is violated to ensure that the model is consistent with its neighbourhood" << endl;
                    unsigned indexSource = generateRandomValue(0, potentialSourceStates.size() - 1);
                    list<State>::const_iterator sourceIt = potentialSourceStates.begin();
                    while (counter != indexSource) {
                        ++sourceIt;
                        ++counter;
                    }
                    source = *sourceIt;
                } else {
                    unsigned indexSource = generateRandomValue(0, potentialSourceStatesWithCompatibleOutDeg.size() - 1);
                    list<State>::const_iterator sourceIt = potentialSourceStatesWithCompatibleOutDeg.begin();
                    while (counter != indexSource) {
                        ++sourceIt;
                        ++counter;
                    }
                    source = *sourceIt;
                }
                unsigned indexTarget = generateRandomValue(0, result.numberOfStates() - 1);
                counter = 0;
                ObservableComponent::StateIterator targetIt = result.stateBegin();
                while (counter != indexTarget) {
                    ++targetIt;
                    ++counter;
                }
                State target = *targetIt;
                Event eventToUse = sharedEventOfNode[node][mappingInteractionToCurrentSide[interaction.getEvent(currentTrans)]];


                result.newTransition(source, target, eventToUse);

                unsigned i = 0;
                while (eventToUse != eventSelection.getItem(i)) {
                    ++i;
                    always_assertion(FunctionException, i < eventSelection.numberOfItems(),
                            "completeObservableCom ponent: use of an event that is not recorded in the event selection. BUG.");
                }

                if (!eventSelection.hasBeenAlreadySelectedOnce(i)) {
                    eventSelection.select(i);
                }
                triggeredTransition[currentTrans] = 1;
                stateMapping[target].insert(currentTrans.target());
                propagateInteractingStates(result,
                        node,
                        sharedEventOfNode,
                        mappingInteractionToCurrentSide,
                        interaction,
                        target,
                        currentTrans.target(),
                        stateMapping);
            }
        }
    }
}

void propagateInteractingStates(ObservableComponent & result, const Node & node,
        SharedEventNodeMap & sharedEventOfNode,
        map<Event, Topology::Connection> & mappingInteractionToCurrentSide,
        const ObservableComponent & interaction,
        State state,
        State correspondingState,
        NodeMap< set<State> > & stateMapping) {

    list< pair<State, State> > stack;
    stack.push_back(make_pair(state, correspondingState));

    while (!stack.empty()) {

        State currentState = stack.back().first;
        State currentCorrespondingState = stack.back().second;
        Diades::Graph::OutEdgeIterator outTransIt = currentCorrespondingState.outEdgeBegin();
        bool stop = false;
        while ((!stop) && (outTransIt != currentCorrespondingState.outEdgeEnd())) {

            Event currentEvent = interaction.getEvent(*outTransIt);
            Event eventResultSide = sharedEventOfNode[node][mappingInteractionToCurrentSide[currentEvent]];
            Diades::Graph::OutEdgeIterator outTransIt2 = currentState.outEdgeBegin();
            bool found = false;
            State targetState;
            while ((!found) && (outTransIt2 != currentState.outEdgeEnd())) {

                found = result.getEvent(*outTransIt2) == eventResultSide;
                if (found) {
                    targetState = outTransIt2->target();
                }
                ++outTransIt2;
            }

            if (found) {
                if (stateMapping[targetState].find(outTransIt->target()) == stateMapping[targetState].end()) {
                    stateMapping[targetState].insert(outTransIt->target());
                    stack.push_back(make_pair(targetState, outTransIt->target()));
                    stop = true;
                }
            }
            ++outTransIt;
        }
        if (!stop) {
            // all the successors of the (currentState,currentCorrespondingState) are correctly tagged
            stack.pop_back();
        }
    }
}




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

void generateLatexFile(const Topology & topology,
        unsigned stateMin,
        unsigned stateMax,
        unsigned evtMin,
        unsigned evtMax,
        unsigned obsMin,
        unsigned obsMax,
        unsigned obsInteractionMin,
        unsigned obsInteractionMax,
        unsigned seed,
        unsigned outputDegreeMax,
        const string & fixedNode,
        const string & behaviourFileName,
        map<string, string> & assignedConnections,
        const ComponentNodeMap & componentOfNode,
        SharedEventNodeMap & sharedEventOfNode,
        const string & filename) {
    ofstream latexfile;
    latexfile.open(filename.c_str());
    generateLatexPreamble(topology,
            stateMin,
            stateMax,
            evtMin,
            evtMax,
            obsMin,
            obsMax,
            obsInteractionMin,
            obsInteractionMax, seed, outputDegreeMax, fixedNode, behaviourFileName, assignedConnections,
            componentOfNode,
            sharedEventOfNode,
            filename,
            latexfile);
    generateLatexTopology(topology, sharedEventOfNode, latexfile);
    generateLatexComponents(topology, sharedEventOfNode, componentOfNode, latexfile);
    generateLatexEventIndex(topology, sharedEventOfNode, componentOfNode, latexfile);
    generateLatexEpilog(latexfile);
    latexfile.close();
}

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

void generateLatexPreamble(const Topology & topology,
        unsigned stateMin,
        unsigned stateMax,
        unsigned evtMin,
        unsigned evtMax,
        unsigned obsMin,
        unsigned obsMax,
        unsigned obsInteractionMin,
        unsigned obsInteractionMax,
        unsigned seed,
        unsigned outputDegreeMax,
        const string & fixedNode,
        const string & behaviourFileName,
        map<string, string> & assignedConnections,
        const ComponentNodeMap & componentOfNode,
        SharedEventNodeMap & sharedEventOfNode,
        const string & filename,
        ofstream & latexfile) {

    latexfile << "\\documentclass[11pt]{article}" << endl;
    latexfile << "\\usepackage{array}" << endl;
    latexfile << "\\textwidth 17cm \\textheight 26cm  \\voffset -3cm \\hoffset -1.6cm" << endl;
    latexfile << "\\title{Generated discrete-event model}" << endl;
    time_t rawtime;
    time(&rawtime);
    latexfile << "\\date{" << ctime(&rawtime) << "}" << endl;
    latexfile << "\\begin{document}" << endl;
    latexfile << "\\maketitle" << endl;
    latexfile << "\\section{Introduction}" << endl;
    latexfile << "This model has been generated with the following parameters of {\\tt des\\_generate}." << endl;
    latexfile << "\\begin{center}" << endl;
    latexfile << "{\\small" << endl;
    latexfile << "\\begin{tabular}{|c|c|c|} " << endl;
    latexfile << "\\hline" << endl;
    latexfile << "Random generator seed & {\\tt --seed} & " << seed << " \\\\ " << endl;
    latexfile << "\\hline" << endl;
    latexfile << "Number of components & {\\tt --topology} & " << topology.numberOfNodes() << " \\\\ " << endl;
    latexfile << "\\hline" << endl;
    latexfile << "Minimal number of observable per component & {\\tt --obsMin} & " << obsMin << " \\\\" << endl;
    latexfile << "\\hline" << endl;
    latexfile << "Maximal number of observable events per component & {\\tt --obsMax} & " << obsMax << " \\\\" << endl;
    latexfile << "\\hline" << endl;
    latexfile << "Minimal number of non-interactive events per component & {\\tt --evtMin} & " << evtMin << " \\\\" << endl;
    latexfile << "\\hline" << endl;
    latexfile << "Maximal number of non-interactive events per component & {\\tt --evtMax} & " << evtMax << " \\\\" << endl;
    latexfile << "\\hline" << endl;
    latexfile << "Minimal number of states per component & {\\tt --stateMin} & " << stateMin << " \\\\" << endl;
    latexfile << "\\hline" << endl;
    latexfile << "Maximal number of states per component & {\\tt --stateMax} & " << stateMax << " \\\\" << endl;
    latexfile << "\\hline" << endl;
    latexfile << "Maximal number of observable interaction per component & {\\tt --obsInteractionMax} & " << obsInteractionMax << " \\\\" << endl;
    latexfile << "\\hline" << endl;
    latexfile << "Minimal number of observable interaction per component & {\\tt --obsInteractionMin} & " << obsInteractionMin << " \\\\" << endl;
    latexfile << "\\hline" << endl;
    latexfile << "Maximal number of output transitions per state & {\\tt --outputDegreeMax} & " << outputDegreeMax << " \\\\" << endl;
    latexfile << "\\hline" << endl;
    latexfile << "\\end{tabular}" << endl;
    latexfile << "}" << endl;
    latexfile << "\\end{center}" << endl;

    if (!fixedNode.empty()) {
        latexfile << "~\\\\";
        latexfile << "The topology node {\\tt " << fixedNode << "} has been fixed by the user and contains the behaviour described in the file: \\begin{center} \\verb| " << behaviourFileName << "| \\end{center}\n";
        if (assignedConnections.empty()) {
            latexfile << "No connection of the node has been assigned by the user." << endl;
        } else {
            latexfile << "Here are the connections assigned by the user:" << endl;
            for (map<string, string>::const_iterator it = assignedConnections.begin();
                    it != assignedConnections.end();
                    ++it) {
                latexfile << it->first << "$\\leftrightarrow$" << it->second << "\\\\";
            }
        }
    }
};



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

void generateLatexTopology(const Topology & topology, SharedEventNodeMap & sharedEventOfNode, ofstream & latexfile) {
    latexfile << "\\section{Topology}" << endl;
    latexfile << "\\label{sec:topology}" << endl;
    latexfile << "The topology of the system is composed of ";
    latexfile << topology.numberOfNodes();
    latexfile << " components and " << topology.numberOfConnections();
    latexfile << " connections." << endl;


    for (Topology::NodeIterator nodeIt = topology.nodeBegin();
            nodeIt != topology.nodeEnd();
            ++nodeIt) {
        latexfile << "\\paragraph{Neighbourhood of component {\\tt ";
        latexfile << topology.getNodeName(*nodeIt) << "}}~\\\\" << endl;
        if (topology.nodeConnectionBegin(*nodeIt) != topology.nodeConnectionEnd(*nodeIt)) {
            latexfile << "\\begin{enumerate}" << endl;
            for (Topology::NodeConnectionIterator connIt = topology.nodeConnectionBegin(*nodeIt);
                    connIt != topology.nodeConnectionEnd(*nodeIt);
                    ++connIt) {
                for (Topology::CliqueIterator cliqueIt = topology.cliqueBegin(*connIt);
                        cliqueIt != topology.cliqueEnd(*connIt);
                        ++cliqueIt) {
                    if (*cliqueIt != *nodeIt) {
                        latexfile << "\\item Component {\\tt " << topology.getNodeName(*cliqueIt) << "} with events {\\tt ";
                        latexfile << sharedEventOfNode[*cliqueIt][*connIt] << "}." << endl;
                    }
                }
            }
            latexfile << "\\end{enumerate}" << endl;
        }
    }
}

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

void generateLatexComponents(const Topology & topology, SharedEventNodeMap & sharedEventOfNode, const ComponentNodeMap & componentOfNode, ofstream & latexfile) {
    for (Topology::NodeIterator nodeIt = topology.nodeBegin();
            nodeIt != topology.nodeEnd();
            ++nodeIt) {
        latexfile << "\\newpage" << endl;
        latexfile << "\\subsection{Component {\\tt " << topology.getNodeName(*nodeIt) << "}}" << endl;
        latexfile << "\\label{comp:" << topology.getNodeName(*nodeIt) << "}" << endl;
        latexfile << "\\begin{center}" << endl;
        latexfile << "{\\small" << endl;
        latexfile << "\\begin{tabular}{|c|m{8cm}|}" << endl;
        latexfile << "\\hline" << endl;
        latexfile << "Number of states & " << componentOfNode[*nodeIt]->numberOfStates() << " \\\\" << endl;
        latexfile << "\\hline" << endl;
        latexfile << "Number of Transitions & " << componentOfNode[*nodeIt]->numberOfTransitions() << " \\\\" << endl;
        latexfile << "\\hline" << endl;
        latexfile << "Interactive events & {\\tt ";
        set<Event> interactives;
        for (map<Topology::Connection, Event>::const_iterator it = sharedEventOfNode[*nodeIt].begin();
                it != sharedEventOfNode[*nodeIt].end();
                ++it) {
            latexfile << "\\verb|" << it->second << "| ";
            interactives.insert(it->second);
        }
        latexfile << "} \\\\" << endl;
        latexfile << "\\hline" << endl;
        latexfile << "Observable events & {\\tt ";
        ObservableComponent::EventIterator it = componentOfNode[*nodeIt]->observableBegin();
        ++it;
        for (;
                it != componentOfNode[*nodeIt]->observableEnd();
                ++it) {
            latexfile << "\\verb|" << *it << "| ";
        }
        latexfile << "} \\\\" << endl;
        latexfile << "\\hline" << endl;
        latexfile << "Non-interactive events & {\\tt ";
        for (ObservableComponent::EventIterator it = componentOfNode[*nodeIt]->eventBegin();
                it != componentOfNode[*nodeIt]->eventEnd();
                ++it) {
            if (interactives.find(*it) == interactives.end()) {
                latexfile << "\\verb|" << *it << "| ";
            }
        }
        latexfile << "} \\\\" << endl;
        latexfile << "\\hline" << endl;
        latexfile << "\\end{tabular} }" << endl << endl;
        latexfile << "\\end{center}" << endl << endl << endl;
        latexfile << "\\paragraph{Initial state:} $" << componentOfNode[*nodeIt]->getLabel(*componentOfNode[*nodeIt]->initialStateBegin()) << "$" << endl;
        latexfile << "\\paragraph{Transition system:}" << endl;
        if (componentOfNode[*nodeIt]->numberOfStates() > 10) {
            latexfile << "Note: as the number of states is greater than 10, only transitions involved in the first 10 states are printed." << endl;
        }

        vector<Node> printedNodes(1);
        printedNodes[0] = *componentOfNode[*nodeIt]->initialStateBegin();
        map<Node, int> mappingNodes;
        mappingNodes[*componentOfNode[*nodeIt]->initialStateBegin()] = 0;
        list<Node> visitingNodes;
        visitingNodes.push_back(*componentOfNode[*nodeIt]->initialStateBegin());
        int stateNb = 1;
        while ((!visitingNodes.empty()) && (stateNb < 10)) {
            Node currentState = visitingNodes.front();
            visitingNodes.pop_front();
            ObservableComponent::OutputTransitionIterator outTransIt = componentOfNode[*nodeIt]->outputTransitionBegin(currentState);
            while ((stateNb < 10) && (outTransIt != componentOfNode[*nodeIt]->outputTransitionEnd(currentState))) {
                if (mappingNodes.find(outTransIt->target()) == mappingNodes.end()) {
                    ++stateNb;
                    printedNodes.push_back(outTransIt->target());
                    mappingNodes[printedNodes.back()] = printedNodes.size() - 1;
                    visitingNodes.push_back(outTransIt->target());
                }
                ++outTransIt;
            }
        }

        latexfile << "\\begin{center}" << endl;
        latexfile << "{\\small" << endl;

        latexfile << "\\begin{tabular}{|c";
        for (unsigned i = 0; i < printedNodes.size(); ++i) {
            latexfile << "|m{1cm}";
        }
        latexfile << "|}" << endl;
        latexfile << "\\hline" << endl;
        for (unsigned i = 0; i < printedNodes.size(); ++i) {
            latexfile << " &  {\\bf $" << componentOfNode[*nodeIt]->getLabel(printedNodes[i]) << "$}";
        }
        latexfile << "\\\\" << endl;
        latexfile << "\\hline" << endl;
        for (unsigned i = 0; i < printedNodes.size(); ++i) {
            latexfile << "{\\bf $" << componentOfNode[*nodeIt]->getLabel(printedNodes[i]) << "$}";
            map< State, set<string> > outEvents;
            for (ObservableComponent::OutputTransitionIterator outTransIt = componentOfNode[*nodeIt]->outputTransitionBegin(printedNodes[i]);
                    outTransIt != componentOfNode[*nodeIt]->outputTransitionEnd(printedNodes[i]);
                    ++outTransIt) {
                if (mappingNodes.find(outTransIt->target()) != mappingNodes.end()) {
                    outEvents[outTransIt->target()].insert(componentOfNode[*nodeIt]->getEvent(*outTransIt).nickname());
                }
            }
            for (unsigned j = 0; j < printedNodes.size(); ++j) {
                latexfile << " &  ";
                for (set<string>::const_iterator stringIt = outEvents[printedNodes[j]].begin();
                        stringIt != outEvents[printedNodes[j]].end();
                        ++stringIt) {
                    latexfile << "\\verb|" << *stringIt << "| ";
                }
            }
            latexfile << "\\\\" << endl;
            latexfile << "\\hline" << endl;

        }

        latexfile << "\\end{tabular}";
        latexfile << "}" << endl;
        latexfile << "\\end{center}";
    }

}

\


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

void generateLatexEpilog(ofstream & latexfile) {
    latexfile << "\\end{document}" << endl;
}


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

void exportTopologyMap(const Topology & topology,
        SharedEventNodeMap & sharedEventOfNode,
        const ComponentNodeMap & componentOfNode,
        const string & mapTopoFileNameDest) {
    TopologyMap mapping(topology);
    for (Topology::NodeIterator it = topology.nodeBegin();
            it != topology.nodeEnd();
            ++it) {
        mapping.mapComponentToNode(*componentOfNode[*it], *it);
    }
    for (Topology::ConnectionIterator it = topology.connectionBegin();
            it != topology.connectionEnd();
            ++it) {
        for (Topology::CliqueIterator it2 = topology.cliqueBegin(*it);
                it2 != topology.cliqueEnd(*it);
                ++it2) {
            mapping.addConnection(*it, *it2, sharedEventOfNode[*it2][*it]);
        }
    }
    mapping.exportMap(mapTopoFileNameDest);
}


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

void writeComponent(const ObservableComponent & component,
        const string & dirName) {
    string compFileNameDest = dirName + "/" + component.name() + ".des_comp";
    verbose<VbOutput>("Writing the file %1%...") % compFileNameDest;
    component.exportDesCompModel(compFileNameDest);
    verbose<VbOutput>("done.\n");
    string compFileNameDestDot = dirName + "/" + component.name() + ".dot";
    verbose<VbOutput>("Writing the file %1%...") % compFileNameDestDot;
    component.component2dot(compFileNameDestDot);
    verbose<VbOutput>("done.\n");
}

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

void propagateConstrainedInteractions(const Topology & topology,
        Topology::Node node,
        Diades::Graph::ConstNodeMap<int> & visitedNodes,
        set<Topology::Node> & generatedNeighbours,
        set<Topology::Node> & nonGeneratedNeighbours,
        list<Topology::Node> & nodesToVisit) {
    for (Topology::NodeConnectionIterator it = topology.nodeConnectionBegin(node);
            it != topology.nodeConnectionEnd(node);
            ++it) {
        for (Topology::CliqueIterator cliqueIt = topology.cliqueBegin(*it);
                cliqueIt != topology.cliqueEnd(*it);
                ++cliqueIt) {
            switch (visitedNodes[*cliqueIt]) {
                case 0: // not visited
                {
                    nodesToVisit.push_back(*cliqueIt);
                    visitedNodes[*cliqueIt] = 1;
                    if (node != *cliqueIt) {
                        nonGeneratedNeighbours.insert(*cliqueIt);
                    }
                    break;
                }
                case 1: // visited 
                {
                    if (node != *cliqueIt) {
                        nonGeneratedNeighbours.insert(*cliqueIt);
                    }
                    break;
                }
                case 2: // saturated
                {
                    if (node != *cliqueIt) {
                        generatedNeighbours.insert(*cliqueIt);
                    }
                    break;
                }
                default:
                {
                    throw (FunctionException("propagateConstrainedInteractions", "The status of a node is neither 'not visited', 'visited', 'generated', BUG"));
                }
            }
        }
    }
}

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

void printDebugStartVisit(const Topology & topology, Topology::Node node) {
    verbose<VbDebug>("************************************************\n");
    verbose<VbDebug>("Generation of %1%  based on P_{%2%}(")
            % topology.getNodeName(node).str()
            % topology.getNodeName(node).str();
}

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

void printDebugProjectionOnGeneratedNeighbours(const set<Topology::Node> & generatedNeighbours,
        const Diades::Graph::NodeMap< pair<string, ObservableComponent *> > & projection) {
    // projection on inputs
    for (set<Node>::const_iterator inIt = generatedNeighbours.begin(); inIt != generatedNeighbours.end(); ++inIt) {
        verbose<VbDebug>("%1% ") % projection[*inIt].second->name();
        set<Node>::const_iterator nextInIt = inIt;
        ++nextInIt;
        if (nextInIt != generatedNeighbours.end()) {
            verbose<VbDebug>(" || ");
        }
    }
    verbose<VbDebug>(")\n");
}

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

void initialiseSynchronisationRules(const Topology & topology,
        set<Node>::const_iterator first,
        set<Node>::const_iterator last,
        SharedEventNodeMap & sharedEventOfNode,
        const Diades::Graph::ConstNodeMap< pair<string, ObservableComponent *> > & projection,
        ParametrizedSynchronisation & synchronisation) {

    for (set<Node>::const_iterator it = first; it != last; ++it) {
        set<Node>::const_iterator nextIt = it;
        ++nextIt;
        for (Topology::NodeConnectionIterator it2 = topology.nodeConnectionBegin(*it);
                it2 != topology.nodeConnectionEnd(*it);
                ++it2) {

            vector<Event> synchronisedEvents;
            verbose<VbDebug>("synchronised events: {");
            if (projection[*it].second->containsEvent(sharedEventOfNode[*it][*it2])) {
                synchronisedEvents.push_back(sharedEventOfNode[*it][*it2]);
                for (Topology::CliqueIterator it3 = topology.cliqueBegin(*it2);
                        it3 != topology.cliqueEnd(*it2);
                        ++it3) {

                    if (find(nextIt, last, *it3) != last) {
                        if (projection[*it3].second->containsEvent(sharedEventOfNode[*it3][*it2])) {
                            verbose<VbDebug>("%1%.%2%") % topology.getNodeName(*it3).str() % sharedEventOfNode[*it3][*it2].label();
                            synchronisedEvents.push_back(sharedEventOfNode[*it3][*it2]);
                        }
                    }
                }
                synchronisation.synchronise(synchronisedEvents);
            }
            verbose<VbDebug>("}.\n");
        }
    }
    synchronisation.close();
}

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

void printDebugLaw(const ParametrizedSynchronisation & synchronisation) {
    stringstream law;
    law << synchronisation;
    verbose<VbDebug>("getSynchronisedInteraction: composition of the input interactions based on the following synchronisation law:\n %1%\n") % law.str();
}

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

void generateNonInteractiveEvents(const Topology & topology,
        Topology::Node node,
        unsigned evtMin,
        unsigned evtMax,
        unsigned obsMin,
        unsigned obsInteractionMax,
        ObservableComponent & result,
        set<Event> & nonInteractiveEvents) {
    always_require(FunctionException, evtMin <= evtMax, "generateNonInteractiveEvents: evtMin > evtMax.");
    always_require(FunctionException, obsMin <= evtMax, "generateNonInteractiveEvents: obsMin > evtMax.");
    always_require(FunctionException, obsInteractionMax <= evtMax, "generateNonInteractiveEvents: obsInteractionMax <=evtMax.");
    always_require(FunctionException, result.numberOfEvents() <= evtMax, "generateNonInteractiveEvents: there is more interactive events in this component that evtMax.");

    unsigned minimumNumberOfNonInteractiveEvents = 0;
    if (obsMin > obsInteractionMax) {
        minimumNumberOfNonInteractiveEvents = obsMin - obsInteractionMax;
    }
    if (result.numberOfEvents() <= evtMin) {
        if ((evtMin - result.numberOfEvents()) > (minimumNumberOfNonInteractiveEvents)) {
            minimumNumberOfNonInteractiveEvents = (evtMin - result.numberOfEvents());
        }
    }
    always_assertion(FunctionException, minimumNumberOfNonInteractiveEvents <= evtMax - result.numberOfEvents(),
            "generateNonInteractiveEvents: impossible case, minimumNumberOfNonInteractiveEvents > evtMax-result->numberOfEvents().BUG");

    unsigned numberOfNonInteractiveEvents =
            generateRandomValue(minimumNumberOfNonInteractiveEvents, evtMax - result.numberOfEvents());

    unsigned numberOfEvents =
            result.numberOfEvents() + numberOfNonInteractiveEvents;

    while (result.numberOfEvents() < numberOfEvents) {
        stringstream stream;
        stream << topology.getNodeName(node) << ".e" << eventNumber;
        Event evt = EventFactory::factory()->getEvent(stream.str());
        stringstream nickname;
        nickname << "e" << eventNumber;
        evt.setNickname(nickname.str());
        result.insertEvent(evt);
        nonInteractiveEvents.insert(evt);
        ++eventNumber;
    }
    always_ensure(FunctionException, nonInteractiveEvents.size() == numberOfNonInteractiveEvents,
            "generateNonInteractiveEvents: BUG wrong number of generated events");
}

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

void defineObservableMask(unsigned obsMin, unsigned obsMax, unsigned obsInteractionMin,
        unsigned obsInteractionMax, const set<Event> & interactiveEvents,
        const set<Event> & nonInteractiveEvents,
        ObservableComponent & result) {
    always_require(FunctionException, obsMin <= obsMax, "defineObservableMask: obsMin > obsMax.");
    always_require(FunctionException, obsInteractionMin <= obsInteractionMax,
            "defineObservableMask: obsInteractionMin > obsInteractionMax.");
    always_require(FunctionException, interactiveEvents.size() + nonInteractiveEvents.size() == result.numberOfEvents(),
            "defineObservableMask: interactiveEvents.size() + nonInteractiveEvents.size() != result.numberOfEvents().");
    always_require(FunctionException, obsInteractionMin <= interactiveEvents.size(), "defineObservableMask: obsInteractionMin > interactiveEvents.size()");
    always_require(FunctionException, obsInteractionMin <= obsMin, "defineObservableMask: obsInteractionMin > obsMin");
    always_require(FunctionException, obsInteractionMax <= obsMax, "defineObservableMask: obsInteractionMax > obsMax");
    always_require(FunctionException, obsMin <= result.numberOfEvents(), "defineObservableMask: obsMin>result.numberOfEvents()");




    //  // Let define the observable mask
    //  unsigned int maxOfMin =  obsInteractionMin < obsMin ? obsMin : obsInteractionMin;
    //  always_assertion(FunctionException, maxOfMin >= obsMin, "defineObservableMask:  maxOfMin < obsMin.");


    //  unsigned int minOfMax = (obsMax<(result.numberOfEvents()))?obsMax:result.numberOfEvents();
    //  always_assertion(FunctionException, minOfMax <= obsMax, "defineObservableMask: minOfMax > obsMax.");
    //  always_assertion(FunctionException, maxOfMin <= minOfMax, "defineObservableMask: maxOfMin > minOfMax.");

    //  unsigned int numberOfObservableEvents = generateRandomValue( maxOfMin, minOfMax );


    //  unsigned int interactiveMinOfMax = obsInteractionMax < numberOfObservableEvents ? obsInteractionMax : numberOfObservableEvents;
    //  if(interactiveMinOfMax > interactiveEvents.size())
    //  {
    //    interactiveMinOfMax = interactiveEvents.size();
    //  }
    // always_assertion(FunctionException,interactiveMinOfMax <= interactiveEvents.size(),
    //                            "defineObservableMask:interactiveMinOfMax > interactiveEvents.size().");

    //  always_assertion(FunctionException,interactiveMinOfMax <= obsInteractionMax,
    //                             "defineObservableMask:interactiveMinOfMax > obsInteractionMax.");
    //  always_assertion(FunctionException,  obsInteractionMin<=  interactiveMinOfMax,
    //                             "defineObservableMask:obsInteractionMin > interactiveMinOfMax.");

    //  unsigned int numberOfObservableInteractions = generateRandomValue(obsInteractionMin,interactiveMinOfMax);
    //  always_assertion(FunctionException, numberOfObservableEvents>= numberOfObservableInteractions,
    //                             "defineObservableMask:numberOfObservableEvents< numberOfObservableInteractions.");

    //  unsigned int numberOfObservableNonInteractiveEvents = numberOfObservableEvents - numberOfObservableInteractions;



    unsigned int numberOfObservableInteractions = 0;
    if (obsMin - obsInteractionMin > nonInteractiveEvents.size()) {
        numberOfObservableInteractions = generateRandomValue(max((unsigned) obsInteractionMin, (unsigned) (obsMin - obsInteractionMin - nonInteractiveEvents.size())), min((unsigned) interactiveEvents.size(), (unsigned) obsInteractionMax));
    } else {
        numberOfObservableInteractions = generateRandomValue(obsInteractionMin, min((unsigned) interactiveEvents.size(), (unsigned) obsInteractionMax));
    }

    unsigned numberOfObservableNonInteractiveEvents = 0;
    if (obsMin > numberOfObservableInteractions) {
        numberOfObservableNonInteractiveEvents = generateRandomValue(obsMin - numberOfObservableInteractions,
                min((unsigned) obsMax - numberOfObservableInteractions, (unsigned) nonInteractiveEvents.size()));
    } else {
        numberOfObservableNonInteractiveEvents = generateRandomValue(0,
                min((unsigned) obsMax - numberOfObservableInteractions, (unsigned) nonInteractiveEvents.size()));
    }


    debug(log<LgDebug>("numberOfObservableEvents = %1%\n  numberOfObservableInteractions = %2%\n numberOfObservableNonInteractiveEvents = %3%")
            % (numberOfObservableInteractions + numberOfObservableNonInteractiveEvents)
            % numberOfObservableInteractions
            % numberOfObservableNonInteractiveEvents);

    always_assertion(FunctionException, numberOfObservableInteractions <= obsInteractionMax,
            "defineObservableMask: numberOfObservableInteractions > obsInteractionMax");
    always_assertion(FunctionException, numberOfObservableInteractions >= obsInteractionMin,
            "defineObservableMask: numberOfObservableInteractions < obsInteractionMin");
    always_assertion(FunctionException, numberOfObservableInteractions + numberOfObservableNonInteractiveEvents >= obsMin,
            "defineObservableMask: numberOfObservables < obsMin");
    always_assertion(FunctionException, numberOfObservableInteractions + numberOfObservableNonInteractiveEvents <= obsMax,
            "defineObservableMask: numberOfObservables > obsMin");
    always_assertion(FunctionException, numberOfObservableInteractions <= interactiveEvents.size(),
            "defineObservableMask: numberOfObservableInteractions > interactiveEvents.size()");
    always_assertion(FunctionException, numberOfObservableNonInteractiveEvents <= nonInteractiveEvents.size(),
            "defineObservableMask: numberOfObservableNonInteractiveEvents > nonInteractiveEvents.size()");

    ObservableMask mask;
    for (ObservableComponent::EventIterator it = result.eventBegin();
            it != result.eventEnd();
            ++it) {
        mask.makeUnobservable(*it);
    }


    list<Event> selectedEvents;
    selectNRandomElements(interactiveEvents.begin(),
            interactiveEvents.end(),
            Diades::Utils::AlwaysTrue<Event>(),
            numberOfObservableInteractions,
            inserter(selectedEvents, selectedEvents.end()));


    // selection of non interactive observable events
    if (!nonInteractiveEvents.empty()) {

        always_assertion(FunctionException, numberOfObservableNonInteractiveEvents <= nonInteractiveEvents.size(),
                "defineObservableMask: numberOfObservableNonInteractiveEvents > nonInteractiveEvents.size()");
        selectNRandomElements(nonInteractiveEvents.begin(),
                nonInteractiveEvents.end(),
                Diades::Utils::AlwaysTrue<Event>(),
                numberOfObservableNonInteractiveEvents,
                inserter(selectedEvents, selectedEvents.end()));
    }

    for (const Event & e : selectedEvents) {
        mask.removeMask(e,mask.noEvent());
        mask.addMask(e, e);
    }

    result.setMask(mask);
    ensure(FunctionException, selectedEvents.size() == numberOfObservableNonInteractiveEvents + numberOfObservableInteractions,
            "defineObservableMask: selectedEvents.size() != numberOfObservableNonInteractiveEvents + numberOfObservableInteractions.");
    ensure(FunctionException,
            result.mask().numberOfIdentifiableEvents() == numberOfObservableNonInteractiveEvents + numberOfObservableInteractions,
            Msg("defineObservableMask: result.mask().numberOfIdentifiableEvents() (%1%) != numberOfObservableNonInteractiveEvents (%2%) + numberOfObservableInteractions (%3%).")
            % result.mask().numberOfIdentifiableEvents() % numberOfObservableNonInteractiveEvents % numberOfObservableInteractions);
    
}

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

Transition getTransitionFromInteractiveCurrentState(const ObservableComponent & interaction,
        State currentInteractingState,
        const Event & eventCurrentNode,
        map<Event, Topology::Connection> & mappingCurrentSideToInteraction,
        map<Topology::Connection, Event> & mappingConnectionToInteraction,
        const set<Event> & constrainedEvents) {
    always_require(FunctionException, currentInteractingState.valid(), "getTransitionFromInteractiveCurrentState: invalid state");
    Transition result;
    map<Event, Topology::Connection>::const_iterator connIt = mappingCurrentSideToInteraction.find(eventCurrentNode);

    if ((constrainedEvents.find(eventCurrentNode) != constrainedEvents.end())
            &&
            (connIt != mappingCurrentSideToInteraction.end())) {

        // there is a transition from currentInteractingState in interaction associated to  eventFromCurrentNode
        ObservableComponent::OutputTransitionIterator outTransIt = interaction.outputTransitionBegin(currentInteractingState);
        bool found = false;
        Event eventInteractionSide = mappingConnectionToInteraction[connIt->second];

        while ((!found) && (outTransIt != interaction.outputTransitionEnd(currentInteractingState))) {

            found = (interaction.getEvent(*outTransIt)) == eventInteractionSide;
            if (!found) {
                ++outTransIt;
            }
        }
        always_assertion(FunctionException, found, "getTransitionFromInteractiveCurrentState: This case is impossible :-(, an event from the interaction should be triggered but it does not exist : bug probably in getSelectedEvents.");
        result = *outTransIt;
    }
    return result;
}



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

bool makeMinimalRequirement(unsigned outputDegreeMax, Selection<Event> & eventSelection,
        vector<State> & candidates, ObservableComponent & result) {
    bool solution = !candidates.empty();
    Selection<Event>::IndexIterator indexIt = eventSelection.nonSelectedIndexBegin();
    while (solution &&
            (indexIt != eventSelection.nonSelectedIndexEnd())) {
        unsigned int index = generateRandomValue(0, candidates.size() - 1);
        State source = candidates[index];
        ObservableComponent::StateIterator targetIt = selectRandomElement(result.numberOfStates(),
                result.stateBegin(),
                result.stateEnd());


        result.newTransition(source, *targetIt, eventSelection.getItem(*indexIt));
        if (source.outDeg() == outputDegreeMax) {
            candidates[index] = candidates[candidates.size() - 1];
            candidates.pop_back();
        }
        solution = !candidates.empty();
        ++indexIt;
    }
    if (!solution) {
        bool isViolated = indexIt != eventSelection.nonSelectedIndexEnd();
        while (indexIt != eventSelection.nonSelectedIndexEnd()) {
            // this is the case where there is no more solution,
            // we violate the outputDegreeMax constraint
            ObservableComponent::StateIterator sourceIt = selectRandomElement(result.numberOfStates(),
                    result.stateBegin(),
                    result.stateEnd());

            ObservableComponent::StateIterator targetIt = selectRandomElement(result.numberOfStates(),
                    result.stateBegin(),
                    result.stateEnd());


            result.newTransition(*sourceIt, *targetIt, eventSelection.getItem(*indexIt));
            ++indexIt;
        }
        if (isViolated) {
            // I tried my best, I give up, I violate the outputDegreeMax condition
            cout << "WARNING, the outputDegreeMax parameter is violated in component " << result.name() << endl;
        }
    }
    return solution;
}


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

void makeComponentComplete(unsigned outputDegreeMax, Selection<Event> & eventSelection, ObservableComponent & result) {
    vector<State> candidates;
    candidates.reserve(result.numberOfStates());
    for (ObservableComponent::StateIterator stateIt = result.stateBegin();
            stateIt != result.stateEnd();
            ++stateIt) {
        if (stateIt->outDeg() < outputDegreeMax) {
            candidates.push_back(*stateIt);
        }
    }
    if (makeMinimalRequirement(outputDegreeMax, eventSelection, candidates, result)) {
        // yeah we are safe all the constraints are ok, let now be a bit more random
        // without constraint violation
        while ((!candidates.empty())
                &&
                (!eventSelection.allSelected())) {
            // now we really select the events
            Event event = eventSelection.getItem(eventSelection.newSelection());
            unsigned nbTransForThisEvent = generateRandomValue(1, candidates.size());
            set<unsigned> sourceSelection;
            selectNValues(0, candidates.size() - 1, nbTransForThisEvent, sourceSelection);
            for (set<unsigned>::const_reverse_iterator selectionIt = sourceSelection.rbegin();
                    selectionIt != sourceSelection.rend(); ++selectionIt) {
                ObservableComponent::StateIterator targetIt = selectRandomElement(result.numberOfStates(),
                        result.stateBegin(),
                        result.stateEnd());
                // it may happen that the source state already has an output transition
                // with this event. In this case, I simply do not add the new one
                // to keep the model deterministic
                if (result.outputEventTransitionBegin(candidates[*selectionIt], event)
                        == result.outputEventTransitionEnd(candidates[*selectionIt], event)) {
                    result.newTransition(candidates[*selectionIt], *targetIt, event);
                    if (candidates[*selectionIt].outDeg() == outputDegreeMax) {
                        candidates[*selectionIt] = candidates[candidates.size() - 1];
                        candidates.pop_back();
                    }
                }
            }

        }
    }
}

void generateLatexEventIndex(const Topology & topology,
        SharedEventNodeMap & sharedEventOfNode,
        const ComponentNodeMap & componentOfNode, ofstream & latexfile) {
    latexfile << "\n \\section{Event index}" << endl;
    map<Event, pair<Node, bool> > infoEvents;
    map<Event, pair < Topology::Connection, pair<Node, bool> > > infoSharedEvents;
    for (Topology::NodeIterator nodeIt = topology.nodeBegin();
            nodeIt != topology.nodeEnd();
            ++nodeIt) {
        for (map<Topology::Connection, Event>::const_iterator cit = sharedEventOfNode[*nodeIt].begin();
                cit != sharedEventOfNode[*nodeIt].end();
                ++cit) {
            infoSharedEvents[cit->second] = make_pair(cit->first, make_pair(*nodeIt, componentOfNode[*nodeIt]->mask().isIdentifiable(cit->second)));
        }
        for (ObservableComponent::EventIterator eventIt = componentOfNode[*nodeIt]->eventBegin();
                eventIt != componentOfNode[*nodeIt]->eventEnd();
                ++eventIt) {
            if (infoSharedEvents.find(*eventIt) == infoSharedEvents.end()) {
                infoEvents[*eventIt] = make_pair(*nodeIt, componentOfNode[*nodeIt]->mask().isIdentifiable(*eventIt));
            }
        }
    }
    latexfile << "\\subsection{Non shared events}" << endl;
    latexfile << "\n Here are the set of non-shared events of the generated model associated" << endl;
    latexfile << " with the component where each of them occurs. The event may be observable or not.\\\\" << endl;

    for (map < Event, pair < Node, bool> >::const_iterator it = infoEvents.begin();
            it != infoEvents.end();
            ++it) {
        latexfile << "{\\tt " << it->first.nickname() << "}: " << "{\\tt " << topology.getNodeName(it->second.first) << "} ";
        if (it->second.second) {
            latexfile << ", observable";
        }
        latexfile << "~\\\\" << endl;
    }
    latexfile << "\\subsection{Shared events}" << endl;
    latexfile << "\n Here are the set of shared events of the generated model associated" << endl;
    latexfile << " with the component where each of them occurs, the connection label involved with the event";
    latexfile << " followed by the clique of components involved in the connection. The event may be observable or not.\\\\" << endl;



    for (map < Event, pair < Topology::Connection, pair < Node, bool> > >::const_iterator it = infoSharedEvents.begin();
            it != infoSharedEvents.end();
            ++it) {
        latexfile << "{\\tt " << it->first.nickname() << "}: " << "{\\tt " << topology.getNodeName(it->second.second.first) << "}, ";
        latexfile << "{\\tt " << topology.getConnectionLabel(it->second.first) << "} $\\{$";

        for (Topology::CliqueIterator cliqueIt = topology.cliqueBegin(it->second.first);
                cliqueIt != topology.cliqueEnd(it->second.first);
                ++cliqueIt) {
            latexfile << "{\\tt " << topology.getNodeName(*cliqueIt) << "} ";
        }
        latexfile << "$\\}$";
        if (it->second.second.second) {
            latexfile << ", observable";
        }
        latexfile << "~\\\\" << endl;
    }
}