Update rips module and Python examples (#36)

Co-authored-by: magnesj <1793152+magnesj@users.noreply.github.com>

Author: github-actions[bot]

docs/rips/PythonExamples/compute_avg_poro_for_region.py

@@ -0,0 +1,35 @@
+###########################################################################################
+# This example will calculate the average value of the porosity property for a specified
+# region in the reservoir model. The region is identified by its EQLNUM value.
+###########################################################################################
+
+import rips
+
+resinsight = rips.Instance.find()
+
+cases = resinsight.project.cases()
+
+time_step = 0
+region_number = 2
+
+for case in cases:
+    sum_poro = 0.0
+    cell_cout = 0
+
+    eqlnum = case.active_cell_property("STATIC_NATIVE", "EQLNUM", time_step)
+    poro = case.active_cell_property("STATIC_NATIVE", "PORO", time_step)
+    if len(eqlnum) != len(poro):
+        print("Size of eqlnum and poro is not identical.")
+        break
+
+    for i in range(len(eqlnum)):
+        if eqlnum[i] == region_number:
+            sum_poro += poro[i]
+            cell_cout += 1
+
+    # Calculate the average porosity for the specified region
+    if cell_cout > 0:
+        average_poro = sum_poro / cell_cout
+        print(
+            f"Case {case.id}: Cell count {cell_cout} Average PORO for region {region_number} = {average_poro}"
+        )

docs/rips/PythonExamples/create_corner_point_grid.py

@@ -0,0 +1,40 @@
+######################################################################
+# This script creates a corner point grid from a Eclipse coord, zcorn
+# and actnum configuration.
+######################################################################
+import rips
+from xtgeo.grid3d._egrid import EGrid
+from xtgeo.io._file import FileFormat
+import numpy as np
+
+grid_filepath = "/home/resinsight/testdata/01_drogon_ahm/realization-0/iter-0/eclipse/model/DROGON-0.EGRID"
+
+name = "DROGON-0 from python"
+
+grid = EGrid.from_file(grid_filepath, fileformat=FileFormat.EGRID)
+print("Grid: ", grid)
+print("Grid type: ", type(grid))
+print("coord: ", grid.coord.shape, grid.coord.dtype)
+print("zcorn:", grid.zcorn.shape, grid.zcorn.dtype)
+print("actnum: ", grid.actnum.shape, grid.actnum.dtype)
+
+resinsight = rips.Instance.find()
+
+project = resinsight.project
+
+coord = np.ascontiguousarray(grid.coord, dtype=np.float32)
+zcorn = np.ascontiguousarray(grid.zcorn, dtype=np.float32)
+actnum = np.ascontiguousarray(grid.actnum, dtype=np.int32)
+
+
+print("coordsv: ", len(coord), type(coord[0]))
+print("zcornsv: ", len(zcorn), type(zcorn[0]))
+print("actnumsv: ", len(actnum), type(actnum[0]))
+
+
+print("Grid dimensions: ", grid.dimensions)
+nx = grid.dimensions.ncol
+ny = grid.dimensions.nrow
+nz = grid.dimensions.nlay
+
+project.create_corner_point_grid(name, nx, ny, nz, coord, zcorn, actnum)

docs/rips/PythonExamples/create_intersection.py

@@ -1,5 +1,4 @@
 # Load ResInsight Processing Server Client Library
-import math, time
 import rips
 
 resinsight = rips.Instance.find()

docs/rips/PythonExamples/create_polygon.py

@@ -0,0 +1,35 @@
+###################################################################################
+# This example will connect to ResInsight, find bounding box and add a polygon
+#
+###################################################################################
+
+# Import the ResInsight Processing Server Module
+import rips
+
+# Connect to ResInsight
+resinsight = rips.Instance.find()
+if resinsight is not None:
+    # Get a list of all cases
+    cases = resinsight.project.cases()
+
+    for c in cases:
+        print("Case name: " + c.name)
+
+        # create a polygon which is same a the bounding box in x and y.
+        # depth is set to middle of the bounding box
+        bbox = c.reservoir_boundingbox()
+        depth = bbox.max_z - ((bbox.max_z - bbox.min_z) / 2.0)
+
+        coordinates = []
+        coordinates.append([bbox.min_x, bbox.min_y, depth])
+        coordinates.append([bbox.max_x, bbox.min_y, depth])
+        coordinates.append([bbox.max_x, bbox.max_y, depth])
+        coordinates.append([bbox.min_x, bbox.max_y, depth])
+
+        polygon_collection = resinsight.project.descendants(rips.PolygonCollection)[0]
+        p = polygon_collection.create_polygon(
+            name="{} bounding box".format(c.name), coordinates=coordinates
+        )
+        print("Coordinates for {}:".format(p.name))
+        for coord in p.coordinates:
+            print(coord)

docs/rips/PythonExamples/create_regular_surface.py

@@ -0,0 +1,82 @@
+######################################################################
+# This script creates a regular surface for each case
+######################################################################
+import rips
+import math
+
+
+def create_x_surface(nx, ny):
+    surface = []
+    for j in range(ny):
+        for i in range(nx):
+            surface.append(float(i))
+    return surface
+
+
+def create_wave_surface(nx, ny):
+    # Fill the coordinate and wave pattern arrays
+    surface = []
+    for j in range(ny):
+        for i in range(nx):
+            # Create wave pattern - combining multiple sine waves
+            x = -5 + 10 * i / (nx - 1)
+            y = -5 + 10 * j / (ny - 1)
+            offset = (
+                math.sin(x**2 + y**2)
+                + 0.5 * math.sin(2 * x) * math.cos(2 * y)
+                + 25.0 * math.cos(5 * x + 2 * y)
+            )
+            surface.append(-depth + offset)
+    return surface
+
+
+resinsight = rips.Instance.find()
+
+project = resinsight.project
+
+
+if resinsight is not None:
+    # Get a list of all cases
+    cases = resinsight.project.cases()
+
+    for c in cases:
+        bbox = c.reservoir_boundingbox()
+        depth = bbox.max_z - ((bbox.max_z - bbox.min_z) / 2.0)
+
+        origin_x = bbox.min_x
+        origin_y = bbox.min_y
+
+        name = "{} surface".format(c.name)
+
+        nx = 200
+        ny = 100
+
+        increment_x = (bbox.max_x - bbox.min_x) / float(nx)
+        increment_y = (bbox.max_y - bbox.min_y) / float(ny)
+
+        surface_collection = resinsight.project.descendants(rips.SurfaceCollection)[0]
+
+        # Create a surface at a given depth
+        s = surface_collection.new_regular_surface(
+            name=name,
+            origin_x=origin_x,
+            origin_y=origin_y,
+            depth=-depth,
+            nx=nx,
+            ny=ny,
+            increment_x=increment_x,
+            increment_y=increment_y,
+        )
+
+        # Rotate the resulting surface
+        s.rotation = 45.0
+        s.update()
+
+        # Add one property
+        s.set_property("first_property", create_x_surface(nx, ny))
+
+        # Add a wave surface
+        s.set_property("wave", create_wave_surface(nx, ny))
+
+        # Use the wave as depth for the surface
+        s.set_property_as_depth("wave")

docs/rips/PythonExamples/create_wbs_plot.py

@@ -1,5 +1,4 @@
 import os
-import grpc
 
 # Load ResInsight Processing Server Client Library
 import rips

docs/rips/PythonExamples/error_handling.py

@@ -4,32 +4,26 @@
 ###################################################################
 
 import rips
-import grpc
 import tempfile
 
+
 resinsight = rips.Instance.find()
 
 case = None
 
 # Try loading a non-existing case. We should get a grpc.RpcError exception from the server
 try:
     case = resinsight.project.load_case("Nonsense")
-except grpc.RpcError as e:
-    print(
-        "Expected Server Exception Received while loading case: ", e.code(), e.details()
-    )
+except rips.RipsError as e:
+    print("Expected Server Exception Received while loading case: ", e)
 
-# Try loading well paths from a non-existing folder.  We should get a grpc.RpcError exception from the server
+# Try loading well paths from a non-existing folder.  We should get a rips.RipsError exception from the server
 try:
     well_path_files = resinsight.project.import_well_paths(
         well_path_folder="NONSENSE/NONSENSE"
     )
-except grpc.RpcError as e:
-    print(
-        "Expected Server Exception Received while loading wellpaths: ",
-        e.code(),
-        e.details(),
-    )
+except rips.RipsError as e:
+    print("Server Exception Received while loading wellpaths: ", e)
 
 # Try loading well paths from an existing but empty folder. We should get a warning.
 try:
@@ -42,7 +36,7 @@
         print("Should get warnings below")
         for warning in resinsight.project.warnings():
             print(warning)
-except grpc.RpcError as e:
+except rips.RipsError as e:
     print("Unexpected Server Exception caught!!!", e)
 
 case = resinsight.project.case(case_id=0)
@@ -54,18 +48,18 @@
     try:
         case.set_active_cell_property(results, "GENERATED", "POROAPPENDED", 0)
         print("Everything went well as expected")
-    except:  # Match any exception, but it should not happen
-        print("Ooops!")
+    except Exception as e:  # Match any exception, but it should not happen
+        print("Ooops!", e)
 
     # Add another value, so this is outside the bounds of the active cell result storage
     results.append(1.0)
 
-    # This time we should get a grpc.RpcError exception, which is a server side error.
+    # This time we should get a rips.RipsError exception.
     try:
         case.set_active_cell_property(results, "GENERATED", "POROAPPENDED", 0)
         print("Everything went well??")
-    except grpc.RpcError as e:
-        print("Expected Server Exception Received: ", e)
+    except rips.RipsError as e:
+        print("Server Exception Received: ", e)
     except IndexError:
         print("Got index out of bounds error. This shouldn't happen here")
 
@@ -77,7 +71,7 @@
     try:
         case.set_active_cell_property(results, "GENERATED", "POROAPPENDED", 0)
         print("Everything went well??")
-    except grpc.RpcError as e:
+    except rips.RipsError as e:
         print("Got unexpected server exception", e, "This should not happen now")
     except IndexError:
         print("Got expected index out of bounds error on client side")

docs/rips/PythonExamples/export_well_path_completions.py

@@ -3,7 +3,6 @@
 #
 ############################################################################
 
-import os
 import rips
 
 # Load instance

docs/rips/PythonExamples/fishbones_completion.py

@@ -1,6 +1,5 @@
 # Load ResInsight Processing Server Client Library
 import rips
-import time
 
 # Connect to ResInsight instance
 resinsight = rips.Instance.find()

docs/rips/PythonExamples/headless_plot_export.py

@@ -1,4 +1,3 @@
-import sys
 import os
 
 import rips