add map for charging functions

evrouting/charge/routing.py

@@ -8,7 +8,7 @@ from evrouting.charge import factories as factories
 
 from ..graph_tools import distance
 from .T import SoCFunction, Label
-from .utils import LabelPriorityQueue
+from .utils import LabelPriorityQueue, ChargingFunctionMap
 
 
 def shortest_path(G: nx.Graph, charging_stations: set, s: Node, t: Node,
@@ -24,6 +24,8 @@ def shortest_path(G: nx.Graph, charging_stations: set, s: Node, t: Node,
     :param U: Capacity
     :return:
     """
+    cf = ChargingFunctionMap(G=G, capacity=capacity, initial_soc=initial_soc)
+
     q = PriorityQueue()
     l_set: Dict[int, set] = {v: set() for v in G}
     l_uns: Dict[int, LabelPriorityQueue] = {
@@ -45,7 +47,7 @@ def shortest_path(G: nx.Graph, charging_stations: set, s: Node, t: Node,
 
     l_uns[s].insert(
         l,
-        factories.charging_function(G, l.last_cs, capacity, initial_soc)
+        cf[l.last_cs]
     )
 
     q.insert(s, 0)
@@ -64,28 +66,13 @@ def shortest_path(G: nx.Graph, charging_stations: set, s: Node, t: Node,
         if minimum_node == t:
             return SoCFunction(
                 label_minimum_node,
-                factories.charging_function(
-                    G,
-                    label_minimum_node.last_cs,
-                    capacity,
-                    initial_soc
-                )
+                cf[label_minimum_node.last_cs]
             ).minimum
 
         # handle charging stations
         if minimum_node in charging_stations and not minimum_node == label_minimum_node.last_cs:
-            cf_last_cs = factories.charging_function(
-                G,
-                label_minimum_node.last_cs,
-                capacity,
-                initial_soc  # Use here in case cs is a dummy station
-            )
-            cf_minimum_node = factories.charging_function(
-                G,
-                minimum_node,
-                capacity,
-                initial_soc  # Use here in case cs is a dummy station
-            )
+            cf_last_cs = cf[label_minimum_node.last_cs]
+            cf_minimum_node = cf[minimum_node]
 
             if cf_minimum_node.c > cf_last_cs.c:
                 # Only charge the minimum at the last charge station
@@ -134,12 +121,7 @@ def shortest_path(G: nx.Graph, charging_stations: set, s: Node, t: Node,
                 try:
                     l_uns[n].insert(
                         l_new,
-                        factories.charging_function(
-                            G,
-                            l_new.last_cs,
-                            capacity,
-                            initial_soc
-                        )
+                        cf[l_new.last_cs]
                     )
                 except ValueError:
                     # Infeasible because last_cs might be an

evrouting/charge/utils.py

+from typing import Dict
 from math import inf
 
+import networkx as nx
 from evrouting.utils import PriorityQueue
-from evrouting.T import SoC, Time
+from evrouting.T import SoC, Time, Node
 
+from .factories import charging_function
 from .T import Label, SoCFunction, ChargingFunction
 
 
@@ -27,3 +30,31 @@ class LabelPriorityQueue(PriorityQueue):
             priority=t_min,
             count=soc_min
         )
+
+
+class ChargingFunctionMap:
+    """Maps Nodes to their charging functions."""
+
+    def __init__(self, G: nx.Graph, capacity: SoC, initial_soc: SoC = None):
+        self.map: Dict[Node, ChargingFunction] = {}
+        self.G: nx.Graph = G
+        self.capacity: SoC = capacity
+        self.initial_soc: SoC = initial_soc
+
+    def __getitem__(self, node: Node) -> ChargingFunction:
+        """
+        Try to get charging function from cache,
+        else create function and add to cache.
+        """
+        try:
+            cf = self.map[node]
+        except KeyError:
+            cf = charging_function(
+                G=self.G,
+                n=node,
+                capacity=self.capacity,
+                initial_soc=self.initial_soc
+            )
+            self.map[node] = cf
+
+        return cf