dynflows 0.1.0__tar.gz

dynflows-0.1.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.3
+Name: dynflows
+Version: 0.1.0
+Summary: A library for computing, illustrating, and evaluating dynamic flows, a.k.a. flows over time, in Vickrey's fluid queuing model mainly used in dynamic traffic assignment.
+Keywords: flows over time,dynamic traffic assignment,scientific computing
+Author: Michael Markl
+Author-email: Michael Markl <marklmichael98@gmail.com>
+Requires-Dist: numpy>=1.23.4,<2
+Requires-Dist: pandas>=2.0.0,<3
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# dynflows
+
+TODO: Add Content.

dynflows-0.1.0/README.md

@@ -0,0 +1,3 @@
+# dynflows
+
+TODO: Add Content.

dynflows-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "dynflows"
+version = "0.1.0"
+description = "A library for computing, illustrating, and evaluating dynamic flows, a.k.a. flows over time, in Vickrey's fluid queuing model mainly used in dynamic traffic assignment."
+authors = [
+    {name = "Michael Markl", email = "marklmichael98@gmail.com"}
+]
+readme = "README.md"
+requires-python=">=3.11"
+keywords = [ "flows over time", "dynamic traffic assignment", "scientific computing" ]
+
+dependencies = [
+    "numpy >= 1.23.4, < 2",
+    "pandas >= 2.0.0, < 3"
+]
+
+[dependency-groups]
+dev = [
+    "matplotlib >= 3.8.3, < 4",
+    "black >= 23.3.0, < 24",
+    "isort >= 5.12.0, < 6",
+    "pylint >= 4, < 5",
+    "pytest >= 8.0.2, < 9"
+]
+
+[build-system]
+requires = ["uv_build>=0.11.14,<0.12"]
+build-backend = "uv_build"

dynflows-0.1.0/src/dynflows/core/active_edges.py

@@ -0,0 +1,62 @@
+from typing import Callable, Dict, FrozenSet, List, Sequence, Set
+
+from dynflows.core.dijkstra import dynamic_dijkstra
+from dynflows.core.graph import DirectedGraph, Edge, Node
+from dynflows.utilities.piecewise_linear import PiecewiseLinear
+
+identity = PiecewiseLinear([0.0], [0.0], 1.0, 1.0)
+
+
+def backward_search(
+    costs: Sequence[Callable[[float], float]],
+    arrivals: Dict[Node, float],
+    source: Node,
+    sink: Node,
+) -> Set[Edge]:
+    active_edges = set()
+    queue: List[Node] = [sink]
+    nodes_enqueued: Set[Node] = {sink}
+    while len(queue) > 0:
+        w = queue.pop()
+        for e in w.incoming_edges:
+            v = e.node_from
+            if v not in arrivals.keys():
+                continue
+            if arrivals[v] + costs[e.id](arrivals[v]) <= arrivals[w]:
+                if v == source:
+                    active_edges.add(e)
+                if v not in nodes_enqueued:
+                    queue.append(v)
+                    nodes_enqueued.add(v)
+    return active_edges
+
+
+def get_active_edges(
+    costs: List[PiecewiseLinear],
+    theta: float,
+    source: Node,
+    sink: Node,
+    relevant_nodes: FrozenSet[Node],
+    graph: DirectedGraph,
+    strong_fifo: bool,
+) -> Set[Edge]:
+    if len([e for e in source.outgoing_edges if e.node_to in relevant_nodes]) <= 1:
+        return set(source.outgoing_edges)
+    arrivals, _ = dynamic_dijkstra(theta, source, sink, relevant_nodes, costs)
+    if strong_fifo:
+        return backward_search(costs, arrivals, source, sink)
+    else:  # Second run of Dijkstra on the reverse graph.
+        graph.reverse()
+        traversals = [cost.plus(identity) for cost in costs]
+        new_costs: List[Callable[[float], float]] = [
+            lambda t: -trav.reversal(-t) - t for trav in traversals
+        ]
+        neg_departures = dynamic_dijkstra(
+            arrivals[sink], sink, source, relevant_nodes, new_costs
+        )
+        graph.reverse()
+        active_edges = set()
+        for e in source.outgoing_edges:
+            if traversals[e.id](theta) <= -neg_departures[e.node_to]:
+                active_edges.add(e)
+        return active_edges

dynflows-0.1.0/src/dynflows/core/bellman_ford.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from typing import Dict, List, Set
+
+from dynflows.core.graph import Node
+from dynflows.core.machine_precision import eps
+from dynflows.utilities.piecewise_linear import PiecewiseLinear
+from dynflows.utilities.queues import PriorityQueue
+
+
+def bellman_ford(
+    sink: Node,
+    costs: List[PiecewiseLinear],
+    interesting_nodes: Set[Node],
+    phi: float,
+    horizon: float = float("inf"),
+) -> Dict[Node, PiecewiseLinear]:
+    """
+    Calculates the earliest arrival time at `sink` as functions (l_v).
+    """
+    identity = PiecewiseLinear([phi], [phi], 1.0, 1.0, (phi, horizon))
+    # g_v(t) = earliest arrival at sink when starting in v at time t
+    g: Dict[Node, PiecewiseLinear] = {sink: identity}
+    node_distance: Dict[Node, int] = {sink: 0}
+
+    def get_fifo_arrival_time(traversal: PiecewiseLinear):
+        new_values = traversal.values.copy()
+        for i in range(len(new_values) - 1):
+            assert new_values[i] <= new_values[i + 1] + eps
+            new_values[i + 1] = max(
+                new_values[i], new_values[i + 1], traversal.times[i + 1]
+            )
+
+        new_traversal = PiecewiseLinear(
+            traversal.times,
+            new_values,
+            traversal.first_slope,
+            traversal.last_slope,
+            traversal.domain,
+        )
+        if new_traversal.last_slope < 1:
+            new_traversal.last_slope = 1
+        return new_traversal
+
+    edge_arrival_times = [
+        get_fifo_arrival_time(identity.plus(cost)).simplify() for cost in costs
+    ]
+
+    changes_detected_at = PriorityQueue([(sink, 0.0)])
+
+    while len(changes_detected_at) > 0:
+        changed_nodes = changes_detected_at
+        changes_detected_at = PriorityQueue([])
+
+        for w in changed_nodes.sorted():
+            for edge in w.incoming_edges:
+                v = edge.node_from
+                if v not in interesting_nodes:
+                    continue
+                T = edge_arrival_times[edge.id]
+                restr_domain = (
+                    T.min_t_above(g[w].domain[0]),
+                    T.max_t_below(g[w].domain[1]),
+                )
+                if restr_domain[0] is None or restr_domain[1] is None:
+                    continue
+                relaxation = g[w].compose(T.restrict(restr_domain))  # type: ignore
+                if v not in g.keys():
+                    node_distance[v] = node_distance[w] + 1
+                    if v not in changes_detected_at:
+                        changes_detected_at.push(v, node_distance[v])
+                    g[v] = relaxation.simplify()
+                elif not g[v].smaller_equals(relaxation):
+                    if not changes_detected_at.has(v):
+                        changes_detected_at.push(v, node_distance[v])
+                    g[v] = g[v].outer_minimum(relaxation).simplify()
+    return g

dynflows-0.1.0/src/dynflows/core/dijkstra.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from typing import Callable, Dict, FrozenSet, List, NamedTuple, Sequence, Set, Tuple
+
+from dynflows.core.graph import Edge, Node
+from dynflows.core.machine_precision import eps
+from dynflows.utilities.queues import PriorityQueue
+
+
+def reverse_dijkstra(
+    sink: Node, costs: List[float], nodes: Set[Node]
+) -> Dict[Node, float]:
+    dist: Dict[Node, float] = {sink: 0}
+    queue = PriorityQueue([(sink, dist[sink])])
+
+    assert sink in nodes
+
+    while len(queue) > 0:
+        w = queue.pop()
+        for edge in w.incoming_edges:
+            v = edge.node_from
+            if v not in nodes:
+                continue
+            relaxation = costs[edge.id] + dist[w]
+            if v not in dist.keys():
+                dist[v] = relaxation
+                queue.push(v, dist[v])
+            elif relaxation < dist[v] - eps:
+                dist[v] = relaxation
+                if queue.has(v):
+                    queue.decrease_key(v, relaxation)
+                else:
+                    queue.push(v, relaxation)
+
+    return dist
+
+
+class DynamicDijkstraResult(NamedTuple):
+    arrival_times: Dict[Node, float]
+    realized_cost: Dict[Edge, float]
+
+
+def dynamic_dijkstra(
+    phi: float,
+    source: Node,
+    sink: Node,
+    relevant_nodes: Set[Node],
+    costs: Sequence[Callable[[float], float]],
+) -> DynamicDijkstraResult:
+    """
+    Assumes costs to follow the FIFO rule and relevant_nodes to contain
+    all nodes that lie on a path from source to sink.
+    Returns the earliest arrival times when departing from source at
+    time phi for nodes that source can reach up to the arrival at sink.
+    """
+    arrival_times: Dict[Node, float] = {}
+    queue: PriorityQueue[Node] = PriorityQueue([(source, phi)])
+    realized_cost = {}
+    while len(queue) > 0:
+        arrival_time, v = queue.min_key(), queue.pop()
+        arrival_times[v] = arrival_time
+        if v == sink:
+            break
+        for e in v.outgoing_edges:
+            w = e.node_to
+            if w in arrival_times or w not in relevant_nodes:
+                continue
+            realized_cost[e] = costs[e.id](arrival_times[v])
+            relaxation = arrival_times[v] + realized_cost[e]
+            if not queue.has(w):
+                queue.push(w, relaxation)
+            elif relaxation < queue.key_of(w):
+                queue.decrease_key(w, relaxation)
+    return DynamicDijkstraResult(arrival_times, realized_cost)
+
+
+def get_active_edges_from_dijkstra(
+    dijkstra_result: DynamicDijkstraResult,
+    source: Node,
+    sink: Node,
+) -> List[Edge]:
+    arrival_times, realised_cost = dijkstra_result
+    active_edges = []
+    touched_nodes = {sink}
+    queue: List[Node] = [sink]
+    while queue:
+        w = queue.pop()
+        for e in w.incoming_edges:
+            if e not in realised_cost.keys():
+                continue
+            v: Node = e.node_from
+            if arrival_times[v] + realised_cost[e] <= arrival_times[w] + eps:
+                if v == source:
+                    active_edges.append(e)
+                if v not in touched_nodes:
+                    touched_nodes.add(v)
+                    queue.append(v)
+
+    assert len(active_edges) > 0
+    return active_edges

dynflows-0.1.0/src/dynflows/core/dynamic_flow.py

@@ -0,0 +1,257 @@
+from __future__ import annotations
+
+from functools import lru_cache
+from typing import Dict, List, Optional, Set, Tuple
+
+from dynflows.core.flow_rates_collection import FlowRatesCollection
+from dynflows.core.machine_precision import eps
+from dynflows.core.network import Network
+from dynflows.utilities.piecewise_linear import PiecewiseLinear
+from dynflows.utilities.queues import PriorityQueue
+from dynflows.utilities.right_constant import RightConstant
+
+ChangeEventValue = Tuple[Dict[int, float], float]
+ChangeEvent = Optional[Tuple[float, ChangeEventValue]]
+
+
+class DepletionQueue:
+    depletions: PriorityQueue[int]
+    change_times: PriorityQueue[int]
+    new_outflow: Dict[int, ChangeEventValue]  # time, comm: outflow, sum over outflow
+
+    def __init__(self):
+        self.depletions = PriorityQueue()
+        self.change_times = PriorityQueue()
+        self.new_outflow = {}
+
+    def set(
+        self, edge: int, depletion_time: float, change_event: ChangeEvent = None
+    ) -> None:
+        assert depletion_time > float("-inf")
+        self.depletions.set(edge, depletion_time)
+
+        if change_event is not None:
+            (change_time, change_value) = change_event
+            self.new_outflow[edge] = change_value
+            self.change_times.set(edge, change_time)
+        elif edge in self.change_times:
+            self.change_times.remove(edge)
+            self.new_outflow.pop(edge)
+
+    def __contains__(self, edge) -> bool:
+        return edge in self.depletions
+
+    def __len__(self) -> int:
+        return len(self.depletions)
+
+    def remove(self, edge: int) -> None:
+        self.depletions.remove(edge)
+        if edge in self.change_times:
+            self.change_times.remove(edge)
+            self.new_outflow.pop(edge)
+
+    def min_change_time(self) -> float:
+        return self.change_times.min_key()
+
+    def min_depletion(self) -> float:
+        return self.depletions.min_key()
+
+    def pop_by_depletion(self) -> Tuple[int, float, ChangeEvent]:
+        depl_time, e = self.depletions.min_key(), self.depletions.pop()
+        change_event = None
+        if e in self.change_times:
+            change_time = self.change_times.key_of(e)
+            self.change_times.remove(e)
+            new_outflow, new_outflow_sum = self.new_outflow.pop(e)
+            change_event = (change_time, (new_outflow, new_outflow_sum))
+        return e, depl_time, change_event
+
+
+class DynamicFlow:
+    """
+    This is a representation of a flow with right-constant edge inflow rates on intervals.
+    """
+
+    phi: float
+    # inflow[e][i] is the function fᵢₑ⁺
+    inflow: List[FlowRatesCollection]
+    # outflow[e][i] is the function fᵢₑ⁻
+    outflow: List[FlowRatesCollection]
+    queues: List[PiecewiseLinear]  # queues[e] is the queue length at e
+    # A priority queue with times when some edge outflow changes
+    outflow_changes: PriorityQueue[Tuple[int, float]]
+    depletions: DepletionQueue  # A priority queue with events at which queues deplete
+    _network: Network
+
+    def __init__(self, network: Network):
+        self._network = network
+        self.phi = 0.0
+        self.inflow = [FlowRatesCollection() for _ in network.graph.edges]
+        self.queues = [
+            PiecewiseLinear([self.phi], [0.0], 0.0, 0.0) for _ in network.graph.edges
+        ]
+        self.outflow = [FlowRatesCollection() for _ in network.graph.edges]
+        self.outflow_changes = PriorityQueue()
+        self.depletions = DepletionQueue()
+
+    def __getstate__(self):
+        """Return state values to be pickled."""
+        state = self.__dict__.copy()
+        # Don't pickle _network b.c. of recursive structure
+        del state["_network"]
+        return state
+
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+        print("Please reset network on flow before accessing its functions")
+
+    def _extend_case_i(self, e: int, cur_queue: float):
+        capacity, travel_time = self._network.capacity[e], self._network.travel_time[e]
+        arrival = self.phi + cur_queue / capacity + travel_time
+
+        self.outflow[e].extend(arrival, {}, 0.0)
+
+        self.outflow_changes.set((e, arrival), arrival)
+
+        queue_slope = 0.0 if cur_queue == 0.0 else -capacity
+        self.queues[e].extend_with_slope(self.phi, queue_slope)
+        if cur_queue > 0:
+            depl_time = self.phi + cur_queue / capacity
+            assert self.queues[e](depl_time) < 1000 * eps
+            self.depletions.set(e, depl_time)
+        elif e in self.depletions:
+            self.depletions.remove(e)
+
+    def _extend_case_ii(
+        self, e: int, new_inflow: Dict[int, float], cur_queue: float, acc_in: float
+    ):
+        capacity, travel_time = self._network.capacity[e], self._network.travel_time[e]
+        arrival = self.phi + cur_queue / capacity + travel_time
+
+        acc_out = min(capacity, acc_in)
+        factor = acc_out / acc_in
+
+        new_outflow = {i: factor * value for i, value in new_inflow.items()}
+        self.outflow[e].extend(arrival, new_outflow, acc_out)
+
+        self.outflow_changes.set((e, arrival), arrival)
+
+        queue_slope = max(acc_in - capacity, 0.0)
+        self.queues[e].extend_with_slope(self.phi, queue_slope)
+        if e in self.depletions:
+            self.depletions.remove(e)
+
+    def _extend_case_iii(
+        self, e: int, new_inflow: Dict[int, float], cur_queue: float, acc_in: float
+    ):
+        capacity, travel_time = self._network.capacity[e], self._network.travel_time[e]
+        arrival = self.phi + cur_queue / capacity + travel_time
+
+        factor = capacity / acc_in
+
+        new_outflow = {i: factor * value for i, value in new_inflow.items()}
+        self.outflow[e].extend(arrival, new_outflow, capacity)
+
+        self.outflow_changes.set((e, arrival), arrival)
+
+        queue_slope = acc_in - capacity
+        self.queues[e].extend_with_slope(self.phi, queue_slope)
+
+        depl_time = self.phi - cur_queue / queue_slope
+        planned_change_time = depl_time + travel_time
+        planned_change_value = (new_inflow, acc_in)
+        assert self.queues[e](depl_time) < 1000 * eps
+
+        self.depletions.set(e, depl_time, (planned_change_time, planned_change_value))
+
+    def _process_depletions(self):
+        while self.depletions.min_depletion() <= self.phi and len(self.depletions) > 0:
+            (e, depl_time, change_event) = self.depletions.pop_by_depletion()
+            self.queues[e].extend_with_slope(depl_time, 0.0)
+            assert abs(self.queues[e].values[-1]) < 1000 * eps
+            self.queues[e].values[-1] = 0.0
+            if change_event is not None:
+                (change_time, (new_outflow, new_outflow_sum)) = change_event
+                self.outflow_changes.set((e, change_time), change_time)
+                self.outflow[e].extend(change_time, new_outflow, new_outflow_sum)
+
+    def extend(
+        self, new_inflow: Dict[int, Dict[int, float]], max_extension_time: float
+    ) -> Set[int]:
+        """
+        Extends the flow with constant inflows new_inflow until some edge outflow changes.
+        Edge inflows not in new_inflow are extended with their previous values.
+        The user can also specify a maximum extension length using max_extension_length.
+        :returns set of edges where the outflow has changed at the new time self.phi
+        """
+        self.get_edge_loads.cache_clear()
+        capacity = self._network.capacity
+
+        for e in new_inflow.keys():
+            if self.inflow[e].get_values_at_time(self.phi) == new_inflow[e]:
+                continue
+            acc_in = sum(new_inflow[e].values())
+            cur_queue = max(self.queues[e].eval_from_end(self.phi), 0.0)
+
+            self.inflow[e].extend(self.phi, new_inflow[e], acc_in)
+            if acc_in == 0.0:
+                self._extend_case_i(e, cur_queue)
+            elif cur_queue == 0.0 or acc_in >= capacity[e] - eps:
+                self._extend_case_ii(e, new_inflow[e], cur_queue, acc_in)
+            else:
+                self._extend_case_iii(e, new_inflow[e], cur_queue, acc_in)
+
+        self.phi = min(
+            self.depletions.min_change_time(),
+            self.outflow_changes.min_key(),
+            max_extension_time,
+        )
+
+        self._process_depletions()
+
+        changed_edges: Set[int] = set()
+        while (
+            self.outflow_changes.min_key() <= self.phi and len(self.outflow_changes) > 0
+        ):
+            changed_edges.add(self.outflow_changes.pop()[0])
+        return changed_edges
+
+    def avg_travel_time(self, i: int, horizon: float) -> float:
+        commodity = self._network.commodities[i]
+        net_outflow: RightConstant = sum(
+            (
+                self.outflow[e.id]._functions_dict[i]
+                for e in commodity.sink.incoming_edges
+                if i in self.outflow[e.id]._functions_dict
+            ),
+            start=RightConstant([0.0], [0.0], (0, float("inf"))),
+        )
+        accum_net_outflow = net_outflow.integral()
+        net_inflow: RightConstant = sum(
+            (inflow for inflow in commodity.sources.values()),
+            start=RightConstant([0.0], [0.0], (0, float("inf"))),
+        )
+        accum_net_inflow = net_inflow.integral()
+
+        avg_travel_time = (
+            accum_net_inflow.integrate(0.0, horizon)
+            - accum_net_outflow.integrate(0.0, horizon)
+        ) / accum_net_inflow(horizon)
+        return avg_travel_time
+
+    @lru_cache()
+    def get_edge_loads(self) -> List[PiecewiseLinear]:
+        edge_loads: List[PiecewiseLinear] = [
+            self.inflow[e].accumulative - self.outflow[e].accumulative
+            for e in range(len(self.inflow))
+        ]
+        assert all(edge_load.domain[0] == 0.0 for edge_load in edge_loads)
+        assert all(abs(edge_load(0.0)) < 1e-10 for edge_load in edge_loads)
+        for edge_load in edge_loads:
+            if edge_load.values[0] != 0.0:
+                edge_load.times.insert(0, 0.0)
+                edge_load.values.insert(0, 0.0)
+            edge_load.first_slope = 0.0
+            edge_load.domain = (float("-inf"), edge_load.domain[1])
+
+        return edge_loads