core: paths: migrate most endpoints to new path model

Some parts are too large and haven't been included,
such as ScheduleMetadataExtractor.

Signed-off-by: Eloi Charpentier <[email protected]>

Author: eckter

core/src/main/kotlin/fr/sncf/osrd/api/etcs/ETCSBrakingCurvesEndpoint.kt

@@ -7,14 +7,10 @@ import fr.sncf.osrd.envelope.part.EnvelopePart
 import fr.sncf.osrd.envelope_sim.EnvelopeProfile
 import fr.sncf.osrd.envelope_sim.EnvelopeSimContext
 import fr.sncf.osrd.envelope_sim.etcs.*
-import fr.sncf.osrd.path.interfaces.BlockPath
+import fr.sncf.osrd.path.interfaces.TrainPath
 import fr.sncf.osrd.path.interfaces.TravelledPath
-import fr.sncf.osrd.path.interfaces.getLegacyBlockPath
-import fr.sncf.osrd.path.interfaces.getLegacyChunkPath
-import fr.sncf.osrd.path.interfaces.getLegacyRoutePath
 import fr.sncf.osrd.signaling.etcs_level2.ETCS_LEVEL2
 import fr.sncf.osrd.sim_infra.api.*
-import fr.sncf.osrd.standalone_sim.PathOffsetBuilder
 import fr.sncf.osrd.standalone_sim.buildSignalingRanges
 import fr.sncf.osrd.standalone_sim.getSimStops
 import fr.sncf.osrd.standalone_sim.makeETCSContext
@@ -66,9 +62,6 @@ class ETCSBrakingCurvesEndpoint(
             // Parse path.
             val trainPath =
                 request.path.toTrainPath(infra.rawInfra, infra.blockInfra, electricalProfileMap)
-            val chunkPath = trainPath.getLegacyChunkPath()
-            val routePath = trainPath.getLegacyRoutePath()
-            val blockPath = trainPath.getLegacyBlockPath()
             val powerRestrictionsLegacyMap =
                 parsePowerRestrictions(request.powerRestrictions).toRangeMap()
             val electrificationMap =
@@ -80,22 +73,15 @@ class ETCSBrakingCurvesEndpoint(
                 )
             val curvesAndConditions =
                 rollingStock.mapTractiveEffortCurves(electrificationMap, request.comfort)
-            val signalingRanges = buildSignalingRanges(infra, blockPath, chunkPath)
+            val signalingRanges = buildSignalingRanges(infra, trainPath)
             val stops = getSimStops(parseRawSimulationScheduleItems(request.schedule))
             val context =
                 EnvelopeSimContext(
                     rollingStock,
                     trainPath,
                     2.0,
                     curvesAndConditions.curves,
-                    makeETCSContext(
-                        rollingStock,
-                        infra,
-                        chunkPath,
-                        routePath,
-                        blockPath,
-                        signalingRanges,
-                    ),
+                    makeETCSContext(rollingStock, infra, trainPath, signalingRanges),
                 )
 
             // Parse mrsp.
@@ -115,17 +101,11 @@ class ETCSBrakingCurvesEndpoint(
                     EoaType.STOP,
                 )
             val stopBrakingCurves = etcsSimulator.computeStopBrakingCurves(mrsp, etcsStops)
-            // Compute conflict braking curves on each of the path's ETCS signals.
-            val pathOffsetBuilder =
-                PathOffsetBuilder(
-                    trainPathBlockOffset(infra.rawInfra, infra.blockInfra, blockPath, chunkPath)
-                        .distance
-                )
-            val etcsSignals =
-                getTravelledPathSignals(infra, blockPath, pathOffsetBuilder, ETCS_LEVEL2.id)
+            val etcsSignals = getTravelledPathSignals(infra, trainPath, ETCS_LEVEL2.id)
             val etcsSignalsOnPath =
                 etcsSignals.filter {
-                    it.offset.distance > Distance.ZERO && it.offset.distance <= chunkPath.length
+                    it.offset.distance > Distance.ZERO &&
+                        it.offset.distance <= trainPath.getLength()
                 }
             val etcsSignalOffsets = etcsSignalsOnPath.map { it.offset }
             val areEtcsSignalRouteDelimiters = etcsSignalsOnPath.map { it.isRouteDelimiter }
@@ -175,26 +155,23 @@ class ETCSBrakingCurvesEndpoint(
      */
     private fun getTravelledPathSignals(
         fullInfra: FullInfra,
-        blockPath: List<BlockId>,
-        pathOffsetBuilder: PathOffsetBuilder,
+        trainPath: TrainPath,
         signalingSystemId: String? = null,
     ): List<TravelledPathSignal> {
         val res = mutableSetOf<TravelledPathSignal>()
-        var currentOffset = Offset<BlockPath>(Distance.ZERO)
-        for (block in blockPath) {
+        for (blockRange in trainPath.getBlocks()) {
+            val block = blockRange.value
             val blockSignalsPositions = fullInfra.blockInfra.getSignalsPositions(block)
             val blockSignals = fullInfra.blockInfra.getBlockSignals(block)
             assert(blockSignalsPositions.size == blockSignals.size)
             for ((signalPosition, signal) in blockSignalsPositions zip blockSignals) {
                 val signSystemId = fullInfra.rawInfra.getSignalingSystemId(signal)
                 val isRouteDelimiter = fullInfra.loadedSignalInfra.getSettings(signal).getFlag("Nf")
                 if (signalingSystemId == null || signSystemId == signalingSystemId) {
-                    val signalOffset =
-                        pathOffsetBuilder.toTravelledPath(currentOffset + signalPosition.distance)
+                    val signalOffset = blockRange.offsetToTrainPath(signalPosition)
                     res.add(TravelledPathSignal(signalOffset, isRouteDelimiter))
                 }
             }
-            currentOffset += fullInfra.blockInfra.getBlockLength(block).distance
         }
         return res.sorted()
     }

core/src/main/kotlin/fr/sncf/osrd/api/standalone_sim/SimulationEndpoint.kt

@@ -1,9 +1,6 @@
 package fr.sncf.osrd.api.standalone_sim
 
 import fr.sncf.osrd.api.*
-import fr.sncf.osrd.path.interfaces.getLegacyBlockPath
-import fr.sncf.osrd.path.interfaces.getLegacyChunkPath
-import fr.sncf.osrd.path.interfaces.getLegacyRoutePath
 import fr.sncf.osrd.reporting.exceptions.OSRDError
 import fr.sncf.osrd.standalone_sim.runStandaloneSimulation
 import fr.sncf.osrd.utils.*
@@ -59,17 +56,11 @@ class SimulationEndpoint(
             // Parse path
             val trainPath =
                 request.path.toTrainPath(infra.rawInfra, infra.blockInfra, electricalProfileMap)
-            val chunkPath = trainPath.getLegacyChunkPath()
-            val routePath = trainPath.getLegacyRoutePath()
-            val blockPath = trainPath.getLegacyBlockPath()
 
             val res =
                 runStandaloneSimulation(
                     infra,
                     trainPath,
-                    chunkPath,
-                    routePath,
-                    blockPath,
                     rollingStock,
                     request.comfort,
                     request.constraintDistribution.toRJS(),

core/src/main/kotlin/fr/sncf/osrd/standalone_sim/SafetySpeed.kt

@@ -2,16 +2,12 @@ package fr.sncf.osrd.standalone_sim
 
 import fr.sncf.osrd.api.FullInfra
 import fr.sncf.osrd.api.standalone_sim.SimulationScheduleItem
-import fr.sncf.osrd.path.implementations.ChunkPath
-import fr.sncf.osrd.path.interfaces.BlockPath
-import fr.sncf.osrd.path.interfaces.TravelledPath
+import fr.sncf.osrd.path.interfaces.TrainPath
 import fr.sncf.osrd.railjson.schema.schedule.RJSTrainStop
 import fr.sncf.osrd.signaling.etcs_level2.ETCS_LEVEL2
 import fr.sncf.osrd.sim_infra.api.*
 import fr.sncf.osrd.utils.DistanceRangeMap
 import fr.sncf.osrd.utils.distanceRangeMapOf
-import fr.sncf.osrd.utils.getRoutePathStartOffset
-import fr.sncf.osrd.utils.indexing.StaticIdx
 import fr.sncf.osrd.utils.units.Offset
 import fr.sncf.osrd.utils.units.Speed
 import fr.sncf.osrd.utils.units.kilometersPerHour
@@ -21,7 +17,7 @@ import fr.sncf.osrd.utils.units.meters
  * Simple internal class representing a stop with safety speed. Makes the function logic more
  * straightforward.
  */
-private data class SafetySpeedStop(val offset: Offset<TravelledPath>, val isShortSlip: Boolean)
+private data class SafetySpeedStop(val offset: Offset<TrainPath>, val isShortSlip: Boolean)
 
 /**
  * Compute safety speed ranges, areas where the train has a lower speed limit because of a scheduled
@@ -30,15 +26,12 @@ private data class SafetySpeedStop(val offset: Offset<TravelledPath>, val isShor
  */
 fun makeSafetySpeedRanges(
     infra: FullInfra,
-    chunkPath: ChunkPath,
-    routes: List<RouteId>,
+    trainPath: TrainPath,
     schedule: List<SimulationScheduleItem>,
     signalingRanges: DistanceRangeMap<String>,
 ): DistanceRangeMap<Speed> {
     val rawInfra = infra.rawInfra
-    val zonePaths = routes.flatMap { rawInfra.getRoutePath(it) }
-    val zonePathStartOffset = getRoutePathStartOffset(rawInfra, chunkPath, routes)
-    val signalOffsets = getSignalOffsets(infra, zonePaths, zonePathStartOffset)
+    val signalOffsets = getSignalOffsets(infra, trainPath)
 
     val stopsWithSafetySpeed =
         schedule
@@ -66,7 +59,7 @@ fun makeSafetySpeedRanges(
                 ETCS_LEVEL2.id,
             )
     ) {
-        makeEndOfPathStop(rawInfra, routes, signalOffsets)?.let { stopsWithSafetySpeed.add(it) }
+        makeEndOfPathStop(rawInfra, trainPath, signalOffsets)?.let { stopsWithSafetySpeed.add(it) }
     }
 
     val res = distanceRangeMapOf<Speed>()
@@ -88,12 +81,12 @@ fun makeSafetySpeedRanges(
         }
     }
     // Safety speed areas may extend outside the path
-    return res.subMap(0.meters, chunkPath.length)
+    return res.subMap(0.meters, trainPath.getLength())
 }
 
 /** Check if a given stop is in a range of a given signaling system. */
 private fun isStopInSignalingSystemRange(
-    stopOffset: Offset<TravelledPath>,
+    stopOffset: Offset<TrainPath>,
     signalingRanges: DistanceRangeMap<String>,
     signalingSystem: String,
 ): Boolean {
@@ -106,41 +99,38 @@ private fun isStopInSignalingSystemRange(
  */
 private fun makeEndOfPathStop(
     infra: RawSignalingInfra,
-    routes: List<RouteId>,
-    signalOffsets: List<Offset<TravelledPath>>,
+    trainPath: TrainPath,
+    signalOffsets: List<Offset<TrainPath>>,
 ): SafetySpeedStop? {
-    val lastRouteExit = infra.getRouteExit(routes.last())
+    val lastRouteExit = infra.getRouteExit(trainPath.getRoutes().last().value)
     val isBufferStop = infra.isBufferStop(lastRouteExit.value)
     if (isBufferStop) return SafetySpeedStop(signalOffsets.last(), true)
     return null
 }
 
 /** Return the offsets of block-delimiting signals on the path. */
-private fun getSignalOffsets(
-    infra: FullInfra,
-    zonePaths: List<StaticIdx<ZonePath>>,
-    pathStartOffset: Offset<BlockPath>,
-): List<Offset<TravelledPath>> {
-    val res = mutableListOf<Offset<TravelledPath>>()
+private fun getSignalOffsets(infra: FullInfra, trainPath: TrainPath): List<Offset<TrainPath>> {
+    val res = mutableListOf<Offset<TrainPath>>()
     val rawInfra = infra.rawInfra
     val signalingInfra = infra.loadedSignalInfra
     var prevZonePathsLength = 0.meters
-    for (zonePath in zonePaths) {
+    for (zonePathRange in trainPath.getZonePaths()) {
+        val zonePath = zonePathRange.value
         val signalPositions = rawInfra.getSignalPositions(zonePath)
         val signals = rawInfra.getSignals(zonePath)
         for ((signal, signalPosition) in signals zip signalPositions) {
             val isDelimiter =
-                signalingInfra.getLogicalSignals(signal).any { signalingInfra.isBlockDelimiter(it) }
+                signalingInfra.getLogicalSignals(signal).any(signalingInfra::isBlockDelimiter)
             if (isDelimiter) {
-                res.add(
-                    Offset(prevZonePathsLength + signalPosition.distance - pathStartOffset.distance)
-                )
+                res.add(zonePathRange.offsetToTrainPath(signalPosition))
             }
         }
         prevZonePathsLength += rawInfra.getZonePathLength(zonePath).distance
     }
     // Add one "signal" at the end of the last route no matter what.
     // There must be either a signal or a buffer stop, on which we may end safety speed ranges.
-    res.add(Offset(prevZonePathsLength - pathStartOffset.distance))
+    val lastRouteRange = trainPath.getRoutes().last()
+    res.add(lastRouteRange.getObjectAbsolutePathEnd(rawInfra.getRouteLength(lastRouteRange.value)))
+
     return res.filter { it.distance >= 0.meters }
 }

core/src/main/kotlin/fr/sncf/osrd/standalone_sim/StandaloneSimulation.kt

@@ -23,9 +23,11 @@ import fr.sncf.osrd.envelope_sim.pipelines.maxEffortEnvelopeFrom
 import fr.sncf.osrd.envelope_sim.pipelines.maxSpeedEnvelopeFrom
 import fr.sncf.osrd.envelope_sim_infra.HasMissingSpeedTag
 import fr.sncf.osrd.envelope_sim_infra.computeMRSP
-import fr.sncf.osrd.path.implementations.ChunkPath
 import fr.sncf.osrd.path.interfaces.TrainPath
 import fr.sncf.osrd.path.interfaces.TravelledPath
+import fr.sncf.osrd.path.interfaces.getLegacyBlockPath
+import fr.sncf.osrd.path.interfaces.getLegacyChunkPath
+import fr.sncf.osrd.path.interfaces.getLegacyRoutePath
 import fr.sncf.osrd.railjson.schema.rollingstock.Comfort
 import fr.sncf.osrd.railjson.schema.schedule.RJSAllowanceDistribution
 import fr.sncf.osrd.reporting.exceptions.ErrorType.ZeroLengthPath
@@ -39,7 +41,6 @@ import fr.sncf.osrd.utils.DistanceRangeMap
 import fr.sncf.osrd.utils.distanceRangeMapOf
 import fr.sncf.osrd.utils.entries
 import fr.sncf.osrd.utils.toRangeMap
-import fr.sncf.osrd.utils.trainPathBlockOffset
 import fr.sncf.osrd.utils.units.Distance
 import fr.sncf.osrd.utils.units.Offset
 import fr.sncf.osrd.utils.units.meters
@@ -54,9 +55,6 @@ val standaloneSimLogger: Logger = LoggerFactory.getLogger("StandaloneSimulation"
 fun runStandaloneSimulation(
     infra: FullInfra,
     trainPath: TrainPath,
-    chunkPath: ChunkPath,
-    routes: List<RouteId>,
-    blockPath: List<BlockId>,
     rollingStock: RollingStock,
     comfort: Comfort,
     constraintDistribution: RJSAllowanceDistribution,
@@ -71,11 +69,10 @@ fun runStandaloneSimulation(
     pathItemPositions: List<Offset<TravelledPath>>,
     driverBehaviour: DriverBehaviour = DriverBehaviour(),
 ): SimulationSuccess {
-    if (chunkPath.length == 0.meters) throw OSRDError(ZeroLengthPath)
-    val signalingRanges = buildSignalingRanges(infra, blockPath, chunkPath)
+    if (trainPath.getLength() == 0.meters) throw OSRDError(ZeroLengthPath)
+    val signalingRanges = buildSignalingRanges(infra, trainPath)
     // MRSP & SpeedLimits
-    val safetySpeedRanges =
-        makeSafetySpeedRanges(infra, chunkPath, routes, schedule, signalingRanges)
+    val safetySpeedRanges = makeSafetySpeedRanges(infra, trainPath, schedule, signalingRanges)
     var mrsp =
         computeMRSP(
             trainPath,
@@ -110,7 +107,7 @@ fun runStandaloneSimulation(
             trainPath,
             timeStep,
             curvesAndConditions.curves,
-            makeETCSContext(rollingStock, infra, chunkPath, routes, blockPath, signalingRanges),
+            makeETCSContext(rollingStock, infra, trainPath, signalingRanges),
         )
 
     // Max speed envelope
@@ -166,10 +163,10 @@ fun runStandaloneSimulation(
         runScheduleMetadataExtractor(
             finalEnvelope,
             trainPath,
-            chunkPath,
+            trainPath.getLegacyChunkPath(), // TODO path migration
             infra,
-            routes,
-            blockPath,
+            trainPath.getLegacyRoutePath(),
+            trainPath.getLegacyBlockPath(),
             rollingStock,
             schedule,
             pathItemPositions,
@@ -185,30 +182,14 @@ fun runStandaloneSimulation(
     )
 }
 
-/** Returns the ranges where each signaling system is encountered, as travelled path offsets. */
-fun buildSignalingRanges(
-    infra: FullInfra,
-    blockPath: List<BlockId>,
-    chunkPath: ChunkPath,
-): DistanceRangeMap<String> {
+/** Returns the ranges where each signaling system is encountered. */
+fun buildSignalingRanges(infra: FullInfra, trainPath: TrainPath): DistanceRangeMap<String> {
     val blockInfra = infra.blockInfra
-    var blockStartOffset =
-        Offset<TravelledPath>(
-            trainPathBlockOffset(infra.rawInfra, infra.blockInfra, blockPath, chunkPath).distance *
-                -1.0
-        )
     val res = distanceRangeMapOf<String>()
-    for (blockId in blockPath) {
-        val blockLength = blockInfra.getBlockLength(blockId)
-        val blockEndOffset = blockStartOffset + blockLength.distance
-        val sigSystem = blockInfra.getBlockSignalingSystem(blockId)
-        val name = infra.signalingSimulator.sigModuleManager.getName(sigSystem)
-        res.put(
-            Distance.max(blockStartOffset.distance, Distance.ZERO),
-            Distance.min(blockEndOffset.distance, chunkPath.length),
-            name,
-        )
-        blockStartOffset += blockLength.distance
+    for (blockRange in trainPath.getBlocks()) {
+        val sigSystem = blockInfra.getBlockSignalingSystem(blockRange.value)
+        val sigSystemName = infra.signalingSimulator.sigModuleManager.getName(sigSystem)
+        res.put(blockRange.pathBegin.distance, blockRange.pathEnd.distance, sigSystemName)
     }
     return res
 }