PNController.hpp

Go to the documentation of this file.

/*********************************************************************
* Software License Agreement (BSD License)
*
*  Copyright (c) 2010, LABUST, UNIZG-FER
*  All rights reserved.
*
*  Redistribution and use in source and binary forms, with or without
*  modification, are permitted provided that the following conditions
*  are met:
*
*   * Redistributions of source code must retain the above copyright
*     notice, this list of conditions and the following disclaimer.
*   * Redistributions in binary form must reproduce the above
*     copyright notice, this list of conditions and the following
*     disclaimer in the documentation and/or other materials provided
*     with the distribution.
*   * Neither the name of the LABUST nor the names of its
*     contributors may be used to endorse or promote products derived
*     from this software without specific prior written permission.
*
*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
*  POSSIBILITY OF SUCH DAMAGE.
*********************************************************************/
#ifndef PNCONTROLLER_HPP_
#define PNCONTROLLER_HPP_
#include <navcon_msgs/RegisterController.h>

#include <boost/config.hpp>
#include <boost/graph/adjacency_list.hpp>

#include <Eigen/Dense>

#include <string>
#include <map>
#include <set>

namespace labust
{
        namespace control
        {
                class PNController
                {
                        struct PlaceInfo
                        {
                                PlaceInfo():
                                        place_num(-1),
                                        enable_t(-1),
                                        disable_t(-1){};

                                int     place_num,
                                enable_t,
                                disable_t;
                        };

                public:
                        PNController();

                        void addToGraph(const navcon_msgs::RegisterControllerRequest& info);
                        void get_firing(const std::string& name);
                        void get_firing_r(const std::string& name);
                        void get_firing_pn(const std::string& name);
                        void reachability();
                        void addToRGraph(const std::string& name);
                        void addToRGraph2(const std::string& name);
                        void addToPNGraph(const navcon_msgs::RegisterControllerRequest& info);
                        void getDotDesc(std::string& desc);
                        void getDotDesc2(std::string& desc);

                private:
                        bool firing_rec(int des_place,
                                        std::set<int>& skip_transitions,
                                        std::set<int>& visited_places);

                        int pnum, tnum;
                        Eigen::MatrixXi Dm,Dp,I;
                        /*
                         * The current marking.
                         */
                        Eigen::VectorXi marking;
                        std::map<int, std::string> placeMap, transitionMap;
                        std::map<std::string, PlaceInfo> nameMap;
                        std::vector<int> firing_seq;
                        std::vector<int> resourcePosition;

                        //Reachability graph stuff
                        struct VertexProperty
                        {
                                Eigen::VectorXi marking;
                        };

                        struct EdgeProperty
                        {
                          typedef boost::edge_property_tag kind;
                                EdgeProperty():
                                        t_num(-1),
                                        weight(1){};
                                EdgeProperty(int t_num):
                                        t_num(t_num),
                                        weight(1){};

                                int t_num;
                                int weight;
                        };

                        typedef boost::adjacency_list<boost::vecS, boost::vecS,
                                boost::directedS, VertexProperty,
                                boost::property<boost::edge_name_t, int> > GraphType;

                        struct PNVertexProperty
                        {
                                enum {t =0, p=1};
                                int type;
                                int t_num;
                                int p_num;
                                bool marked;
                                std::string name;
                                std::set<int> dep_resource;
                        };

                        struct PNEdgeProperty
                        {
                                int weight;
                        };

                        typedef boost::adjacency_list<boost::vecS, boost::vecS,
                                boost::bidirectionalS, PNVertexProperty,
                                boost::property<boost::edge_name_t, int> > PNGraphType;

                        struct pn_writer
                        {
                                pn_writer(GraphType& graph):graph(graph){}
                                template <class Vertex>
                                void operator()(std::ostream &out, const Vertex& e) const
                                {
                                        out << "[label= \"(";
                                        for(int i=0; i<graph[e].marking.size();++i)
                                        {
                                                out<<graph[e].marking[i]<<",";
                                        }
                                        out<< ")\"]";
                                }
                                GraphType& graph;
                        };

                        struct pn_writer2 {
                                pn_writer2(PNGraphType& graph):graph(graph){}
                                template <class Vertex>
                                void operator()(std::ostream &out, const Vertex& e) const
                                {
                                        if (graph[e].type == PNVertexProperty::p)
                                        {
                                                out << "[label="<< graph[e].name<<"]";
                                        }
                                        else
                                        {
                                                out << "[height=0.05, style=filled, shape=rectangle, color=black, label=\"\"]";
                                        }
                                }
                                PNGraphType& graph;
                        };

                        template<class PropertyMap, class NameMap>
                        struct edge_writer {
                          edge_writer(PropertyMap edge_map, NameMap map):
                                edge_map(edge_map),
                                map(map){};
                          template <class Edge>
                          void operator()(std::ostream &out, const Edge& e) const
                          {
                            out << "[label=\"" << map.at(edge_map[e]) << "\"]";
                          }
                          PropertyMap edge_map;
                          NameMap map;
                        };

                        template<class PropertyMap, class NameMap>
                        edge_writer<PropertyMap, NameMap> make_edge_writer(PropertyMap pmap, NameMap map)
                        {
                                return edge_writer<PropertyMap, NameMap>(pmap,map);
                        }

                        GraphType rgraph, rgraph2;
                        PNGraphType pngraph;

                        std::map<int, int> placeToVertexMap;

                        std::vector<Eigen::VectorXi> all_markings;
                        std::vector<GraphType::vertex_descriptor> all_idx;
                };
        }
}

/* PNCONTROLLER_HPP_ */
#endif