clean up legacy namings across files

jdlph · jdlph · commit 20b7da4af2ed · 2023-08-12T14:10:19.000-04:00
- those namings were inherited from DTALite_s.py which has been deprecated;
- convert possible integer node id to string for some API's including
  find_shortest_path(), get_accessible_nodes(), and get_accessible_links();
- update docstrings for the above API accordingly;
- drop o_zone_name and d_zone_name from od_accessibility.csv, which
  are always empty;
- remove str conversion on node id and link id from output_columns()
  and get_agent_node_path() as node id and link id are strings;
- remove str conversion on zone id in add_centroids_connectors as zone
  is string;
- change pre_source_node_id in AccessNetwork and from_node_id_prev in
  find_shortest_path() from -1 to '' as node id is string.
diff --git a/path4gmns/accessibility.py b/path4gmns/accessibility.py
@@ -57,10 +57,7 @@ def _update_min_travel_time(an, at, min_travel_times, time_dependent, demand_per
 def _output_od_accessibility(min_travel_times, zones, mode, output_dir):
     """ output accessibility for each OD pair (i.e., travel time) """
     with open(output_dir+'/od_accessibility.csv', 'w',  newline='') as f:
-        headers = ['o_zone_id', 'o_zone_name',
-                   'd_zone_id', 'd_zone_name',
-                   'accessibility', 'distance',
-                   'geometry']
+        headers = ['o_zone_id', 'd_zone_id', 'accessibility', 'distance', 'geometry']
 
         writer = csv.writer(f)
         writer.writerow(headers)
diff --git a/path4gmns/classes.py b/path4gmns/classes.py
@@ -15,10 +15,10 @@
 
 class Node:
 
-    def __init__(self, node_seq_no, node_id, zone_id, x='', y='', is_activity_node=False):
+    def __init__(self, node_no, node_id, zone_id, x='', y='', is_activity_node=False):
         """ the attributes of node  """
-        # node_seq_no: internal node index used for calculation
-        self.node_seq_no = node_seq_no
+        # node_no: internal node index used for calculation
+        self.node_no = node_no
         # node_id: user defined node id from input
         self.node_id = node_id
         # link objects
@@ -42,7 +42,7 @@ def get_node_id(self):
         return self.node_id
 
     def get_node_no(self):
-        return self.node_seq_no
+        return self.node_no
 
     def get_coordinate(self):
         return self.coord_x + ' ' + self.coord_y
@@ -65,7 +65,7 @@ class Link:
 
     def __init__(self,
                  id,
-                 link_seq_no,
+                 link_no,
                  from_node_no,
                  to_node_no,
                  from_node_id,
@@ -80,9 +80,9 @@ def __init__(self,
                  demand_period_size=1):
         """ the attributes of link """
         self.id = id
-        self.link_seq_no = link_seq_no
-        self.from_node_seq_no = from_node_no
-        self.to_node_seq_no = to_node_no
+        self.link_no = link_no
+        self.from_node_no = from_node_no
+        self.to_node_no = to_node_no
         self.from_node_id = from_node_id
         self.to_node_id = to_node_id
         # length is mile or km
@@ -117,7 +117,7 @@ def get_link_id(self):
         return self.id
 
     def get_seq_no(self):
-        return self.link_seq_no
+        return self.link_no
 
     def get_from_node_id(self):
         return self.from_node_id
@@ -195,11 +195,11 @@ class Agent:
     id: integer starts from 1
     seq_no: internal agent index starting from 0 used for calculation
     """
-    def __init__(self, agent_id, agent_seq_no, agent_type_id, demand_period_id,
+    def __init__(self, agent_id, agent_no, agent_type_id, demand_period_id,
                  o_zone_id, d_zone_id):
         """ the attribute of agent """
         self.id = agent_id
-        self.seq_no = agent_seq_no
+        self.seq_no = agent_no
         # vehicle
         self.at_id = agent_type_id
         self.dp_id = demand_period_id
@@ -416,8 +416,8 @@ def allocate_for_CAPI(self):
         node_label_cost = [MAX_LABEL_COST] * node_size
 
         # initialize from_node_no_array, to_node_no_array, and link_cost_array
-        from_node_no_array = [link.from_node_seq_no for link in self.links]
-        to_node_no_array = [link.to_node_seq_no for link in self.links]
+        from_node_no_array = [link.from_node_no for link in self.links]
+        to_node_no_array = [link.to_node_no for link in self.links]
         link_cost_array = [link.fftt for link in self.links]
 
         # initialize others
@@ -434,7 +434,7 @@ def allocate_for_CAPI(self):
             first_link_from[i] = j
             for link in node.outgoing_links:
                 # set up the mapping from j to the true link seq no
-                sorted_link_no_array[j] = link.link_seq_no
+                sorted_link_no_array[j] = link.link_no
                 j += 1
             last_link_from[i] = j
 
@@ -475,7 +475,7 @@ def add_centroids_connectors(self):
                 continue
 
             # create a centroid
-            node_id = 'c_' + str(z)
+            node_id = 'c_' + z
             centroid = Node(node_no, node_id, z)
             # try coordinate of the centroid from each zone first. if the values
             # are invalid, then use that of the first node from each zone.
@@ -607,7 +607,7 @@ def get_agent_node_path(self, agent_id, path_only):
         path = ''
         if agent.node_path:
             path = ';'.join(
-                str(self.map_no_to_id[x]) for x in reversed(agent.node_path)
+                self.map_no_to_id[x] for x in reversed(agent.node_path)
             )
 
         if path_only:
@@ -721,7 +721,7 @@ def get_agent_type_name(self):
         """ for allowed uses in single_source_shortest_path()"""
         return self.agent_type_name
 
-    def get_link_seq_no(self, id):
+    def get_link_no(self, id):
         return self.link_ids[id]
 
     def get_agents(self):
@@ -1171,7 +1171,7 @@ def __init__(self, base, add_cc=True):
         self.link_size = base.get_link_size()
         self.centroids_added = self.base.centroids_added
         self.agent_type_name = 'all'
-        self.pre_source_node_id = -1
+        self.pre_source_node_id = ''
         if add_cc:
             self._add_centroids_connectors()
         self.capi_allocated = False
@@ -1196,8 +1196,8 @@ def get_nodes_from_zone(self, zone_id):
     def _get_zone_coord(self, zone_id):
         """ coordinate of each zone is from its first node """
         node_id = self.get_nodes_from_zone(zone_id)[0]
-        node_seq_no = self.base.get_node_no(node_id)
-        node = self.base.get_nodes()[node_seq_no]
+        node_no = self.base.get_node_no(node_id)
+        node = self.base.get_nodes()[node_no]
         return node.coord_x, node.coord_y
 
     def set_target_mode(self, mode):
@@ -1279,9 +1279,9 @@ def get_sp_distance(self, node_no):
 
         dist = 0
         while node_no >= 0:
-            link_seq_no = self.link_preds[node_no]
-            if link_seq_no >= 0:
-                dist += self.get_link(link_seq_no).get_length()
+            link_no = self.link_preds[node_no]
+            if link_no >= 0:
+                dist += self.get_link(link_no).get_length()
 
             node_no = self.node_preds[node_no]
 
@@ -1497,6 +1497,10 @@ def find_shortest_path(self, from_node_id, to_node_id, mode, seq_type='node'):
         at_name, _ = self._convert_mode(mode)
         self.network.set_agent_type_name(at_name)
 
+        # add backward compatibility in case the user still use integer node id's
+        from_node_id = str(from_node_id)
+        to_node_id = str(to_node_id)
+
         return find_shortest_path(self.network, from_node_id,
                                   to_node_id, seq_type)
 
@@ -1542,9 +1546,9 @@ def get_link(self, seq_no):
         """ return link object corresponding to link seq no """
         return self.network.get_link(seq_no)
 
-    def get_link_seq_no(self, id):
+    def get_link_no(self, id):
         """ id is string """
-        return self.network.get_link_seq_no(id)
+        return self.network.get_link_no(id)
 
     def get_node_no(self, id):
         """ id is integer """
@@ -1558,6 +1562,8 @@ def get_node_label_cost(self, node_no):
 
     def get_accessible_nodes(self, source_node_id, time_budget,
                              mode, time_dependent, tau):
+        source_node_id = str(source_node_id)
+
         if source_node_id not in self.network.map_id_to_no.keys():
             raise Exception(f'Node ID: {source_node_id} not in the network')
 
@@ -1727,7 +1733,7 @@ def set_simu_start_time(self, st):
 
     def set_capacity_ratio(self, tau, link_id, r):
         try:
-            link_no = self.get_link_seq_no(link_id)
+            link_no = self.get_link_no(link_id)
         except KeyError:
             return
 
@@ -1793,10 +1799,10 @@ def find_shortest_path(self, from_node_id, to_node_id,
         Parameters
         ----------
         from_node_id
-            the starting node id
+            the starting node id, which shall be a string
 
         to_node_id
-            the ending node id
+            the ending node id, which shall be a string
 
         seq_type
             'node' or 'link'. You will get the shortest path in sequence of
@@ -1837,7 +1843,7 @@ def get_accessible_nodes(self,
         Parameters
         ----------
         source_node_id
-            the starting node id for evaluation
+            the starting node id for evaluation, which shall be string
 
         time_budget
             the amount of time to travel in minutes
@@ -1894,7 +1900,7 @@ def get_accessible_links(self,
         Parameters
         ----------
         source_node_id
-            the starting node id for evaluation
+            the starting node id for evaluation, which shall be string
 
         time_budget
             the amount of time to travel in minutes
diff --git a/path4gmns/colgen.py b/path4gmns/colgen.py
@@ -150,15 +150,15 @@ def _backtrace_shortest_path_tree(centroid,
         link_path = []
         dist = 0
 
-        curr_node_seq_no = c.get_node_no()
+        curr_node_no = c.get_node_no()
         # retrieve the sequence backwards
-        while curr_node_seq_no >= 0:
-            curr_link_seq_no = link_preds[curr_node_seq_no]
-            if curr_link_seq_no >= 0:
-                link_path.append(curr_link_seq_no)
-                dist += links[curr_link_seq_no].length
+        while curr_node_no >= 0:
+            curr_link_no = link_preds[curr_node_no]
+            if curr_link_no >= 0:
+                link_path.append(curr_link_no)
+                dist += links[curr_link_no].length
 
-            curr_node_seq_no = node_preds[curr_node_seq_no]
+            curr_node_no = node_preds[curr_node_no]
 
         # make sure this is a valid path
         if not link_path:
@@ -199,12 +199,12 @@ def _update_column_attributes(column_pool, links):
 
             for j in col.links:
                 link = links[j]
-                nodes.append(links[j].to_node_seq_no)
+                nodes.append(links[j].to_node_no)
                 travel_time += link.travel_time_by_period[dp]
                 path_toll += links[j].get_toll()
 
             # last node
-            nodes.append(links[col.links[-1]].from_node_seq_no)
+            nodes.append(links[col.links[-1]].from_node_no)
 
             col.set_travel_time(travel_time)
             col.set_toll(path_toll)
diff --git a/path4gmns/path.py b/path4gmns/path.py
@@ -111,7 +111,7 @@ def _single_source_shortest_path_fifo(G, origin_node_no):
         from_node = SEList.pop(0)
         status[from_node] = 0
         for link in G.nodes[from_node].outgoing_links:
-            to_node = link.to_node_seq_no
+            to_node = link.to_node_no
             new_to_node_cost = (G.node_label_cost[from_node]
                                 + link.fftt)
             # we only compare cost at the downstream node ToID
@@ -124,7 +124,7 @@ def _single_source_shortest_path_fifo(G, origin_node_no):
                 G.node_preds[to_node] = from_node
                 # pointer to previous physical node index
                 # from the current label at current node and time
-                G.link_preds[to_node] = link.link_seq_no
+                G.link_preds[to_node] = link.link_no
                 if not status[to_node]:
                     SEList.append(to_node)
                     status[to_node] = 1
@@ -151,7 +151,7 @@ def _single_source_shortest_path_deque(G, origin_node_no):
         from_node = SEList.popleft()
         status[from_node] = 2
         for link in G.nodes[from_node].outgoing_links:
-            to_node = link.to_node_seq_no
+            to_node = link.to_node_no
             new_to_node_cost = (G.node_label_cost[from_node]
                                 + link.fftt)
             # we only compare cost at the downstream node ToID
@@ -164,7 +164,7 @@ def _single_source_shortest_path_deque(G, origin_node_no):
                 G.node_preds[to_node] = from_node
                 # pointer to previous physical node index
                 # from the current label at current node and time
-                G.link_preds[to_node] = link.link_seq_no
+                G.link_preds[to_node] = link.link_no
                 if status[to_node] != 1:
                     if status[to_node] == 2:
                         SEList.appendleft(to_node)
@@ -198,7 +198,7 @@ def _single_source_shortest_path_dijkstra(G, origin_node_no):
             continue
         status[from_node] = 1
         for link in G.nodes[from_node].outgoing_links:
-            to_node = link.to_node_seq_no
+            to_node = link.to_node_no
             new_to_node_cost = label_cost + link.fftt
             # we only compare cost at the downstream node ToID
             # at the new arrival time t
@@ -210,7 +210,7 @@ def _single_source_shortest_path_dijkstra(G, origin_node_no):
                 G.node_preds[to_node] = from_node
                 # pointer to previous physical node index
                 # from the current label at current node and time
-                G.link_preds[to_node] = link.link_seq_no
+                G.link_preds[to_node] = link.link_no
                 heapq.heappush(SEList, (G.node_label_cost[to_node], to_node))
 
 
@@ -255,26 +255,26 @@ def output_path_sequence(G, to_node_id, type='node'):
     Note that this function returns GENERATOR rather than list.
     """
     path = []
-    current_node_seq_no = G.map_id_to_no[to_node_id]
+    curr_node_no = G.map_id_to_no[to_node_id]
 
     if type.startswith('node'):
         # retrieve the sequence backwards
-        while current_node_seq_no >= 0:
-            path.append(current_node_seq_no)
-            current_node_seq_no = G.node_preds[current_node_seq_no]
+        while curr_node_no >= 0:
+            path.append(curr_node_no)
+            curr_node_no = G.node_preds[curr_node_no]
         # reverse the sequence
-        for node_seq_no in reversed(path):
-            yield G.map_no_to_id[node_seq_no]
+        for node_no in reversed(path):
+            yield G.map_no_to_id[node_no]
     else:
         # retrieve the sequence backwards
-        current_link_seq_no = G.link_preds[current_node_seq_no]
-        while current_link_seq_no >= 0:
-            path.append(current_link_seq_no)
-            current_node_seq_no = G.node_preds[current_node_seq_no]
-            current_link_seq_no = G.link_preds[current_node_seq_no]
+        curr_link_no = G.link_preds[curr_node_no]
+        while curr_link_no >= 0:
+            path.append(curr_link_no)
+            curr_node_no = G.node_preds[curr_node_no]
+            curr_link_no = G.link_preds[curr_node_no]
         # reverse the sequence
-        for link_seq_no in reversed(path):
-            yield G.links[link_seq_no].get_link_id()
+        for link_no in reversed(path):
+            yield G.links[link_no].get_link_id()
 
 
 def _get_path_cost(G, to_node_id):
@@ -320,7 +320,7 @@ def find_path_for_agents(G, column_pool, engine_type='c'):
         print('setting up individual agents')
         G.setup_agents(column_pool)
 
-    from_node_id_prev = -1
+    from_node_id_prev = ''
     for agent in G.agents:
         from_node_id = agent.o_node_id
         to_node_id = agent.d_node_id
@@ -344,17 +344,17 @@ def find_path_for_agents(G, column_pool, engine_type='c'):
         node_path = []
         link_path = []
 
-        current_node_seq_no = G.map_id_to_no[to_node_id]
+        curr_node_no = G.map_id_to_no[to_node_id]
         # set up the cost
-        agent.path_cost = G.node_label_cost[current_node_seq_no]
+        agent.path_cost = G.node_label_cost[curr_node_no]
 
         # retrieve the sequence backwards
-        while current_node_seq_no >= 0:
-            node_path.append(current_node_seq_no)
-            current_link_seq_no = G.link_preds[current_node_seq_no]
-            if current_link_seq_no >= 0:
-                link_path.append(current_link_seq_no)
-            current_node_seq_no = G.node_preds[current_node_seq_no]
+        while curr_node_no >= 0:
+            node_path.append(curr_node_no)
+            curr_link_no = G.link_preds[curr_node_no]
+            if curr_link_no >= 0:
+                link_path.append(curr_link_no)
+            curr_node_no = G.node_preds[curr_node_no]
 
         # make sure it is a valid path
         if not link_path:
diff --git a/path4gmns/utils.py b/path4gmns/utils.py
diff --git a/tests/demo.py b/tests/demo.py
