#13313 Python: Add support for setting geometry on an existing case

Author: kriben

ApplicationLibCode/ProjectDataModel/RimCornerPointCase.cpp

@@ -108,6 +108,35 @@ std::expected<RimCornerPointCase*, QString> RimCornerPointCase::createFromCoordi
     return cornerPointCase;
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+std::expected<void, QString> RimCornerPointCase::replaceGridFromCoordinatesArray( RimCornerPointCase&       cornerPointCase,
+                                                                                  const int                 nx,
+                                                                                  const int                 ny,
+                                                                                  const int                 nz,
+                                                                                  const std::vector<float>& coord,
+                                                                                  const std::vector<float>& zcorn,
+                                                                                  const std::vector<float>& actnum )
+{
+    // cornerPointCase.
+    //    cornerPointCase.closeReservoirCase();
+
+    RigActiveCellInfo* activeCellInfo = cornerPointCase.eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
+    CVF_ASSERT( activeCellInfo );
+    activeCellInfo->clear();
+
+    RigActiveCellInfo* fractureActiveCellInfo =
+        cornerPointCase.eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL );
+    CVF_ASSERT( fractureActiveCellInfo );
+    fractureActiveCellInfo->clear();
+
+    buildGrid( *cornerPointCase.eclipseCaseData(), nx, ny, nz, coord, zcorn, actnum );
+    cornerPointCase.computeCachedData();
+
+    return {};
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimCornerPointCase.h

@@ -50,6 +50,14 @@ class RimCornerPointCase : public RimEclipseCase
                                                                                    const std::vector<float>& zcorn,
                                                                                    const std::vector<float>& actnum );
 
+    static std::expected<void, QString> replaceGridFromCoordinatesArray( RimCornerPointCase&       cornerPointCase,
+                                                                         const int                 nx,
+                                                                         const int                 ny,
+                                                                         const int                 nz,
+                                                                         const std::vector<float>& coord,
+                                                                         const std::vector<float>& zcorn,
+                                                                         const std::vector<float>& actnum );
+
 protected:
     void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;
 

ApplicationLibCode/ProjectDataModelCommands/RimcEclipseCase.cpp

@@ -21,6 +21,7 @@
 #include "RiaApplication.h"
 #include "RiaGuiApplication.h"
 #include "RiaKeyValueStoreUtil.h"
+#include "RiaViewRedrawScheduler.h"
 
 #include "RigActiveCellInfo.h"
 #include "RigCaseCellResultsData.h"
@@ -32,9 +33,13 @@
 #include "RigResultAccessor.h"
 #include "RigResultAccessorFactory.h"
 
+#include "Rim3dView.h"
 #include "RimCase.h"
+#include "RimCornerPointCase.h"
 #include "RimEclipseCase.h"
+#include "RimEclipseView.h"
 #include "RimProject.h"
+#include "RimReloadCaseTools.h"
 
 #include "cafPdmFieldScriptingCapability.h"
 
@@ -254,3 +259,93 @@ std::expected<caf::PdmObjectHandle*, QString> RimcEclipseCase_exportCornerPointG
 
     return nullptr;
 }
+
+CAF_PDM_OBJECT_METHOD_SOURCE_INIT( RimEclipseCase, RimcEclipseCase_replaceCornerPointGridInternal, "replace_corner_point_grid_internal" );
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimcEclipseCase_replaceCornerPointGridInternal::RimcEclipseCase_replaceCornerPointGridInternal( caf::PdmObjectHandle* self )
+    : caf::PdmVoidObjectMethod( self )
+{
+    CAF_PDM_InitObject( "Replace Corner Point Grid Internal", "", "", "Replace Corner Point Grid Internal" );
+
+    CAF_PDM_InitScriptableFieldNoDefault( &m_nx, "Nx", "" );
+    CAF_PDM_InitScriptableFieldNoDefault( &m_ny, "Ny", "" );
+    CAF_PDM_InitScriptableFieldNoDefault( &m_nz, "Nz", "" );
+    CAF_PDM_InitScriptableFieldNoDefault( &m_coordKey, "CoordKey", "" );
+    CAF_PDM_InitScriptableFieldNoDefault( &m_zcornKey, "ZcornKey", "" );
+    CAF_PDM_InitScriptableFieldNoDefault( &m_actnumKey, "ActnumKey", "" );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+std::expected<caf::PdmObjectHandle*, QString> RimcEclipseCase_replaceCornerPointGridInternal::execute()
+{
+    auto eclipseCase = self<RimEclipseCase>();
+    if ( !eclipseCase )
+    {
+        return std::unexpected( "Unable to get Eclipse case." );
+    }
+
+    int nx = m_nx();
+    int ny = m_ny();
+    int nz = m_nz();
+    if ( nx <= 0 || ny <= 0 || nz <= 0 )
+    {
+        return std::unexpected( "Invalid grid dimensions. nx, ny and nz must be positive." );
+    }
+
+    auto keyValueStore = RiaApplication::instance()->keyValueStore();
+
+    std::vector<float> coord  = RiaKeyValueStoreUtil::convertToFloatVector( keyValueStore->get( m_coordKey().toStdString() ) );
+    std::vector<float> zcorn  = RiaKeyValueStoreUtil::convertToFloatVector( keyValueStore->get( m_zcornKey().toStdString() ) );
+    std::vector<float> actnum = RiaKeyValueStoreUtil::convertToFloatVector( keyValueStore->get( m_actnumKey().toStdString() ) );
+
+    if ( coord.empty() || zcorn.empty() || actnum.empty() )
+    {
+        return std::unexpected( "Found unexpected empty coord, zcorn or actnum array." );
+    }
+
+    RimCornerPointCase* cornerPointCase = dynamic_cast<RimCornerPointCase*>( eclipseCase );
+    if ( !cornerPointCase )
+    {
+        return std::unexpected( "Grid is not a corner point case!!!!!" );
+    }
+
+    // Create a new corner point grid from the provided geometry
+    auto result = RimCornerPointCase::replaceGridFromCoordinatesArray( *cornerPointCase, nx, ny, nz, coord, zcorn, actnum );
+    if ( !result.has_value() )
+    {
+        return std::unexpected( "Failed to replace grid" );
+    }
+
+    // Update all 3D views to reflect the new grid
+    // We must completely reinitialize the views because the grid size has changed
+    RiaViewRedrawScheduler::instance()->blockUpdate( true );
+
+    std::vector<Rim3dView*> views = eclipseCase->views();
+    for ( Rim3dView* view : views )
+    {
+        if ( RimEclipseView* eclView = dynamic_cast<RimEclipseView*>( view ) )
+        {
+            // Force complete regeneration by calling loadDataAndUpdate
+            // This will reinitialize all geometry managers with the new grid size
+            eclView->loadDataAndUpdate();
+        }
+    }
+
+    RiaViewRedrawScheduler::instance()->clearViewsScheduledForUpdate();
+    RiaViewRedrawScheduler::instance()->blockUpdate( false );
+
+    // Update connected editors
+    eclipseCase->updateConnectedEditors();
+
+    // Clean up key-value store
+    keyValueStore->remove( m_coordKey().toStdString() );
+    keyValueStore->remove( m_zcornKey().toStdString() );
+    keyValueStore->remove( m_actnumKey().toStdString() );
+
+    return nullptr;
+}

ApplicationLibCode/ProjectDataModelCommands/RimcEclipseCase.h

@@ -80,3 +80,24 @@ class RimcEclipseCase_exportCornerPointGridInternal : public caf::PdmVoidObjectM
     caf::PdmField<QString> m_coordKey;
     caf::PdmField<QString> m_actnumKey;
 };
+
+//==================================================================================================
+///
+//==================================================================================================
+class RimcEclipseCase_replaceCornerPointGridInternal : public caf::PdmVoidObjectMethod
+{
+    CAF_PDM_HEADER_INIT;
+
+public:
+    RimcEclipseCase_replaceCornerPointGridInternal( caf::PdmObjectHandle* self );
+
+    std::expected<caf::PdmObjectHandle*, QString> execute() override;
+
+private:
+    caf::PdmField<int>     m_nx;
+    caf::PdmField<int>     m_ny;
+    caf::PdmField<int>     m_nz;
+    caf::PdmField<QString> m_coordKey;
+    caf::PdmField<QString> m_zcornKey;
+    caf::PdmField<QString> m_actnumKey;
+};

GrpcInterface/Python/rips/case.py

@@ -1435,3 +1435,56 @@ def export_corner_point_grid(
         return (zcorn, coord, actnum, nx, ny, nz)
     else:
         return ([], [], [], 0, 0, 0)
+
+
+@add_method(Case)
+def replace_corner_point_grid(
+    self,
+    nx: int,
+    ny: int,
+    nz: int,
+    coord: List[float],
+    zcorn: List[float],
+    actnum: List[int],
+):
+    """Replace the current case grid with new corner point grid geometry
+
+    This method modifies the geometry of an existing case by replacing it with
+    new grid parameters. All existing properties will be cleared.
+
+    Arguments:
+        nx(int): Number of cells in x direction
+        ny(int): Number of cells in y direction
+        nz(int): Number of cells in z direction
+        coord(list[float]): Coordinate lines as COORD keyword in Eclipse.
+          Each coordinate line is defined by two points (top and bottom).
+          Size: (nx+1) * (ny+1) * 2 * 3. Points are ordered as in Eclipse.
+        zcorn(list[float]): Corner depths as defined by the Eclipse keyword ZCORN.
+          Size: nx * ny * nz * 8
+        actnum(list[int]): Active cell info: cells with values > 0 are active.
+          Size: nx * ny * nz
+    """
+    # Generate unique keys for three arrays
+    coord_key = "{}_{}".format(uuid.uuid4(), "coord")
+    zcorn_key = "{}_{}".format(uuid.uuid4(), "zcorn")
+    actnum_key = "{}_{}".format(uuid.uuid4(), "actnum")
+
+    # Get project to access key-value store
+    project = self.ancestor(rips.project.Project)
+    if not project:
+        raise RuntimeError("Unable to get project from case")
+
+    # Store arrays in key-value store
+    project.set_key_values(coord_key, coord)
+    project.set_key_values(zcorn_key, zcorn)
+    project.set_key_values(actnum_key, actnum)
+
+    # Call internal C++ method to replace the grid
+    self.replace_corner_point_grid_internal(
+        nx=nx,
+        ny=ny,
+        nz=nz,
+        coord_key=coord_key,
+        zcorn_key=zcorn_key,
+        actnum_key=actnum_key,
+    )

GrpcInterface/Python/rips/tests/test_export_corner_point_grid.py

@@ -172,3 +172,119 @@ def test_export_corner_point_grid_roundtrip(rips_instance, initialize_test):
 
             max_diff = max(diff_x, diff_y, diff_z)
             assert max_diff < 1e-3
+
+
+def test_replace_corner_point_grid_basic(rips_instance, initialize_test):
+    """Test the replace_corner_point_grid method by creating a grid and replacing it with a larger one"""
+
+    # Create initial grid with 2x2x2 cells
+    nx_init, ny_init, nz_init = 2, 2, 2
+
+    # Generate simple coordinate data for initial grid
+    coord_init = []
+    for j in range(ny_init + 1):
+        for i in range(nx_init + 1):
+            x = i * 100.0
+            y = j * 100.0
+            # Top point
+            coord_init.extend([x, y, 1000.0])
+            # Bottom point
+            coord_init.extend([x, y, 1100.0])
+
+    # Generate simple ZCORN data for initial grid
+    zcorn_init = []
+    for k in range(nz_init):
+        for j in range(ny_init):
+            for i in range(nx_init):
+                base_depth = 1000.0 + k * 100.0
+                # 8 corner depths for each cell
+                zcorn_init.extend(
+                    [
+                        base_depth,
+                        base_depth,
+                        base_depth,
+                        base_depth,
+                        base_depth + 100.0,
+                        base_depth + 100.0,
+                        base_depth + 100.0,
+                        base_depth + 100.0,
+                    ]
+                )
+
+    # Generate ACTNUM for initial grid (all cells active)
+    actnum_init = [1] * (nx_init * ny_init * nz_init)
+
+    # Create the initial grid case
+    case = rips_instance.project.create_corner_point_grid(
+        "InitialGrid", nx_init, ny_init, nz_init, coord_init, zcorn_init, actnum_init
+    )
+
+    # Verify initial grid dimensions
+    initial_cell_count = case.cell_count()
+    assert initial_cell_count.reservoir_cell_count == nx_init * ny_init * nz_init
+
+    # Now create replacement grid with more cells (3x3x3)
+    nx_new, ny_new, nz_new = 3, 3, 3
+
+    # Generate coordinate data for new grid
+    coord_new = []
+    for j in range(ny_new + 1):
+        for i in range(nx_new + 1):
+            x = i * 100.0
+            y = j * 100.0
+            # Top point
+            coord_new.extend([x, y, 1000.0])
+            # Bottom point
+            coord_new.extend([x, y, 1200.0])
+
+    # Generate ZCORN data for new grid
+    zcorn_new = []
+    for k in range(nz_new):
+        for j in range(ny_new):
+            for i in range(nx_new):
+                base_depth = 1000.0 + k * 100.0
+                # 8 corner depths for each cell
+                zcorn_new.extend(
+                    [
+                        base_depth,
+                        base_depth,
+                        base_depth,
+                        base_depth,
+                        base_depth + 100.0,
+                        base_depth + 100.0,
+                        base_depth + 100.0,
+                        base_depth + 100.0,
+                    ]
+                )
+
+    # Generate ACTNUM for new grid (all cells active)
+    actnum_new = [1] * (nx_new * ny_new * nz_new)
+
+    # Replace the grid geometry
+    case.replace_corner_point_grid(
+        nx_new, ny_new, nz_new, coord_new, zcorn_new, actnum_new
+    )
+
+    # Verify that the grid now has the new dimensions
+    new_cell_count = case.cell_count()
+    assert new_cell_count.reservoir_cell_count == nx_new * ny_new * nz_new
+    assert new_cell_count.reservoir_cell_count == 27  # 3x3x3
+
+    # Verify the grid has more cells than before
+    assert new_cell_count.reservoir_cell_count > initial_cell_count.reservoir_cell_count
+
+    # Export the replaced grid and verify dimensions
+    exported_zcorn, exported_coord, exported_actnum, export_nx, export_ny, export_nz = (
+        case.export_corner_point_grid()
+    )
+
+    # Verify dimensions match
+    assert export_nx == nx_new
+    assert export_ny == ny_new
+    assert export_nz == nz_new
+
+    # Verify array sizes
+    print(exported_actnum)
+    assert len(exported_actnum) == nx_new * ny_new * nz_new
+    # All cells should be active
+    assert sum(1 for x in exported_actnum if x > 0) == len(actnum_new)