Update rips module, proto files, and Python examples

Author: magnesj

docs/rips/case.py

@@ -1435,3 +1435,56 @@ def export_corner_point_grid(
         return (zcorn, coord, actnum, nx, ny, nz)
     else:
         return ([], [], [], 0, 0, 0)
+
+
+@add_method(Case)
+def replace_corner_point_grid(
+    self,
+    nx: int,
+    ny: int,
+    nz: int,
+    coord: List[float],
+    zcorn: List[float],
+    actnum: List[int],
+):
+    """Replace the current case grid with new corner point grid geometry
+
+    This method modifies the geometry of an existing case by replacing it with
+    new grid parameters. All existing properties will be cleared.
+
+    Arguments:
+        nx(int): Number of cells in x direction
+        ny(int): Number of cells in y direction
+        nz(int): Number of cells in z direction
+        coord(list[float]): Coordinate lines as COORD keyword in Eclipse.
+          Each coordinate line is defined by two points (top and bottom).
+          Size: (nx+1) * (ny+1) * 2 * 3. Points are ordered as in Eclipse.
+        zcorn(list[float]): Corner depths as defined by the Eclipse keyword ZCORN.
+          Size: nx * ny * nz * 8
+        actnum(list[int]): Active cell info: cells with values > 0 are active.
+          Size: nx * ny * nz
+    """
+    # Generate unique keys for three arrays
+    coord_key = "{}_{}".format(uuid.uuid4(), "coord")
+    zcorn_key = "{}_{}".format(uuid.uuid4(), "zcorn")
+    actnum_key = "{}_{}".format(uuid.uuid4(), "actnum")
+
+    # Get project to access key-value store
+    project = self.ancestor(rips.project.Project)
+    if not project:
+        raise RuntimeError("Unable to get project from case")
+
+    # Store arrays in key-value store
+    project.set_key_values(coord_key, coord)
+    project.set_key_values(zcorn_key, zcorn)
+    project.set_key_values(actnum_key, actnum)
+
+    # Call internal C++ method to replace the grid
+    self.replace_corner_point_grid_internal(
+        nx=nx,
+        ny=ny,
+        nz=nz,
+        coord_key=coord_key,
+        zcorn_key=zcorn_key,
+        actnum_key=actnum_key,
+    )

docs/rips/generated/generated_classes.py

@@ -129,6 +129,23 @@ def __init__(self, pb2_object: Optional[PdmObject_pb2.PdmObject]=None, channel:
         if CornerPointCase.__custom_init__ is not None:
             CornerPointCase.__custom_init__(self, pb2_object=pb2_object, channel=channel)
 
+    def replace_corner_point_grid_internal(self, nx: int=0, ny: int=0, nz: int=0, coord_key: str="", zcorn_key: str="", actnum_key: str="") -> None:
+        """
+        Replace Corner Point Grid
+
+        Arguments:
+            nx (int): 
+            ny (int): 
+            nz (int): 
+            coord_key (str): 
+            zcorn_key (str): 
+            actnum_key (str): 
+        Returns:
+            
+        """
+        self._call_pdm_method_void("replace_corner_point_grid_internal", nx=nx, ny=ny, nz=nz, coord_key=coord_key, zcorn_key=zcorn_key, actnum_key=actnum_key)
+
+
 class CurveIntersection(PdmObjectBase):
     """
     Attributes:

docs/rips/tests/test_export_corner_point_grid.py

@@ -172,3 +172,119 @@ def test_export_corner_point_grid_roundtrip(rips_instance, initialize_test):
 
             max_diff = max(diff_x, diff_y, diff_z)
             assert max_diff < 1e-3
+
+
+def test_replace_corner_point_grid_basic(rips_instance, initialize_test):
+    """Test the replace_corner_point_grid method by creating a grid and replacing it with a larger one"""
+
+    # Create initial grid with 2x2x2 cells
+    nx_init, ny_init, nz_init = 2, 2, 2
+
+    # Generate simple coordinate data for initial grid
+    coord_init = []
+    for j in range(ny_init + 1):
+        for i in range(nx_init + 1):
+            x = i * 100.0
+            y = j * 100.0
+            # Top point
+            coord_init.extend([x, y, 1000.0])
+            # Bottom point
+            coord_init.extend([x, y, 1100.0])
+
+    # Generate simple ZCORN data for initial grid
+    zcorn_init = []
+    for k in range(nz_init):
+        for j in range(ny_init):
+            for i in range(nx_init):
+                base_depth = 1000.0 + k * 100.0
+                # 8 corner depths for each cell
+                zcorn_init.extend(
+                    [
+                        base_depth,
+                        base_depth,
+                        base_depth,
+                        base_depth,
+                        base_depth + 100.0,
+                        base_depth + 100.0,
+                        base_depth + 100.0,
+                        base_depth + 100.0,
+                    ]
+                )
+
+    # Generate ACTNUM for initial grid (all cells active)
+    actnum_init = [1] * (nx_init * ny_init * nz_init)
+
+    # Create the initial grid case
+    case = rips_instance.project.create_corner_point_grid(
+        "InitialGrid", nx_init, ny_init, nz_init, coord_init, zcorn_init, actnum_init
+    )
+
+    # Verify initial grid dimensions
+    initial_cell_count = case.cell_count()
+    assert initial_cell_count.reservoir_cell_count == nx_init * ny_init * nz_init
+
+    # Now create replacement grid with more cells (3x3x3)
+    nx_new, ny_new, nz_new = 3, 3, 3
+
+    # Generate coordinate data for new grid
+    coord_new = []
+    for j in range(ny_new + 1):
+        for i in range(nx_new + 1):
+            x = i * 100.0
+            y = j * 100.0
+            # Top point
+            coord_new.extend([x, y, 1000.0])
+            # Bottom point
+            coord_new.extend([x, y, 1200.0])
+
+    # Generate ZCORN data for new grid
+    zcorn_new = []
+    for k in range(nz_new):
+        for j in range(ny_new):
+            for i in range(nx_new):
+                base_depth = 1000.0 + k * 100.0
+                # 8 corner depths for each cell
+                zcorn_new.extend(
+                    [
+                        base_depth,
+                        base_depth,
+                        base_depth,
+                        base_depth,
+                        base_depth + 100.0,
+                        base_depth + 100.0,
+                        base_depth + 100.0,
+                        base_depth + 100.0,
+                    ]
+                )
+
+    # Generate ACTNUM for new grid (all cells active)
+    actnum_new = [1] * (nx_new * ny_new * nz_new)
+
+    # Replace the grid geometry
+    case.replace_corner_point_grid(
+        nx_new, ny_new, nz_new, coord_new, zcorn_new, actnum_new
+    )
+
+    # Verify that the grid now has the new dimensions
+    new_cell_count = case.cell_count()
+    assert new_cell_count.reservoir_cell_count == nx_new * ny_new * nz_new
+    assert new_cell_count.reservoir_cell_count == 27  # 3x3x3
+
+    # Verify the grid has more cells than before
+    assert new_cell_count.reservoir_cell_count > initial_cell_count.reservoir_cell_count
+
+    # Export the replaced grid and verify dimensions
+    exported_zcorn, exported_coord, exported_actnum, export_nx, export_ny, export_nz = (
+        case.export_corner_point_grid()
+    )
+
+    # Verify dimensions match
+    assert export_nx == nx_new
+    assert export_ny == ny_new
+    assert export_nz == nz_new
+
+    # Verify array sizes
+    print(exported_actnum)
+    assert len(exported_actnum) == nx_new * ny_new * nz_new
+    # All cells should be active
+    assert sum(1 for x in exported_actnum if x > 0) == len(actnum_new)

docs/rips/tests/test_summary_cases.py

@@ -3,6 +3,7 @@
 import contextlib
 import shutil
 import tempfile
+import pytest
 
 sys.path.insert(1, os.path.join(sys.path[0], "../../"))
 
@@ -115,8 +116,66 @@ def test_summary_set_values(rips_instance, initialize_test):
     current_keyword_count = len(addresses.values)
     assert current_keyword_count == original_keyword_count + 1
 
-    # invalid value count, check that available addresses are unchanged
-    summary_case.set_summary_values("FOPT_2", "", [])
+    # invalid value count should now raise an error (no longer fails silently)
+    with pytest.raises(Exception) as exc_info:
+        summary_case.set_summary_values("FOPT_2", "", [])
+    # Verify error message is informative
+    assert "size" in str(exc_info.value).lower() or "Expected" in str(exc_info.value)
+
+    # Verify addresses are unchanged after failed operation
     addresses = summary_case.available_addresses()
     current_keyword_count = len(addresses.values)
     assert current_keyword_count == original_keyword_count + 1
+
+
+def test_summary_set_values_with_long_keyword(rips_instance, initialize_test):
+    """Test that setting summary values with a keyword exceeding 8 characters fails with an informative error."""
+    casePath = dataroot.PATH + "/flow_diagnostics_test/SIMPLE_SUMMARY2.SMSPEC"
+    summary_case = rips_instance.project.import_summary_case(casePath)
+    assert summary_case.id == 1
+
+    summary_data = summary_case.summary_vector_values("FOPT")
+    assert len(summary_data.values) == 60
+
+    # This keyword exceeds the 8-character SMSPEC limit
+    long_keyword = "ROPR_FROM_1_TO_23"
+
+    # Currently this fails silently - after fix, it should raise an exception with a clear error message
+    with pytest.raises(Exception) as exc_info:
+        summary_case.set_summary_values(long_keyword, "", summary_data.values)
+
+    # Check that the error message is informative
+    error_message = str(exc_info.value)
+    assert (
+        "8" in error_message
+        or "character" in error_message
+        or "length" in error_message
+    ), f"Error message should mention the 8-character limit, but got: {error_message}"
+
+
+def test_summary_set_values_with_wrong_size(rips_instance, initialize_test):
+    """Test that setting summary values with wrong vector size fails with an informative error."""
+    casePath = dataroot.PATH + "/flow_diagnostics_test/SIMPLE_SUMMARY2.SMSPEC"
+    summary_case = rips_instance.project.import_summary_case(casePath)
+    assert summary_case.id == 1
+
+    summary_data = summary_case.summary_vector_values("FOPT")
+    expected_size = len(summary_data.values)
+    assert expected_size == 60
+
+    # Try to set values with wrong size
+    wrong_size_values = [1.0, 2.0, 3.0]  # Only 3 values instead of 60
+
+    # Currently this fails silently - after fix, it should raise an exception with a clear error message
+    with pytest.raises(Exception) as exc_info:
+        summary_case.set_summary_values("TEST_KW", "", wrong_size_values)
+
+    # Check that the error message is informative
+    error_message = str(exc_info.value)
+    assert (
+        "size" in error_message.lower() or "length" in error_message.lower()
+    ), f"Error message should mention size/length mismatch, but got: {error_message}"
+    assert (
+        str(expected_size) in error_message
+        or str(len(wrong_size_values)) in error_message
+    ), f"Error message should mention expected ({expected_size}) or received ({len(wrong_size_values)}) size, but got: {error_message}"