From 01dec404fb948258f3deb9d7d5c45cd120652c5d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tristram=20Gr=C3=A4bener?= <tristramg@gmail.com>
Date: Tue, 18 May 2010 14:46:44 +0200
Subject: [PATCH] Reverted the bad commit c2584325b7e32d80c297

---
 ch/Makefile           |   7 +-
 ch/bench.cc           |  34 +------
 ch/graph.h            |   1 -
 ch/main.cc            |  15 ++-
 ch/query.cc           |  61 +------------
 ch/query.h            |   1 -
 lib/CMakeLists.txt    |   8 +-
 lib/README.CONFIG.txt |   9 ++
 lib/benchmark.py      |  26 ++----
 lib/graph_wrapper.cpp | 208 +++++++-----------------------------------
 lib/graph_wrapper.h   |   9 +-
 lib/layer.py          |  38 +++-----
 lib/martins.cpp       |   1 -
 lib/martins.h         |   2 +-
 lib/martins_impl.h    |  18 +---
 lib/tsaggouris.cpp    |   1 +
 16 files changed, 92 insertions(+), 347 deletions(-)
 create mode 100644 lib/README.CONFIG.txt

diff --git a/ch/Makefile b/ch/Makefile
index 08bea7b..3327203 100644
--- a/ch/Makefile
+++ b/ch/Makefile
@@ -1,5 +1,5 @@
-ch: main.o bench.o test.o dijkstra.o contraction.o query.o tsaggouris.o
-	g++ -o ch main.o bench.o test.o dijkstra.o contraction.o query.o tsaggouris.o -lpqxx -Wall -lboost_serialization
+ch: main.o bench.o test.o dijkstra.o contraction.o query.o
+	g++ -o ch main.o bench.o test.o dijkstra.o contraction.o query.o -lpqxx -Wall -lboost_serialization
 
 main.o: main.cc
 	g++ -O3 -Wall -o main.o -c main.cc
@@ -16,8 +16,5 @@ dijkstra.o: dijkstra.cc
 contraction.o: contraction.cc
 	g++ -O3 -Wall -o contraction.o -c contraction.cc
 
-tsaggouris.o: tsaggouris.cc
-	g++ -O3 -Wall -o tsaggouris.o -c tsaggouris.cc
-
 query.o: query.cc
 	g++ -O3 -Wall -o query.o -c query.cc
diff --git a/ch/bench.cc b/ch/bench.cc
index 144eea5..2d9fde2 100644
--- a/ch/bench.cc
+++ b/ch/bench.cc
@@ -1,6 +1,6 @@
 #include "dijkstra.h"
 #include "query.h"
-#include "tsaggouris.h"
+
 #include <boost/graph/dijkstra_shortest_paths.hpp>
 
 struct found_goal{};
@@ -58,14 +58,14 @@ void bench(Graph & g, Graph & gc)
         boost::progress_timer t;
         for(int i=0; i < runs; i++)
         {
-            query_mono(starts[i], dests[i], gc.graph);
+            //query_mono(starts[i], dests[i], gc.graph);
         }
     } 
 }
 
 void martins_bench(Graph & g, Graph & gc)
 {
-    int runs = 100;
+    int runs = 10;
     std::vector<int> starts(runs);
     std::vector<int> dests(runs);
     for(int i=0; i < runs; i++)
@@ -77,7 +77,7 @@ void martins_bench(Graph & g, Graph & gc)
         boost::progress_timer t;
         for(int i=0; i < runs; i++)
         {
-            martins(starts[i], dests[i], g);
+            //martins(starts[i], dests[i], g);
         }
     }
 
@@ -90,29 +90,3 @@ void martins_bench(Graph & g, Graph & gc)
     }
  
 }
-
-void tsaggouris_bench(Graph & g)
-{
-    int runs = 10;
-    std::vector<int> starts(runs);
-    for(int i=0; i < runs; i++)
-    {
-        starts[i] = rand() % boost::num_vertices(g.graph);
-    }
-    { 
-        boost::progress_timer t;
-        for(int i=0; i < runs; i++)
-        {
-            martins_all(starts[i], g);
-        }
-    }
-
-    {
-        boost::progress_timer t;
-        for(int i=0; i < runs; i++)
-        {
-            ssmosp(g, starts[i]);
-        }
-    }
- 
-}
diff --git a/ch/graph.h b/ch/graph.h
index d9f240e..dbe492d 100644
--- a/ch/graph.h
+++ b/ch/graph.h
@@ -79,7 +79,6 @@ struct Graph
     typedef boost::adjacency_list<boost::listS, boost::vecS, boost::bidirectionalS, Node, Edge > Type;
     typedef boost::graph_traits<Type>::edge_descriptor edge_t;
     typedef boost::graph_traits<Type>::vertex_descriptor node_t;
-    typedef boost::graph_traits<Type>::edge_iterator edge_iterator;
 
     struct inc_order
     {
diff --git a/ch/main.cc b/ch/main.cc
index b499510..d461d78 100644
--- a/ch/main.cc
+++ b/ch/main.cc
@@ -8,7 +8,6 @@
 
 void bench(Graph & g, Graph & gc);
 void martins_bench(Graph & g, Graph & gc);
-void tsaggouris_bench(Graph & g);
 void test(Graph & g, Graph & gc);
 float secu(int cat, int length)
 {
@@ -26,7 +25,7 @@ float secu(int cat, int length)
 
 int main(int, char** argv)
 {
- /*   Graph g;
+/*    Graph g;
     std::map<int, int> map;
     pqxx::connection Conn("dbname=mumoro");
 
@@ -56,12 +55,12 @@ int main(int, char** argv)
         g.add_edge(map[source], map[destination], edge_prop);
 //        g.add_edge(map[destination], map[source], edge_prop);
         ++show_progress;
-    }
-    g.save("paris_original");
+    }*/
+/*    g.save("paris_original");
     Graph gc(g);
     gc.contract();
-    gc.save("paris_ch");*/
-    
+    gc.save("paris_ch");
+  */  
     //   51937 nodes
 //   619894 edges
 
@@ -75,7 +74,7 @@ int main(int, char** argv)
 //   619894 edges
     
    Graph g("paris_original");
-  //Graph gc("paris_ch");
+  Graph gc("paris_ch");
 /*  gc.split();
   gc.save("paris_ch");*/
 //    Graph gc(g);
@@ -86,7 +85,7 @@ int main(int, char** argv)
 
     //test(g,gc); 
 //    bench(g, gc);
-    tsaggouris_bench(g);
+    martins_bench(g, gc);
 
 
 }
diff --git a/ch/query.cc b/ch/query.cc
index a14ed4b..6d60cac 100644
--- a/ch/query.cc
+++ b/ch/query.cc
@@ -157,65 +157,6 @@ bool martins(Graph::node_t start_node, Graph::node_t dest_node, const Graph & g)
     return false;
 }
 
-// Algo de martins sur le graphe normal, vers tous les nœuds
-bool martins_all(Graph::node_t start_node, const Graph & g)
-{
-    my_queue::Type Q;
-    std::vector< std::deque<Label> > P(num_vertices(g.graph));
-
-    Label start;
-    start.node = start_node;
-    for(int i=0; i < Graph::objectives; i++)
-        start.cost[i] = 0;
-
-    Q.insert(start);
-    const  my_queue::by_cost cost_q_it = Q.get<0>();
-    const  my_queue::by_nodes node_q = Q.get<1>();
-
-    int visited = 0;
-    while( !Q.empty() )
-    {
-        Label l = *(cost_q_it.begin());
-        visited++;
-        P[l.node].push_back(l);
-        //        std::cout << "Label! node=" << l.node << " [" << l.cost[0] << "," << l.cost[1] << "]" << std::endl;
-        Q.erase(cost_q_it.begin());
-        BOOST_FOREACH(Graph::edge_t e, out_edges(l.node, g.graph))
-        {
-            Label l2;
-            l2.node = boost::target(e, g.graph);
-            for(int i=0; i < Graph::objectives; i++)
-                l2.cost[i] = l.cost[i] + g[e].cost[i];
-
-            if(!is_dominated_by_any(node_q.equal_range(l2.node), l2) && !is_dominated_by_any(P[l2.node],l2) )
-            {
-                my_queue::nodes_it it, end;
-                tie(it, end) = node_q.equal_range(l2.node);
-                while(it != end)
-                {
-                    if(Graph::dominates(l2.cost, it->cost) || l2.cost == it->cost)
-                        it = Q.get<1>().erase(it);
-                    else
-                    {
-                        it++;
-                    }
-                }
-                Q.insert(l2);
-            }
-        }
-    }
-
-    size_t total = 0;
-    for(int n = 0; n<boost::num_vertices(g.graph); n++)
-    {
-        total += P[n].size();
-    }
-
-    std::cout << "Number of elements found " << total << std::endl;
-    return false;
-}
-
-
 // Algo de martins dans un graphe CH
 // On maintient une liste de couts réalisables trouvés
 // À la création d'un nouveau label, on vérifie qu'il n'est pas dominé par aucun label des couts réalisables
@@ -256,7 +197,7 @@ bool ch_martins(Graph::node_t start_node, Graph::node_t dest_node, const Graph &
     Q1.insert(start);
     Q2.insert(dest);
 
-    while(!Q1.empty() || !Q2.empty())
+    while(!Q1.empty() && !Q2.empty())
     {
         if(!Q1.empty())
         {
diff --git a/ch/query.h b/ch/query.h
index e0e1975..5b9aec1 100644
--- a/ch/query.h
+++ b/ch/query.h
@@ -29,7 +29,6 @@ struct Path
 std::list<Path> query(Graph::node_t source, Graph::node_t target, const Graph::Type & graph);
 
 bool martins(Graph::node_t start_node, Graph::node_t dest_node, const Graph & g);
-bool martins_all(Graph::node_t start_node, const Graph & g);
 bool ch_martins(Graph::node_t start_node, Graph::node_t dest_node, const Graph & g);
 bool martins_witness(Graph::node_t start_node, Graph::node_t dest_node, Graph::cost_t cost, const Graph::Type & g);
 #endif
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index 8a9536b..0ee256e 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -2,6 +2,8 @@ CMAKE_MINimum_required(VERSION 2.6)
 
 SET( CMAKE_BUILD_TYPE DEBUG )
 
+FIND_LIBRARY(PQXX pqxx /opt/local/lib)
+
 find_package(Boost COMPONENTS graph REQUIRED)
 FIND_PACKAGE(PythonLibs REQUIRED)
 INCLUDE_DIRECTORIES(${PYTHON_INCLUDE_PATH})
@@ -9,10 +11,10 @@ INCLUDE_DIRECTORIES(${PYTHON_INCLUDE_PATH})
 
 include_directories(${Boost_INCLUDE_DIRS})
 
-ADD_DEFINITIONS( -O3 -Wall -fPIC -Wno-deprecated)
+ADD_DEFINITIONS( -O3 -Wall -Wno-deprecated)
 
-ADD_LIBRARY(mum_lib martins.cpp graph_wrapper.cpp) 
-TARGET_LINK_LIBRARIES(mum_lib)
+ADD_LIBRARY(mum_lib martins.cpp tsaggouris.cpp graph_wrapper.cpp) 
+TARGET_LINK_LIBRARIES(mum_lib ${PQXX})
 
 #ADD_EXECUTABLE(mum_test main.cpp )
 #TARGET_LINK_LIBRARIES(mum_test mum_lib)
diff --git a/lib/README.CONFIG.txt b/lib/README.CONFIG.txt
new file mode 100644
index 0000000..45a6472
--- /dev/null
+++ b/lib/README.CONFIG.txt
@@ -0,0 +1,9 @@
+Delete first line, replace values and save file as config.cfg
+[DBSettings]
+DBName: mumoroRE
+DBUser: root
+DBPassword: test
+DBHost: localhost
+DBTableNodes: nodes
+DBTableEdges: edges
+
diff --git a/lib/benchmark.py b/lib/benchmark.py
index 6afc93a..d3b7d01 100644
--- a/lib/benchmark.py
+++ b/lib/benchmark.py
@@ -3,9 +3,9 @@
 import time
 import random
 
-foot = layer.Layer('foot', mumoro.Foot, {'nodes': 'sf_nodes_ch4', 'edges': 'sf_edges_ch4'})
-bike = layer.Layer('bike', mumoro.Bike, {'nodes': 'sf_nodes_ch4', 'edges': 'sf_edges_ch4'})
-pt = layer.GTFSLayer('muni', 'pt2')
+foot = layer.Layer('foot', mumoro.Foot, {'nodes': 'sf_nodes', 'edges': 'sf_edges'})
+bike = layer.Layer('bike', mumoro.Bike, {'nodes': 'sf_nodes', 'edges': 'sf_edges'})
+pt = layer.GTFSLayer('muni', 'pt')
 g = layer.MultimodalGraph([foot, pt, bike])
 
 e = mumoro.Edge()
@@ -17,22 +17,17 @@
 g.connect_nearest_nodes(pt, foot, e, e2)
 
 g.connect_nearest_nodes(bike, foot, e)
-#g.connect_nearest_nodes(bike, pt, e)
 
 random.seed(time.clock())
 found = 0
 comp = []
-runs = 2
-
-found = 0
 
+runs = 10
 for x in range(runs):
     s = random.randint(0, bike.count - 1) + bike.offset
     t = random.randint(0, foot.count - 1)
     comp.append((s,t))
 
-
-
 found = 0
 start = time.clock()
 for (s,t) in comp:
@@ -45,11 +40,7 @@
     p = mumoro.relaxed_martins(s, t, g.graph, 30000, mumoro.mode_change, 120)
     efound += len(p)
 eend = time.clock()
-fstart = time.clock()
-for (s,t) in comp:
-    p = mumoro.relaxed_martins(s, -1, g.graph, 30000, mumoro.mode_change, 120)
-fend = time.clock()
-print "\"t + ms\" {0} {1} {2} {3} ".format(float(found)/runs, float(end - start) * 1000 / runs, float(efound)/runs, float(eend - estart) * 1000 / runs)
+print "t + ms & {0} & {1} & {2} & {3}".format(float(found)/runs, float(end - start) * 1000 / runs, float(efound)/runs, float(eend - estart) * 1000 / runs)
 
 
 found = 0
@@ -64,7 +55,7 @@
     p = mumoro.relaxed_martins(s, t, g.graph, 30000, mumoro.mode_change, 120, mumoro.line_change, 60)
     efound += len(p)
 eend = time.clock()
-print "\"t + ms + ls\" {0} {1} {2} {3}".format(float(found)/runs, float(end - start) * 1000 / runs, float(efound)/runs, float(eend - estart) * 1000 / runs)
+print "t + ms + ls & {0} & {1} & {2} & {3}".format(float(found)/runs, float(end - start) * 1000 / runs, float(efound)/runs, float(eend - estart) * 1000 / runs)
 
 
 found = 0
@@ -79,7 +70,7 @@
     p = mumoro.relaxed_martins(s, t, g.graph, 30000, mumoro.elevation, 10)
     efound += len(p)
 eend = time.clock()
-print "\"t + a\" {0} {1} {2} {3}".format(float(found)/runs, float(end - start) * 1000 / runs, float(efound)/runs, float(eend - estart) * 1000 / runs)
+print "t + a & {0} & {1} & {2} & {3}".format(float(found)/runs, float(end - start) * 1000 / runs, float(efound)/runs, float(eend - estart) * 1000 / runs)
 
 
 found = 0
@@ -94,6 +85,7 @@
     p = mumoro.relaxed_martins(s, t, g.graph, 30000, mumoro.elevation, 10, mumoro.line_change, 60, mumoro.mode_change, 120)
     efound += len(p)
 eend = time.clock()
-print "\"t + a + ms + ls\" {0} {1} {2} {3}".format(float(found)/runs, float(end - start) * 1000 / runs, float(efound)/runs, float(eend - estart) * 1000 / runs)
+print "t + a + ms + ls& {0} & {1} & {2} & {3}".format(float(found)/runs, float(end - start) * 1000 / runs, float(efound)/runs, float(eend - estart) * 1000 / runs)
+
 
 
diff --git a/lib/graph_wrapper.cpp b/lib/graph_wrapper.cpp
index 728e20e..db080ee 100644
--- a/lib/graph_wrapper.cpp
+++ b/lib/graph_wrapper.cpp
@@ -1,12 +1,8 @@
 #include "graph_wrapper.h"
 #include <iostream>
 #include <boost/graph/dijkstra_shortest_paths.hpp>
-#include <boost/graph/astar_search.hpp>
-#include <math.h>    // for sqrt
 
-using namespace boost;
-
-Edge::Edge() : distance(0), elevation(0), mode_change(0), cost(0), line_change(0), co2(0)
+Edge::Edge() : distance(0), elevation(0), mode_change(0), cost(0), line_change(0)
 {
 }
 
@@ -32,11 +28,7 @@ float Duration::operator()(float start) const
             if (it->first >= start)
                 return it->second;
         }
-        //it = timetable.lower_bound(start);
-        //if(it->first >= start)
-        //    return it->second;
-        //else
-            return (start / (24*3600) + 1)  * 24*3600 + timetable.begin()->second;
+        return (start / (24*3600) + 1)  * 24*3600 + timetable.begin()->second;
     }
 }
 
@@ -45,14 +37,6 @@ Graph::Graph(int nb_nodes) : g(nb_nodes)
 {
 }
 
-void Graph::set_coord(int node, float x, float y)
-{
-    Node n;
-    n.x = x;
-    n.y = y;
-    g[node] = n;
-}
-
 void Graph::add_edge(int source, int target, const Edge & e)
 {
     boost::add_edge(source, target, e, g);
@@ -76,47 +60,24 @@ bool Graph::public_transport_edge(int source, int target, float start, float arr
     }; // exception for termination
 
     // visitor that terminates when we find the goal
-int visited;
 
-class dijkstra_goal_visitor : public boost::default_dijkstra_visitor
-{   
-    public:
-
-        dijkstra_goal_visitor(int goal) : m_goal(goal)
-    {
-    }   
-
-        template <class Graph_t>
-            void examine_vertex(int u, Graph_t&)
-            {   
-                visited++;
-                if (u == m_goal)
-                {
-                    throw found_goal();
-                }
-            }
-    private:
-        int m_goal;
-};
-
-
-// visitor that terminates when we find the goal
-class astar_goal_visitor : public boost::default_astar_visitor
-{
-    public:
-        astar_goal_visitor(int goal) : m_goal(goal) {}
-        template <class Graph_t>
-            void examine_vertex(int u, Graph_t& g) {
-                visited++;
-                if(u == m_goal)
-                {
-                    throw found_goal();
+    class dijkstra_goal_visitor : public boost::default_dijkstra_visitor
+    {   
+        public:
+            
+            dijkstra_goal_visitor(int goal) : m_goal(goal)
+        {
+        }   
+            
+            template <class Graph_t>
+                void examine_vertex(int u, Graph_t& g)
+                {   
+                    if (u == m_goal)
+                        throw found_goal();
                 }
-            }
-    private:
-        int m_goal;
-};
-
+        private:
+            int m_goal;
+    };
 
 float calc_duration(float in, Duration d)
 {
@@ -129,128 +90,25 @@ struct Comp
     bool operator()(const Duration &, float) const {return false;}
 };
 
-int Graph::dijkstra(int source, int target)
+bool Graph::dijkstra(int source, int target)
 {
-    visited = 0;
+    std::vector<int> p(boost::num_vertices(g));
     std::vector<float> d(boost::num_vertices(g));
-    dijkstra_goal_visitor vis(target);
-    if(target >= 0)
-    {
-        try{
-            boost::dijkstra_shortest_paths(g, source,
-                    boost::distance_map(&d[0])
-                    .weight_map(get(&Edge::duration, g))
-                    .visitor(vis)
-                    .distance_zero(30000)
-                    .distance_combine(&calc_duration)
-                    .distance_compare(Comp())
-                    );
-        }
-        catch(found_goal)
-        {
-        }
-    }
-    else
-    {
-        boost::dijkstra_shortest_paths(g, source,
-                distance_map(&d[0])
-                .weight_map(get(&Edge::duration, g))
-                .visitor(vis)
-                .distance_zero(30000)
-                .distance_combine(&calc_duration)
-                .distance_compare(Comp())
-                );
-    }
-    return visited;
-}
-
-
-int Graph::dijkstra_dist(int source, int target)
-{
-    visited = 0;
-    dijkstra_goal_visitor vis(target);
-    std::vector<float> d(boost::num_vertices(g));
-    if(target >= 0)
-    {
-        try{
-            boost::dijkstra_shortest_paths(g, source,
-                    distance_map(&d[0])
-                    .weight_map(get(&Edge::distance, g))
-                    .visitor(vis)
-                    );
-        }
-        catch(found_goal)
-        {
-        }
-    }
-    else
-    {
-        boost::dijkstra_shortest_paths(g, source,
-                distance_map(&d[0])
-                .weight_map(get(&Edge::distance, g))
-                .visitor(vis)
-                .distance_zero(30000)
-                );
-    }
-    return visited;
-}
-
-
-class distance_heuristic : public astar_heuristic<Graph_t, float>
-{
-    public:
-        distance_heuristic(Graph & gr, int goal)
-            : g(gr), m_goal(goal){}
-        float operator()(int u)
-        {
-            return g.distance(u, m_goal) / 16; //environ 55km/h vitesse moyenne du bart
-        }
-    private:
-        Graph & g;
-        int m_goal;
-};
-
-
-int Graph::astar(int source, int target)
-{
-
-    visited = 0;
-    std::vector<float> d(boost::num_vertices(g));
-    std::vector<float> r(boost::num_vertices(g));
-    astar_goal_visitor vis(target);
-    try
-    {
-        astar_search
-            (g, source,
-             distance_heuristic(*this, target),
-             distance_map(&d[0])
-             .rank_map(&r[0])
-             .visitor(vis)
-             .weight_map(get(&Edge::duration, g))
-             .distance_zero(30000)
-             .distance_combine(&calc_duration)
-             .distance_compare(Comp())
+    try{
+    boost::dijkstra_shortest_paths(g, source,
+            boost::predecessor_map(&p[0])
+            .distance_map(&d[0])
+            .weight_map(get(&Edge::duration, g))
+//            .visitor(dijkstra_goal_visitor(target))
+            .distance_zero(30000)
+            .distance_combine(calc_duration)
+            .distance_compare(Comp())
             );
+    return false;
     }
     catch(found_goal)
-    {}
-    return visited;
-}
-double rad(double deg)
-{
-    return deg * 3.14159265 / 180;
-}
-
-
-float Graph::distance(int source, int target)
-{
-    const double r = 6371000;
+    {
+        return true;
+    }
 
-    float lon1 = g[source].x;
-    float lon2 = g[target].x;
-    float lat1 = g[source].y;
-    float lat2 = g[target].y;
-    return acos( sin( rad(lat1) ) * sin( rad(lat2) ) +
-            cos( rad(lat1) ) * cos( rad(lat2) ) * cos( rad(lon2-lon1 ) )
-            ) * r;
 }
diff --git a/lib/graph_wrapper.h b/lib/graph_wrapper.h
index ecf80c8..2c97c55 100644
--- a/lib/graph_wrapper.h
+++ b/lib/graph_wrapper.h
@@ -18,8 +18,6 @@ class Duration
 
 struct Node
 {
-    float x;
-    float y;
 };
 
 struct Edge
@@ -30,7 +28,6 @@ struct Edge
     float mode_change;
     float cost;
     float line_change;
-    float co2;
     Duration duration;
 };
 
@@ -42,12 +39,8 @@ struct Graph
     Graph_t g;
     Graph(int nb_nodes);
     void add_edge(int source, int target, const Edge & e);
-    void set_coord(int node, float x, float y);
     bool public_transport_edge(int source, int target, float start, float arrival);
-    int dijkstra(int source, int target = -1);
-    int dijkstra_dist(int source, int target = -1);
-    int astar(int source, int target);
-    float distance(int source, int target);
+    bool dijkstra(int source, int target);
 };
 
 const int invalid_node = -1;
diff --git a/lib/layer.py b/lib/layer.py
index 2b94ed1..08ab39e 100644
--- a/lib/layer.py
+++ b/lib/layer.py
@@ -36,16 +36,6 @@ def duration(length, property, mode):
     else:
         raise NotAccessible()
  
-def co2(length, mode):
-    if mode == mumoro.Foot:
-        return 0
-    elif mode == mumoro.Bike:
-        return 0
-    elif mode == mumoro.Car:
-        return length * 0.15
-    elif mode == mumoro.PublicTransport:
-        return length * 0.05
-        
 class BaseLayer:
     def map(self, original_id):
         c = self.nodes_db.cursor()
@@ -97,15 +87,18 @@ def __init__(self, name, mode, data):
         self.mode = mode
         self.data = data
         self.name = name
-        c = config.Config()        
-        try:
-            self.conn = pg.connect("dbname=" + c.dbname + " user=" + c.dbuser + " password=" + c.dbpassword + " host=" + c.host);
+	c = config.Config()        
+	try:
+            if( c.host != "" and c.dbpassword != ""):
+                self.conn = pg.connect("dbname=" + c.dbname + " user=" + c.dbuser  + " password=" + c.dbpassword + " host=" + c.host)
+            else:
+                self.conn = pg.connect("dbname=" + c.dbname + " user=" + c.dbuser)
         except:
             print "I am unable to connect to the database"
         self.nodes_offset = 0
-        eld = elevation.ElevationData("North_America")
-        self.nodes_db = sqlite3.connect(':memory:', check_same_thread = False)
-        self.nodes_db.executescript('''
+	eld = elevation.ElevationData("Eurasia")
+	self.nodes_db = sqlite3.connect(':memory:', check_same_thread = False)
+	self.nodes_db.executescript('''
 CREATE TABLE nodes(
 original_id INTEGER PRIMARY KEY,
 id INTEGER,
@@ -157,7 +150,6 @@ def edges(self):
  
             try:
                 dur = duration(e.length, property, self.mode)
-                e.co2 = co2(e.length, self.mode)
                 e.duration = mumoro.Duration(dur)
                 if self.mode == mumoro.Bike:
                     e.elevation = max(0, target_alt - source_alt)
@@ -239,8 +231,6 @@ def __init__(self, layers):
                 else:
                     if self.graph.public_transport_edge(e['source'], e['target'], e['departure'], e['arrival']):
                         count += 1
-            for n in l.nodes():
-                self.graph.set_coord(n['id'], n['lon'], n['lat'])
 	    print "On layer {0}, {1} edges".format(l, count)
         print "The multimodal graph has been built and has {0} nodes and {1} edges".format(nb_nodes, count)
  
@@ -269,6 +259,7 @@ def connect_same_nodes(self, layer1, layer2, property):
             n2 = layer2.map(n1['original_id'])
             if n2:
                 self.graph.add_edge(n1['id'], n2, property)
+
     def connect_same_nodes_random(self, layer1, layer2, property, freq):
         count = 0
         for n1 in layer1.nodes():
@@ -276,6 +267,7 @@ def connect_same_nodes_random(self, layer1, layer2, property, freq):
             if n2 and count % freq == 0:
                 self.graph.add_edge(n1['id'], n2, property)
                 count += 1
+                self.graph.add_edge(n1, n2, property)
 
 
     def connect_nodes_from_list(self, layer1, layer2, list, property, property2 = None):
@@ -292,11 +284,11 @@ def connect_nodes_from_list(self, layer1, layer2, list, property, property2 = No
 
 
     def connect_nearest_nodes(self, layer1, layer2, property, property2 = None):
+        if property2 == None:
+            property2 = property
         for n in layer1.nodes():
             nearest = layer2.match(n['lon'], n['lat'])
             if nearest:
-                if property != None:
-                    self.graph.add_edge(n['id'], nearest, property)
-                if property2 != None:
-                    self.graph.add_edge(nearest, n['id'], property2)
+                self.graph.add_edge(n['id'], nearest, property)
+                self.graph.add_edge(nearest, n['id'], property2)
  
diff --git a/lib/martins.cpp b/lib/martins.cpp
index 086b7ba..c633731 100644
--- a/lib/martins.cpp
+++ b/lib/martins.cpp
@@ -10,7 +10,6 @@ float Edge::* get_objective(Objective o)
         case mode_change: return &Edge::mode_change; break;
         case cost: return &Edge::cost; break;
         case line_change: return &Edge::line_change; break;
-        case co2: return &Edge::co2; break;
         default: std::cerr << "Unknown objective..." << std::endl; break;
     }
 }
diff --git a/lib/martins.h b/lib/martins.h
index 77ed80c..d193cdd 100644
--- a/lib/martins.h
+++ b/lib/martins.h
@@ -3,7 +3,7 @@
 
 #include "graph_wrapper.h"
 
-enum Objective {dist, elevation, mode_change, cost, line_change, co2};
+enum Objective {dist, elevation, mode_change, cost, line_change};
 
 struct Path
 {
diff --git a/lib/martins_impl.h b/lib/martins_impl.h
index 5ec89e9..b0b26d3 100644
--- a/lib/martins_impl.h
+++ b/lib/martins_impl.h
@@ -7,14 +7,15 @@
 #include <string>
 #include <fstream>
 #include <deque>
+#include <boost/spirit/include/classic_core.hpp>
 #include <boost/multi_index_container.hpp>
 #include <boost/multi_index/ordered_index.hpp>
 #include "boost/multi_index/hashed_index.hpp"
 #include <boost/multi_index/member.hpp>
 #include <boost/array.hpp>
-#include <boost/foreach.hpp>
 
 using namespace boost::multi_index;
+using namespace boost::spirit::classic;
 using namespace boost;
 using namespace std;
 
@@ -165,7 +166,7 @@ ostream & operator<<(ostream & os, Label<N> l)
     os << "}";
     return os;
 }
-/*
+
 template<size_t N, typename Comp>
 bool is_dominated_by_any(const typename my_queue<N>::Type & Q, const Label<N> & l, Comp c)
 {
@@ -178,17 +179,6 @@ bool is_dominated_by_any(const typename my_queue<N>::Type & Q, const Label<N> &
     }
     return false;
 }
-*/
-template<size_t N, typename Comp, typename Container>
-bool is_dominated_by_any(const Container & Q, const Label<N> & l, Comp c)
-{
-    BOOST_FOREACH(Label<N> a, Q)
-    {
-        if( c(a, l) || a.cost == l.cost)
-            return true;
-    }
-    return false;
-}
 
 template<size_t N>
         bool is_dominated_by_any(const typename my_queue<N>::Type & Q, const Label<N> & l)
@@ -249,7 +239,7 @@ vector<Path> martins(int start_node, int dest_node, Graph & g, int start_time, s
             for(size_t i=1; i < N; i++)
                 l2.cost[i] = l.cost[i] + g.g[*ei].*objectives[i-1];
 
-            if(!is_dominated_by_any(node_q.equal_range(l2.node), l2, std_comp) && !is_dominated_by_any(P[l2.node],l2, std_comp) && (dest_node == invalid_node || !is_dominated_by_any(P[dest_node],l2, std_comp)))
+            if(!is_dominated_by_any(Q, l2, std_comp) && !is_dominated_by_any(P[l2.node],l2, std_comp) && (dest_node == invalid_node || !is_dominated_by_any(P[dest_node],l2, std_comp)))
             {
                 typename my_queue<N>::nodes_it it, end;
                 tie(it, end) = node_q.equal_range(l2.node);
diff --git a/lib/tsaggouris.cpp b/lib/tsaggouris.cpp
index efc0128..fc944d8 100644
--- a/lib/tsaggouris.cpp
+++ b/lib/tsaggouris.cpp
@@ -43,6 +43,7 @@ void ssmosp(Graph & g, int start)
 
     for(size_t i = 1; i < nodes; i++)
     {
+        std::cout << "New round ! (" << i << "/" << nodes - 1 << ")" << std::endl;
         Graph_t::edge_iterator e, e_end;
         tie(e, e_end) = edges(g.g);
         for(; e != e_end; e++)