core: implements ZonesConstraints and uses it in the LMR pathfinding

close #13250

Signed-off-by: Angelina Kuntz <[email protected]>

Author: anglnn

core/src/main/kotlin/fr/sncf/osrd/api/RollingStockParser.kt

@@ -14,7 +14,7 @@ import fr.sncf.osrd.train.RollingStock.*
 /** Parse the rolling stock model into something the backend can work with */
 fun parseRawRollingStock(
     rawPhysicsConsist: PhysicsConsistModel,
-    loadingGaugeType: RJSLoadingGaugeType = RJSLoadingGaugeType.G1,
+    loadingGaugeType: RJSLoadingGaugeType? = RJSLoadingGaugeType.G1,
     rollingStockSupportedSignalingSystems: List<String> = listOf(),
 ): RollingStock {
     // Parse effort_curves

core/src/main/kotlin/fr/sncf/osrd/api/pathfinding/PathfindingBlocksEndpoint.kt

@@ -114,6 +114,7 @@ fun runPathfinding(infra: FullInfra, request: PathfindingBlockRequest): Pathfind
             request.rollingStockLoadingGauge,
             request.rollingStockSupportedElectrifications,
             request.rollingStockSupportedSignalingSystems,
+            null,
         )
 
     val heuristics =

core/src/main/kotlin/fr/sncf/osrd/api/stdcm/STDCMEndpoint.kt

@@ -137,6 +137,7 @@ class STDCMEndpoint(
                     parseMarginValue(request.margin),
                     Pathfinding.TIMEOUT,
                     temporarySpeedLimitManager,
+                    request.zones,
                 )
             if (path == null || hasDuplicateTracks(infra, path.blocks)) {
                 val response = PathNotFound()

core/src/main/kotlin/fr/sncf/osrd/api/stdcm/STDCMRequest.kt

@@ -31,7 +31,7 @@ class STDCMRequest(
     // Pathfinding inputs
     /// List of waypoints. Each waypoint is a list of track offsets
     @Json(name = "path_items") val pathItems: List<STDCMPathItem>,
-    @Json(name = "rolling_stock_loading_gauge") val rollingStockLoadingGauge: RJSLoadingGaugeType,
+    @Json(name = "rolling_stock_loading_gauge") val rollingStockLoadingGauge: RJSLoadingGaugeType?,
     @Json(name = "rolling_stock_supported_signaling_systems")
     val rollingStockSupportedSignalingSystems: List<String>,
 
@@ -57,6 +57,7 @@ class STDCMRequest(
     @Json(name = "temporary_speed_limits")
     val temporarySpeedLimits: Collection<STDCMTemporarySpeedLimit>,
     @Json(name = "work_schedules") val workSchedules: Collection<WorkSchedule> = listOf(),
+    val zones: HashSet<String>?,
 )
 
 data class STDCMTemporarySpeedLimit(

core/src/main/kotlin/fr/sncf/osrd/pathfinding/constraints/ConstraintCombiner.kt

@@ -27,13 +27,15 @@ class ConstraintCombiner<EdgeT, OffsetType>(
 fun initConstraints(
     fullInfra: FullInfra,
     rollingStock: RollingStock,
+    zones: HashSet<String>?,
 ): List<PathfindingConstraint<Block>> {
     return initConstraintsFromRSProps(
         fullInfra,
         rollingStock.isThermal,
         rollingStock.loadingGaugeType,
         rollingStock.modeNames.toList(),
         rollingStock.supportedSignalingSystems.toList(),
+        zones,
     )
 }
 
@@ -43,6 +45,7 @@ fun initConstraintsFromRSProps(
     rollingStockLoadingGauge: RJSLoadingGaugeType,
     rollingStockSupportedElectrification: List<String>,
     rollingStockSupportedSignalingSystems: List<String>,
+    zones: HashSet<String>?,
 ): List<PathfindingConstraint<Block>> {
     val res = mutableListOf<PathfindingConstraint<Block>>()
     if (!rollingStockIsThermal) {
@@ -60,5 +63,6 @@ fun initConstraintsFromRSProps(
             infra.signalingSimulator.sigModuleManager.findSignalingSystem(it)
         }
     res.add(SignalingSystemConstraints(infra.blockInfra, listOf(sigSystemIds)))
+    res.add(ZonesConstraints(infra.blockInfra, infra.rawInfra, zones))
     return res
 }

core/src/main/kotlin/fr/sncf/osrd/pathfinding/constraints/ZonesConstraints.kt

@@ -0,0 +1,45 @@
+package fr.sncf.osrd.pathfinding.constraints
+
+import fr.sncf.osrd.graph.PathfindingConstraint
+import fr.sncf.osrd.path.implementations.buildTrainPathFromBlock
+import fr.sncf.osrd.path.interfaces.TrainPath
+import fr.sncf.osrd.pathfinding.Pathfinding
+import fr.sncf.osrd.sim_infra.api.Block
+import fr.sncf.osrd.sim_infra.api.BlockId
+import fr.sncf.osrd.sim_infra.api.BlockInfra
+import fr.sncf.osrd.sim_infra.api.RawSignalingInfra
+import fr.sncf.osrd.utils.units.Offset
+
+data class ZonesConstraints(
+    val blockInfra: BlockInfra,
+    val infra: RawSignalingInfra,
+    val zones: HashSet<String>?,
+) : PathfindingConstraint<Block> {
+    override fun apply(edge: BlockId): Collection<Pathfinding.Range<Block>> {
+        val res = HashSet<Pathfinding.Range<Block>>()
+        val path = buildTrainPathFromBlock(infra, blockInfra, edge)
+        res.addAll(getBlockedRanges(zones, path))
+        return res
+    }
+
+    private fun getBlockedRanges(
+        zones: HashSet<String>?,
+        path: TrainPath,
+    ): Collection<Pathfinding.Range<Block>> {
+
+        val res = HashSet<Pathfinding.Range<Block>>()
+        val invalidTrackSections =
+            infra.trackSections.filter { zones?.contains(infra.getTrackSectionName(it)) == false }
+
+        val invalidTrackSectionsInsideBlock =
+            path.getChunks().filter {
+                val trackSection = infra.getTrackFromChunk(it.value.value)
+                invalidTrackSections.contains(trackSection)
+            }
+
+        for ((_, from, to) in invalidTrackSectionsInsideBlock) {
+            res.add(Pathfinding.Range(Offset(from.distance), Offset(to.distance)))
+        }
+        return res
+    }
+}

core/src/main/kotlin/fr/sncf/osrd/stdcm/graph/STDCMPathfinding.kt

@@ -59,6 +59,7 @@ fun findPath(
     standardAllowance: AllowanceValue?,
     pathfindingTimeout: Double,
     temporarySpeedLimitManager: TemporarySpeedLimitManager,
+    zones: HashSet<String>?,
 ): STDCMResult? {
     return STDCMPathfinding(
             fullInfra,
@@ -74,6 +75,7 @@ fun findPath(
             standardAllowance,
             pathfindingTimeout,
             temporarySpeedLimitManager,
+            zones,
         )
         .findPath()
 }
@@ -92,6 +94,7 @@ class STDCMPathfinding(
     standardAllowance: AllowanceValue?,
     private val pathfindingTimeout: Double = Pathfinding.TIMEOUT,
     private val temporarySpeedLimitManager: TemporarySpeedLimitManager,
+    private val zones: HashSet<String>?,
 ) {
 
     private var starts: Set<STDCMNode> = HashSet()
@@ -116,7 +119,7 @@ class STDCMPathfinding(
         runInputSanityChecks()
 
         val constraints =
-            ConstraintCombiner(initConstraints(fullInfra, rollingStock).toMutableList())
+            ConstraintCombiner(initConstraints(fullInfra, rollingStock, zones).toMutableList())
 
         assert(steps.last().stop) { "The last stop is supposed to be an actual stop" }
         starts = getStartNodes(graph, listOf(constraints))

core/src/test/kotlin/fr/sncf/osrd/pathfinding/constraints/ZonesConstraintsTest.kt

@@ -0,0 +1,103 @@
+package fr.sncf.osrd.pathfinding.constraints
+
+import fr.sncf.osrd.pathfinding.Pathfinding
+import fr.sncf.osrd.sim_infra.api.Block
+import fr.sncf.osrd.sim_infra.api.BlockId
+import fr.sncf.osrd.sim_infra.api.TrackChunk
+import fr.sncf.osrd.utils.Direction
+import fr.sncf.osrd.utils.Helpers
+import fr.sncf.osrd.utils.units.Length
+import fr.sncf.osrd.utils.units.Offset
+import fr.sncf.osrd.utils.units.meters
+import java.util.stream.Stream
+import org.assertj.core.api.Assertions
+import org.junit.jupiter.api.BeforeAll
+import org.junit.jupiter.api.TestInstance
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.Arguments
+import org.junit.jupiter.params.provider.MethodSource
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class ZonesConstraintsTest {
+
+    private var zonesConstraints: ZonesConstraints? = null
+
+    private var ta0Chunk0Length: Length<TrackChunk> = Length(0.meters)
+    private var ta0Chunk0block: BlockId? = null
+    private var ta0Chunk1block: BlockId? = null
+    private var ta1Chunk0block: BlockId? = null
+
+    @BeforeAll
+    fun setup() {
+        val infra = Helpers.smallInfra
+        val zones =
+            hashSetOf(
+                "TA1",
+                "TA2",
+                "TA3",
+                "TA4",
+                "TA5",
+                "TA6",
+                "TA7",
+                "TG0",
+                "TG1",
+                "TG2",
+                "TG3",
+                "TG4",
+                "TG5",
+                "TH0",
+                "TH1",
+                "TE1",
+                "TE2",
+                "TE3",
+                "TD0",
+                "TD1",
+                "TD2",
+                "TD3",
+            )
+        zonesConstraints = ZonesConstraints(infra.blockInfra, infra.rawInfra, zones)
+        val ta0 = infra.rawInfra.getTrackSectionFromName("TA0")!!
+        val ta0Chunks = infra.rawInfra.getTrackSectionChunks(ta0)
+        assert(ta0Chunks.size == 2)
+        val ta0Chunk0 =
+            if (infra.rawInfra.getTrackChunkOffset(ta0Chunks[0]) <= Offset(0.meters)) ta0Chunks[0]
+            else ta0Chunks[1]
+        val ta0Chunk1 =
+            if (infra.rawInfra.getTrackChunkOffset(ta0Chunks[0]) <= Offset(0.meters)) ta0Chunks[1]
+            else ta0Chunks[0]
+        ta0Chunk0Length = infra.rawInfra.getTrackChunkLength(ta0Chunk0)
+        ta0Chunk0block =
+            infra.blockInfra.getBlocksFromTrackChunk(ta0Chunk0, Direction.INCREASING).getAtIndex(0)
+        ta0Chunk1block =
+            infra.blockInfra.getBlocksFromTrackChunk(ta0Chunk1, Direction.INCREASING).getAtIndex(0)
+        val ta1 = infra.rawInfra.getTrackSectionFromName("TA1")!!
+        val ta1Chunks = infra.rawInfra.getTrackSectionChunks(ta1)
+        val ta1Chunk0 = ta1Chunks[0]
+        ta1Chunk0block =
+            infra.blockInfra.getBlocksFromTrackChunk(ta1Chunk0, Direction.INCREASING).getAtIndex(0)
+    }
+
+    @ParameterizedTest
+    @MethodSource("testZonesArgs")
+    fun testDeadSectionAndElectrificationBlockedRanges(
+        blockId: BlockId,
+        expectedBlockedRanges: Collection<Pathfinding.Range<Block>>,
+    ) {
+        val blockedRanges = zonesConstraints!!.apply(blockId)
+        Assertions.assertThat(blockedRanges).isEqualTo(expectedBlockedRanges)
+    }
+
+    private fun testZonesArgs(): Stream<Arguments> {
+        return Stream.of(
+            Arguments.of(
+                ta0Chunk0block!!.index.toInt(),
+                setOf(Pathfinding.Range(Length(0.meters), ta0Chunk0Length)),
+            ),
+            Arguments.of(
+                ta0Chunk1block!!.index.toInt(),
+                setOf(Pathfinding.Range(Length<TrackChunk>(0.meters), Length(180.meters))),
+            ),
+            Arguments.of(ta1Chunk0block!!.index.toInt(), HashSet<Any>()),
+        )
+    }
+}

core/src/test/kotlin/fr/sncf/osrd/stdcm/STDCMPathfindingBuilder.kt

@@ -177,6 +177,7 @@ data class STDCMPathfindingBuilder(
             standardAllowance,
             pathfindingTimeout,
             temporarySpeedLimitManager,
+            null,
         )
     }
 }