adevs_pdevs.h

#ifndef _adevs_hier_h_
#define _adevs_hier_h_
#include "adevs_base.h"
#include <set>
#include <map>

namespace adevs
{

template <typename DataType, typename TimeType> class Network;

template <typename DataType,typename TimeType=Time>
class Devs:
        public Model<DataType,TimeType>
{
        public:
                Devs():Model<DataType,TimeType>(),m_parent(NULL){}
                Network<DataType,TimeType>* parent() const { return m_parent; }
                virtual void add(SimEnv<DataType,TimeType>* env) = 0;
                virtual ~Devs(){}
        private:
                Network<DataType,TimeType>* m_parent;
                friend class Network<DataType,TimeType>;
};

template <typename DataType, typename TimeType=Time>
class Atomic:
        public Devs<DataType,TimeType>
{
        public:
                Atomic():Devs<DataType,TimeType>(){}
                virtual void delta_int() = 0;
                virtual void delta_ext(TimeType e, std::vector<DataType>& x) = 0;
                virtual void delta_conf(std::vector<DataType>& x) = 0;
                virtual TimeType ta() = 0;
                virtual void output_func(std::vector<DataType>& y) = 0;
                TimeType init(SimEnv<DataType,TimeType>* env);
                TimeType update(SimEnv<DataType,TimeType>* env);
                TimeType update(
                                SimEnv<DataType,TimeType>* env, std::vector<DataType>& x);
                void fini(TimeType){}
                void add(SimEnv<DataType,TimeType>* env) { env->add(this); }
        private:
                TimeType schedule_internal_events(SimEnv<DataType,TimeType>* env);
                void transmit_output(SimEnv<DataType,TimeType>* env);
                std::vector<DataType> y;
                enum Mode { STATE_CHANGE, OUTPUT, PASSIVE };
                Mode mode;
                TimeType tL, tN;
};

template <typename DataType, typename TimeType>
TimeType Atomic<DataType,TimeType>::init(
                SimEnv<DataType,TimeType>* env)
{
        tL = env->now();
        return (tN = schedule_internal_events(env));
}

template <typename DataType, typename TimeType>
TimeType Atomic<DataType,TimeType>::update(
                SimEnv<DataType,TimeType>* env)
{
        assert(mode != PASSIVE);
        // Assign the state caused by the interal event 
        if (mode == STATE_CHANGE)
        {
                delta_int();
                tL = env->now();
                tN = schedule_internal_events(env);
        }
        // Otherwise generate output for this event and
        // then schedule the change of state
        else // (mode == OUTPUT)
        {
                transmit_output(env);
                mode = STATE_CHANGE;
                tN = env->now() + adevs_epsilon<TimeType>();
        }
        return tN;
}

template <typename DataType, typename TimeType>
TimeType Atomic<DataType,TimeType>::update(
                SimEnv<DataType,TimeType>* env, std::vector<DataType>& x)
{
        // External event
        if (env->now() < tN || (env->now() == tN && mode != STATE_CHANGE))
        {
                delta_ext(env->now()-tL,x);
                tL = env->now();
                tN = schedule_internal_events(env);
        }
        // Confluent event
        else
        {
                delta_conf(x);
                tL = env->now();
                tN = schedule_internal_events(env);
        }
        return tN;
}

template <typename DataType, typename TimeType>
TimeType Atomic<DataType,TimeType>::schedule_internal_events(
                SimEnv<DataType,TimeType>* env)
{
        // Get the time of the next event
        TimeType h = ta();
        // If this is for the next instant then send
        // output generated by the initial state and
        // the next state will be assigned at that
        // time
        if (h == adevs_zero<TimeType>())
        {
                transmit_output(env);
                mode = STATE_CHANGE;
                return env->now() + adevs_epsilon<TimeType>();
        }
        // Otherwise if h < inf() schedule an event
        // immediately prior to the new state to
        // generate that output
        if (h < adevs_inf<TimeType>())
        {
                mode = OUTPUT;
                return env->now()+h;
        }
        // Otherwise we are passive
        mode = PASSIVE;
        return h;
}

template <typename DataType, typename TimeType>
void Atomic<DataType,TimeType>::transmit_output(SimEnv<DataType,TimeType>* env)
{
        output_func(y);
        for (unsigned i = 0; i < y.size() && this->parent() != NULL; i++)
                env->send(this,this->parent(),y[i]);
        y.clear();
}

template <typename DataType, typename TimeType=Time>
class Network:
        public Devs<DataType,TimeType>
{
        public:
                Network():Devs<DataType,TimeType>(),routing(false){}
                void assign_parent(Devs<DataType,TimeType>* model) {
                        model->m_parent = this;
                }
                virtual void route(
                        Model<DataType,TimeType>* src, DataType data,
                        std::vector<std::pair<Model<DataType,TimeType>*,DataType> >& msgs) = 0;
                virtual ~Network(){}
                TimeType update(SimEnv<DataType,TimeType>*) { return adevs_inf<TimeType>(); }
                TimeType update(SimEnv<DataType,TimeType>*, std::vector<DataType>&) {
                        return adevs_inf<TimeType>();
                }
                TimeType init(SimEnv<DataType,TimeType>*) { return adevs_inf<TimeType>(); }
                void fini(TimeType){}
                std::pair<Model<DataType,TimeType>*,DataType> relay(
                                Model<DataType,TimeType>* src, DataType x);
        private:
                std::vector<std::pair<Model<DataType,TimeType>*,DataType> > msgs;
                unsigned pos;
                bool routing;
};

template <typename DataType, typename TimeType>
std::pair<Model<DataType,TimeType>*,DataType>
Network<DataType,TimeType>::relay(Model<DataType,TimeType>* src, DataType x)
{
        if (!routing)
        {
                // If the source is our parent, route it to our children
                if (src == this->parent() || src == NULL)
                        route(this,x,msgs);
                // The source is us or a child of the network
                else
                        route(src,x,msgs);
                routing = true;
                pos = 0;
        }
        while (pos < msgs.size())
        {
                // This is a message to child of the network
                if (msgs[pos].first != this)
                {
                        return msgs[pos++];
                }
                // Output from the network goes to its parent to be routed
                if (this->parent() != NULL)
                {
                        msgs[pos].first = this->parent();
                        return msgs[pos++];
                }
                pos++;
        }
        msgs.clear();
        routing = false;
        return std::pair<Model<DataType,TimeType>*,DataType>(NULL,x);
}

template <typename DataType>
struct port_value
{
        int port;
        DataType value;
        port_value(){}
        port_value(int port, DataType value):
                port(port),value(value){}
};

template <typename DataType, typename TimeType=Time>
class Digraph:
        public Network<port_value<DataType>,TimeType>
{
        public:
                Digraph():Network<port_value<DataType>,TimeType>(){}
                ~Digraph();
                void add(SimEnv<port_value<DataType>,TimeType>* env);
                void couple(Devs<port_value<DataType>,TimeType>* src, int src_port,
                        Devs<port_value<DataType>,TimeType>* dst, int dst_port);
                void route(
                        Model<port_value<DataType>,TimeType>* src, port_value<DataType> data,
                        std::vector<std::pair<Model<port_value<DataType>,TimeType>*,
                                port_value<DataType> > >& msgs);
        private:
                std::set<Devs<port_value<DataType>,TimeType>* > models;
                std::map<std::pair<Model<port_value<DataType>,TimeType>*,int>,
                        std::vector<std::pair<Model<port_value<DataType>,TimeType>*,int> > > graph;
};

template <typename DataType, typename TimeType>
Digraph<DataType,TimeType>::~Digraph()
{
        typename std::set<Devs<port_value<DataType>,TimeType>* >::iterator iter =
                models.begin();
        for (; iter != models.end(); iter++)
                if (*iter != this)
                        delete *iter;
}

template <typename DataType, typename TimeType>
void Digraph<DataType,TimeType>::add(
                SimEnv<port_value<DataType>,TimeType>* env)
{
        typename std::set<Devs<port_value<DataType>,TimeType>* >::iterator iter =
                models.begin();
        for (; iter != models.end(); iter++)
        {
                if (*iter != this)
                {
                        this->assign_parent(*iter);
                        (*iter)->add(env);
                }
        }
}

template <typename DataType, typename TimeType>
void Digraph<DataType,TimeType>::couple(
        Devs<port_value<DataType>,TimeType>* src, int src_port,
        Devs<port_value<DataType>,TimeType>* dst, int dst_port)
{
        models.insert(src);
        models.insert(dst);
        std::pair<Model<port_value<DataType>,TimeType>*,int> a(src,src_port);
        std::pair<Model<port_value<DataType>,TimeType>*,int> b(dst,dst_port);
        graph[a].push_back(b);
}

template <typename DataType, typename TimeType>
void Digraph<DataType,TimeType>::route(
        Model<port_value<DataType>,TimeType>* src, port_value<DataType> data,
        std::vector<std::pair<Model<port_value<DataType>,TimeType>*,
        port_value<DataType> > >& msgs)
{
        std::pair<Model<port_value<DataType>,TimeType>*,int> a(src,data.port);
        typename std::map<std::pair<Model<port_value<DataType>,TimeType>*,int>,
                std::vector<std::pair<Model<port_value<DataType>,TimeType>*,int> > >::const_iterator
                        iter = graph.find(a); 
        if (iter != graph.end())
        {
                const std::vector<std::pair<Model<port_value<DataType>,TimeType>*,int> >&
                        link = (*iter).second;
                for (unsigned i = 0; i < link.size(); i++)
                {
                        data.port = link[i].second;
                        msgs.push_back(
                                std::pair<Model<port_value<DataType>,TimeType>*,port_value<DataType> >(
                                        link[i].first,data));
                }
        }
}

template <typename DataType, typename TimeType=Time>
class SimpleDigraph:
        public Network<DataType,TimeType>
{
        public:
                SimpleDigraph():Network<DataType,TimeType>(){}
                ~SimpleDigraph();
                void add(SimEnv<DataType,TimeType>* env);
                void couple(Devs<DataType,TimeType>* src, Devs<DataType,TimeType>* dst);
                void route(
                        Model<DataType,TimeType>* src, DataType data,
                        std::vector<std::pair<Model<DataType,TimeType>*,DataType> >& msgs);
        private:
                std::set<Devs<DataType,TimeType>* > models;
                std::map<Model<DataType,TimeType>*,
                        std::vector<Model<DataType,TimeType>* > > graph;
};

template <typename DataType, typename TimeType>
SimpleDigraph<DataType,TimeType>::~SimpleDigraph()
{
        typename std::set<Devs<DataType,TimeType>* >::iterator iter =
                models.begin();
        for (; iter != models.end(); iter++)
                if (*iter != this)
                        delete *iter;
}

template <typename DataType, typename TimeType>
void SimpleDigraph<DataType,TimeType>::add(SimEnv<DataType,TimeType>* env)
{
        typename std::set<Devs<DataType,TimeType>* >::iterator iter =
                models.begin();
        for (; iter != models.end(); iter++)
        {
                if (*iter != this)
                {
                        this->assign_parent(*iter);
                        (*iter)->add(env);
                }
        }
}

template <typename DataType, typename TimeType>
void SimpleDigraph<DataType,TimeType>::couple(
        Devs<DataType,TimeType>* src, Devs<DataType,TimeType>* dst)
{
        models.insert(src);
        models.insert(dst);
        graph[src].push_back(dst);
}

template <typename DataType, typename TimeType>
void SimpleDigraph<DataType,TimeType>::route(
        Model<DataType,TimeType>* src, DataType data,
        std::vector<std::pair<Model<DataType,TimeType>*,
        DataType> >& msgs)
{
        typename std::map<Model<DataType,TimeType>*,
                std::vector<Model<DataType,TimeType>* > >::const_iterator
                        iter = graph.find(src); 
        if (iter != graph.end())
        {
                const std::vector<Model<DataType,TimeType>*>& link =
                        (*iter).second;
                for (unsigned i = 0; i < link.size(); i++)
                {
                        msgs.push_back(
                                std::pair<Model<DataType,TimeType>*,DataType >(
                                        link[i],data));
                }
        }
}

}; // end of namespace

#endif