core, editoast: return conflict requirements

emersion · emersion · commit 095b8a331c0d · 2024-09-17T13:35:34.000+02:00
Closes: #8680 Signed-off-by: Simon Ser <contact@emersion.fr>
diff --git a/core/src/main/java/fr/sncf/osrd/api/ConflictDetectionEndpoint.java b/core/src/main/java/fr/sncf/osrd/api/ConflictDetectionEndpoint.java
@@ -90,11 +90,31 @@ public enum ConflictType {
             @Json(name = "conflict_type")
             public final ConflictType conflictType;
 
-            public Conflict(Collection<Long> trainIds, double startTime, double endTime, ConflictType conflictType) {
+            public final transient 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;
             }
         }
 
diff --git a/core/src/main/java/fr/sncf/osrd/conflicts/Conflicts.kt b/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,15 @@ 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 +189,16 @@ 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 +225,16 @@ 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 +252,16 @@ 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)
+                        )
                     )
             }
         }
@@ -421,7 +442,11 @@ enum class EventType {
     END
 }
 
-class Event(val eventType: EventType, val time: Double) : Comparable<Event> {
+class Event(
+    val eventType: EventType,
+    val time: Double,
+    val requirements: Collection<ConflictRequirement>
+) : Comparable<Event> {
     override fun compareTo(other: Event): Int {
         val timeDelta = this.time.compareTo(other.time)
         if (timeDelta != 0) return timeDelta
@@ -443,28 +468,32 @@ fun mergeMap(
         // create an event list and sort it
         val events = mutableListOf<Event>()
         for (conflict in conflicts) {
-            events.add(Event(EventType.BEGIN, conflict.startTime))
-            events.add(Event(EventType.END, conflict.endTime))
+            events.add(Event(EventType.BEGIN, conflict.startTime, conflict.requirements))
+            events.add(Event(EventType.END, conflict.endTime, conflict.requirements))
         }
 
         events.sort()
         var eventCount = 0
         var eventBeginning = 0.0
+        var conflictReqs = mutableListOf<ConflictRequirement>()
         for (event in events) {
             when (event.eventType) {
                 EventType.BEGIN -> {
                     if (++eventCount == 1) eventBeginning = event.time
+                    conflictReqs.addAll(event.requirements)
                 }
                 EventType.END -> {
-                    if (--eventCount == 0)
-                        newConflicts.add(
-                            Conflict(
-                                trainIds.toMutableList(),
-                                eventBeginning,
-                                event.time,
-                                conflictType
-                            )
+                    if (--eventCount > 0) continue
+                    newConflicts.add(
+                        Conflict(
+                            trainIds.toMutableList(),
+                            eventBeginning,
+                            event.time,
+                            conflictType,
+                            conflictReqs
                         )
+                    )
+                    conflictReqs = mutableListOf()
                 }
             }
         }
diff --git a/core/src/main/kotlin/fr/sncf/osrd/api/api_v2/conflicts/ConflictDetectionEndpointV2.kt b/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())),
+                    )
+                }
             )
         }
     )
diff --git a/core/src/main/kotlin/fr/sncf/osrd/api/api_v2/conflicts/ConflictDetectionResponse.kt b/core/src/main/kotlin/fr/sncf/osrd/api/api_v2/conflicts/ConflictDetectionResponse.kt
@@ -18,6 +18,13 @@ class Conflict(
     @Json(name = "end_time") val endTime: ZonedDateTime,
     @Json(name = "conflict_type")
     val conflictType: ConflictDetectionEndpoint.ConflictDetectionResult.Conflict.ConflictType,
+    @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> =
diff --git a/core/src/test/java/fr/sncf/osrd/standalone_sim/ConflictDetectionTest.java b/core/src/test/java/fr/sncf/osrd/standalone_sim/ConflictDetectionTest.java
@@ -10,10 +10,13 @@
 import static fr.sncf.osrd.utils.Helpers.fullInfraFromRJS;
 import static fr.sncf.osrd.utils.units.Distance.fromMeters;
 import static fr.sncf.osrd.utils.units.Distance.toMeters;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertIterableEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import fr.sncf.osrd.api.ConflictDetectionEndpoint.ConflictDetectionResult.Conflict;
+import fr.sncf.osrd.api.ConflictDetectionEndpoint.ConflictDetectionResult.ConflictRequirement;
 import fr.sncf.osrd.api.FullInfra;
 import fr.sncf.osrd.conflicts.ConflictsKt;
 import fr.sncf.osrd.conflicts.TrainRequirements;
@@ -31,6 +34,7 @@
 import fr.sncf.osrd.utils.Helpers;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.stream.LongStream;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -131,8 +135,35 @@ public void headToHeadRoutingConflict() throws Exception {
         {
             var conflicts = ConflictsKt.detectConflicts(List.of(
                     convertRequirements(0L, 0.0, simResultA.train), convertRequirements(1L, 0.0, simResultB.train)));
-            assertTrue(conflicts.stream().anyMatch((conflict) -> conflict.conflictType == ROUTING));
             assertFalse(conflicts.stream().anyMatch((conflict) -> conflict.conflictType == SPACING));
+            var routingConflicts = conflicts.stream()
+                    .filter((conflict) -> conflict.conflictType == ROUTING)
+                    .toList();
+            Assertions.assertEquals(1, routingConflicts.size());
+            var conflict = routingConflicts.get(0);
+            System.out.println(conflict.requirements.stream().toList().get(0).toString());
+            System.out.println(conflict.trainIds.toString());
+            // Assertions.assertEquals(conflict.requirements.size(), 1);
+
+            var expectedStartTime = -5;
+            var expectedEndTime = 15.573734;
+            var expectedConflictsReqs = List.of(
+                            "zone.[DA3:INCREASING, DA6_1:DECREASING]",
+                            "zone.[DA6_1:INCREASING, DA6_2:DECREASING]",
+                            "zone.[DA6_2:INCREASING, DA6_3:DECREASING]",
+                            "zone.[DA6_3:INCREASING, DA6_4:DECREASING]",
+                            "zone.[DA6_4:INCREASING, DA6_5:DECREASING]",
+                            "zone.[DA5:DECREASING, DA6_5:INCREASING]")
+                    .stream()
+                    .map(zone -> new ConflictRequirement(zone, expectedStartTime, expectedEndTime))
+                    .toList();
+            var expectedRoutingConflicts = List.of(new Conflict(
+                    LongStream.of(0, 1).boxed().toList(),
+                    expectedStartTime,
+                    expectedEndTime,
+                    ROUTING,
+                    expectedConflictsReqs));
+            assertThat(routingConflicts).usingRecursiveComparison().isEqualTo(expectedRoutingConflicts);
         }
 
         // no conflicts should occur if trains don't run at the same time
diff --git a/editoast/openapi.yaml b/editoast/openapi.yaml
@@ -2953,6 +2953,7 @@ components:
       - start_time
       - end_time
       - conflict_type
+      - requirements
       properties:
         conflict_type:
           type: string
@@ -2963,6 +2964,11 @@ components:
           type: string
           format: date-time
           description: Datetime of the end of the conflict
+        requirements:
+          type: array
+          items:
+            $ref: '#/components/schemas/ConflictRequirement'
+          description: List of requirements causing the conflict
         start_time:
           type: string
           format: date-time
@@ -2987,6 +2993,7 @@ components:
             - start_time
             - end_time
             - conflict_type
+            - requirements
             properties:
               conflict_type:
                 type: string
@@ -2997,6 +3004,11 @@ components:
                 type: string
                 format: date-time
                 description: Datetime of the end of the conflict
+              requirements:
+                type: array
+                items:
+                  $ref: '#/components/schemas/ConflictRequirement'
+                description: List of requirements causing the conflict
               start_time:
                 type: string
                 format: date-time
@@ -3008,6 +3020,26 @@ components:
                   format: int64
                 description: List of train ids involved in the conflict
           description: List of conflicts detected
+    ConflictRequirement:
+      type: object
+      description: |-
+        Unmet requirement causing a conflict.
+
+        The start and end time describe the conflicting time span (not the full
+        requirement's time span).
+      required:
+      - zone
+      - start_time
+      - end_time
+      properties:
+        end_time:
+          type: string
+          format: date-time
+        start_time:
+          type: string
+          format: date-time
+        zone:
+          type: string
     CopyOperation:
       type: object
       description: JSON Patch 'copy' operation representation
diff --git a/editoast/src/core/conflict_detection.rs b/editoast/src/core/conflict_detection.rs
@@ -13,6 +13,7 @@ use super::simulation::SpacingRequirement;
 editoast_common::schemas! {
     ConflictDetectionResponse,
     Conflict,
+    ConflictRequirement,
 }
 
 #[derive(Debug, Serialize)]
@@ -47,6 +48,19 @@ pub struct Conflict {
     /// Type of the conflict
     #[schema(inline)]
     pub conflict_type: ConflictType,
+    /// List of requirements causing the conflict
+    pub requirements: Vec<ConflictRequirement>,
+}
+
+/// Unmet requirement causing a conflict.
+///
+/// The start and end time describe the conflicting time span (not the full
+/// requirement's time span).
+#[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)]
diff --git a/front/src/common/api/generatedEditoastApi.ts b/front/src/common/api/generatedEditoastApi.ts
@@ -2744,10 +2744,17 @@ export type TimetableDetailedResult = {
   timetable_id: number;
   train_ids: number[];
 };
+export type ConflictRequirement = {
+  end_time: string;
+  start_time: string;
+  zone: string;
+};
 export type Conflict = {
   conflict_type: 'Spacing' | 'Routing';
   /** Datetime of the end of the conflict */
   end_time: string;
+  /** List of requirements causing the conflict */
+  requirements: ConflictRequirement[];
   /** Datetime of the start of the conflict */
   start_time: string;
   /** List of train ids involved in the conflict */

Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,14 @@ private fun makeConflictDetectionResponse(`
`52`	`52`	`it.trainIds,`
`53`	`53`	`startTime.plus(Duration.ofMillis((it.startTime * 1000).toLong())),`
`54`	`54`	`startTime.plus(Duration.ofMillis((it.endTime * 1000).toLong())),`
`55`		`- it.conflictType`
	`55`	`+ it.conflictType,`
	`56`	`+ it.requirements.map {`
	`57`	`+ ConflictRequirement(`
	`58`	`+ it.zone,`
	`59`	`+ startTime.plus(Duration.ofMillis((it.startTime * 1000).toLong())),`
	`60`	`+ startTime.plus(Duration.ofMillis((it.endTime * 1000).toLong())),`
	`61`	`+ )`
	`62`	`+ }`
`56`	`63`	`)`
`57`	`64`	`}`
`58`	`65`	`)`