core: stdcm: limit the loop where we look for possible delays

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

@@ -9,6 +9,8 @@ import fr.sncf.osrd.utils.units.Distance.Companion.fromMeters
 import fr.sncf.osrd.utils.units.Offset
 import fr.sncf.osrd.utils.units.meters
 import java.util.*
+import kotlin.math.max
+import kotlin.math.min
 
 /**
  * This class contains all the methods used to handle delays (how much we can add, how much we need
@@ -29,14 +31,17 @@ internal constructor(
      */
     fun minimumDelaysPerOpening(
         infraExplorerWithNewEnvelope: InfraExplorerWithEnvelope,
-        startTime: Double,
+        timeData: TimeData,
         envelope: Envelope,
         startOffset: Offset<Block>,
     ): NavigableSet<Double> {
+        val startTime = timeData.earliestReachableTime
+        val maximumDelay = computeMaximumDelay(timeData)
         val res = TreeSet<Double>()
         val endOffset = startOffset + fromMeters(envelope.endPos)
         var time = startTime
         while (java.lang.Double.isFinite(time)) {
+            if (time - startTime > maximumDelay) break
             val availability =
                 getLastBlockAvailability(
                     infraExplorerWithNewEnvelope,
@@ -58,6 +63,18 @@ internal constructor(
         return res
     }
 
+    /**
+     * Compute how much delay we may add here. Prevents the generation of edges very far in the
+     * future that would necessarily be discarded.
+     */
+    private fun computeMaximumDelay(data: TimeData): Double {
+        val maxExtraRunTime = maxRunTime - data.totalRunningTime
+        val maxDelayForMaxRunTime = data.maxDepartureDelayingWithoutConflict + maxExtraRunTime
+        val maxDelayWithLocalConflict =
+            data.timeOfNextConflictAtLocation - data.earliestReachableTime
+        return max(0.0, min(maxDelayForMaxRunTime, maxDelayWithLocalConflict))
+    }
+
     /** Returns the start time of the next occupancy for the block */
     fun findNextOccupancy(
         infraExplorer: InfraExplorerWithEnvelope,

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

@@ -132,7 +132,7 @@ internal constructor(
     private fun getDelaysPerOpening(): Set<Double> {
         return graph.delayManager.minimumDelaysPerOpening(
             getExplorerWithNewEnvelope()!!,
-            prevNode.timeData.earliestReachableTime,
+            prevNode.timeData,
             envelope!!,
             startOffset,
         )

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

@@ -25,6 +25,7 @@ import io.opentelemetry.instrumentation.annotations.WithSpan
 import java.time.Duration
 import java.time.Instant
 import java.util.*
+import kotlin.Double.Companion.POSITIVE_INFINITY
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 
@@ -272,7 +273,7 @@ class STDCMPathfinding(
                             earliestReachableTime = startTime,
                             maxDepartureDelayingWithoutConflict = maxDepartureDelay,
                             departureTime = startTime,
-                            timeOfNextConflictAtLocation = 0.0,
+                            timeOfNextConflictAtLocation = POSITIVE_INFINITY,
                             totalRunningTime = 0.0,
                             stopTimeData = listOf(),
                             maxFirstDepartureDelaying = maxDepartureDelay,

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

@@ -89,6 +89,9 @@ data class TimeData(
         var maxDepartureDelayingWithoutConflict = maxDepartureDelayingWithoutConflict
         val nextEarliestReachableTime =
             earliestReachableTime + extraTravelTime + (extraStopTime ?: 0.0)
+        var timeOfNextConflict = timeOfNextConflictAtLocation
+        if (maxAdditionalStopTime != null)
+            timeOfNextConflict = nextEarliestReachableTime + maxAdditionalStopTime
         if (extraStopTime != null) {
             val stopDataCopy = newStopData.toMutableList()
             stopDataCopy.add(
@@ -108,6 +111,7 @@ data class TimeData(
             maxDepartureDelayingWithoutConflict = maxDepartureDelayingWithoutConflict,
             maxFirstDepartureDelaying =
                 min(maxFirstDepartureDelaying, (maxAdditionalStopTime ?: POSITIVE_INFINITY)),
+            timeOfNextConflictAtLocation = timeOfNextConflict,
         )
     }