network_route -> network_links

examples/4_3_using_network_routing.ipynb

@@ -481,7 +481,7 @@
     }
    ],
    "source": [
-    "list(n.schedule[\"17732\"].routes())[0].network_route"
+    "list(n.schedule[\"17732\"].routes())[0].network_links"
    ]
   },
   {

examples/5_2_modifying_network_pt_schedule.ipynb

@@ -821,7 +821,7 @@
     }
    ],
    "source": [
-    "n.schedule[\"new_service\"].route(\"new_route\").network_route"
+    "n.schedule[\"new_service\"].route(\"new_route\").network_links"
    ]
   },
   {
@@ -914,7 +914,7 @@
     }
    ],
    "source": [
-    "n.schedule[\"new_service\"].route(\"new_route\").network_route"
+    "n.schedule[\"new_service\"].route(\"new_route\").network_links"
    ]
   },
   {

examples/example_data/example_json/schedule.json

@@ -53,7 +53,7 @@
             ],
             "route_long_name": "",
             "id": "VJ6c64ab7b477e201cae950efde5bd0cb4e2e8888e",
-            "network_route": [
+            "network_links": [
               "1",
               "10"
             ],

genet/core.py

@@ -663,8 +663,8 @@ def subnetwork(
                     "network routes will also be retained."
                 )
                 subschedule = self.schedule.subschedule(services)
-                routes = subschedule.route_attribute_data(keys=["network_route"])
-                links = links | set(np.concatenate(routes["network_route"].values))
+                routes = subschedule.route_attribute_data(keys=["network_links"])
+                links = links | set(np.concatenate(routes["network_links"].values))
                 subnetwork.schedule = subschedule
         subnetwork.graph = self.subgraph_on_link_conditions(conditions={"id": links})
         subnetwork.link_id_mapping = {k: v for k, v in self.link_id_mapping.items() if k in links}
@@ -2294,7 +2294,7 @@ def route_path(ordered_stops):
         routes = routes[
             routes.index.to_series().isin({item for sublist in _rs for item in sublist})
         ]
-        routes["network_route"] = routes["ordered_stops"].apply(lambda x: route_path(x))
+        routes["network_links"] = routes["ordered_stops"].apply(lambda x: route_path(x))
         routes = routes.drop("ordered_stops", axis=1).T.to_dict()
 
         self.add_nodes({node: nodes[node] for node in set(nodes) - set(self.graph.nodes)})
@@ -2383,18 +2383,18 @@ def _reroute_route(self, _id, additional_modes=None):
             logging.info(f"Rerouting Route `{_id}`")
             modes = {route.mode} | persistence.setify(additional_modes)
             subgraph = self.modal_subgraph(modes)
-            network_route = [linkrefids[0]]
+            network_links = [linkrefids[0]]
             for from_stop_link_id, to_stop_link_id in zip(linkrefids[:-1], linkrefids[1:]):
-                network_route += self.find_shortest_path(
+                network_links += self.find_shortest_path(
                     self.link(from_stop_link_id)["to"],
                     self.link(to_stop_link_id)["from"],
                     subgraph=subgraph,
                 )
-                network_route.append(to_stop_link_id)
-            self.schedule.apply_attributes_to_routes({_id: {"network_route": network_route}})
+                network_links.append(to_stop_link_id)
+            self.schedule.apply_attributes_to_routes({_id: {"network_links": network_links}})
             links_for_mode_add = {
                 link_id
-                for link_id in set(network_route)
+                for link_id in set(network_links)
                 if not {route.mode}.issubset(persistence.setify(self.link(link_id)["modes"]))
             }
             if links_for_mode_add:
@@ -2432,9 +2432,9 @@ def schedule_routes(self) -> Iterator[schedule_elements.Route]:
     def schedule_routes_nodes(self):
         routes = []
         for _route in self.schedule_routes():
-            if _route.network_route:
+            if _route.network_links:
                 route_nodes = graph_operations.convert_list_of_link_ids_to_network_nodes(
-                    self, _route.network_route
+                    self, _route.network_links
                 )
                 if len(route_nodes) != 1:
                     logging.warning(
@@ -2448,8 +2448,8 @@ def schedule_routes_nodes(self):
     def schedule_routes_links(self):
         routes = []
         for service_id, _route in self.schedule_routes():
-            if _route.network_route:
-                routes.append(_route.network_route)
+            if _route.network_links:
+                routes.append(_route.network_links)
         return routes
 
     def schedule_network_routes_geodataframe(self):
@@ -2466,19 +2466,19 @@ def combine_geometry(group):
 
         gdf_links = self.to_geodataframe()["links"]
         routes = self.schedule.route_attribute_data(
-            keys=["id", "route_short_name", "mode", "network_route"]
+            keys=["id", "route_short_name", "mode", "network_links"]
         )
         routes = routes.rename(columns={"id": "route_id"})
-        routes["route_sequence"] = routes["network_route"].apply(lambda x: list(range(len(x))))
+        routes["route_sequence"] = routes["network_links"].apply(lambda x: list(range(len(x))))
 
         # expand on network route link sequence
         routes = pd.DataFrame(
             {
-                col: np.repeat(routes[col].values, routes["network_route"].str.len())
+                col: np.repeat(routes[col].values, routes["network_links"].str.len())
                 for col in {"route_id", "route_short_name", "mode"}
             }
         ).assign(
-            network_route=np.concatenate(routes["network_route"].values),
+            network_links=np.concatenate(routes["network_links"].values),
             route_sequence=np.concatenate(routes["route_sequence"].values),
         )
         routes["service_id"] = routes["route_id"].apply(
@@ -2487,7 +2487,7 @@ def combine_geometry(group):
 
         # get geometry for link IDs
         routes = pd.merge(
-            routes, gdf_links[["id", "geometry"]], left_on="network_route", right_on="id"
+            routes, gdf_links[["id", "geometry"]], left_on="network_links", right_on="id"
         )
         routes = routes.groupby("route_id").apply(combine_geometry).reset_index(drop=True)
         return gpd.GeoDataFrame(routes).set_crs(self.epsg)
@@ -2678,23 +2678,23 @@ def index_graph_edges(self):
 
     def has_schedule_with_valid_network_routes(self):
         routes = [route for route in self.schedule_routes()]
-        if all([route.has_network_route() for route in routes]):
+        if all([route.has_network_links() for route in routes]):
             return all([self.is_valid_network_route(route) for route in routes])
         return False
 
     def calculate_route_to_crow_fly_ratio(self, route: schedule_elements.Route):
-        route_dist = self.route_distance(route.network_route)
+        route_dist = self.route_distance(route.network_links)
         crowfly_dist = route.crowfly_distance()
         if crowfly_dist:
             return route_dist / crowfly_dist
         else:
             return "Division by zero"
 
     def is_valid_network_route(self, route: schedule_elements.Route):
-        if self.has_links(route.network_route):
-            valid_link_chain = self.has_valid_link_chain(route.network_route)
+        if self.has_links(route.network_links):
+            valid_link_chain = self.has_valid_link_chain(route.network_links)
             links_have_correct_modes = self.has_links(
-                route.network_route, {"modes": route.mode}, mixed_dtypes=True
+                route.network_links, {"modes": route.mode}, mixed_dtypes=True
             )
             if not links_have_correct_modes:
                 logging.info(
@@ -2754,7 +2754,7 @@ def invalid_network_routes(self):
         return [
             route.id
             for route in self.schedule.routes()
-            if not route.has_network_route() or not self.is_valid_network_route(route)
+            if not route.has_network_links() or not self.is_valid_network_route(route)
         ]
 
     def generate_validation_report(
@@ -3242,10 +3242,10 @@ def split_link_at_node(
         if self.schedule:
             logging.info("Updating network routes in the PT schedule.")
             # update schedule routes
-            df_routes = self.schedule.route_attribute_data(keys=["network_route"])
-            df_routes = df_routes[df_routes["network_route"].apply(lambda x: link_id in x)]
+            df_routes = self.schedule.route_attribute_data(keys=["network_links"])
+            df_routes = df_routes[df_routes["network_links"].apply(lambda x: link_id in x)]
             if not df_routes.empty:
-                df_routes["network_route"] = df_routes["network_route"].apply(
+                df_routes["network_links"] = df_routes["network_links"].apply(
                     lambda x: replace_link_on_pt_route(x, {link_id: [new_link_1, new_link_2]})
                 )
                 self.schedule.apply_attributes_to_routes(df_routes.T.to_dict())

genet/input/matsim_reader.py

@@ -344,7 +344,7 @@ def write_transitLinesTransitRoute(transitLine, transitRoutes, transportMode):
                 route_short_name=transitLine["transitLine_data"]["name"],
                 mode=mode,
                 stops=stops,
-                network_route=route,
+                network_links=route,
                 trips=trips,
                 arrival_offsets=arrival_offsets,
                 departure_offsets=departure_offsets,

genet/max_stable_set.py

@@ -495,7 +495,7 @@ def new_network_nodes(self, max_stable_set):
 
     def update_df_route_data(self, df_route_data, max_stable_set):
         # update stops and generate routed paths
-        df_route_data.loc[:, "network_route"] = df_route_data.loc[:, "ordered_stops"].apply(
+        df_route_data.loc[:, "network_links"] = df_route_data.loc[:, "ordered_stops"].apply(
             lambda x: max_stable_set.routed_path(x)
         )
         _map = max_stable_set.stops_to_artificial_stops_map()
@@ -507,7 +507,7 @@ def update_df_route_data(self, df_route_data, max_stable_set):
     def generate_additional_links_modes(self, max_stable_set):
         link_ids = {
             link_id
-            for route_list in self.df_route_data["network_route"].values
+            for route_list in self.df_route_data["network_links"].values
             for link_id in route_list
         }
         links = max_stable_set.network_spatial_tree.links.copy()

genet/output/matsim_xml_writer.py

@@ -278,15 +278,15 @@ def write_matsim_schedule(output_dir, schedule, reproj_processes=1):
                                             ).lower()
                                     xf.write(etree.Element("stop", stop_attribs))
 
-                            if not route.network_route:
+                            if not route.network_links:
                                 logging.warning(
                                     "Route needs to have a network route composed of a list of network links that "
                                     "the vehicle on this route traverses. If read the Schedule from GTFS, the "
                                     "resulting Route objects will not have reference to the network route taken."
                                 )
                             else:
                                 with xf.element("route"):
-                                    for link_id in route.network_route:
+                                    for link_id in route.network_links:
                                         route_attribs = {"refId": str(link_id)}
                                         xf.write(etree.Element("link", route_attribs))
 

genet/schedule_elements.py

@@ -797,7 +797,7 @@ def __init__(
         departure_offsets: list[str],
         trips: Optional[dict[str, list[str]]] = None,
         headway_spec: Optional[dict] = None,
-        network_route: Optional[list] = None,
+        network_links: Optional[list] = None,
         route_long_name: str = "",
         id: str = "",
         await_departure: Optional[list] = None,
@@ -829,7 +829,7 @@ def __init__(
                 Dictionary with tuple keys: (from time, to time) and headway values in minutes:
                 `{('HH:MM:SS', 'HH:MM:SS'): headway_minutes}`.
                 Defaults to None.
-            route (Optional[list], optional):
+            network_links (Optional[list], optional):
                 Network link_ids traversed by the vehicles in this Route instance. Defaults to None.
             route_long_name (str, optional):
                 Verbose name for the route if exists. Defaults to "".
@@ -861,10 +861,10 @@ def __init__(
                 "Please provide trip or headway information to initialise Route object"
             )
 
-        if network_route is None:
-            self.network_route = []
+        if network_links is None:
+            self.network_links = []
         else:
-            self.network_route = network_route
+            self.network_links = network_links
         if await_departure is None:
             self.await_departure = []
         else:
@@ -1197,22 +1197,22 @@ def has_more_than_one_stop(self):
             return True
         return False
 
-    def has_network_route(self):
-        return self.network_route
+    def has_network_links(self) -> bool:
+        return bool(self.network_links)
 
-    def divide_network_route_between_stops(self):
-        if self.has_network_route():
+    def divide_network_links_between_stops(self):
+        if self.has_network_links():
             stops_linkrefids = [self._graph.nodes[i]["linkRefId"] for i in self.ordered_stops]
             if not stops_linkrefids:
                 raise RuntimeError(
                     "This Stops in this Route are not snapped to the network via `linkRefId` attribute"
                 )
-            return use_schedule.divide_network_route(self.network_route, stops_linkrefids)
+            return use_schedule.divide_network_route(self.network_links, stops_linkrefids)
         else:
             raise RuntimeError("This Route does not have a network route to divide")
 
     def has_correctly_ordered_route(self):
-        if self.has_network_route():
+        if self.has_network_links():
             stops_linkrefids = [
                 self._graph.nodes[i]["linkRefId"]
                 for i in self.ordered_stops
@@ -1221,7 +1221,7 @@ def has_correctly_ordered_route(self):
             if len(stops_linkrefids) != len(self.ordered_stops):
                 logging.warning("Not all stops reference network link ids.")
                 return False
-            divided_route = self.divide_network_route_between_stops()
+            divided_route = self.divide_network_links_between_stops()
             if not divided_route:
                 return False
             reassembled_route = sum(divided_route, [])
@@ -1231,7 +1231,7 @@ def has_correctly_ordered_route(self):
                 if reassembled_route[i - 1] != reassembled_route[i]
             ]
             if (len(stops_linkrefids) - 1) == len(divided_route) and (
-                reassembled_route == self.network_route
+                reassembled_route == self.network_links
             ):
                 return True
         return False

genet/use/schedule.py

@@ -203,43 +203,43 @@ def combine_route(group):
         "output as well."
     )
 
-    routes_df = schedule.route_attribute_data(keys=["id", "network_route", "ordered_stops"])
+    routes_df = schedule.route_attribute_data(keys=["id", "network_links", "ordered_stops"])
     routes_df["linkrefids"] = routes_df.apply(
         lambda x: [
             schedule._graph.nodes[i]["linkRefId"]
             for i in schedule._graph.graph["routes"][x["id"]]["ordered_stops"]
         ],
         axis=1,
     )
-    routes_df["network_route"] = routes_df.apply(
-        lambda x: divide_network_route(x["network_route"], x["linkrefids"]), axis=1
+    routes_df["network_links"] = routes_df.apply(
+        lambda x: divide_network_route(x["network_links"], x["linkrefids"]), axis=1
     )
     routes_df.drop("linkrefids", axis=1, inplace=True)
     routes_df["ordered_stops"] = routes_df["ordered_stops"].apply(
         lambda x: list(zip(x[:-1], x[1:]))
     )
     stop_cols = np.concatenate(routes_df["ordered_stops"].values)
-    route_cols = sum(routes_df["network_route"].values, [])
+    route_cols = sum(routes_df["network_links"].values, [])
     # expand across stop pairs
     routes_df = pd.DataFrame(
         {
             col: np.repeat(routes_df[col].values, routes_df["ordered_stops"].str.len())
-            for col in set(routes_df.columns) - {"ordered_stops", "network_route"}
+            for col in set(routes_df.columns) - {"ordered_stops", "network_links"}
         }
-    ).assign(from_stop=stop_cols[:, 0], to_stop=stop_cols[:, 1], network_route=route_cols)
+    ).assign(from_stop=stop_cols[:, 0], to_stop=stop_cols[:, 1], network_links=route_cols)
     # expand across route
-    routes_df["sequence"] = routes_df["network_route"].apply(lambda x: list(range(len(x))))
+    routes_df["sequence"] = routes_df["network_links"].apply(lambda x: list(range(len(x))))
     routes_df = pd.DataFrame(
         {
-            col: np.repeat(routes_df[col].values, routes_df["network_route"].str.len())
-            for col in set(routes_df.columns) - {"network_route", "sequence"}
+            col: np.repeat(routes_df[col].values, routes_df["network_links"].str.len())
+            for col in set(routes_df.columns) - {"network_links", "sequence"}
         }
     ).assign(
-        network_route=np.concatenate(routes_df["network_route"].values),
+        network_links=np.concatenate(routes_df["network_links"].values),
         sequence=np.concatenate(routes_df["sequence"].values),
     )
     routes_gdf = gdf_network_links[["length", "geometry"]].merge(
-        routes_df, right_on="network_route", left_index=True
+        routes_df, right_on="network_links", left_index=True
     )
 
     new_route = routes_gdf.groupby(["id", "from_stop", "to_stop"], as_index=False).apply(

genet/utils/simplification.py

@@ -286,8 +286,8 @@ def simplify_graph(n, no_processes=1):
         logging.info("Updated Stop Link Reference Ids")
 
         # update schedule routes
-        df_routes = n.schedule.route_attribute_data(keys=["network_route"])
-        df_routes["network_route"] = df_routes["network_route"].apply(
+        df_routes = n.schedule.route_attribute_data(keys=["network_links"])
+        df_routes["network_links"] = df_routes["network_links"].apply(
             lambda x: update_link_ids(x, n.link_simplification_map)
         )
         n.schedule.apply_attributes_to_routes(df_routes.T.to_dict())