Update rips module and proto files

Author: magnesj

docs/proto/Commands.proto

@@ -178,6 +178,8 @@ message ScaleFractureTemplateRequest {
   int32 id = 1;
   double halfLength = 2;
   double height = 3;
+  double dFactor = 4;
+  double conductivity = 5;
 }
 
 message SetFracContainmentRequest {

docs/rips/generated/Commands_pb2.py

@@ -211,6 +211,30 @@ def test_selected_cells(rips_instance, initialize_test):
         assert len(soil_results) == 0
 
 
+def test_selected_cells_async(rips_instance, initialize_test):
+    case = rips_instance.project.load_case(
+        dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    )
+    accumulated = []
+    for chunk in case.selected_cells_async():
+        accumulated.extend(chunk.cells)
+    assert accumulated == case.selected_cells()
+
+
+def test_selected_cell_property_async(rips_instance, initialize_test):
+    case = rips_instance.project.load_case(
+        dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    )
+    accumulated = []
+    for chunk in case.selected_cell_property_async(
+        rips.PropertyType.DYNAMIC_NATIVE, "SOIL", 0
+    ):
+        accumulated.extend(chunk.values)
+    assert accumulated == case.selected_cell_property(
+        rips.PropertyType.DYNAMIC_NATIVE, "SOIL", 0
+    )
+
+
 def test_multiple_load_of_same_case(rips_instance, initialize_test):
     # Test related to issue https://github.com/OPM/ResInsight/issues/9332
     path_name = dataroot.PATH + "/flow_diagnostics_test/SIMPLE_SUMMARY2.EGRID"

docs/rips/tests/test_cases.py

@@ -67,6 +67,55 @@ def test_10k(rips_instance, initialize_test):
     check_corner(cell_corners[cell_index].c7, expected_corners[7])
 
 
+def test_10k_cell_centers_async(rips_instance, initialize_test):
+    casePath = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    case = rips_instance.project.load_case(path=casePath)
+    grid = case.grid(index=0)
+
+    accumulated = []
+    for chunk in grid.cell_centers_async():
+        accumulated.extend(chunk.centers)
+
+    sync_centers = grid.cell_centers()
+    assert len(accumulated) == len(sync_centers)
+
+    cell_index = 168143
+    assert math.isclose(accumulated[cell_index].x, sync_centers[cell_index].x)
+    assert math.isclose(accumulated[cell_index].y, sync_centers[cell_index].y)
+    assert math.isclose(accumulated[cell_index].z, sync_centers[cell_index].z)
+
+
+def test_10k_cell_corners_async(rips_instance, initialize_test):
+    casePath = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    case = rips_instance.project.load_case(path=casePath)
+    grid = case.grid(index=0)
+
+    accumulated = []
+    for chunk in grid.cell_corners_async():
+        accumulated.extend(chunk.cells)
+
+    sync_corners = grid.cell_corners()
+    assert len(accumulated) == len(sync_corners)
+
+    cell_index = 168143
+    check_corner(
+        accumulated[cell_index].c0,
+        [
+            sync_corners[cell_index].c0.x,
+            sync_corners[cell_index].c0.y,
+            sync_corners[cell_index].c0.z,
+        ],
+    )
+    check_corner(
+        accumulated[cell_index].c7,
+        [
+            sync_corners[cell_index].c7.x,
+            sync_corners[cell_index].c7.y,
+            sync_corners[cell_index].c7.z,
+        ],
+    )
+
+
 def check_reek_grid_box(case: rips.Case):
     assert len(case.grids()) == 1
     grid = case.grid(index=0)

docs/rips/tests/test_grids.py

@@ -16,6 +16,21 @@ def test_set_and_get_values(rips_instance, initialize_test):
     assert input_values == output_values
 
 
+def test_set_and_get_values_async(rips_instance, initialize_test):
+    project = rips_instance.project
+    key = "my-async-key"
+    input_values = [float(x) for x in range(2000)]
+    project.set_key_values(key, input_values)
+
+    accumulated = []
+    chunk_count = 0
+    for chunk in project.key_values_async(key):
+        accumulated.extend(chunk.values)
+        chunk_count += 1
+    assert chunk_count > 0
+    assert input_values == accumulated
+
+
 def test_get_non_existing_key(rips_instance, initialize_test):
     project = rips_instance.project
     key = "this-key-does-not-exist"

docs/rips/tests/test_key_value_store.py

@@ -61,6 +61,52 @@ def test_10kSync(rips_instance, initialize_test):
         assert new_data[i] == new_prop_vals[i]
 
 
+def test_10k_nnc_connections_async(rips_instance, initialize_test):
+    casePath = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    case = rips_instance.project.load_case(path=casePath)
+
+    accumulated = []
+    chunk_count = 0
+    for chunk in case.nnc_connections_async():
+        accumulated.extend(chunk.connections)
+        chunk_count += 1
+    assert chunk_count > 0
+
+    sync_connections = case.nnc_connections()
+    assert len(accumulated) == len(sync_connections)
+
+    first = accumulated[0]
+    assert first.cell1.i == 33
+    assert first.cell1.j == 40
+    assert first.cell1.k == 14
+    assert first.cell_grid_index1 == 0
+
+
+def test_10k_nnc_connections_static_values_async(rips_instance, initialize_test):
+    casePath = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    case = rips_instance.project.load_case(path=casePath)
+
+    accumulated = []
+    for chunk in case.nnc_connections_static_values_async("TRAN"):
+        accumulated.extend(chunk.values)
+    assert accumulated == case.nnc_connections_static_values("TRAN")
+
+
+def test_10k_nnc_connections_generated_values_async(rips_instance, initialize_test):
+    casePath = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    case = rips_instance.project.load_case(path=casePath)
+
+    nnc_connections = case.nnc_connections()
+    new_data = [float(c) for c, _ in enumerate(nnc_connections)]
+    property_name = "ASYNC_PROP"
+    case.set_nnc_connections_values(new_data, property_name, 0)
+
+    accumulated = []
+    for chunk in case.nnc_connections_generated_values_async(property_name, 0):
+        accumulated.extend(chunk.values)
+    assert accumulated == new_data
+
+
 def test_non_existing_dynamic_values(rips_instance, initialize_test):
     casePath = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
     case = rips_instance.project.load_case(path=casePath)

docs/rips/tests/test_nnc_properties.py

@@ -66,6 +66,178 @@ def test_loadGridCaseGroup(rips_instance, initialize_test):
     )
     assert grid_case_group is not None and grid_case_group.group_id == 0
 
+    project = rips_instance.project
+    groups = project.grid_case_groups()
+    assert len(groups) == 1
+    looked_up = project.grid_case_group(grid_case_group.group_id)
+    assert looked_up is not None
+    assert looked_up.group_id == grid_case_group.group_id
+    assert project.grid_case_group(9999) is None
+
+
+def test_save_project_round_trip(rips_instance, initialize_test):
+    case_path = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    project = rips_instance.project
+    project.load_case(case_path)
+    assert len(project.cases()) == 1
+
+    with tempfile.TemporaryDirectory(prefix="rips") as tmpdirname:
+        project_file = os.path.join(tmpdirname, "round_trip.rsp")
+        project.save(project_file)
+        assert os.path.exists(project_file)
+
+        project.close()
+        assert len(rips_instance.project.cases()) == 0
+
+        reopened = rips_instance.project.open(project_file)
+        cases = reopened.cases()
+        assert len(cases) == 1
+        assert cases[0].name == "TEST10K_FLT_LGR_NNC"
+
+
+def test_views_and_view_lookup(rips_instance, initialize_test):
+    case_path = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    case = rips_instance.project.load_case(case_path)
+    case.create_view()
+
+    project = rips_instance.project
+    views = project.views()
+    assert len(views) >= 1
+
+    first_view = views[0]
+    looked_up = project.view(first_view.id)
+    assert looked_up is not None
+    assert looked_up.id == first_view.id
+    assert project.view(999999) is None
+
+
+def test_well_path_by_name(rips_instance, initialize_test):
+    well_files = [dataroot.PATH + "/TEST10K_FLT_LGR_NNC/wellpath_a.dev"]
+    rips_instance.project.import_well_paths(well_path_files=well_files)
+
+    project = rips_instance.project
+    well_path = project.well_path_by_name("Well Path A")
+    assert well_path is not None
+    assert well_path.name == "Well Path A"
+    assert project.well_path_by_name("Nonexistent Well Path") is None
+
+
+def test_plot_lookup(rips_instance, initialize_test):
+    project = rips_instance.project.open(
+        dataroot.PATH + "/TEST10K_FLT_LGR_NNC/10KWithWellLog.rsp"
+    )
+    plots = project.plots()
+    assert len(plots) >= 1
+
+    first_plot = plots[0]
+    looked_up = project.plot(first_plot.id)
+    assert looked_up is not None
+    assert looked_up.id == first_plot.id
+    assert project.plot(999999) is None
+
+
+def test_export_well_paths(rips_instance, initialize_test):
+    well_files = [dataroot.PATH + "/TEST10K_FLT_LGR_NNC/wellpath_a.dev"]
+    rips_instance.project.import_well_paths(well_path_files=well_files)
+
+    with tempfile.TemporaryDirectory(prefix="rips") as tmpdirname:
+        rips_instance.set_export_folder(export_type="WELLPATHS", path=tmpdirname)
+        rips_instance.project.export_well_paths(
+            well_paths="Well Path A", md_step_size=10.0
+        )
+        exported = os.listdir(tmpdirname)
+        assert any(name.endswith(".dev") for name in exported)
+
+
+def test_scale_fracture_template_and_set_containment(rips_instance, initialize_test):
+    project = rips_instance.project.open(
+        dataroot.PATH + "/TEST10K_FLT_LGR_NNC/small-completion-export-fractures.rsp"
+    )
+    template = project.descendants(rips.FractureTemplate)[0]
+    assert template.height_scale_factor == 1.0
+    # The half-length scale factor uses the legacy keyword "WidthScaleFactor".
+    assert template.width_scale_factor == 1.0
+    assert template.d_factor_scale_factor == 1.0
+    assert template.conductivity_factor == 1.0
+
+    project.scale_fracture_template(
+        template_id=0, half_length=2.0, height=3.0, d_factor=4.0, conductivity=5.0
+    )
+
+    after_scale = project.descendants(rips.FractureTemplate)[0]
+    assert after_scale.width_scale_factor == 2.0
+    assert after_scale.height_scale_factor == 3.0
+    assert after_scale.d_factor_scale_factor == 4.0
+    assert after_scale.conductivity_factor == 5.0
+
+    project.set_fracture_containment(template_id=0, top_layer=5, base_layer=10)
+
+    # RimFractureContainment fields are not scriptable, so verify the change
+    # made it through by saving the project and inspecting the .rsp XML.
+    with tempfile.TemporaryDirectory(prefix="rips") as tmpdirname:
+        out_path = os.path.join(tmpdirname, "containment.rsp")
+        project.save(out_path)
+        with open(out_path) as rsp:
+            content = rsp.read()
+        assert "<TopKLayer>5</TopKLayer>" in content
+        assert "<BaseKLayer>10</BaseKLayer>" in content
+
+
+def test_summary_cases(rips_instance, initialize_test):
+    case_path = dataroot.PATH + "/flow_diagnostics_test/SIMPLE_SUMMARY2.SMSPEC"
+    project = rips_instance.project
+    assert project.summary_cases() == []
+
+    summary_case = project.import_summary_case(case_path)
+    cases = project.summary_cases()
+    assert len(cases) == 1
+    assert cases[0].id == summary_case.id
+
+
+def test_import_formation_names(rips_instance, initialize_test):
+    case_path = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    case = rips_instance.project.load_case(case_path)
+
+    rips_instance.project.import_formation_names(
+        formation_files=dataroot.PATH + "/20Layers.lyr"
+    )
+
+    available = case.available_properties(rips.PropertyType.FORMATION_NAMES)
+    assert "Active Formation Names" in available
+
+
+_MINIMAL_LAS = """~Version Information
+ VERS.                 2.0 : CWLS log ASCII Standard - VERSION 2.0
+ WRAP.                 NO  : One line per depth step
+~Well Information
+#MNEM.UNIT       Value      Description
+#---------    -----------   ---------------
+ STRT.M       1000.0       : Start Depth
+ STOP.M       1002.0       : Stop Depth
+ STEP.M          1.0       : Step
+ NULL.        -999.25      : Null Value
+ WELL.        RIPS_TEST    : WELL
+~Curve Information
+ DEPT.M               : Depth
+ GR.GAPI              : Gamma Ray
+~ASCII
+ 1000.0   50.0
+ 1001.0   55.0
+ 1002.0   60.0
+"""
+
+
+def test_import_well_log_files(rips_instance, initialize_test):
+    with tempfile.TemporaryDirectory(prefix="rips") as tmpdirname:
+        las_path = os.path.join(tmpdirname, "rips_test.las")
+        with open(las_path, "w") as las_file:
+            las_file.write(_MINIMAL_LAS)
+
+        well_path_names = rips_instance.project.import_well_log_files(
+            well_log_folder=tmpdirname
+        )
+        assert "RIPS_TEST" in well_path_names
+
 
 def test_exportSnapshots(rips_instance, initialize_test):
     if not rips_instance.is_gui():

docs/rips/tests/test_project.py

@@ -184,6 +184,42 @@ def test_10k_property_strings(rips_instance, initialize_test):
     assert len(round_trip) == len(integer_values)
 
 
+def test_10k_grid_property_async(rips_instance, initialize_test):
+    casePath = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    case = rips_instance.project.load_case(path=casePath)
+
+    chunks = case.grid_property_async(rips.PropertyType.STATIC_NATIVE, "PORO", 0)
+    accumulated = []
+    chunk_count = 0
+    for chunk in chunks:
+        accumulated.extend(chunk.values)
+        chunk_count += 1
+    assert chunk_count > 0
+
+    sync_values = case.grid_property(rips.PropertyType.STATIC_NATIVE, "PORO", 0)
+    assert len(accumulated) == len(sync_values)
+    for async_value, sync_value in zip(accumulated, sync_values):
+        assert async_value == pytest.approx(sync_value)
+
+
+def test_10k_available_properties_categories(rips_instance, initialize_test):
+    casePath = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    case = rips_instance.project.load_case(path=casePath)
+
+    dynamic = case.available_properties(rips.PropertyType.DYNAMIC_NATIVE)
+    assert "SOIL" in dynamic
+    assert "PRESSURE" in dynamic
+
+    cell_count_info = case.cell_count()
+    zeros = [0.0] * cell_count_info.active_cell_count
+    case.set_active_cell_property(
+        zeros, rips.PropertyType.GENERATED, "AVAILABLE_PROBE", 0
+    )
+
+    generated = case.available_properties(rips.PropertyType.GENERATED)
+    assert "AVAILABLE_PROBE" in generated
+
+
 def test_exportPropertyInView(rips_instance, initialize_test):
     case_path = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
     case = rips_instance.project.load_case(case_path)