Update rips module and Python examples

Author: magnesj

docs/rips/PythonExamples/wells_and_fractures/accumulated_perforation_length.py

@@ -0,0 +1,51 @@
+###################################################################################
+# This example will connect to ResInsight, retrieve a list of
+# simulation wells for a case and get the accumulated perforated length for all
+# simulation wells per timestep. If a well is closed at a given timestep, the
+# accumulated perforated length will be zero.
+###################################################################################
+
+# Import the ResInsight Processing Server Module
+import rips
+import sys
+
+# Connect to ResInsight
+resinsight = rips.Instance.find()
+if resinsight is None:
+    sys.exit("ResInsight is not running. Please start ResInsight and try again.")
+
+# Get a list of all wells
+cases = resinsight.project.cases()
+if len(cases) == 0:
+    sys.exit("No cases found in the project. Please open a case and try again.")
+
+case = cases[0]
+print("Using Case: " + case.name)
+
+timesteps = case.time_steps()
+
+# store results in a dictionary,
+# use well name as the key and a list of the wells accumulated perforation
+# lengths for each timestep as the value
+results = {}
+
+# loop over all available simulation wells
+sim_wells = case.simulation_wells()
+for sim_well in sim_wells:
+    acclengths = []
+    for tidx, timestep in enumerate(timesteps):
+        acclengths.append(sim_well.accumulated_perforation_length(tidx))
+    results[sim_well.name] = acclengths
+
+# Print header
+header = ["Timestep"]
+for tidx, ts in enumerate(timesteps):
+    header.append("%d/%d/%d" % (ts.day, ts.month, ts.year))
+print(";".join(header))
+
+# Print the results
+for well_name, lengths in results.items():
+    line = [well_name]
+    for idx, length in enumerate(lengths):
+        line.append(str(length))
+    print(";".join(line))

docs/rips/PythonExamples/wells_and_fractures/modeled_well_path.py

@@ -68,6 +68,17 @@
 completions_settings.well_type_for_export = "GAS"
 completions_settings.update()  # Commit updates back to ResInsight
 
+# Add diameter roughness intervals for interval-specific configuration
+interval1 = completions_settings.add_diameter_roughness_interval(
+    start_md=3200, end_md=3300, diameter=0.18, roughness_factor=1.5e-5
+)
+interval2 = completions_settings.add_diameter_roughness_interval(
+    start_md=3300, end_md=3400, diameter=0.16, roughness_factor=2.0e-5
+)
+print(
+    f"Added diameter roughness intervals: {interval1.start_md}-{interval1.end_md}m and {interval2.start_md}-{interval2.end_md}m"
+)
+
 # Optionally update the MSW settings
 msw_settings = well_path.msw_settings()
 msw_settings.custom_values_for_lateral = False

docs/rips/generated/SimulationWell_pb2.py

@@ -49,6 +49,11 @@ def __init__(self, channel):
                 request_serializer=SimulationWell__pb2.SimulationWellRequest.SerializeToString,
                 response_deserializer=SimulationWell__pb2.SimulationWellCellInfoArray.FromString,
                 _registered_method=True)
+        self.GetPerfLength = channel.unary_unary(
+                '/rips.SimulationWell/GetPerfLength',
+                request_serializer=SimulationWell__pb2.SimulationWellRequest.SerializeToString,
+                response_deserializer=SimulationWell__pb2.SimulationWellPerfLength.FromString,
+                _registered_method=True)
 
 
 class SimulationWellServicer(object):
@@ -66,6 +71,12 @@ def GetSimulationWellCells(self, request, context):
         context.set_details('Method not implemented!')
         raise NotImplementedError('Method not implemented!')
 
+    def GetPerfLength(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
 
 def add_SimulationWellServicer_to_server(servicer, server):
     rpc_method_handlers = {
@@ -79,6 +90,11 @@ def add_SimulationWellServicer_to_server(servicer, server):
                     request_deserializer=SimulationWell__pb2.SimulationWellRequest.FromString,
                     response_serializer=SimulationWell__pb2.SimulationWellCellInfoArray.SerializeToString,
             ),
+            'GetPerfLength': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetPerfLength,
+                    request_deserializer=SimulationWell__pb2.SimulationWellRequest.FromString,
+                    response_serializer=SimulationWell__pb2.SimulationWellPerfLength.SerializeToString,
+            ),
     }
     generic_handler = grpc.method_handlers_generic_handler(
             'rips.SimulationWell', rpc_method_handlers)
@@ -142,3 +158,30 @@ def GetSimulationWellCells(request,
             timeout,
             metadata,
             _registered_method=True)
+
+    @staticmethod
+    def GetPerfLength(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/rips.SimulationWell/GetPerfLength',
+            SimulationWell__pb2.SimulationWellRequest.SerializeToString,
+            SimulationWell__pb2.SimulationWellPerfLength.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)

docs/rips/generated/SimulationWell_pb2_grpc.py

@@ -234,6 +234,27 @@ def __init__(self, pb2_object: Optional[PdmObject_pb2.PdmObject]=None, channel:
         if DepthSurface.__custom_init__ is not None:
             DepthSurface.__custom_init__(self, pb2_object=pb2_object, channel=channel)
 
+class DiameterRoughnessInterval(PdmObjectBase):
+    """
+    DiameterRoughnessInterval
+
+    Attributes:
+        diameter (float): Diameter
+        end_md (float): End MD
+        roughness_factor (float): Roughness Factor
+        start_md (float): Start MD
+    """
+    __custom_init__ = None #: Assign a custom init routine to be run at __init__
+
+    def __init__(self, pb2_object: Optional[PdmObject_pb2.PdmObject]=None, channel: Optional[grpc.Channel]=None) -> None:
+        self.diameter: float = 1.520000000000000e-01
+        self.end_md: float = 0.000000000000000e+00
+        self.roughness_factor: float = 1.000000000000000e-05
+        self.start_md: float = 0.000000000000000e+00
+        PdmObjectBase.__init__(self, pb2_object, channel)
+        if DiameterRoughnessInterval.__custom_init__ is not None:
+            DiameterRoughnessInterval.__custom_init__(self, pb2_object=pb2_object, channel=channel)
+
 class EclipseCase(Reservoir):
     """
     The Regular Eclipse Results Case
@@ -1708,6 +1729,7 @@ class MswSettings(PdmObjectBase):
 
     Attributes:
         custom_values_for_lateral (bool): Custom Values for Lateral
+        diameter_roughness_mode (str): One of [Uniform, Intervals]
         enforce_max_segment_length (bool): Enforce Max Segment Length
         length_and_depth (str): One of [INC, ABS]
         liner_diameter (float): Liner Inner Diameter
@@ -1721,6 +1743,7 @@ class MswSettings(PdmObjectBase):
 
     def __init__(self, pb2_object: Optional[PdmObject_pb2.PdmObject]=None, channel: Optional[grpc.Channel]=None) -> None:
         self.custom_values_for_lateral: bool = False
+        self.diameter_roughness_mode: str = "Uniform"
         self.enforce_max_segment_length: bool = False
         self.length_and_depth: str = "ABS"
         self.liner_diameter: float = 1.520000000000000e-01
@@ -2783,6 +2806,21 @@ def __init__(self, pb2_object: Optional[PdmObject_pb2.PdmObject]=None, channel:
         if WellPathCompletionSettings.__custom_init__ is not None:
             WellPathCompletionSettings.__custom_init__(self, pb2_object=pb2_object, channel=channel)
 
+    def add_diameter_roughness_interval(self, start_md: float=0.000000000000000e+00, end_md: float=1.000000000000000e+02, diameter: float=1.520000000000000e-01, roughness_factor: float=1.000000000000000e-05) -> DiameterRoughnessInterval:
+        """
+        
+
+        Arguments:
+            start_md (float): 
+            end_md (float): 
+            diameter (float): 
+            roughness_factor (float): 
+        Returns:
+            DiameterRoughnessInterval
+        """
+        return self._call_pdm_method_return_value("AddDiameterRoughnessInterval", DiameterRoughnessInterval, start_md=start_md, end_md=end_md, diameter=diameter, roughness_factor=roughness_factor)
+
+
 class WellPathCompletions(PdmObjectBase):
     __custom_init__ = None #: Assign a custom init routine to be run at __init__
 
@@ -2989,6 +3027,7 @@ def class_dict() -> Dict[str, Type[PdmObjectBase]]:
     classes['DataContainerTime'] = DataContainerTime
     classes['DepthSurface'] = DepthSurface
     classes['DepthTrackPlot'] = DepthTrackPlot
+    classes['DiameterRoughnessInterval'] = DiameterRoughnessInterval
     classes['EclipseCase'] = EclipseCase
     classes['EclipseCaseEnsemble'] = EclipseCaseEnsemble
     classes['EclipseContourMap'] = EclipseContourMap

docs/rips/generated/generated_classes.py

@@ -77,6 +77,23 @@ def cells(
     return self.__simulation_well_stub.GetSimulationWellCells(sim_well_request).data
 
 
+@add_method(SimulationWell)
+def accumulated_perforation_length(self: SimulationWell, timestep: int) -> float:
+    """Get accumulated perforation lenght for the given timestep.
+       If a well is closed the length will be 0.
+
+    Arguments:
+        timestep(int): Time step index
+
+    """
+    sim_well_request = SimulationWell_pb2.SimulationWellRequest(
+        case_id=self.case().id, well_name=self.name, timestep=timestep
+    )
+    return self.__simulation_well_stub.GetPerfLength(
+        sim_well_request
+    ).accumulated_length
+
+
 @add_method(SimulationWell)
 def case(self: SimulationWell) -> Optional[Case]:
     view = self.ancestor(View)

docs/rips/simulation_well.py

@@ -0,0 +1,46 @@
+import rips
+
+
+def test_diameter_roughness_intervals(rips_instance, initialize_test):
+    """Test the new diameter roughness intervals Python GRPC interface"""
+
+    # Create a test well
+    well_path_coll = rips_instance.project.well_path_collection()
+    well_path = well_path_coll.add_new_object(rips.ModeledWellPath)
+    well_path.name = "Test Well for Diameter Intervals"
+
+    completions_settings = well_path.completion_settings()
+    assert completions_settings is not None, "Completion settings should not be None"
+
+    # Test our new method - create first interval
+    interval1 = completions_settings.add_diameter_roughness_interval(
+        start_md=100, end_md=200, diameter=0.15, roughness_factor=1e-5
+    )
+
+    # Assertions to verify the first interval
+    assert interval1 is not None, "First interval should not be None"
+    assert interval1.start_md == 100
+    assert interval1.end_md == 200
+    assert interval1.diameter == 0.15
+    assert interval1.roughness_factor == 1e-5
+
+    # Test creating a second interval with different values
+    interval2 = completions_settings.add_diameter_roughness_interval(
+        start_md=200, end_md=300, diameter=0.12, roughness_factor=2e-5
+    )
+
+    # Assertions to verify the second interval
+    assert interval2 is not None, "Second interval should not be None"
+    assert interval2.start_md == 200
+    assert interval2.end_md == 300
+    assert interval2.diameter == 0.12
+    assert interval2.roughness_factor == 2e-5
+
+    # Test default values
+    interval3 = completions_settings.add_diameter_roughness_interval()
+
+    assert interval3 is not None, "Third interval with defaults should not be None"
+    assert interval3.start_md == 0.0
+    assert interval3.end_md == 100.0
+    assert interval3.diameter == 0.152
+    assert interval3.roughness_factor == 1e-5

docs/rips/tests/test_diameter_roughness_intervals.py

@@ -1,5 +1,6 @@
 import sys
 import os
+import math
 
 sys.path.insert(1, os.path.join(sys.path[0], "../../"))
 
@@ -57,3 +58,19 @@ def test_10k(rips_instance, initialize_test):
                     + str(len(cells))
                 )
                 assert len(cells) == expected_cell_count[sim_well.name]
+
+
+def test_10k_acclength(rips_instance, initialize_test):
+    case_path = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    case = rips_instance.project.load_case(path=case_path)
+    case.create_view()
+    sim_wells = case.simulation_wells()
+
+    expected_length = {}
+    expected_length["GP1"] = 4708.0
+    expected_length["GI1"] = 2132.8
+    expected_length["GP2"] = 49.0
+
+    for sim_well in sim_wells:
+        length = sim_well.accumulated_perforation_length(1)
+        assert math.fabs(length - expected_length[sim_well.name]) < 0.1

docs/rips/tests/test_simulation_wells.py

@@ -6,6 +6,16 @@ Wells And Fractures
 
 This page shows Python examples from the **wells_and_fractures** folder.
 
+.. _wells_and_fractures_accumulated_perforation_length:
+
+Accumulated Perforation Length
+------------------------------
+
+.. literalinclude:: ../rips/PythonExamples/wells_and_fractures/accumulated_perforation_length.py
+   :language: python
+   :linenos:
+   :caption: accumulated_perforation_length.py
+
 .. _wells_and_fractures_all_simulation_wells:
 
 All Simulation Wells