Simulator.cc

Go to the documentation of this file.

#include <diades/utils/Exceptions.hh>
#include <diades/utils/Random.hh>
#include <diades/utils/Functors.hh>
#include <diades/automata/Trace.hh>
#include "Simulator.hh"

using namespace std;
using namespace Diades::Utils;

namespace Diades {
    namespace Automata {

        void randomSimulateState(const ObservableComponent & component,
                State source,
                const set<Event> & noEvents,
                unsigned obsMin,
                unsigned obsMax, unsigned depth,
                list<Event> & simulation) {
            if (obsMin == 0) {
                // the simulation has reached the required minimum
                if (obsMax != 0) {
                    // let now generate the effective number of observable
                    // we want to generate
                    unsigned nbObsLeft = generateRandomValue(0, obsMax);
                    if (nbObsLeft != 0) {
                        randomSimulateState(component, source, noEvents, nbObsLeft, nbObsLeft, depth, simulation);
                    }
                    //else stop
                }
                //else stop
            } else {
                if (depth > 2 * component.numberOfTransitions()) {
                    throw (FunctionException("randomSimulateState",
                            "simulated twice the number of transitions of the component and still no observable transitions: the simulation is very likely in an unobservable deadend. Give up for the beauty of randomness."));
                } else {
                    Component::OutputTransitionIterator transIt = selectRandomElement(component.outputTransitionBegin(source),
                            component.outputTransitionEnd(source),
                            fgx(isNotIn(noEvents.begin(), noEvents.end()),
                            GetEvent(component)));
                    if (transIt == component.outputTransitionEnd(source)) {
                        stringstream msg;
                        msg << "Reaching the state " << component.getLabel(source);
                        if (source.outDeg() == 0) {
                            msg << " but it has no output events. Simulation stopped" << std::endl;
                        } else {
                            msg << " but it has only fordidden events as output events, cannot go futher. Simulation stopped"
                                    << endl << "Output events of the last state:" << endl;

                            for (Component::OutputTransitionIterator it = component.outputTransitionBegin(source);
                                    it != component.outputTransitionEnd(source);
                                    ++it) {
                                msg << component.getEvent(*it) << std::endl;
                            }
                        }
                        std::cerr << "WARNING: " << msg.str() << std::endl;
                    } else {
                        Transition transition = *transIt;
                        simulation.push_back(component.getEvent(transition));
                        if (component.mask().isObservable(component.getEvent(transition))) {
                            depth = 0;
                            --obsMin;
                            --obsMax;
                        } else {
                            ++depth;
                        }
                        randomSimulateState(component, transition.target(), noEvents, obsMin, obsMax, depth, simulation);
                    }
                }
            }
        }

        void randomSimulate(const ObservableComponent & component,
                const set<Event> & noEvents,
                unsigned obsMin,
                unsigned obsMax,
                list<Event> & simulation) {
            // select randomly an initial state
            State state = *selectRandomElement(component.numberOfInitialStates(),
                    component.initialStateBegin(),
                    component.initialStateEnd());

            randomSimulateState(component, state, noEvents, obsMin, obsMax, 0, simulation);
        }

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

        void reallySimulate(const ObservableComponent & component,
                const set<Event> & noEvents,
                unsigned obsMin,
                unsigned obsMax,
                list<Event> & simulation) {
            randomSimulate(component, noEvents, obsMin, obsMax, simulation);
        }


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

        bool getEvents(const Component & component,
                const set<string> & labels,
                set<Event> & events) {
            set<string> labelsLeft = labels;
            ObservableComponent::EventIterator eventIt = component.eventBegin();
            while ((!labelsLeft.empty()) && (eventIt != component.eventEnd())) {
                set<string>::iterator labelIt = labelsLeft.find(eventIt->label());
                if (labelIt == labelsLeft.end()) {
                    labelIt = labelsLeft.find(eventIt->nickname());
                }
                if (labelIt != labelsLeft.end()) {
                    events.insert(*eventIt);
                    labelsLeft.erase(labelIt);
                }
                ++eventIt;
            }

            return labelsLeft.empty();
        }


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

        bool simulate(const ObservableComponent & component,
                const set<string> & absentEvents,
                unsigned obsMin,
                unsigned obsMax,
                unsigned seed,
                list<Event> & simulation) {
            bool result = true;
            try {

                set<Event> noEvents;
                getEvents(component, absentEvents, noEvents);


                // initialise the random generator
                initialiseRandomGenerator(seed);

                // get normal obsMin and obsMax if not initialised
                if (obsMax < obsMin) {
                    throw (FunctionException("simulate", "Please check obsMin and obsMax, they are inconsistent."));
                }
                if (obsMin == 0) {
                    obsMin = 1;
                }
                if (obsMax == 0) {
                    obsMax = 100;
                }

                //let start the real job
                reallySimulate(component, noEvents, obsMin, obsMax, simulation);
            } catch (exception & e) {
                log<LgProcess>("The function 'simulate' caught the exception: \n\t%1%") % e.what();
                result = false;
            }
            return result;
        }


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

        void randomSimulateState(ComposableModel & composable,
                const ObservableMask & mask,
                State source,
                const set<Event> & noEvents,
                unsigned obsMin,
                unsigned obsMax, unsigned depth,
                list<Event> & simulation) {
            if (obsMin == 0) {
                // the simulation has reached the required minimum
                if (obsMax != 0) {
                    // let now generate the effective number of observable
                    // we want to generate
                    unsigned nbObsLeft = generateRandomValue(0, obsMax);
                    if (nbObsLeft != 0) {
                        randomSimulateState(composable, mask, source, noEvents, nbObsLeft, nbObsLeft, depth, simulation);
                    }
                    //else stop
                }
                //else stop
            } else {
                if (depth > 200) {
                    throw (FunctionException("randomSimulateState",
                            "simulated 200 transitions of the model and still no observable transitions: the simulation is very likely in an unobservable deadend. Give up for the beauty of randomness."));
                } else {
                    ComposableModel::OutputTransitionIterator transIt = selectRandomElement(composable.outputTransitionBegin(source),
                            composable.outputTransitionEnd(source),
                            fgx(isNotIn(noEvents.begin(), noEvents.end()),
                            GetEvent(composable.component())));
                    if (transIt == composable.outputTransitionEnd(source)) {
                        stringstream msg;
                        msg << "Reaching the state " << composable.component().getLabel(source);

                        if (source.outDeg() == 0) {
                            msg << " but it has no output events. Simulation stopped" << std::endl;
                        } else {
                            msg << " but it has only fordidden events as output events, cannot go futher. Simulation stopped"
                                    << endl << "Output events of the last state:" << endl;

                            for (Component::OutputTransitionIterator it = composable.component().outputTransitionBegin(source);
                                    it != composable.component().outputTransitionEnd(source);
                                    ++it) {
                                msg << composable.component().getEvent(*it) << std::endl;
                            }
                        }
                        std::cerr << "WARNING: " << msg.str() << std::endl;
                    } else {
                        Transition transition = *transIt;
                        simulation.push_back(composable.component().getEvent(transition));
                        if (mask.isObservable(composable.component().getEvent(transition)))
 {
                            depth = 0;
                            --obsMin;
                            --obsMax;
                        }
                        else {
                            ++depth;
                        }
                        randomSimulateState(composable, mask, transition.target(), noEvents, obsMin, obsMax, depth, simulation);
                    }
                }
            }
        }


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

        void randomSimulate(ComposableModel & composable,
                const ObservableMask & mask,
                const set<Event> & noEvents,
                unsigned obsMin,
                unsigned obsMax,
                list<Event> & simulation) {
            // select randomly an initial state
            State state = *selectRandomElement(composable.numberOfInitialStates(),
                    composable.beginOfInitialStates(),
                    composable.endOfInitialStates());

            randomSimulateState(composable, mask, state, noEvents, obsMin, obsMax, 0, simulation);

        }

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

        void reallySimulate(ComposableModel & composable,
                const ObservableMask & mask,
                const set<Event> & noEvents,
                unsigned obsMin,
                unsigned obsMax,
                list<Event> & simulation) {
            randomSimulate(composable, mask, noEvents, obsMin, obsMax, simulation);
        }

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

        bool simulate(ComposableModel & composable,
                const ObservableMask & mask,
                const set<string> & absentEvents,
                unsigned obsMin,
                unsigned obsMax,
                unsigned seed,
                list<Event> & simulation) {
            bool result = true;
            try {

                set<Event> noEvents;
                getEvents(composable.component(), absentEvents, noEvents);


                // initialise the random generator
                initialiseRandomGenerator(seed);

                // get normal obsMin and obsMax if not initialised
                if (obsMax < obsMin) {
                    throw (FunctionException("simulate", "Please check obsMin and obsMax, they are inconsistent."));
                }
                if (obsMin == 0) {
                    obsMin = 1;
                }
                if (obsMax == 0) {
                    obsMax = 100;
                }

                //let start the real job
                reallySimulate(composable, mask, noEvents, obsMin, obsMax, simulation);
            } catch (exception & e) {
                log<LgProcess>("The function 'simulate' caught the exception: \n\t%1%") % e.what();
                result = false;
            }
            return result;
        }

        void printStop(unsigned index)
        {
            cout << endl << "\t[" << index << "]- Stop" << endl;
        }

        template<typename StateIterator>
        void generateStateList(const Component & component,
                               StateIterator first, 
                               StateIterator last)
        {
            unsigned index = 1;
            while(first != last)
            {
                cout << "\t[" << index << "]- " << component.getLabel(*first) << endl;
                ++first;
                ++index;
            }
            printStop(index);
        }
        
        
        
        
        template<typename StateIterator>
        State getStateOfIndex(const Component & component,
                               StateIterator first, 
                               StateIterator last,
                               unsigned index)
        {
            unsigned current = 1;
            while(current != index)
            {
                ++first; ++ current;
            }
            return *first;
        }
        
        
        
        
        
        bool readResponse(istream & in, unsigned & index,
                          unsigned maxValue,
                          bool & stop)
        {
            in >> index;
            if(index < 1 || index > (maxValue+1))
            {
                return false;
            }
            stop = (index== maxValue+1);
            return true;
        }
        
        
        
        bool initialStateSelection(const Component & component, 
                                   State & result)
        { 
            bool stop = false;
            if(component.numberOfInitialStates()==0)
            {
                return true;
            }
            if(component.numberOfInitialStates()==1)
            {
                result = *component.initialStateBegin();
                cout << "Initial state: " 
                     << component.getLabel(result)
                     << endl;
            }
            else
            {
                generateStateList(component,component.initialStateBegin(),component.initialStateEnd());
                unsigned index = 0;
                while(!readResponse(cin,index,component.numberOfInitialStates(),stop)) {}
                if(!stop)
                {
                    result = getStateOfIndex(component,component.initialStateBegin(),
                                             component.initialStateEnd(),
                                             index);
                }
            }
            return !stop;
        }
        
        
        bool initialStateSelection(ComposableModel & model, 
                                   State & result)
        { 
            return initialStateSelection(model.component(),result);
        }
        
        
        
        
        
      
        
        template<typename TransitionIterator>
        void generateTransitionList(const Component & component, const ObservableMask & mask, 
                TransitionIterator first,
                TransitionIterator last)
        {
            cout << "Current State: " << component.getLabel(first->source()) << endl;
            cout << endl;
            unsigned index = 1;
            while(first!=last)
            {
                cout << "\t[" << index << "]- " 
                     << component.getLabel(first->source()) 
                     << " -> "
                     << component.getLabel(first->target())
                     << " ["
                     << component.getEvent(*first) << ":"
                     << toStream(mask.observableBegin(component.getEvent(*first)),
                        mask.observableEnd(component.getEvent(*first))) << "]"
                     << endl;
                ++first;
                ++index;
            }
            printStop(index);
            
        }
        
        
        template<typename TransitionIterator>
        Transition getTransitionOfIndex(const Component & component,
                TransitionIterator first,
                TransitionIterator last,unsigned index)
        {
            unsigned current = 1;
            while(current != index)
            {
                ++first; ++ current;
            }
            return *first;
        }
               
        
        bool interactiveSimulation(const ObservableComponent & component,
                                   State & current,
                                   list<Event> & simulation)
        {
            bool stop = false;
            if(current.outDeg()==0)
            {
                log<LgProcess>("The current state is a deadlock. STOP.");
                return true;
            }
            generateTransitionList(component,component.mask(),
                                   component.outputTransitionBegin(current),
                                   component.outputTransitionEnd(current));
            unsigned index = 0;
            while(!readResponse(cin,index,current.outDeg(),stop)) {}
            if(!stop)
            {
                Transition selection = getTransitionOfIndex(component,component.outputTransitionBegin(current),
                                                            component.outputTransitionEnd(current),
                                                            index);
                simulation.push_back(component.getEvent(selection));
                cout << "run : " << component.getLabel(current) << " -> " 
                     << component.getLabel(selection.target()) << " ["
                     << component.getEvent(selection) << ":"
                     << toStream(component.mask().observableBegin(component.getEvent(selection)),
                        component.mask().observableEnd(component.getEvent(selection))) << "]" << endl;
                current = selection.target();
            }
            return !stop;
            
        }
        
        bool interactiveSimulation(ComposableModel & model,
                const ObservableMask & mask,
                                   State & current,
                                   list<Event> & simulation)
        {
            bool stop = false;
            unsigned outDeg = 0;
            // computation of the output transitions if
            // they are not computed yet
            for(auto it = model.outputTransitionBegin(current);
                it != model.outputTransitionEnd(current);
                ++it)
            {
                ++outDeg;
            }
            
            if(outDeg==0)
            {
                log<LgProcess>("The current state is a deadlock. STOP.");
                return true;
            }
            const Component & component = model.component(); 
            generateTransitionList(component,mask,component.outputTransitionBegin(current),
                                   component.outputTransitionEnd(current));
            unsigned index = 0;
            while(!readResponse(cin,index,current.outDeg(),stop)) {}
            if(!stop)
            {
                Transition selection = getTransitionOfIndex(component,component.outputTransitionBegin(current),
                                                            component.outputTransitionEnd(current),
                                                            index);
                simulation.push_back(component.getEvent(selection));
                cout << "run : " << component.getLabel(current) << " -> " 
                     << component.getLabel(selection.target()) << " ["
                     << component.getEvent(selection) << ":"
                     << toStream(mask.observableBegin(component.getEvent(selection)),
                        mask.observableEnd(component.getEvent(selection))) << "]" << endl;
                current = selection.target();
            }
            return !stop;
            
        }
        
        
        bool interactiveSimulation(const ObservableComponent & component,
                list<Event> & simulation)
        {
            State current;
            if(!initialStateSelection(component,current))
            {
                log<LgProcess>("The interactive simulation has been aborted by the user.");
                return false;
            }
            if(!current.valid())
            {
                log<LgProcess>("The interactive simulation has failed as there is no valid initial state.");
                return false;
            }
            while(interactiveSimulation(component,current,simulation)){}
            return true;
        }


        bool interactiveSimulation(ComposableModel & composable,
                const ObservableMask & mask,
                list<Event> & simulation)
        {
            State current;
            if(!initialStateSelection(composable,current))
            {
                log<LgProcess>("The interactive simulation has been aborted by the user.");
                return false;
            }
            if(!current.valid())
            {
                log<LgProcess>("The interactive simulation has failed as there is no valid initial state.");
                return false;
            }
            while(interactiveSimulation(composable,mask,current,simulation)){}
            return true;
        }

    };
};