Case And Grid Operations

This page shows Python examples from the case_and_grid_operations folder.

Add Combined Data Filter

add_combined_data_filter.py

#######################################################
#
# Adds two case-level "Data Filters" combined filters
# that AND-combine a PERMX property filter with a K-slice
# range filter (K = 5..10):
#   1) one with an explicit name (preserved verbatim).
#   2) one with no name supplied, so the combined
#      filter's display name is auto-derived from its
#      children and updates when their names/bounds
#      change.
#
# Then shows how to mutate the PERMX lower bound after
# creation and confirms the auto-derived combined filter
# tracks the change while the named one stays put.
#
# Assumes a case is already loaded in the running
# ResInsight instance.
#
#######################################################

import rips

resinsight = rips.Instance.find()

cases = resinsight.project.cases()
assert cases, "No case loaded in ResInsight. Open a case before running this script."
case = cases[0]

data_filters = case.data_filter_collection()


def _build_children(combined):
    """Add a PERMX property filter and a K=5..10 range filter to `combined`."""
    permx = combined.add_property_filter(
        result_variable="PERMX",
        result_type="STATIC_NATIVE",
    )
    permx.lower_bound = 100.0
    permx.upper_bound = 20000.0
    permx.update()

    combined.add_range_filter(
        name="K=5..10",
        start_k=5,
        cell_count_k=6,
    )
    return permx


# 1) Combined filter with a user-supplied name. The name is preserved verbatim
#    even when its children change.
named_combined = data_filters.add_combined_filter(
    name="My PERMX-and-K filter",
    combine_mode="AND",
)
named_permx = _build_children(named_combined)

# 2) Combined filter with no name. The display name is auto-derived from its
#    children and updates when child names change.
auto_combined = data_filters.add_combined_filter(combine_mode="AND")
auto_permx = _build_children(auto_combined)


def _print_state(label):
    print(f"--- {label} ---")
    # Re-read the collection so names reflect the current project tree.
    for c in data_filters.filters():
        print(f"  {c.name}")
        for child in c.filters():
            print(f"    - {child.name}")


_print_state("Initial state")

# Mutate the PERMX lower bound on both.
named_permx.lower_bound = 250.0
named_permx.update()

auto_permx.lower_bound = 250.0
auto_permx.update()

_print_state("After lower_bound 100 -> 250")

Add Perforation Filter

add_perforation_filter.py

#######################################################
#
# Demonstrates associating a case-level cell filter
# with one or more perforation intervals on a well path.
#
# The combined filter is created at case level (under
# "Data Filters") and shared between two perforation
# intervals via add_filter(). The filter is stored as a
# typed reference, so two perforations can point to the
# same filter without duplicating its configuration.
#
# This is metadata only at the moment — completion
# export is not yet wired to consume the perforation's
# cell filter.
#
# Assumes a case is already loaded in the running
# ResInsight instance.
#
#######################################################

import rips

resinsight = rips.Instance.find()

cases = resinsight.project.cases()
assert cases, "No case loaded in ResInsight. Open a case before running this script."
case = cases[0]

data_filters = case.data_filter_collection()

# Create a case-level combined filter that AND-combines a PERMX property filter
# (100..20000) with a K-slice 5..10 range filter.
combined = data_filters.add_combined_filter(combine_mode="AND")

permx = combined.add_property_filter(
    result_variable="PERMX",
    result_type="STATIC_NATIVE",
)
permx.lower_bound = 100.0
permx.upper_bound = 20000.0
permx.update()

combined.add_range_filter(name="K=5..10", start_k=5, cell_count_k=6)

# Place the well in the centre of the case's bounding box so the example works
# regardless of where the loaded reservoir lives in domain space.
#
# Note: bounding-box z is positive-up (sea level = 0, subsurface negative), but
# append_well_target expects z positive-downward (depth). Convert with -z.
bbox = case.reservoir_boundingbox()
center_x = 0.5 * (bbox.min_x + bbox.max_x)
center_y = 0.5 * (bbox.min_y + bbox.max_y)
depth_top = -bbox.max_z  # depth to reservoir top (positive)
depth_bot = -bbox.min_z  # depth to reservoir bottom (positive)

# Build a vertical modeled well path: surface -> reservoir top -> just below the
# reservoir bottom, all on the central (x, y).
well_path_coll = resinsight.project.well_path_collection()
well_path = well_path_coll.add_new_object(rips.ModeledWellPath)
well_path.name = "Perforation Filter Demo Well"
well_path.update()

geometry = well_path.well_path_geometry()
geometry.append_well_target([center_x, center_y, 0.0])
geometry.append_well_target([center_x, center_y, depth_top])
geometry.append_well_target([center_x, center_y, depth_bot + 50.0])
geometry.update()

# Vertical well -> MD is depth below surface. Place two perforation intervals
# inside the reservoir's vertical extent.
md_span = depth_bot - depth_top
perf1_start = depth_top + 0.20 * md_span
perf1_end = perf1_start + 0.10 * md_span
perf2_start = depth_top + 0.55 * md_span
perf2_end = perf2_start + 0.20 * md_span

perf1 = well_path.append_perforation_interval(perf1_start, perf1_end, 0.2, 0.76)
perf1.add_filter(combined)

perf2 = well_path.append_perforation_interval(perf2_start, perf2_end, 0.2, 0.76)
perf2.add_filter(combined)

# Read back through the well path / completions tree to confirm both perforations
# resolve to the same filter object.
perforations = well_path.completions().perforations().perforations()
for p in perforations:
    f = p.cell_filter()
    print(
        f"  perforation {p.start_measured_depth} .. {p.end_measured_depth} -> "
        f"{f.name if f else '<no filter>'}"
    )

Case Grid Group

case_grid_group.py

import os
import rips

resinsight = rips.Instance.find()

test_model_path = "e:/gitroot-second/ResInsight/TestModels"

case_paths = []
case_paths.append(test_model_path + "/Case_with_10_timesteps/Real0/BRUGGE_0000.EGRID")
case_paths.append(test_model_path + "/Case_with_10_timesteps/Real10/BRUGGE_0010.EGRID")
case_paths.append(test_model_path + "/Case_with_10_timesteps/Real30/BRUGGE_0030.EGRID")
case_paths.append(test_model_path + "/Case_with_10_timesteps/Real40/BRUGGE_0040.EGRID")

for case_path in case_paths:
    assert os.path.exists(case_path), (
        "You need to set valid case paths for this script to work"
    )

case_group = resinsight.project.create_grid_case_group(case_paths=case_paths)

case_group.compute_statistics()

view = case_group.views()[0]
view.apply_cell_result(rips.PropertyType.DYNAMIC_NATIVE, "PRESSURE_DEV")

Case Grid Group Generated Results

case_grid_group_generated_results.py

import os
import rips

resinsight = rips.Instance.find()

# ResInsight includes some test models. Adjust this path to fit your system
test_model_path = "e:/gitroot-second/ResInsight/TestModels"

case_paths = []
case_paths.append(test_model_path + "/Case_with_10_timesteps/Real0/BRUGGE_0000.EGRID")
case_paths.append(test_model_path + "/Case_with_10_timesteps/Real10/BRUGGE_0010.EGRID")
case_paths.append(test_model_path + "/Case_with_10_timesteps/Real30/BRUGGE_0030.EGRID")
case_paths.append(test_model_path + "/Case_with_10_timesteps/Real40/BRUGGE_0040.EGRID")

for case_path in case_paths:
    assert os.path.exists(case_path), (
        "You need to set valid case paths for this script to work"
    )

case_group = resinsight.project.create_grid_case_group(case_paths=case_paths)

cases = case_group.descendants(rips.EclipseCase)
print("Got " + str(len(cases)) + " cases: ")

for case in cases:
    time_step_info = case.time_steps()
    porv_results = case.active_cell_property(rips.PropertyType.STATIC_NATIVE, "PORV", 0)

    for time_step_index in range(0, len(time_step_info)):
        pressure_results = case.active_cell_property(
            rips.PropertyType.DYNAMIC_NATIVE, "PRESSURE", time_step_index
        )

        results = []
        for pressure, porv in zip(pressure_results, porv_results):
            results.append(pressure * porv)

        # set the computed values in the case
        case.set_active_cell_property(
            results, rips.PropertyType.GENERATED, "PRESSURE_PORV", time_step_index
        )

    print(
        "Case id: " + str(case.id),
        "  Case name: " + case.name,
        " : Calculation complete",
    )


print("Transferred all results back to ResInsight")

# Pick a value from rips.ResultType (e.g. GENERATED, DYNAMIC_NATIVE, STATIC_NATIVE).
# https://api.resinsight.org/en/main/rips.html#result-definition
property_type = rips.ResultType.GENERATED

property_name = "PRESSURE_PORV"

statistics_case = case_group.create_statistics_case()
statistics_case.set_source_properties(property_type, [property_name])
statistics_case.compute_statistics()

view = statistics_case.create_view()
statistics_property_name = property_name + "_MEAN"
view.apply_cell_result(
    result_type=property_type, result_variable=statistics_property_name
)

Compute Avg Poro For Region

compute_avg_poro_for_region.py

###########################################################################################
# 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(
        rips.PropertyType.STATIC_NATIVE, "EQLNUM", time_step
    )
    poro = case.active_cell_property(rips.PropertyType.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}"
        )

Create Corner Point Grid

create_corner_point_grid.py

######################################################################
# 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

case = project.create_corner_point_grid(name, nx, ny, nz, coord, zcorn, actnum)

# Geometry properties (DEPTH, DX, DY, DZ, TOPS, BOTTOM) are computed automatically
print("Static properties: ", case.available_properties("STATIC_NATIVE"))
depth = case.active_cell_property("STATIC_NATIVE", "DEPTH", 0)
print("DEPTH min/max: ", min(depth), max(depth))

Export Corner Point Grid

export_corner_point_grid.py

######################################################################
# This script demonstrates how to export corner point grid data from
# ResInsight cases and recreate new grids from the exported data.
#
# This is the inverse operation of create_corner_point_grid.py - it
# extracts COORD, ZCORN, and ACTNUM arrays from existing Eclipse cases.
######################################################################

import rips


def validate_grid_dimensions(coord_array, zcorn_array, actnum_array, nx, ny, nz):
    """
    Validate that the exported arrays match the expected dimensions.

    Args:
        coord_array: COORD array (coordinate lines)
        zcorn_array: ZCORN array (corner depths)
        actnum_array: ACTNUM array (active cell flags)
        nx, ny, nz: Grid dimensions

    Returns:
        bool: True if arrays match expected dimensions
    """
    total_cells = nx * ny * nz
    expected_coord_size = (nx + 1) * (ny + 1) * 6  # 6 values per coordinate line
    expected_zcorn_size = nx * ny * nz * 8  # 8 corner depths per cell

    return (
        len(actnum_array) == total_cells
        and len(coord_array) == expected_coord_size
        and len(zcorn_array) == expected_zcorn_size
    )


def main():
    # Connect to ResInsight, launching it if no existing instance is found.
    try:
        resinsight = rips.Instance.find()
    except rips.RipsError:
        print("Starting ResInsight...")
        resinsight = rips.Instance.launch(console=True)

    project = resinsight.project
    if not project.cases():
        print("No cases in current project")
        return

    original_case = project.cases()[0]
    if original_case is None:
        print("Failed to load case")
        return

    print(f"Loaded case: {original_case.name}")

    # Get basic case information
    cell_count = original_case.cell_count()
    print("Case information:")
    print(f"  Total cells: {cell_count.reservoir_cell_count}")
    print(f"  Active cells: {cell_count.active_cell_count}")

    # Export corner point grid data
    print("\nExporting corner point grid data...")
    zcorn, coord, actnum, nx, ny, nz = original_case.export_corner_point_grid()

    print("Exported arrays:")
    print(f"  ZCORN: {len(zcorn):,} values (corner depths)")
    print(f"  COORD: {len(coord):,} values (coordinate lines)")
    print(f"  ACTNUM: {len(actnum):,} values (active cell flags)")

    # Grid dimensions are now returned directly from the export method!
    print(f"\nGrid dimensions from export: {nx} x {ny} x {nz} = {nx * ny * nz:,} cells")

    # Validate that the arrays match the expected dimensions
    if validate_grid_dimensions(coord, zcorn, actnum, nx, ny, nz):
        print("✓ Array sizes match expected dimensions perfectly")
    else:
        print("⚠ Array sizes don't match expected dimensions - this shouldn't happen")
        return

    # Create a new corner point grid from the exported data
    print("\nCreating new corner point grid from exported data...")
    recreated_name = f"{original_case.name}_Recreated"
    recreated_case = project.create_corner_point_grid(
        recreated_name, nx, ny, nz, coord, zcorn, actnum
    )

    if recreated_case is None:
        print("Failed to create recreated case")
        return

    print(f"Created recreated case: {recreated_case.name}")

    # Compare the two grids
    print("\nComparing original and recreated grids:")

    orig_cell_count = original_case.cell_count()
    recreated_cell_count = recreated_case.cell_count()

    print("Original grid:")
    print(f"  Total cells: {orig_cell_count.reservoir_cell_count:,}")
    print(f"  Active cells: {orig_cell_count.active_cell_count:,}")

    print("Recreated grid:")
    print(f"  Total cells: {recreated_cell_count.reservoir_cell_count:,}")
    print(f"  Active cells: {recreated_cell_count.active_cell_count:,}")

    # Get coordinate ranges for comparison
    print("\nCoordinate ranges:")

    # Sample some coordinates for comparison
    orig_bbox = original_case.reservoir_boundingbox()
    recreated_bbox = recreated_case.reservoir_boundingbox()

    print("Original bounding box:")
    print(f"  X: {orig_bbox.min_x:.2f} to {orig_bbox.max_x:.2f}")
    print(f"  Y: {orig_bbox.min_y:.2f} to {orig_bbox.max_y:.2f}")
    print(f"  Z: {orig_bbox.min_z:.2f} to {orig_bbox.max_z:.2f}")

    print("Recreated bounding box:")
    print(f"  X: {recreated_bbox.min_x:.2f} to {recreated_bbox.max_x:.2f}")
    print(f"  Y: {recreated_bbox.min_y:.2f} to {recreated_bbox.max_y:.2f}")
    print(f"  Z: {recreated_bbox.min_z:.2f} to {recreated_bbox.max_z:.2f}")


if __name__ == "__main__":
    main()

Fault Distance

fault_distance.py

###################################################################################
# This example prints the distance to and the name of the fault closest to a point
###################################################################################

import rips

resinsight = rips.Instance.find()

cases = resinsight.project.cases()
if len(cases) == 0:
    exit(1)

case = cases[0]
print("Using case: " + case.name)

# random test point (positive Z for depth)
point_x = 5039.84
point_y = 6303.76
point_z = 4144.21

print("Looking for closest fault to point %f, %f, %f:" % (point_x, point_y, point_z))

faultname, distance, facename = case.distance_to_closest_fault(
    point_x, point_y, point_z
)

if facename == "":
    print("- No fault found!")
else:
    print(
        "- Distance to closest fault %s is %f, closest face direction is %s"
        % (faultname, distance, facename)
    )

Grid Information

grid_information.py

######################################################################################
# This example prints information about the grids of all cases in the current project
######################################################################################

import rips

resinsight = rips.Instance.find()

cases = resinsight.project.cases()
print("Number of cases found: ", len(cases))
for case in cases:
    print(case.name)
    grids = case.grids()
    print("Number of grids: ", len(grids))
    for grid in grids:
        print("Grid dimensions: ", grid.dimensions())

Import Case Properties

import_case_properties.py

#######################################################
#
# This file shows how to import properties for a
# grid case created with .ROFFASC files
#
# Same procedure can also be used for .GRDECL files
#
#######################################################


# Access to environment variables and path tools
import os
import pathlib

# Load ResInsight Processing Server Client Library
import rips

# Connect to ResInsight instance
resinsight = rips.Instance.find()

# This requires the TestModels to be installed with ResInsight (RESINSIGHT_BUNDLE_TESTMODELS):
resinsight_exe_path = os.environ.get("RESINSIGHT_EXECUTABLE")

# Get the TestModels path from the executable path
resinsight_install_path = pathlib.PurePath(
    os.path.dirname(resinsight_exe_path)
).as_posix()

test_models_path = resinsight_install_path + "/TestModels/"

# Get the .roff case
roff_case_path = os.path.join(
    test_models_path, "reek/reek_box_grid_w_out_props.roffasc"
)

roff_case = resinsight.project.load_case(roff_case_path)

# PORO and EQLNUM should not be among available properties yet
print("Available properties:")
for prop in roff_case.available_properties(rips.PropertyType.INPUT_PROPERTY):
    print(prop)

# Import properties with file paths
poro_property_path = os.path.join(
    test_models_path, "reek/reek_box_PORO_property.roffasc"
)
eqlnum_property_path = os.path.join(
    test_models_path, "reek/reek_box_EQLNUM_property.roffasc"
)

imported_names = roff_case.import_properties(
    file_names=[poro_property_path, eqlnum_property_path]
)

print("Imported properties:")
for name in imported_names.values:
    print(name)

# PORO and EQLNUM should now be among available properties
print("Available properties:")
for prop in roff_case.available_properties(rips.PropertyType.INPUT_PROPERTY):
    print(prop)

Input Prop Test Async

input_prop_test_async.py

########################################################################################
# This example generates a derived property in an asynchronous manner
# Meaning it does not wait for all the data for each stage to be read before proceeding
########################################################################################
import rips
import time


# Internal function for creating a result from a small chunk of poro and permx results
# The return value of the function is a generator for the results rather than the result itself.
def create_result(poro_chunks, permx_chunks):
    # Loop through all the chunks of poro and permx in order
    for poroChunk, permxChunk in zip(poro_chunks, permx_chunks):
        resultChunk = []
        # Loop through all the values inside the chunks, in order
        for poro, permx in zip(poroChunk.values, permxChunk.values):
            resultChunk.append(poro * permx)
        # Return a generator object that behaves like a Python iterator
        yield resultChunk


resinsight = rips.Instance.find()
start = time.time()
case = resinsight.project.cases()[0]

# Get a generator for the poro results. The generator will provide a chunk each time it is iterated
poro_chunks = case.active_cell_property_async(
    rips.PropertyType.STATIC_NATIVE, "PORO", 0
)
# Get a generator for the permx results. The generator will provide a chunk each time it is iterated
permx_chunks = case.active_cell_property_async(
    rips.PropertyType.STATIC_NATIVE, "PERMX", 0
)

# Send back the result with the result provided by a generator object.
# Iterating the result generator will cause the script to read from the poro and permx generators
# And return the result of each iteration
case.set_active_cell_property_async(
    create_result(poro_chunks, permx_chunks),
    rips.PropertyType.GENERATED,
    "POROPERMXAS",
    0,
)

end = time.time()
print("Time elapsed: ", end - start)
print("Transferred all results back")
view = case.views()[0].apply_cell_result(rips.PropertyType.GENERATED, "POROPERMXAS")

Input Prop Test Sync

input_prop_test_sync.py

########################################################################################
# This example generates a derived property in an synchronous manner
# Meaning it completes reading each result before calculating the derived result
# See InputPropTestAsync for how to do this asynchronously instead.
#
# Property/porosity/result types accept either a typed enum
# (rips.PropertyType.STATIC_NATIVE) or a plain string ("STATIC_NATIVE"). This
# example uses the string form; see input_prop_test_async.py for the typed-enum
# form.
########################################################################################
import rips
import time
import grpc

resinsight = rips.Instance.find()
start = time.time()
case = resinsight.project.cases()[0]

# Read poro result into list
poro_results = case.active_cell_property("STATIC_NATIVE", "PORO", 0)
# Read permx result into list
permx_results = case.active_cell_property("STATIC_NATIVE", "PERMX", 0)

# Generate output result
results = []
for poro, permx in zip(poro_results, permx_results):
    results.append(poro * permx)

try:
    # Send back output result
    case.set_active_cell_property(results, "GENERATED", "POROPERMXSY", 0)
except grpc.RpcError as e:
    print("Exception Received: ", e)


end = time.time()
print("Time elapsed: ", end - start)
print("Transferred all results back")

view = case.views()[0].apply_cell_result("GENERATED", "POROPERMXSY")

Polygon Region From Project

polygon_region_from_project.py

####################################################################################
# This example demonstrates how to use existing polygons already defined in the
# ResInsight project to create grid cell filters and assign a unique integer
# region value to every active cell:
# 1. Retrieve polygons from the project's PolygonCollection
# 2. For each active cell, determine which polygon region it belongs to
# 3. Create a Generated result that stores the unique integer region index
####################################################################################

import rips


def point_in_polygon_2d(px, py, polygon_xy):
    """Check if point (px, py) is inside a 2D polygon using the ray casting algorithm.

    Arguments:
        px (float): X coordinate of the point
        py (float): Y coordinate of the point
        polygon_xy (list): List of [x, y] pairs defining the polygon vertices

    Returns:
        bool: True if the point is inside the polygon, False otherwise
    """
    n = len(polygon_xy)
    inside = False
    j = n - 1
    for i in range(n):
        xi, yi = polygon_xy[i][0], polygon_xy[i][1]
        xj, yj = polygon_xy[j][0], polygon_xy[j][1]
        if ((yi > py) != (yj > py)) and (px < (xj - xi) * (py - yi) / (yj - yi) + xi):
            inside = not inside
        j = i
    return inside


resinsight = rips.Instance.find()

cases = resinsight.project.cases()
if not cases:
    print("No cases found in the project")
    exit()

case = cases[0]
print(f"Using case: {case.name}")

# Step 1: Retrieve polygons from the project's PolygonCollection.
# These polygons must already exist in the project before running this script.
# Use the companion example polygon_grid_region.py to create example polygons,
# or define your own interactively in ResInsight.
polygon_collection = resinsight.project.descendants(rips.PolygonCollection)[0]
polygons = polygon_collection.polygons()

if not polygons:
    print(
        "No polygons found in the project. "
        "Please create polygons in ResInsight before running this script."
    )
    exit()

print(f"Found {len(polygons)} polygon(s) in the project:")
for i, p in enumerate(polygons):
    print(f"  [{i + 1}] {p.name}  ({len(p.coordinates)} vertices)")

# Step 2: For each active cell, determine which polygon region it belongs to
# by checking whether the cell center (X, Y) falls inside the polygon.
# The polygon coordinates contain Z (depth) values which are ignored for the
# 2D containment test.
print("Computing cell-to-region assignments...")
cell_centers = case.active_cell_centers()

# Initialize all cells with value 0 (no region assigned)
region_values = [0.0] * len(cell_centers)

for cell_idx, cell_center in enumerate(cell_centers):
    for polygon_idx, polygon in enumerate(polygons):
        polygon_xy = [[c[0], c[1]] for c in polygon.coordinates]
        if point_in_polygon_2d(cell_center.x, cell_center.y, polygon_xy):
            # Assign 1-based region index so each region has a unique integer value
            region_values[cell_idx] = float(polygon_idx + 1)
            break  # Assign cell to the first matching polygon

# Step 3: Create a Generated result that stores the unique integer region value
# for every active cell. Cells not covered by any polygon receive value 0.
property_name = "POLYGON_REGION"
case.set_active_cell_property(
    region_values, rips.PropertyType.GENERATED, property_name, 0
)

print(f"Generated property '{property_name}' created successfully")
for i, polygon in enumerate(polygons):
    count = sum(1 for v in region_values if v == float(i + 1))
    print(f"  Region {i + 1} (polygon '{polygon.name}'): {count} cells")

unassigned = sum(1 for v in region_values if v == 0.0)
print(f"  Unassigned (no polygon): {unassigned} cells")

# Apply the generated result in the view to visualize the regions
view = case.views()[0] if case.views() else case.create_view()
view.apply_cell_result(
    result_type=rips.PropertyType.GENERATED, result_variable=property_name
)
print(f"Applied '{property_name}' cell result to view")

Result Aliases

result_aliases.py

#######################################################
#
# This file shows how to set up an alias name for
# a result, so that you could access the data
# using the alias name.
#
# This works for both eclipse and roff cases.
#
#######################################################


# Access to environment variables and path tools
import os
import pathlib

# Load ResInsight Processing Server Client Library
import rips

# Connect to ResInsight instance
resinsight = rips.Instance.find()

# This requires the TestModels to be installed with ResInsight
# (RESINSIGHT_BUNDLE_TESTMODELS):
resinsight_exe_path = os.environ.get("RESINSIGHT_EXECUTABLE")

# Get the TestModels path from the executable path
resinsight_install_path = pathlib.PurePath(
    os.path.dirname(resinsight_exe_path)
).as_posix()

test_models_path = resinsight_install_path + "/TestModels/"

# Get the .roff case
roff_case_path = os.path.join(test_models_path, "reek/reek_box_grid_w_props.roff")

roff_case = resinsight.project.load_case(roff_case_path)

# Print all available properties
print("Results on file:")
for prop in roff_case.available_properties(rips.PropertyType.STATIC_NATIVE):
    print(prop)

# The name "DYBDE" should point to the "DEPTH" result
roff_case.add_result_alias("DEPTH", "DYBDE")

# The name "PERMX" should point to the "BOTTOM" result
roff_case.add_result_alias("BOTTOM", "PERMX")

# Print all available properties, now with two additional props
print("Results including aliases:")
for prop in roff_case.available_properties(rips.PropertyType.STATIC_NATIVE):
    print(prop)

real_result = roff_case.grid_property(rips.PropertyType.STATIC_NATIVE, "BOTTOM", 0)
alias_result = roff_case.grid_property(rips.PropertyType.STATIC_NATIVE, "PERMX", 0)

if real_result[40] == alias_result[40]:
    print("Result values at index 40 match!")

# Remove our aliases
roff_case.clear_result_aliases()

# Print all available properties, now just the original ones
print("Original results:")
for prop in roff_case.available_properties(rips.PropertyType.STATIC_NATIVE):
    print(prop)

try:
    alias_result = roff_case.grid_property(rips.PropertyType.STATIC_NATIVE, "PERMX", 0)
except Exception:
    print("Result PERMX no longer exists!")

Selected Cells

selected_cells.py

############################################################################
# This example prints center and corners for the currently selected cells
# in ResInsight
############################################################################

import rips

resinsight = rips.Instance.find()
cases = resinsight.project.cases()

print("Got " + str(len(cases)) + " cases: ")
for case in cases:
    print(case.name)
    cells = case.selected_cells()
    print("Found " + str(len(cells)) + " selected cells")

    time_step_info = case.time_steps()

    for idx, cell in enumerate(cells):
        print(
            "Selected cell: [{}, {}, {}] grid: {}".format(
                cell.ijk.i + 1, cell.ijk.j + 1, cell.ijk.k + 1, cell.grid_index
            )
        )

        # Get the grid and dimensions
        grid = case.grids()[cell.grid_index]
        dimensions = grid.dimensions()

        # Map ijk to cell index
        cell_index = (
            dimensions.i * dimensions.j * cell.ijk.k
            + dimensions.i * cell.ijk.j
            + cell.ijk.i
        )

        # Print the cell center
        cell_centers = grid.cell_centers()
        cell_center = cell_centers[cell_index]
        print(
            "Cell center: [{}, {}, {}]".format(
                cell_center.x, cell_center.y, cell_center.z
            )
        )

        # Print the cell corners
        cell_corners = grid.cell_corners()[cell_index]
        print("Cell corners:")
        print("c0:\n" + str(cell_corners.c0))
        print("c1:\n" + str(cell_corners.c1))
        print("c2:\n" + str(cell_corners.c2))
        print("c3:\n" + str(cell_corners.c3))
        print("c4:\n" + str(cell_corners.c4))
        print("c5:\n" + str(cell_corners.c5))
        print("c6:\n" + str(cell_corners.c6))
        print("c7:\n" + str(cell_corners.c7))

        for tidx, timestep in enumerate(time_step_info):
            # Read the full SOIL result for time step
            soil_results = case.selected_cell_property(
                rips.PropertyType.DYNAMIC_NATIVE, "SOIL", tidx
            )
            print(
                "SOIL: {} ({}.{}.{})".format(
                    soil_results[idx], timestep.year, timestep.month, timestep.day
                )
            )

Set Cell Result

set_cell_result.py

######################################################################
# This script applies a cell result to the first view in the project
######################################################################
import rips

resinsight = rips.Instance.find()

view = resinsight.project.views()[0]
view.apply_cell_result(
    result_type=rips.PropertyType.STATIC_NATIVE, result_variable="DX"
)

Set Discrete Active Cell Property

set_discrete_active_cell_property.py

######################################################################
# This script creates a discrete (integer) property for all active
# cells in the first case in the project.
#
# Passing data_type=rips.PropertyDataType.INTEGER flags the property as
# discrete regardless of the property name (previously this required the
# name to end with "NUM").
######################################################################
import rips

resinsight = rips.Instance.find()

case = resinsight.project.case(case_id=0)

# Derive a discrete region id from a continuous property.
poro = case.active_cell_property(rips.PropertyType.STATIC_NATIVE, "PORO", 0)
region_ids = [int(value * 100) % 4 for value in poro]

print("Applying discrete values to active cells")
case.set_active_cell_property(
    region_ids,
    rips.PropertyType.GENERATED,
    "MY_REGION",
    0,
    data_type=rips.PropertyDataType.INTEGER,
)

# Bind integer values to text labels so the legend shows names instead of numbers.
case.set_discrete_property_category_names(
    property_name="MY_REGION",
    value_names={0: "Sand", 1: "Shale", 2: "Coal", 3: "Limestone"},
)

# Introspect the property: data_type, category names, and category colors.
data_type = case.property_data_type(
    property_type=rips.PropertyType.GENERATED,
    property_name="MY_REGION",
)
print(f"MY_REGION data type: {data_type}")
assert data_type == rips.PropertyDataType.INTEGER

print("MY_REGION category names:", case.discrete_property_category_names("MY_REGION"))
print("MY_REGION category colors:", case.discrete_property_category_colors("MY_REGION"))

Set Discrete Grid Property

set_discrete_grid_property.py

######################################################################
# This script creates a discrete (integer) grid property for all grid
# cells in the first case in the project.
#
# A discrete property is visualized with a category legend, in contrast
# to the continuous legend used for floating point properties. Passing
# data_type=rips.PropertyDataType.INTEGER flags the property as discrete
# regardless of the property name (previously this required the name to
# end with "NUM").
######################################################################
import rips

resinsight = rips.Instance.find()

case = resinsight.project.case(case_id=0)
grid = case.grid()
grid_cell_count = grid.cell_count()
print("total cell count : " + str(grid_cell_count))

# Assign a simple region id based on IJK index.
values = []
for i in range(0, grid_cell_count):
    values.append(i % 4)

print("Applying discrete values to main grid")
case.set_grid_property(
    values,
    rips.PropertyType.STATIC_NATIVE,
    "MY_REGION",
    0,
    data_type=rips.PropertyDataType.INTEGER,
)

# Bind integer values to text labels so the legend shows names instead of numbers.
# Colors are optional — values without a color get an auto-assigned palette color.
case.set_discrete_property_category_names(
    property_name="MY_REGION",
    value_names={0: "Sand", 1: "Shale", 2: "Coal", 3: "Limestone"},
    value_colors={0: "#e6c878", 1: "#646464"},
)

Set Flow Diagnostics Result

set_flow_diagnostics_result.py

######################################################################
# This script applies a flow diagnostics cell result to the first view in the project
######################################################################

# Load ResInsight Processing Server Client Library
import rips

# Connect to ResInsight instance
resinsight = rips.Instance.find()

view = resinsight.project.view(view_id=1)
# view.apply_flow_diagnostics_cell_result(result_variable='Fraction',
#                                    selection_mode='FLOW_TR_INJ_AND_PROD')

# Example of setting individual wells. Commented out because well names are case specific.
view.apply_flow_diagnostics_cell_result(
    result_variable="Fraction",
    selection_mode="FLOW_TR_BY_SELECTION",
    injectors=["C-1H", "C-2H", "F-2H"],
    producers=["B-1AH", "B-3H", "D-1H"],
)

Set Grid Properties

set_grid_properties.py

######################################################################
# This script sets values for all grid cells in the first case in the project
# The script is intended to be used for TEST10K_FLT_LGR_NNC.EGRID
# This grid case contains one LGR
######################################################################
import rips

resinsight = rips.Instance.find()

case = resinsight.project.case(case_id=0)
grid = case.grid()
grid_cell_count = grid.cell_count()
print("total cell count : " + str(grid_cell_count))

values = []
for i in range(0, grid_cell_count):
    values.append(i % 2 * 0.75)

# Assign value to IJK grid cell at (31, 53, 21)
grid = case.grid()
property_data_index = grid.property_data_index_from_ijk(31, 53, 21)
values[property_data_index] = 1.5

print("Applying values to main grid")
case.set_grid_property(values, rips.PropertyType.STATIC_NATIVE, "MY_DATA", 0)

values_from_ri = case.grid_property(rips.PropertyType.STATIC_NATIVE, "MY_DATA", 0)
assert values[property_data_index] == values_from_ri[property_data_index]

# Get LGR grid as grid index 1
grid = case.grid(1)
grid_cell_count = grid.cell_count()
print("lgr cell count : " + str(grid_cell_count))

values = []
for i in range(0, grid_cell_count):
    values.append(i % 3 * 0.75)

print("Applying values to LGR grid")
case.set_grid_property(values, rips.PropertyType.STATIC_NATIVE, "MY_DATA", 0, 1)
values_from_ri = case.grid_property(rips.PropertyType.STATIC_NATIVE, "MY_DATA", 0, 1)

Soil Average Async

soil_average_async.py

###########################################################################################
# This example will asynchronously calculate the average value for SOIL for all time steps
###########################################################################################

import rips
import time

resinsight = rips.Instance.find()

start = time.time()

# Get the case with case id 0
case = resinsight.project.case(case_id=0)

# Get a list of all time steps
timeSteps = case.time_steps()

averages = []
for i in range(0, len(timeSteps)):
    # Get the results from time step i asynchronously
    # It actually returns a generator object almost immediately
    result_chunks = case.active_cell_property_async(
        rips.PropertyType.DYNAMIC_NATIVE, "SOIL", i
    )
    mysum = 0.0
    count = 0
    # Loop through and append the average. each time we loop resultChunks
    # We will trigger a read of the input data, meaning the script will start
    # Calculating averages before the whole resultValue for this time step has been received
    for chunk in result_chunks:
        mysum += sum(chunk.values)
        count += len(chunk.values)

    averages.append(mysum / count)

end = time.time()
print("Time elapsed: ", end - start)
print(averages)

Soil Average Sync

soil_average_sync.py

###########################################################################################
# This example will synchronously calculate the average value for SOIL for all time steps
#
# Property/porosity types accept either a typed enum (rips.PropertyType.DYNAMIC_NATIVE) or
# a plain string ("DYNAMIC_NATIVE"). This example uses the string form; see
# soil_average_async.py for the typed-enum form.
###########################################################################################
import rips
import time

resinsight = rips.Instance.find()

start = time.time()

# Get the case with case id 0
case = resinsight.project.case(case_id=0)

# Get a list of all time steps
time_steps = case.time_steps()

averages = []
for i in range(0, len(time_steps)):
    # Get a list of all the results for time step i
    results = case.active_cell_property("DYNAMIC_NATIVE", "SOIL", i)
    mysum = sum(results)
    averages.append(mysum / len(results))

end = time.time()
print("Time elapsed: ", end - start)
print(averages)

Soil Porv Async

soil_porv_async.py

##############################################################################
# This example will create a derived result for each time step asynchronously
##############################################################################

import rips
import time


# Internal function for creating a result from a small chunk of soil and porv results
# The return value of the function is a generator for the results rather than the result itself.
def create_result(soil_chunks, porv_chunks):
    for soil_chunk, porv_chunk in zip(soil_chunks, porv_chunks):
        resultChunk = []
        for soil_value, porv_value in zip(soil_chunk.values, porv_chunk.values):
            resultChunk.append(soil_value * porv_value)
        # Return a Python generator
        yield resultChunk


resinsight = rips.Instance.find()
start = time.time()
case = resinsight.project.cases()[0]
timeStepInfo = case.time_steps()

# Get a generator for the porv results. The generator will provide a chunk each time it is iterated
porv_chunks = case.active_cell_property_async(
    rips.PropertyType.STATIC_NATIVE, "PORV", 0
)

# Read the static result into an array, so we don't have to transfer it for each iteration
# Note we use the async method even if we synchronise here, because we need the values chunked
# ... to match the soil chunks
porv_array = []
for porv_chunk in porv_chunks:
    porv_array.append(porv_chunk)

for i in range(0, len(timeStepInfo)):
    # Get a generator object for the SOIL property for time step i
    soil_chunks = case.active_cell_property_async(
        rips.PropertyType.DYNAMIC_NATIVE, "SOIL", i
    )
    # Create the generator object for the SOIL * PORV derived result
    result_generator = create_result(soil_chunks, iter(porv_array))
    # Send back the result asynchronously with a generator object
    case.set_active_cell_property_async(
        result_generator, rips.PropertyType.GENERATED, "SOILPORVAsync", i
    )

end = time.time()
print("Time elapsed: ", end - start)

print("Transferred all results back")

view = case.views()[0].apply_cell_result(rips.PropertyType.GENERATED, "SOILPORVAsync")

Soil Porv Sync

soil_porv_sync.py

##############################################################################
# This example will create a derived result for each time step synchronously
##############################################################################

import rips
import time

resinsight = rips.Instance.find()
start = time.time()
case = resinsight.project.cases()[0]

# Read the full porv result
porv_results = case.active_cell_property(rips.PropertyType.STATIC_NATIVE, "PORV", 0)
time_step_info = case.time_steps()

for i in range(0, len(time_step_info)):
    # Read the full SOIl result for time step i
    soil_results = case.active_cell_property(
        rips.PropertyType.DYNAMIC_NATIVE, "SOIL", i
    )

    # Generate the result by looping through both lists in order
    results = []
    for soil, porv in zip(soil_results, porv_results):
        results.append(soil * porv)

    # Send back result
    case.set_active_cell_property(
        results, rips.PropertyType.GENERATED, "SOILPORVSync", i
    )

end = time.time()
print("Time elapsed: ", end - start)

print("Transferred all results back")

view = case.views()[0].apply_cell_result(rips.PropertyType.GENERATED, "SOILPORVSync")