core, editoast: return conflict requirements

Author: emersion

core/src/main/java/fr/sncf/osrd/api/ConflictDetectionEndpoint.java

@@ -90,11 +90,26 @@ public enum ConflictType {
             @Json(name = "conflict_type")
             public final ConflictType conflictType;
 
-            public Conflict(Collection<Long> trainIds, double startTime, double endTime, ConflictType conflictType) {
+            public final Collection<ConflictRequirement> requirements;
+
+            public Conflict(Collection<Long> trainIds, double startTime, double endTime, ConflictType conflictType, Collection<ConflictRequirement> requirements) {
                 this.trainIds = trainIds;
                 this.startTime = startTime;
                 this.endTime = endTime;
                 this.conflictType = conflictType;
+                this.requirements = requirements;
+            }
+        }
+
+        public static class ConflictRequirement {
+            public final String zone;
+            public final double startTime;
+            public final double endTime;
+
+            public ConflictRequirement(String zone, double startTime, double endTime) {
+                this.zone = zone;
+                this.startTime = startTime;
+                this.endTime = endTime;
             }
         }
 

core/src/main/java/fr/sncf/osrd/conflicts/Conflicts.kt

@@ -4,6 +4,7 @@ import com.carrotsearch.hppc.IntArrayList
 import com.squareup.moshi.Json
 import fr.sncf.osrd.api.ConflictDetectionEndpoint.ConflictDetectionResult.Conflict
 import fr.sncf.osrd.api.ConflictDetectionEndpoint.ConflictDetectionResult.Conflict.ConflictType
+import fr.sncf.osrd.api.ConflictDetectionEndpoint.ConflictDetectionResult.ConflictRequirement
 import fr.sncf.osrd.standalone_sim.result.ResultTrain.RoutingRequirement
 import fr.sncf.osrd.standalone_sim.result.ResultTrain.SpacingRequirement
 import kotlin.math.max
@@ -171,12 +172,13 @@ class IncrementalConflictDetectorImpl(trainRequirements: List<TrainRequirements>
         // look for requirement times overlaps.
         // as spacing requirements are exclusive, any overlap is a conflict
         val res = mutableListOf<Conflict>()
-        for (requirements in spacingZoneRequirements.values) {
-            for (conflictGroup in detectRequirementConflicts(requirements) { _, _ -> true }) {
+        for (entry in spacingZoneRequirements) {
+            for (conflictGroup in detectRequirementConflicts(entry.value) { _, _ -> true }) {
                 val trains = conflictGroup.map { it.trainId }
                 val beginTime = conflictGroup.minBy { it.beginTime }.beginTime
                 val endTime = conflictGroup.maxBy { it.endTime }.endTime
-                res.add(Conflict(trains, beginTime, endTime, ConflictType.SPACING))
+                val conflictReq = ConflictRequirement(entry.key, beginTime, endTime)
+                res.add(Conflict(trains, beginTime, endTime, ConflictType.SPACING, listOf(conflictReq)))
             }
         }
         return res
@@ -185,13 +187,14 @@ class IncrementalConflictDetectorImpl(trainRequirements: List<TrainRequirements>
     private fun detectRoutingConflicts(): List<Conflict> {
         // for each zone, check compatibility of overlapping requirements
         val res = mutableListOf<Conflict>()
-        for (requirements in routingZoneRequirements.values) {
+        for (entry in routingZoneRequirements) {
             for (conflictGroup in
-                detectRequirementConflicts(requirements) { a, b -> a.config != b.config }) {
+                detectRequirementConflicts(entry.value) { a, b -> a.config != b.config }) {
                 val trains = conflictGroup.map { it.trainId }
                 val beginTime = conflictGroup.minBy { it.beginTime }.beginTime
                 val endTime = conflictGroup.maxBy { it.endTime }.endTime
-                res.add(Conflict(trains, beginTime, endTime, ConflictType.ROUTING))
+                val conflictReq = ConflictRequirement(entry.key, beginTime, endTime)
+                res.add(Conflict(trains, beginTime, endTime, ConflictType.ROUTING, listOf(conflictReq)))
             }
         }
         return res
@@ -218,9 +221,10 @@ class IncrementalConflictDetectorImpl(trainRequirements: List<TrainRequirements>
         for (otherReq in requirements) {
             val beginTime = max(req.beginTime, otherReq.beginTime)
             val endTime = min(req.endTime, otherReq.endTime)
+            val conflictReq = ConflictRequirement(req.zone, beginTime, endTime)
             if (beginTime < endTime)
                 res.add(
-                    Conflict(listOf(otherReq.trainId), beginTime, endTime, ConflictType.SPACING)
+                    Conflict(listOf(otherReq.trainId), beginTime, endTime, ConflictType.SPACING, listOf(conflictReq))
                 )
         }
 
@@ -238,9 +242,10 @@ class IncrementalConflictDetectorImpl(trainRequirements: List<TrainRequirements>
                 if (otherReq.config == zoneReqConfig) continue
                 val beginTime = max(req.beginTime, otherReq.beginTime)
                 val endTime = min(zoneReq.endTime, otherReq.endTime)
+                val conflictReq = ConflictRequirement(zoneReq.zone, beginTime, endTime)
                 if (beginTime < endTime)
                     res.add(
-                        Conflict(listOf(otherReq.trainId), beginTime, endTime, ConflictType.ROUTING)
+                        Conflict(listOf(otherReq.trainId), beginTime, endTime, ConflictType.ROUTING, listOf(conflictReq))
                     )
             }
         }
@@ -447,6 +452,12 @@ fun mergeMap(
             events.add(Event(EventType.END, conflict.endTime))
         }
 
+        // TODO: accumulate in the for loop below somehow?
+        val conflictReqs = mutableListOf<ConflictRequirement>()
+        for (conflict in conflicts) {
+            conflictReqs.addAll(conflict.requirements);
+        }
+
         events.sort()
         var eventCount = 0
         var eventBeginning = 0.0
@@ -462,7 +473,8 @@ fun mergeMap(
                                 trainIds.toMutableList(),
                                 eventBeginning,
                                 event.time,
-                                conflictType
+                                conflictType,
+                                conflictReqs
                             )
                         )
                 }

core/src/main/kotlin/fr/sncf/osrd/api/api_v2/conflicts/ConflictDetectionEndpointV2.kt

@@ -52,7 +52,14 @@ private fun makeConflictDetectionResponse(
                 it.trainIds,
                 startTime.plus(Duration.ofMillis((it.startTime * 1000).toLong())),
                 startTime.plus(Duration.ofMillis((it.endTime * 1000).toLong())),
-                it.conflictType
+                it.conflictType,
+                it.requirements.map {
+                    ConflictRequirement(
+                        it.zone,
+                        startTime.plus(Duration.ofMillis((it.startTime * 1000).toLong())),
+                        startTime.plus(Duration.ofMillis((it.endTime * 1000).toLong())),
+                    )
+                }
             )
         }
     )

core/src/main/kotlin/fr/sncf/osrd/api/api_v2/conflicts/ConflictDetectionResponse.kt

@@ -18,6 +18,14 @@ class Conflict(
     @Json(name = "end_time") val endTime: ZonedDateTime,
     @Json(name = "conflict_type")
     val conflictType: ConflictDetectionEndpoint.ConflictDetectionResult.Conflict.ConflictType,
+    // TODO: would "zones" be a better name?
+    @Json(name = "requirements") val requirements: Collection<ConflictRequirement>,
+)
+
+class ConflictRequirement(
+    @Json(name = "zone") val zone: String,
+    @Json(name = "start_time") val startTime: ZonedDateTime,
+    @Json(name = "end_time") val endTime: ZonedDateTime,
 )
 
 val conflictResponseAdapter: JsonAdapter<ConflictDetectionResponse> =

editoast/src/core/v2/conflict_detection.rs

@@ -13,6 +13,7 @@ use super::simulation::SpacingRequirement;
 editoast_common::schemas! {
     ConflictDetectionResponse,
     Conflict,
+    ConflictRequirement,
 }
 
 #[derive(Debug, Serialize)]
@@ -48,6 +49,15 @@ pub struct Conflict {
     /// Type of the conflict
     #[schema(inline)]
     pub conflict_type: ConflictType,
+    /// List of requirements causing the conflict
+    pub requirements: Vec<ConflictRequirement>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize, ToSchema)]
+pub struct ConflictRequirement {
+    pub zone: String,
+    pub start_time: DateTime<Utc>,
+    pub end_time: DateTime<Utc>,
 }
 
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, ToSchema)]