core: stdcm: tests: add tests that check spacing requirements

Author: eckter

core/src/main/java/fr/sncf/osrd/api/stdcm/STDCMEndpoint.java

@@ -132,7 +132,7 @@ private static List<STDCMStep> parseSteps(FullInfra infra, List<STDCMRequest.STD
     }
 
     /** Generate a train schedule matching the envelope and rolling stock, with one stop at the end */
-    private static StandaloneTrainSchedule makeTrainSchedule(
+    public static StandaloneTrainSchedule makeTrainSchedule(
             double endPos,
             RollingStock rollingStock,
             RollingStock.Comfort comfort,

core/src/test/java/fr/sncf/osrd/stdcm/FullSTDCMTests.java

@@ -1,14 +1,23 @@
 package fr.sncf.osrd.stdcm;
 
 import static fr.sncf.osrd.Helpers.getExampleRollingStock;
+import static fr.sncf.osrd.api.stdcm.STDCMEndpoint.makeTrainSchedule;
+import static fr.sncf.osrd.train.TestTrains.REALISTIC_FAST_TRAIN;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import com.google.common.collect.HashMultimap;
 import fr.sncf.osrd.Helpers;
+import fr.sncf.osrd.api.FullInfra;
 import fr.sncf.osrd.railjson.parser.RJSRollingStockParser;
+import fr.sncf.osrd.standalone_sim.ScheduleMetadataExtractor;
+import fr.sncf.osrd.standalone_sim.result.ResultTrain;
+import fr.sncf.osrd.train.RollingStock;
 import fr.sncf.osrd.utils.units.Distance;
 import org.junit.jupiter.api.Test;
 import java.io.IOException;
 import java.net.URISyntaxException;
+import java.util.List;
 import java.util.Set;
 
 public class FullSTDCMTests {
@@ -42,9 +51,12 @@ public void testTinyInfraSmallOpening() throws IOException, URISyntaxException {
                 "rt.buffer_stop_b->tde.foo_b-switch_foo", Distance.fromMeters(100)));
         var end = Set.of(Helpers.convertRouteLocation(infra,
                 "rt.tde.foo_b-switch_foo->buffer_stop_c", Distance.fromMeters(10125)));
-        var occupancies = STDCMHelpers.makeOccupancyFromPath(infra, start, end, 0);
+        var requirements = STDCMHelpers.makeRequirementsFromPath(infra, start, end, 0);
+        var occupancies = STDCMHelpers.makeOccupancyFromRequirements(infra, requirements);
         double minDelay = STDCMHelpers.getMaxOccupancyLength(occupancies); // Eventually we may need to add a % margin
-        occupancies.putAll(STDCMHelpers.makeOccupancyFromPath(infra, start, end, minDelay * 2));
+        occupancies.putAll(STDCMHelpers.makeOccupancyFromRequirements(infra,
+                STDCMHelpers.makeRequirementsFromPath(infra, start, end, minDelay * 2)
+        ));
         var res = new STDCMPathfindingBuilder()
                 .setInfra(infra)
                 .setStartTime(minDelay)
@@ -53,6 +65,7 @@ public void testTinyInfraSmallOpening() throws IOException, URISyntaxException {
                 .setUnavailableTimes(occupancies)
                 .run();
         assertNotNull(res);
+        checkNoConflict(infra, requirements, res);
     }
 
     /** We try to fit a train in a short opening between two trains, this time on small_infra */
@@ -63,15 +76,62 @@ public void testSmallInfraSmallOpening() throws IOException, URISyntaxException
                 "rt.buffer_stop.3->DB0", Distance.fromMeters(1590)));
         var end = Set.of(Helpers.convertRouteLocation(infra,
                 "rt.DH2->buffer_stop.7", Distance.fromMeters(5000)));
-        var occupancies = STDCMHelpers.makeOccupancyFromPath(infra, start, end, 0);
-        occupancies.putAll(STDCMHelpers.makeOccupancyFromPath(infra, start, end, 600));
+        var requirements = STDCMHelpers.makeRequirementsFromPath(infra, start, end, 0);
+        requirements.addAll(STDCMHelpers.makeRequirementsFromPath(infra, start, end, 600));
         var res = new STDCMPathfindingBuilder()
                 .setInfra(infra)
                 .setStartTime(300)
                 .setStartLocations(start)
                 .setEndLocations(end)
-                .setUnavailableTimes(occupancies)
+                .setUnavailableTimes(STDCMHelpers.makeOccupancyFromRequirements(infra, requirements))
                 .run();
         assertNotNull(res);
+        checkNoConflict(infra, requirements, res);
+    }
+
+    /** We make an opening that is just too small to fit a train,
+     * we check that it isn't taken and doesn't cause conflicts */
+    @Test
+    public void testSmallInfraImpossibleOpening() throws IOException, URISyntaxException {
+        var infra = Helpers.fullInfraFromRJS(Helpers.getExampleInfra("small_infra/infra.json"));
+        var start = Set.of(Helpers.convertRouteLocation(infra,
+                "rt.buffer_stop.3->DB0", Distance.fromMeters(1590)));
+        var end = Set.of(Helpers.convertRouteLocation(infra,
+                "rt.DH2->buffer_stop.7", Distance.fromMeters(5000)));
+        var requirements = STDCMHelpers.makeRequirementsFromPath(infra, start, end, 0);
+        var occupancies = STDCMHelpers.makeOccupancyFromRequirements(infra, requirements);
+        double minDelay = STDCMHelpers.getMaxOccupancyLength(occupancies);
+        occupancies.putAll(STDCMHelpers.makeOccupancyFromRequirements(infra,
+                STDCMHelpers.makeRequirementsFromPath(infra, start, end, minDelay * 0.95)
+        ));
+        var res = new STDCMPathfindingBuilder()
+                .setInfra(infra)
+                .setStartLocations(start)
+                .setEndLocations(end)
+                .setUnavailableTimes(STDCMHelpers.makeOccupancyFromRequirements(infra, requirements))
+                .run();
+        assertNotNull(res);
+        checkNoConflict(infra, requirements, res);
+    }
+
+    /** Check that the result we find doesn't cause a conflict */
+    private void checkNoConflict(FullInfra infra, List<ResultTrain.SpacingRequirement> requirements, STDCMResult res) {
+        var requirementMap = HashMultimap.<String, ResultTrain.SpacingRequirement>create();
+        for (var requirement : requirements) {
+            requirementMap.put(requirement.zone, requirement);
+        }
+        var newRequirements = ScheduleMetadataExtractor.run(
+                res.envelope(),
+                res.trainPath(),
+                makeTrainSchedule(res.envelope().getEndPos(), REALISTIC_FAST_TRAIN,
+                        RollingStock.Comfort.STANDARD, res.stopResults()),
+                infra
+        ).spacingRequirements;
+        for (var requirement : newRequirements) {
+            for (var existingRequirement : requirementMap.get(requirement.zone)) {
+                assertTrue(requirement.beginTime > existingRequirement.endTime
+                        || requirement.endTime < existingRequirement.beginTime);
+            }
+        }
     }
 }

core/src/test/java/fr/sncf/osrd/stdcm/STDCMHelpers.java

@@ -26,8 +26,10 @@
 import java.util.Set;
 
 public class STDCMHelpers {
-    /** Make the occupancy multimap of a train going from point A to B starting at departureTime */
-    public static Multimap<Integer, OccupancySegment> makeOccupancyFromPath(
+    /**
+     * Make the occupancy multimap of a train going from point A to B starting at departureTime
+     */
+    public static List<ResultTrain.SpacingRequirement> makeRequirementsFromPath(
             FullInfra infra,
             Set<Pathfinding.EdgeLocation<Integer>> startLocations,
             Set<Pathfinding.EdgeLocation<Integer>> endLocations,
@@ -53,18 +55,26 @@ public static Multimap<Integer, OccupancySegment> makeOccupancyFromPath(
                 new DriverBehaviour(0, 0)
         );
         var rawOccupancies = result.baseSimulations.get(0).spacingRequirements;
-        var occupancies = new ArrayList<ResultTrain.SpacingRequirement>();
+        var requirements = new ArrayList<ResultTrain.SpacingRequirement>();
         for (var entry : rawOccupancies) {
-            occupancies.add(new ResultTrain.SpacingRequirement(
+            requirements.add(new ResultTrain.SpacingRequirement(
                     entry.zone,
                     departureTime + entry.beginTime,
                     departureTime + entry.endTime
             ));
         }
+        return requirements;
+    }
+
+    /** Make the route occupancies from a spacing requirement list */
+    public static Multimap<Integer, OccupancySegment> makeOccupancyFromRequirements(
+            FullInfra infra,
+            List<ResultTrain.SpacingRequirement> requirements
+    ) {
         return UnavailableSpaceBuilder.computeUnavailableSpace(
                 infra.rawInfra(),
                 infra.blockInfra(),
-                occupancies,
+                requirements,
                 REALISTIC_FAST_TRAIN,
                 0,
                 0