Case And Grid Operations

This page shows Python examples from the case_and_grid_operations folder.

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("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("STATIC_NATIVE", "PORV", 0)

    for time_step_index in range(0, len(time_step_info)):
        pressure_results = case.active_cell_property(
            "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, "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")

# one of "GENERATED", "DYNAMIC_NATIVE", "STATIC_NATIVE", "IMPORTED"
# https://api.resinsight.org/en/main/rips.html#result-definition
property_type = "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("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}"
        )

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

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

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
    resinsight = rips.Instance.find()
    if resinsight is None:
        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()
if resinsight is None:
    exit(1)

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("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("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("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("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), "GENERATED", "POROPERMXAS", 0
)

end = time.time()
print("Time elapsed: ", end - start)
print("Transferred all results back")
view = case.views()[0].apply_cell_result("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.
########################################################################################
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")

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("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("STATIC_NATIVE"):
    print(prop)

real_result = roff_case.grid_property("STATIC_NATIVE", "BOTTOM", 0)
alias_result = roff_case.grid_property("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("STATIC_NATIVE"):
    print(prop)

try:
    alias_result = roff_case.grid_property("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()
if resinsight is not None:
    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(
                    "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="STATIC_NATIVE", result_variable="DX")

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, "STATIC_NATIVE", "MY_DATA", 0)

values_from_ri = case.grid_property("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, "STATIC_NATIVE", "MY_DATA", 0, 1)
values_from_ri = case.grid_property("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("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
###########################################################################################
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("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("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, "GENERATED", "SOILPORVAsync", i
    )

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

print("Transferred all results back")

view = case.views()[0].apply_cell_result("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("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("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, "GENERATED", "SOILPORVSync", i)

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

print("Transferred all results back")

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