Update rips module and proto files

Author: magnesj

docs/rips/generated/generated_classes.py

@@ -3931,16 +3931,18 @@ def events(self) -> List[WellEvent]:
         return self.children("Events", WellEvent)
 
 
-    def generate_schedule(self, eclipse_case_id: int=-1) -> DataContainerString:
+    def generate_schedule(self, eclipse_case: Optional[Reservoir]=None, include_welsegs: bool=True, include_compsegs: bool=True) -> DataContainerString:
         """
         Generate Eclipse schedule text for all wells in the collection
 
         Arguments:
-            eclipse_case_id (int): Eclipse Case ID
+            eclipse_case (Optional[Reservoir]): Eclipse Case
+            include_welsegs (bool): Include WELSEGS keyword in the exported schedule
+            include_compsegs (bool): Include COMPSEGS keyword in the exported schedule
         Returns:
             DataContainerString
         """
-        return self._call_pdm_method_return_value("GenerateSchedule", DataContainerString, eclipse_case_id=eclipse_case_id)
+        return self._call_pdm_method_return_value("GenerateSchedule", DataContainerString, eclipse_case=eclipse_case, include_welsegs=include_welsegs, include_compsegs=include_compsegs)
 
 
     def set_timestamp(self, timestamp: str="2024-01-01") -> None:

docs/rips/tests/test_well_events.py

@@ -1231,6 +1231,102 @@ def test_schedule_multiple_dates_in_order(self, project_with_case_and_well):
         assert jan_pos < feb_pos, "January should come before February"
         assert feb_pos < jun_pos, "February should come before June"
 
+    def test_welsegs_compsegs_optional(self, project_with_case_and_well):
+        """Regression for #14064: callers can suppress WELSEGS and/or COMPSEGS
+        without affecting other keywords (WSEGVALV/WSEGAICD/COMPDAT/WELSPECS).
+        """
+        project, case, timeline = project_with_case_and_well
+        well_paths = project.well_paths()
+        assert len(well_paths) >= 1
+
+        wp = well_paths[0]
+        timeline.add_tubing_event(
+            event_date="2024-01-01",
+            well_path=wp,
+            start_md=0.0,
+            end_md=2500.0,
+            inner_diameter=0.15,
+            roughness=1.0e-5,
+        )
+        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")
+
+        # Baseline (defaults) must still emit WELSEGS and COMPSEGS.
+        baseline = timeline.generate_schedule_text(eclipse_case=case)
+        assert "WELSEGS" in baseline
+        assert "COMPSEGS" in baseline
+
+        # Suppress both.
+        suppressed = timeline.generate_schedule_text(
+            eclipse_case=case, include_welsegs=False, include_compsegs=False
+        )
+        print(f"\nSchedule with WELSEGS/COMPSEGS suppressed:\n{suppressed}")
+        assert "WELSEGS" not in suppressed, (
+            f"WELSEGS should be suppressed:\n{suppressed}"
+        )
+        assert "COMPSEGS" not in suppressed, (
+            f"COMPSEGS should be suppressed:\n{suppressed}"
+        )
+        # COMPDAT (perforation completions) is unrelated to the MSW flags.
+        assert "COMPDAT" in suppressed
+
+        # Independent toggling.
+        only_compsegs_off = timeline.generate_schedule_text(
+            eclipse_case=case, include_compsegs=False
+        )
+        assert "WELSEGS" in only_compsegs_off
+        assert "COMPSEGS" not in only_compsegs_off
+
+        only_welsegs_off = timeline.generate_schedule_text(
+            eclipse_case=case, include_welsegs=False
+        )
+        assert "WELSEGS" not in only_welsegs_off
+        assert "COMPSEGS" in only_welsegs_off
+
+    def test_keywords_grouped_across_wells(self, project_with_case_and_well):
+        """Regression for #14063: WELSPECS / COMPDAT records for multiple wells on
+        the same date must appear under a single keyword header (not one block per well).
+        """
+        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)
+        print(f"\nSchedule text for multi-well grouping:\n{schedule_text}")
+
+        # Exactly one "WELSPECS\n" header for all wells.
+        welspecs_count = schedule_text.count("WELSPECS\n")
+        assert welspecs_count == 1, (
+            f"WELSPECS should appear once for grouped output; got {welspecs_count}:\n{schedule_text}"
+        )
+
+        # Both well names must appear inside the WELSPECS block (between header and trailing '/' line).
+        welspecs_block = schedule_text.split("WELSPECS\n", 1)[1].split("\n/\n", 1)[0]
+        for wp in well_paths[:2]:
+            assert wp.name.replace(" ", "") in welspecs_block.replace(" ", ""), (
+                f"Well {wp.name!r} missing from grouped WELSPECS block: {welspecs_block!r}"
+            )
+
 
 class TestKeywordEvents:
     """Tests for well keyword event functionality."""
@@ -1428,6 +1524,53 @@ def test_keyword_event_schedule_output_multiple_keywords(
         assert "WRFTPLT" in schedule_text, "Schedule should contain WRFTPLT keyword"
         assert "DATES" in schedule_text, "Schedule should contain DATES keyword"
 
+    def test_wconhist_item_order_canonical(self, project_with_case_and_well):
+        """Regression for #14065: WCONHIST items must appear in the Eclipse-defined
+        canonical order regardless of how keyword_data was constructed in Python.
+
+        Canonical WCONHIST order: WELL, STATUS, CMODE, ORAT, WRAT, GRAT, VFP_TABLE,
+        ALQ, THP, BHP, WGASRAT_HIS, NGLRAT_HIS.
+        """
+        project, case, timeline = project_with_case_and_well
+        well_path = project.well_paths()[0]
+
+        # Intentionally non-canonical insertion order: BHP placed before ORAT/WRAT/GRAT.
+        timeline.add_well_keyword_event(
+            event_date="2024-01-15",
+            well_path=well_path,
+            keyword_name="WCONHIST",
+            keyword_data={
+                "WELL": well_path.name,
+                "STATUS": "OPEN",
+                "CMODE": "RESV",
+                "BHP": 250.0,
+                "ORAT": 3999.99,
+                "WRAT": 0.01,
+                "GRAT": 550678.44,
+                "VFP_TABLE": 1,
+            },
+        )
+
+        schedule_text = timeline.generate_schedule_text(eclipse_case=case)
+        print(f"\nSchedule text for canonical-order check:\n{schedule_text}")
+
+        assert "WCONHIST" in schedule_text
+        # Extract the WCONHIST record body (between the keyword and its terminating '/').
+        wconhist_block = schedule_text.split("WCONHIST", 1)[1].split("/", 1)[0]
+
+        orat_pos = wconhist_block.find("3999.99")
+        grat_pos = wconhist_block.find("550678")
+        bhp_pos = wconhist_block.find("250")
+        assert orat_pos >= 0, "ORAT value missing from WCONHIST output"
+        assert grat_pos >= 0, "GRAT value missing from WCONHIST output"
+        assert bhp_pos >= 0, "BHP value missing from WCONHIST output"
+        assert orat_pos < bhp_pos, (
+            f"ORAT must precede BHP in canonical WCONHIST order; got block: {wconhist_block!r}"
+        )
+        assert grat_pos < bhp_pos, (
+            f"GRAT must precede BHP in canonical WCONHIST order; got block: {wconhist_block!r}"
+        )
+
     def test_invalid_keyword_data_unsupported_type(self, project_with_case_and_well):
         """Test error handling for unsupported data types in keyword events."""
         project, case, timeline = project_with_case_and_well
@@ -1848,3 +1991,55 @@ def test_keyword_event_type_inference(self, project_with_case_and_well):
         )
 
         assert event is not None, "Event with mixed types should be created"
+
+    def test_rptrst_mnemonic_output(self, project_with_case_and_well):
+        """RPTRST/RPTSCHED are mnemonic-list keywords. bool True must emit a
+        bare KEY, int/float/str must emit KEY=VALUE, bool False must be omitted.
+        """
+        project, case, timeline = project_with_case_and_well
+        well_path = project.well_paths()[0]
+
+        # Schedule generation requires at least one well event so a well path is
+        # selected for output; the assertions below target only the RPTRST block.
+        timeline.add_control_event(
+            event_date="2024-01-01",
+            well_path=well_path,
+            control_mode="ORAT",
+            control_value=1000.0,
+            oil_rate=1000.0,
+            is_producer=True,
+        )
+
+        timeline.add_keyword_event(
+            event_date="2024-01-01",
+            keyword_name="RPTRST",
+            keyword_data={
+                "BASIC": 2,
+                "DEN": True,
+                "ROCKC": True,
+                "RPORV": True,
+                "RFIP": True,
+                "FLOWS": True,
+                "NORST": 1,
+                "FLORES": True,
+                "OBSOLETE": False,
+            },
+        )
+
+        schedule_text = timeline.generate_schedule_text(eclipse_case=case)
+        print(f"\nRPTRST mnemonic output:\n{schedule_text}")
+
+        assert "RPTRST" in schedule_text
+        rptrst_block = schedule_text.split("RPTRST", 1)[1].split("/", 1)[0]
+
+        # Keyed mnemonics rendered as KEY=VALUE.
+        assert "BASIC=2" in rptrst_block
+        assert "NORST=1" in rptrst_block
+        # Flag mnemonics rendered as bare tokens. Whitespace-bounded so we don't accept
+        # accidental substring matches like 'DEN' inside another token.
+        for flag in ("DEN", "ROCKC", "RPORV", "RFIP", "FLOWS", "FLORES"):
+            assert f" {flag} " in rptrst_block or rptrst_block.rstrip().endswith(
+                f" {flag}"
+            ), f"flag {flag!r} missing from RPTRST output: {rptrst_block!r}"
+        # False-valued flag must be omitted entirely.
+        assert "OBSOLETE" not in rptrst_block

docs/rips/well_events.py

@@ -10,7 +10,7 @@
 from datetime import date, datetime
 
 from .pdmobject import add_method
-from .resinsight_classes import Case
+from .resinsight_classes import EclipseCase
 from .generated.generated_classes import (
     KeywordEvent,
     WellEventKeyword,
@@ -121,15 +121,24 @@ def add_well_keyword_event(
     item_values = []
 
     for name, value in keyword_data.items():
+        # Handle bool before int (bool is subclass of int in Python).
+        # bool semantics: True -> flag (emitted as bare KEY in mnemonic-list keywords,
+        # ignored elsewhere); False -> the entry is dropped entirely.
+        if isinstance(value, bool):
+            if not value:
+                continue
+            item_names.append(name)
+            item_types.append("FLAG")
+            # The value is ignored for FLAG items but must be a non-empty string;
+            # empty strings get dropped by the GRPC vector<string> serialization.
+            item_values.append("1")
+            continue
+
         item_names.append(name)
 
         if isinstance(value, str):
             item_types.append("STRING")
             item_values.append(value)
-        elif isinstance(value, bool):
-            # Handle bool before int (bool is subclass of int in Python)
-            item_types.append("INT")
-            item_values.append("1" if value else "0")
         elif isinstance(value, int):
             item_types.append("INT")
             item_values.append(str(value))
@@ -228,15 +237,24 @@ def add_keyword_event(
     item_values = []
 
     for name, value in keyword_data.items():
+        # Handle bool before int (bool is subclass of int in Python).
+        # bool semantics: True -> flag (emitted as bare KEY in mnemonic-list keywords,
+        # ignored elsewhere); False -> the entry is dropped entirely.
+        if isinstance(value, bool):
+            if not value:
+                continue
+            item_names.append(name)
+            item_types.append("FLAG")
+            # The value is ignored for FLAG items but must be a non-empty string;
+            # empty strings get dropped by the GRPC vector<string> serialization.
+            item_values.append("1")
+            continue
+
         item_names.append(name)
 
         if isinstance(value, str):
             item_types.append("STRING")
             item_values.append(value)
-        elif isinstance(value, bool):
-            # Handle bool before int (bool is subclass of int in Python)
-            item_types.append("INT")
-            item_values.append("1" if value else "0")
         elif isinstance(value, int):
             item_types.append("INT")
             item_values.append(str(value))
@@ -263,7 +281,12 @@ def add_keyword_event(
 
 
 @add_method(WellEventTimeline)
-def generate_schedule_text(self: WellEventTimeline, eclipse_case: Case) -> str:
+def generate_schedule_text(
+    self: WellEventTimeline,
+    eclipse_case: EclipseCase,
+    include_welsegs: bool = True,
+    include_compsegs: bool = True,
+) -> str:
     """Generate Eclipse schedule text for all wells in the collection.
 
     The timeline is shared across all wells in the well path collection.
@@ -274,7 +297,13 @@ def generate_schedule_text(self: WellEventTimeline, eclipse_case: Case) -> str:
     text directly instead of a DataContainerString.
 
     Arguments:
-        eclipse_case (Case): Eclipse case to use for schedule generation.
+        eclipse_case (EclipseCase): Eclipse case to use for schedule generation.
+        include_welsegs (bool): When False, omit the WELSEGS keyword from the
+            output. Other multi-segment-well keywords (COMPSEGS, WSEGVALV,
+            WSEGAICD) are not affected. Defaults to True.
+        include_compsegs (bool): When False, omit the COMPSEGS keyword from
+            the output. WELSEGS, WSEGVALV, WSEGAICD are not affected.
+            Defaults to True.
 
     Returns:
         str: Eclipse schedule text containing DATES, COMPDAT, WELSEGS, WCONPROD, etc.
@@ -312,7 +341,11 @@ def generate_schedule_text(self: WellEventTimeline, eclipse_case: Case) -> str:
         print(schedule_text)
         ```
     """
-    container = self.generate_schedule(eclipse_case_id=eclipse_case.id)
+    container = self.generate_schedule(
+        eclipse_case=eclipse_case,
+        include_welsegs=include_welsegs,
+        include_compsegs=include_compsegs,
+    )
     if container and container.values:
         return "".join(container.values)
     return ""