Merge pull request #3024 from matsim-org/support-turn-restrictions-in…

…-SpeedyALT

Support turn restrictions in SpeedyALT

.gitignore

@@ -12,5 +12,8 @@ matsimExamples
 matsim/docs/doxygen/html
 matsim/src/main/java/Doxyfile
 
+# VS Code files
+.vscode
+
 # ignore output directories:
 output/

contribs/drt/src/main/java/org/matsim/contrib/drt/optimizer/insertion/extensive/MultiInsertionDetourPathCalculator.java

@@ -43,6 +43,7 @@
 import org.matsim.core.mobsim.framework.events.MobsimBeforeCleanupEvent;
 import org.matsim.core.mobsim.framework.listeners.MobsimBeforeCleanupListener;
 import org.matsim.core.router.speedy.SpeedyGraph;
+import org.matsim.core.router.speedy.SpeedyGraphBuilder;
 import org.matsim.core.router.util.TravelDisutility;
 import org.matsim.core.router.util.TravelTime;
 
@@ -63,7 +64,7 @@ class MultiInsertionDetourPathCalculator implements MobsimBeforeCleanupListener
 
 	MultiInsertionDetourPathCalculator(Network network, TravelTime travelTime, TravelDisutility travelDisutility,
 			DrtConfigGroup drtCfg) {
-		SpeedyGraph graph = new SpeedyGraph(network);
+		SpeedyGraph graph = SpeedyGraphBuilder.build(network);
 		IdMap<Node, Node> nodeMap = new IdMap<>(Node.class);
 		nodeMap.putAll(network.getNodes());
 

contribs/dvrp/src/main/java/org/matsim/contrib/zone/skims/TravelTimeMatrices.java

@@ -34,6 +34,7 @@
 import org.matsim.contrib.zone.skims.SparseMatrix.SparseRow;
 import org.matsim.core.router.speedy.LeastCostPathTree;
 import org.matsim.core.router.speedy.SpeedyGraph;
+import org.matsim.core.router.speedy.SpeedyGraphBuilder;
 import org.matsim.core.router.util.TravelDisutility;
 import org.matsim.core.router.util.TravelTime;
 import org.matsim.core.utils.misc.Counter;
@@ -115,7 +116,7 @@ private interface Calculation<E> {
 
 	private static <E> void calculate(RoutingParams params, Collection<? extends E> elements, Calculation<E> calculation, String counterPrefix) {
 		var trees = IntStream.range(0, params.numberOfThreads)
-			.mapToObj(i -> new LeastCostPathTree(new SpeedyGraph(params.routingNetwork), params.travelTime, params.travelDisutility))
+			.mapToObj(i -> new LeastCostPathTree(SpeedyGraphBuilder.build(params.routingNetwork), params.travelTime, params.travelDisutility))
 			.toList();
 		var executorService = new ExecutorServiceWithResource<>(trees);
 		var counter = new Counter(counterPrefix, " / " + elements.size());

contribs/dvrp/src/main/java/org/matsim/core/router/speedy/SpeedyMultiSourceALTFactory.java

@@ -37,7 +37,7 @@ public class SpeedyMultiSourceALTFactory {
 
 	public SpeedyMultiSourceALT createPathCalculator(Network network, TravelDisutility travelCosts,
 			TravelTime travelTimes) {
-		SpeedyGraph graph = this.graphs.computeIfAbsent(network, SpeedyGraph::new);
+		SpeedyGraph graph = this.graphs.computeIfAbsent(network, SpeedyGraphBuilder::build);
 
 		var graphTravelCostsPair = Pair.of(graph, travelCosts);
 		int landmarksCount = Math.min(16, graph.nodeCount);

contribs/dvrp/src/test/java/org/matsim/contrib/dvrp/path/OneToManyPathCalculatorTest.java

@@ -31,6 +31,7 @@
 import org.matsim.api.core.v01.Coord;
 import org.matsim.api.core.v01.Id;
 import org.matsim.api.core.v01.IdMap;
+import org.matsim.api.core.v01.TransportMode;
 import org.matsim.api.core.v01.network.Link;
 import org.matsim.api.core.v01.network.Network;
 import org.matsim.api.core.v01.network.Node;
@@ -39,6 +40,7 @@
 import org.matsim.core.network.NetworkUtils;
 import org.matsim.core.router.speedy.LeastCostPathTree;
 import org.matsim.core.router.speedy.SpeedyGraph;
+import org.matsim.core.router.speedy.SpeedyGraphBuilder;
 import org.matsim.core.router.util.LeastCostPathCalculator.Path;
 import org.matsim.core.router.util.TravelTime;
 import org.matsim.core.trafficmonitoring.FreeSpeedTravelTime;
@@ -65,7 +67,7 @@ public class OneToManyPathCalculatorTest {
 	private final IdMap<Node, Node> nodeMap = new IdMap<>(Node.class);
 
 	private final TravelTime travelTime = new FreeSpeedTravelTime();
-	private final LeastCostPathTree dijkstraTree = new LeastCostPathTree(new SpeedyGraph(network), travelTime,
+	private final LeastCostPathTree dijkstraTree = new LeastCostPathTree(SpeedyGraphBuilder.build(network), travelTime,
 			new TimeAsTravelDisutility(travelTime));
 
 	@BeforeEach

contribs/dvrp/src/test/java/org/matsim/core/router/speedy/SpeedyMultiSourceALTBackwardTest.java

@@ -27,6 +27,7 @@
 import org.junit.jupiter.api.Test;
 import org.matsim.api.core.v01.Coord;
 import org.matsim.api.core.v01.Id;
+import org.matsim.api.core.v01.TransportMode;
 import org.matsim.api.core.v01.network.Link;
 import org.matsim.api.core.v01.network.Network;
 import org.matsim.api.core.v01.network.Node;
@@ -74,7 +75,7 @@ public class SpeedyMultiSourceALTBackwardTest {
 
 	private final TravelTime travelTime = new FreeSpeedTravelTime();
 	private final TravelDisutility travelDisutility = new TimeAsTravelDisutility(travelTime);
-	private final SpeedyGraph speedyGraph = new SpeedyGraph(network);
+	private final SpeedyGraph speedyGraph = SpeedyGraphBuilder.build(network);
 	private final SpeedyALTData landmarks = new SpeedyALTData(speedyGraph, 3, travelDisutility);
 	private final SpeedyMultiSourceALT multiSourceALT = new SpeedyMultiSourceALT(landmarks, travelTime,
 			travelDisutility);

contribs/dvrp/src/test/java/org/matsim/core/router/speedy/SpeedyMultiSourceALTForwardTest.java

@@ -27,6 +27,7 @@
 import org.junit.jupiter.api.Test;
 import org.matsim.api.core.v01.Coord;
 import org.matsim.api.core.v01.Id;
+import org.matsim.api.core.v01.TransportMode;
 import org.matsim.api.core.v01.network.Link;
 import org.matsim.api.core.v01.network.Network;
 import org.matsim.api.core.v01.network.Node;
@@ -72,7 +73,7 @@ public class SpeedyMultiSourceALTForwardTest {
 
 	private final TravelTime travelTime = new FreeSpeedTravelTime();
 	private final TravelDisutility travelDisutility = new TimeAsTravelDisutility(travelTime);
-	private final SpeedyGraph speedyGraph = new SpeedyGraph(network);
+	private final SpeedyGraph speedyGraph = SpeedyGraphBuilder.build(network);
 	private final SpeedyALTData landmarks = new SpeedyALTData(speedyGraph, 3, travelDisutility);
 	private final SpeedyMultiSourceALT multiSourceALT = new SpeedyMultiSourceALT(landmarks, travelTime,
 			travelDisutility);

contribs/sbb-extensions/src/main/java/ch/sbb/matsim/analysis/skims/NetworkSkimMatrices.java

@@ -32,6 +32,7 @@
 import org.matsim.api.core.v01.population.Person;
 import org.matsim.core.network.NetworkUtils;
 import org.matsim.core.population.PopulationUtils;
+import org.matsim.core.router.speedy.SpeedyGraphBuilder;
 import org.matsim.core.router.util.TravelDisutility;
 import org.matsim.core.router.util.TravelTime;
 import org.matsim.core.utils.misc.Counter;
@@ -58,7 +59,7 @@ private NetworkSkimMatrices() {
 
     public static <T> NetworkIndicators<T> calculateSkimMatrices(Network xy2lNetwork, Network routingNetwork, Map<T, Coord[]> coordsPerZone, double departureTime, TravelTime travelTime,
             TravelDisutility travelDisutility, int numberOfThreads) {
-        SpeedyGraph routingGraph = new SpeedyGraph(routingNetwork);
+        SpeedyGraph routingGraph = SpeedyGraphBuilder.build(routingNetwork);
         Map<T, Node[]> nodesPerZone = new HashMap<>();
         for (Map.Entry<T, Coord[]> e : coordsPerZone.entrySet()) {
             T zoneId = e.getKey();

contribs/taxi/src/main/java/org/matsim/contrib/taxi/optimizer/assignment/VehicleAssignmentProblem.java

@@ -35,6 +35,7 @@
 import org.matsim.contrib.taxi.optimizer.VehicleData;
 import org.matsim.contrib.taxi.optimizer.assignment.AssignmentDestinationData.DestEntry;
 import org.matsim.core.router.speedy.SpeedyGraph;
+import org.matsim.core.router.speedy.SpeedyGraphBuilder;
 import org.matsim.core.router.util.LeastCostPathCalculator;
 import org.matsim.core.router.util.TravelDisutility;
 import org.matsim.core.router.util.TravelTime;
@@ -71,7 +72,7 @@ public VehicleAssignmentProblem(Network network, TravelTime travelTime, TravelDi
 
 		IdMap<Node, Node> nodeMap = new IdMap<>(Node.class);
 		nodeMap.putAll(network.getNodes());
-		pathSearch = OneToManyPathSearch.createSearch(new SpeedyGraph(network), nodeMap, travelTime, travelDisutility,
+		pathSearch = OneToManyPathSearch.createSearch(SpeedyGraphBuilder.build(network), nodeMap, travelTime, travelDisutility,
 				false);
 
 		// TODO this kNN is slow

matsim/src/main/java/org/matsim/core/network/DisallowedNextLinks.java

@@ -1,12 +1,15 @@
 package org.matsim.core.network;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Set;
 import java.util.stream.Collectors;
 
 import javax.annotation.Nullable;
@@ -34,10 +37,34 @@ public class DisallowedNextLinks {
 	// list in favor of a smaller memory footprint.
 	private final Map<String, List<List<Id<Link>>>> linkIdSequencesMap = new HashMap<>();
 
+    /**
+     * A builder to allow building a populated instance in one statement.
+     * Be aware that several calls to the build() method of a particular Builder instance will
+     * return the same DisallowedNextLinks instance!
+     */
+    public static class Builder {
+        private final DisallowedNextLinks instance = new DisallowedNextLinks();
+
+        public Builder withDisallowedLinkSequence(String mode, List<Id<Link>> linkSequence) {
+            instance.addDisallowedLinkSequence(mode, linkSequence);
+            return this;
+        }
+
+        /**
+         * Be aware that several calls to the build() method of a particular Builder
+         * instance will return the same DisallowedNextLinks instance!
+         * 
+         * @return an instance with the required disallowedNextLinks set
+         */
+        public DisallowedNextLinks build() {
+            return instance;
+        }
+    }
+
 	public DisallowedNextLinks() { // ! remove constructor, if routing considers this
 		if (!warnedAboutNotConsideredInRouting) {
 			warnedAboutNotConsideredInRouting = true;
-			LOG.warn("Considering DisallowedNextLinks in routing is not yet implemented!");
+			LOG.warn("Considering DisallowedNextLinks in routing is only implemented by SpeedyDijkstra and SpeedyALT!");
 		}
 	}
 
@@ -75,6 +102,25 @@ public List<List<Id<Link>>> getDisallowedLinkSequences(String mode) {
 		return sequences != null ? Collections.unmodifiableList(sequences) : Collections.emptyList();
 	}
 
+    /**
+     * Returns an aggregation of all link restrictions, for all modes. This is meant to be used in monomodal networks.
+     */
+	public Collection<List<Id<Link>>> getMergedDisallowedLinkSequences() {
+        // Implementation note: we do not want duplicates, so the logical choice is a set,
+        // as the argument for memory footprint does not hold here (short lived object).
+        // This makes the return types inconsistent, but one could argue that all methods should
+        // return Collections rather than Lists (ordering is not meaningful)
+        // We use a LinkedHashSet to preserve iteration order, to be consistent with other methods in this class
+        // td 04.24
+        final Set<List<Id<Link>>> sequences = new LinkedHashSet<>();
+
+        for (List<List<Id<Link>>> sequencesForMode : linkIdSequencesMap.values()) {
+            sequences.addAll(sequencesForMode);
+        }
+
+		return Collections.unmodifiableSet(sequences);
+	}
+
 	@Nullable
 	public List<List<Id<Link>>> removeDisallowedLinkSequences(String mode) {
 		return this.linkIdSequencesMap.remove(mode);
@@ -85,6 +131,18 @@ public Map<String, List<List<Id<Link>>>> getAsMap() {
 				.collect(Collectors.toMap(Entry::getKey, e -> Collections.unmodifiableList(e.getValue())));
 	}
 
+    public DisallowedNextLinks copyOnlyModes(final Collection<String> modes) {
+        final DisallowedNextLinks newInstance = new DisallowedNextLinks();
+
+        for (String mode : modes) {
+            for (List<Id<Link>> sequence : getDisallowedLinkSequences(mode)) {
+                newInstance.addDisallowedLinkSequence(mode, sequence);
+            }
+        }
+
+        return newInstance;
+    }
+
 	public void clear() {
 		this.linkIdSequencesMap.clear();
 	}
@@ -120,4 +178,9 @@ public int hashCode() {
 		return this.linkIdSequencesMap.hashCode();
 	}
 
+    @Override
+    public String toString() {
+        return "DisallowedNextLinks [linkIdSequencesMap=" + linkIdSequencesMap + "]";
+    }
+
 }

matsim/src/main/java/org/matsim/core/network/algorithms/TransportModeNetworkFilter.java

@@ -28,6 +28,7 @@
 import org.matsim.api.core.v01.network.Network;
 import org.matsim.api.core.v01.network.NetworkFactory;
 import org.matsim.api.core.v01.network.Node;
+import org.matsim.core.network.DisallowedNextLinks;
 import org.matsim.core.network.NetworkChangeEvent;
 import org.matsim.core.network.NetworkUtils;
 import org.matsim.core.network.TimeDependentNetwork;
@@ -102,6 +103,11 @@ public void filter(final Network subNetwork, final Set<String> extractModes) {
 				NetworkUtils.setType(link2, NetworkUtils.getType(link));
 				AttributesUtils.copyAttributesFromTo(link, link2);
 				subNetwork.addLink(link2);
+
+                DisallowedNextLinks disallowedNextLinks = NetworkUtils.getDisallowedNextLinks(link);
+                if (disallowedNextLinks != null) {
+                    NetworkUtils.setDisallowedNextLinks(link2, disallowedNextLinks.copyOnlyModes(extractModes));
+                }
 			}
 		}
 

matsim/src/main/java/org/matsim/core/router/NetworkRoutingProvider.java

@@ -99,20 +99,7 @@ public RoutingModule get() {
 						   + routingMode + ";\tmode=" + mode) ;
 
 		// the network refers to the (transport)mode:
-		Network filteredNetwork = null;
-
-		// Ensure this is not performed concurrently by multiple threads!
-		synchronized (this.singleModeNetworksCache.getSingleModeNetworksCache()) {
-			filteredNetwork = this.singleModeNetworksCache.getSingleModeNetworksCache().get(mode);
-			if (filteredNetwork == null) {
-				TransportModeNetworkFilter filter = new TransportModeNetworkFilter(network);
-				Set<String> modes = new HashSet<>();
-				modes.add(mode);
-				filteredNetwork = NetworkUtils.createNetwork(networkConfigGroup);
-				filter.filter(filteredNetwork, modes);
-				this.singleModeNetworksCache.getSingleModeNetworksCache().put(mode, filteredNetwork);
-			}
-		}
+		Network filteredNetwork = singleModeNetworksCache.getOrCreateSingleModeNetwork(mode);
 
 		// the travel time & disutility refer to the routing mode:
 		TravelDisutilityFactory travelDisutilityFactory = this.travelDisutilityFactories.get(routingMode);

matsim/src/main/java/org/matsim/core/router/SingleModeNetworksCache.java

@@ -21,16 +21,46 @@
 
  package org.matsim.core.router;
 
+import java.util.HashSet;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
 import org.matsim.api.core.v01.network.Network;
+import org.matsim.core.config.groups.NetworkConfigGroup;
+import org.matsim.core.network.NetworkUtils;
+import org.matsim.core.network.algorithms.TransportModeNetworkFilter;
+
+import com.google.inject.Inject;
 
 public class SingleModeNetworksCache {
 
-	private Map<String, Network> singleModeNetworksCache = new ConcurrentHashMap<>();
+	private final Map<String, Network> singleModeNetworksCache = new ConcurrentHashMap<>();
+    private final Network fullNetwork;
+    private final NetworkConfigGroup networkConfigGroup;
+
+    @Inject
+    public SingleModeNetworksCache(Network fullNetwork, NetworkConfigGroup networkConfigGroup) {
+        this.fullNetwork = fullNetwork;
+        this.networkConfigGroup = networkConfigGroup;
+    }
 
 	public Map<String, Network> getSingleModeNetworksCache() {
 		return singleModeNetworksCache;
 	}
+
+    public Network getOrCreateSingleModeNetwork(final String mode) {
+        return getSingleModeNetworksCache().computeIfAbsent(mode, this::filterNetwork);
+    }
+
+    private Network filterNetwork(final String mode) {
+        TransportModeNetworkFilter filter = new TransportModeNetworkFilter(fullNetwork);
+        Set<String> modes = new HashSet<>();
+        modes.add(mode);
+
+        final Network filteredNetwork = NetworkUtils.createNetwork(networkConfigGroup);
+        filter.filter(filteredNetwork, modes);
+
+        return filteredNetwork;
+    }
 }

matsim/src/main/java/org/matsim/core/router/speedy/SpeedyALTFactory.java

@@ -21,7 +21,7 @@ public class SpeedyALTFactory implements LeastCostPathCalculatorFactory {
 	public LeastCostPathCalculator createPathCalculator(Network network, TravelDisutility travelCosts, TravelTime travelTimes) {
 		SpeedyGraph graph = this.graphs.get(network);
 		if (graph == null) {
-			graph = new SpeedyGraph(network);
+			graph = SpeedyGraphBuilder.build(network);
 			this.graphs.put(network, graph);
 		}
 		SpeedyALTData landmarks = this.landmarksData.get(graph);

matsim/src/main/java/org/matsim/core/router/speedy/SpeedyDijkstraFactory.java

@@ -20,7 +20,7 @@ public class SpeedyDijkstraFactory implements LeastCostPathCalculatorFactory {
 	public LeastCostPathCalculator createPathCalculator(Network network, TravelDisutility travelCosts, TravelTime travelTimes) {
 		SpeedyGraph graph = graphs.get(network);
 		if (graph == null) {
-			graph = new SpeedyGraph(network);
+			graph = SpeedyGraphBuilder.build(network);
 			graphs.put(network, graph);
 		}
 		return new SpeedyDijkstra(graph, travelTimes, travelCosts);