#14063 Well Event: Sort schedule output by well name

The well list driving schedule generation originates from a
std::set<RimWellPath*>, so it was ordered by pointer address and the
per-well keyword records (WELSPECS, COMPDAT, COMPLUMP, MSW keywords, well
control) came out in a non-deterministic order that only looked sorted by
coincidence.

Sort the well list once by the deck export name in generateSchedule, so
every per-well keyword is emitted in a stable, well-name-sorted order,
matching the convention already used by the file-based completion export.
Schedule-level keywords (GRUPTREE, RPTRST, TUNING) are left untouched.

Author: kriben

ApplicationLibCode/Commands/CompletionExportCommands/RicScheduleDataGenerator.cpp

@@ -35,6 +35,7 @@
 #include "opm/input/eclipse/Deck/DeckKeyword.hpp"
 #include "opm/input/eclipse/Deck/DeckRecord.hpp"
 
+#include <algorithm>
 #include <map>
 #include <set>
 
@@ -54,10 +55,23 @@ QString RicScheduleDataGenerator::generateSchedule( const RimWellEventTimeline&
     result += "-- Schedule data based on well events\n";
     result += "--\n";
 
+    // The incoming well list is ordered by pointer (it originates from a std::set), which makes the
+    // per-well keyword records appear in a non-deterministic order. Sort once by the deck export
+    // name so every per-well keyword (WELSPECS, COMPDAT, COMPLUMP, WELSEGS/COMPSEGS, WSEGVALV/
+    // WSEGAICD, well control) is emitted in a stable, well-name-sorted order.
+    auto exportName = []( const RimWellPath* well ) -> QString
+    { return well && well->completionSettings() ? well->completionSettings()->wellNameForExport() : QString(); };
+
+    std::vector<RimWellPath*> sortedWellPaths = wellPaths;
+    std::stable_sort( sortedWellPaths.begin(),
+                      sortedWellPaths.end(),
+                      [&exportName]( const RimWellPath* a, const RimWellPath* b )
+                      { return QString::compare( exportName( a ), exportName( b ) ) < 0; } );
+
     // Generate section for each date
     for ( const auto& date : dates )
     {
-        QString dateSection = generateDateSection( timeline, eclipseCase, wellPaths, date, mswWells );
+        QString dateSection = generateDateSection( timeline, eclipseCase, sortedWellPaths, date, mswWells );
         if ( !dateSection.isEmpty() )
         {
             result += dateSection;

GrpcInterface/Python/rips/tests/test_well_events.py

@@ -1516,6 +1516,57 @@ def test_keywords_grouped_across_wells(self, project_with_case_and_well):
                 f"Well {wp.name!r} missing from grouped WELSPECS block: {welspecs_block!r}"
             )
 
+    def test_per_well_keywords_sorted_by_well_name(self, project_with_case_and_well):
+        """Per-well keyword records are emitted in deck-name-sorted well order, so WELSPECS
+        and COMPDAT share the same ascending well order rather than an arbitrary one.
+
+        Note: the fixture imports wells A then B, so insertion order already matches name
+        order; this test locks in the deterministic ascending ordering and cross-keyword
+        consistency that the sort guarantees.
+        """
+        project, case, timeline = project_with_case_and_well
+        well_paths = project.well_paths()
+        assert len(well_paths) >= 2, (
+            "Test requires at least two well paths in the fixture"
+        )
+
+        for wp in well_paths[:2]:
+            timeline.add_perf_event(
+                event_date="2024-01-01",
+                well_path=wp,
+                start_md=2000.0,
+                end_md=2200.0,
+                diameter=0.1,
+                state="OPEN",
+            )
+
+        timeline.set_timestamp(timestamp="2024-12-31")
+        schedule_text = timeline.generate_schedule_text(
+            eclipse_case=case, export_msw_for_wells=project.well_paths()
+        )
+        print(f"\nSchedule text for sorted well order:\n{schedule_text}")
+
+        export_names = sorted(wp.name.replace(" ", "") for wp in well_paths[:2])
+
+        def first_positions(block):
+            squashed = block.replace(" ", "")
+            return [squashed.find(name) for name in export_names]
+
+        welspecs_block = schedule_text.split("WELSPECS\n", 1)[1].split("\n/\n", 1)[0]
+        compdat_block = schedule_text.split("COMPDAT\n", 1)[1].split("\n/\n", 1)[0]
+
+        for block_name, block in (
+            ("WELSPECS", welspecs_block),
+            ("COMPDAT", compdat_block),
+        ):
+            positions = first_positions(block)
+            assert all(p >= 0 for p in positions), (
+                f"Both wells must appear in the {block_name} block: {block!r}"
+            )
+            assert positions == sorted(positions), (
+                f"{block_name} wells not in ascending name order {export_names}: {block!r}"
+            )
+
     def test_welsegs_compsegs_not_merged_across_wells(self, project_with_case_and_well):
         """WELSEGS and COMPSEGS carry a per-well header record and therefore cannot
         be merged across wells: each MSW well must get its own keyword block on the