#12957 Sector Model Export: add non-uniform cell refinement

ApplicationLibCode/Application/Tools/RiaCellDividingTools.cpp

@@ -32,6 +32,11 @@
 //--------------------------------------------------------------------------------------------------
 std::vector<cvf::Vec3d> splitLine( cvf::Vec3d ptStart, cvf::Vec3d ptEnd, size_t partCount );
 
+//--------------------------------------------------------------------------------------------------
+/// Splits a line using cumulative fractions instead of equal parts
+//--------------------------------------------------------------------------------------------------
+std::vector<cvf::Vec3d> splitLineNonUniform( cvf::Vec3d ptStart, cvf::Vec3d ptEnd, const std::vector<double>& cumulativeFractions );
+
 //--------------------------------------------------------------------------------------------------
 /// Calculates all points on a face described by edge points from all four edges.
 /// The result is a grid of points including the given edge points
@@ -50,6 +55,15 @@ std::vector<std::vector<cvf::Vec3d>> calcFacePoints( const std::vector<cvf::Vec3
                                                      const std::vector<cvf::Vec3d> edgeYPtsLow,
                                                      const std::vector<cvf::Vec3d> edgeYPtsHigh );
 
+//--------------------------------------------------------------------------------------------------
+/// Calculates face points using non-uniform X-direction fractions for interior rows
+//--------------------------------------------------------------------------------------------------
+std::vector<std::vector<cvf::Vec3d>> calcFacePointsNonUniform( const std::vector<cvf::Vec3d>& edgeXPtsLow,
+                                                               const std::vector<cvf::Vec3d>& edgeXPtsHigh,
+                                                               const std::vector<cvf::Vec3d>& edgeYPtsLow,
+                                                               const std::vector<cvf::Vec3d>& edgeYPtsHigh,
+                                                               const std::vector<double>&     xCumulativeFractions );
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -204,3 +218,135 @@ std::vector<std::vector<cvf::Vec3d>> calcFacePoints( const std::vector<cvf::Vec3
     pts.push_back( edgeXPtsHigh );
     return pts;
 }
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+std::vector<cvf::Vec3d> splitLineNonUniform( cvf::Vec3d ptStart, cvf::Vec3d ptEnd, const std::vector<double>& cumulativeFractions )
+{
+    std::vector<cvf::Vec3d> pts = { ptStart };
+
+    for ( size_t i = 0; i < cumulativeFractions.size() - 1; ++i )
+    {
+        double f = cumulativeFractions[i];
+        pts.push_back( cvf::Vec3d( ptStart.x() + ( ptEnd.x() - ptStart.x() ) * f,
+                                   ptStart.y() + ( ptEnd.y() - ptStart.y() ) * f,
+                                   ptStart.z() + ( ptEnd.z() - ptStart.z() ) * f ) );
+    }
+    pts.push_back( ptEnd );
+    return pts;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+std::vector<std::vector<cvf::Vec3d>> calcFacePointsNonUniform( const std::vector<cvf::Vec3d>& edgeXPtsLow,
+                                                               const std::vector<cvf::Vec3d>& edgeXPtsHigh,
+                                                               const std::vector<cvf::Vec3d>& edgeYPtsLow,
+                                                               const std::vector<cvf::Vec3d>& edgeYPtsHigh,
+                                                               const std::vector<double>&     xCumulativeFractions )
+{
+    CVF_ASSERT( edgeYPtsLow.size() == edgeYPtsHigh.size() );
+
+    size_t ySize = edgeYPtsLow.size();
+
+    std::vector<std::vector<cvf::Vec3d>> pts;
+
+    pts.push_back( edgeXPtsLow );
+
+    for ( size_t y = 1; y < ySize - 1; y++ )
+    {
+        auto interiorPts = splitLineNonUniform( edgeYPtsLow[y], edgeYPtsHigh[y], xCumulativeFractions );
+        pts.push_back( interiorPts );
+    }
+
+    pts.push_back( edgeXPtsHigh );
+    return pts;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+std::vector<cvf::Vec3d> RiaCellDividingTools::createHexCornerCoords( const std::array<cvf::Vec3d, 8>& mainCellCorners,
+                                                                     const std::vector<double>&       cumulativeFractionsX,
+                                                                     const std::vector<double>&       cumulativeFractionsY,
+                                                                     const std::vector<double>&       cumulativeFractionsZ )
+{
+    size_t nx = cumulativeFractionsX.size();
+    size_t ny = cumulativeFractionsY.size();
+    size_t nz = cumulativeFractionsZ.size();
+
+    std::array<std::pair<size_t, size_t>, 12> edgeCorners = {
+        std::make_pair( 0, 1 ),
+        std::make_pair( 3, 2 ),
+        std::make_pair( 4, 5 ),
+        std::make_pair( 7, 6 ), // X
+        std::make_pair( 0, 3 ),
+        std::make_pair( 4, 7 ),
+        std::make_pair( 1, 2 ),
+        std::make_pair( 5, 6 ), // Y
+        std::make_pair( 0, 4 ),
+        std::make_pair( 1, 5 ),
+        std::make_pair( 3, 7 ),
+        std::make_pair( 2, 6 ), // Z
+    };
+
+    // Split edges using appropriate cumulative fractions per dimension
+    const std::vector<double>* dimFractions[3] = { &cumulativeFractionsX, &cumulativeFractionsY, &cumulativeFractionsZ };
+
+    std::array<std::vector<cvf::Vec3d>, 12> edgePoints;
+    for ( int i = 0; i < 12; i++ )
+    {
+        int dimIndex = i / 4;
+        edgePoints[i] =
+            splitLineNonUniform( mainCellCorners[edgeCorners[i].first], mainCellCorners[edgeCorners[i].second], *dimFractions[dimIndex] );
+    }
+
+    std::vector<std::vector<std::vector<cvf::Vec3d>>> nodes;
+    nodes.reserve( ( nx + 1 ) * ( ny + 1 ) * ( nz + 1 ) );
+
+    auto xyFacePtsLow  = calcFacePointsNonUniform( edgePoints[0], edgePoints[1], edgePoints[4], edgePoints[6], cumulativeFractionsX );
+    auto xyFacePtsHigh = calcFacePointsNonUniform( edgePoints[2], edgePoints[3], edgePoints[5], edgePoints[7], cumulativeFractionsX );
+    auto yzFacePtsLow  = calcFacePointsNonUniform( edgePoints[4], edgePoints[5], edgePoints[8], edgePoints[10], cumulativeFractionsY );
+    auto yzFacePtsHigh = calcFacePointsNonUniform( edgePoints[6], edgePoints[7], edgePoints[9], edgePoints[11], cumulativeFractionsY );
+    auto xzFacePtsLow  = calcFacePointsNonUniform( edgePoints[0], edgePoints[2], edgePoints[8], edgePoints[9], cumulativeFractionsX );
+    auto xzFacePtsHigh = calcFacePointsNonUniform( edgePoints[1], edgePoints[3], edgePoints[10], edgePoints[11], cumulativeFractionsX );
+
+    nodes.push_back( xyFacePtsLow );
+
+    for ( size_t z = 1; z < nz; z++ )
+    {
+        auto xyFacePoints =
+            calcFacePointsNonUniform( xzFacePtsLow[z], xzFacePtsHigh[z], yzFacePtsLow[z], yzFacePtsHigh[z], cumulativeFractionsX );
+        nodes.push_back( xyFacePoints );
+    }
+
+    nodes.push_back( xyFacePtsHigh );
+
+    std::vector<cvf::Vec3d> coords;
+    coords.reserve( nx * ny * nz * 8 );
+
+    for ( size_t z = 1; z < nz + 1; z++ )
+    {
+        for ( size_t y = 1; y < ny + 1; y++ )
+        {
+            for ( size_t x = 1; x < nx + 1; x++ )
+            {
+                std::array<cvf::Vec3d, 8> cs;
+
+                cs[0] = nodes[z - 1][y - 1][x - 1];
+                cs[1] = nodes[z - 1][y - 1][x];
+                cs[2] = nodes[z - 1][y][x];
+                cs[3] = nodes[z - 1][y][x - 1];
+
+                cs[4] = nodes[z][y - 1][x - 1];
+                cs[5] = nodes[z][y - 1][x];
+                cs[6] = nodes[z][y][x];
+                cs[7] = nodes[z][y][x - 1];
+
+                coords.insert( coords.end(), cs.begin(), cs.end() );
+            }
+        }
+    }
+    return coords;
+}

ApplicationLibCode/Application/Tools/RiaCellDividingTools.h

@@ -31,5 +31,11 @@ class RiaCellDividingTools
 public:
     static std::vector<cvf::Vec3d> createHexCornerCoords( std::array<cvf::Vec3d, 8> mainCellCorners, size_t nx, size_t ny, size_t nz );
 
+    // Non-uniform overload: takes cumulative fractions per dimension instead of integer counts
+    static std::vector<cvf::Vec3d> createHexCornerCoords( const std::array<cvf::Vec3d, 8>& mainCellCorners,
+                                                          const std::vector<double>&       cumulativeFractionsX,
+                                                          const std::vector<double>&       cumulativeFractionsY,
+                                                          const std::vector<double>&       cumulativeFractionsZ );
+
     static double computeFlowDistance( const std::array<cvf::Vec3d, 8>& cellVertices, const cvf::Vec3d& areaCenter );
 };

ApplicationLibCode/Commands/ExportCommands/CMakeLists_files.cmake

@@ -15,6 +15,7 @@ set(SOURCE_GROUP_HEADER_FILES
     ${CMAKE_CURRENT_LIST_DIR}/RicExportEclipseSectorModelUi.h
     ${CMAKE_CURRENT_LIST_DIR}/RicExportSectorModelFeature.h
     ${CMAKE_CURRENT_LIST_DIR}/RicExportSectorModelUi.h
+    ${CMAKE_CURRENT_LIST_DIR}/RicRefinementSettings.h
     ${CMAKE_CURRENT_LIST_DIR}/RicSnapshotAllPlotsToFileFeature.h
     ${CMAKE_CURRENT_LIST_DIR}/RicSnapshotAllViewsToFileFeature.h
     ${CMAKE_CURRENT_LIST_DIR}/RicSnapshotFilenameGenerator.h
@@ -49,6 +50,7 @@ set(SOURCE_GROUP_SOURCE_FILES
     ${CMAKE_CURRENT_LIST_DIR}/RicExportEclipseSectorModelUi.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RicExportSectorModelFeature.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RicExportSectorModelUi.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/RicRefinementSettings.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RicSaveEclipseResultAsInputPropertyExec.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RicSaveEclipseResultAsInputPropertyFeature.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RicSnapshotAllPlotsToFileFeature.cpp

ApplicationLibCode/Commands/ExportCommands/RicExportSectorModelFeature.cpp

@@ -99,7 +99,7 @@ void RicExportSectorModelFeature::doExport( RicExportSectorModelUi* exportSettin
     RigSimulationInputSettings settings;
     settings.setMin( exportSettings->min() );
     settings.setMax( exportSettings->max() );
-    settings.setRefinement( exportSettings->refinement() );
+    settings.setRefinement( exportSettings->effectiveRefinement() );
 
     std::vector<std::string> keywordsToRemove;
     for ( auto& s : exportSettings->keywordsToRemove() )

ApplicationLibCode/Commands/ExportCommands/RicExportSectorModelUi.cpp

@@ -19,6 +19,9 @@
 #include "RicExportSectorModelUi.h"
 
 #include "RiaApplication.h"
+#include "RiaLogging.h"
+
+#include "RicRefinementSettings.h"
 
 #include "RigActiveCellInfo.h"
 #include "RigEclipseCaseData.h"
@@ -89,15 +92,8 @@ RicExportSectorModelUi::RicExportSectorModelUi()
     m_maxJ.setMinValue( 1 );
     m_maxK.setMinValue( 1 );
 
-    CAF_PDM_InitField( &m_refineGrid, "RefineGrid", false, "Enable Grid Refinement" );
-    caf::PdmUiNativeCheckBoxEditor::configureFieldForEditor( &m_refineGrid );
-    CAF_PDM_InitField( &m_refinementCountI, "RefinementCountI", 1, "Cell Count I, J, K" );
-    CAF_PDM_InitField( &m_refinementCountJ, "RefinementCountJ", 1, "" );
-    CAF_PDM_InitField( &m_refinementCountK, "RefinementCountK", 1, "" );
-
-    m_refinementCountI.setRange( 1, 10 );
-    m_refinementCountJ.setRange( 1, 10 );
-    m_refinementCountK.setRange( 1, 10 );
+    CAF_PDM_InitFieldNoDefault( &m_refinementSettings, "RefinementSettings", "" );
+    m_refinementSettings = new RicRefinementSettings();
 
     CAF_PDM_InitFieldNoDefault( &m_bcpropKeywords, "BcpropKeywords", "BCPROP Keywords" );
     m_bcpropKeywords.uiCapability()->setUiEditorTypeName( caf::PdmUiTableViewEditor::uiEditorTypeName() );
@@ -238,16 +234,8 @@ void RicExportSectorModelUi::defineUiOrdering( QString uiConfigName, caf::PdmUiO
     }
     else if ( uiConfigName == m_pageNames[WizardPageEnum::GridRefinement] )
     {
-        uiOrdering.add( &m_refineGrid );
-        uiOrdering.addNewLabel( "" );
-
-        uiOrdering.add( &m_refinementCountI, { .newRow = true, .totalColumnSpan = 2, .leftLabelColumnSpan = 1 } );
-        uiOrdering.appendToRow( &m_refinementCountJ );
-        uiOrdering.appendToRow( &m_refinementCountK );
-
-        m_refinementCountI.uiCapability()->setUiReadOnly( !m_refineGrid() );
-        m_refinementCountJ.uiCapability()->setUiReadOnly( !m_refineGrid() );
-        m_refinementCountK.uiCapability()->setUiReadOnly( !m_refineGrid() );
+        m_refinementSettings->setSectorBounds( min(), max() );
+        m_refinementSettings->addToUiOrdering( uiOrdering );
     }
     else if ( uiConfigName == m_pageNames[WizardPageEnum::BoundaryConditions] )
     {
@@ -461,16 +449,38 @@ void RicExportSectorModelUi::setMax( const caf::VecIjk0& max )
     m_maxK = static_cast<int>( max.z() ) + 1;
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RicRefinementSettings* RicExportSectorModelUi::refinementSettings() const
+{
+    return m_refinementSettings();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+std::unique_ptr<RigRefinement> RicExportSectorModelUi::effectiveRefinement() const
+{
+    m_refinementSettings->setSectorBounds( min(), max() );
+    return m_refinementSettings->effectiveRefinement();
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
 cvf::Vec3st RicExportSectorModelUi::refinement() const
 {
-    if ( !m_refineGrid() )
-    {
-        return cvf::Vec3st( 1, 1, 1 );
-    }
-    return cvf::Vec3st( m_refinementCountI(), m_refinementCountJ(), m_refinementCountK() );
+    m_refinementSettings->setSectorBounds( min(), max() );
+    return m_refinementSettings->refinement();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+bool RicExportSectorModelUi::hasNonUniformRefinement() const
+{
+    return m_refinementSettings->hasNonUniformRefinement();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -560,7 +570,7 @@ void RicExportSectorModelUi::fieldChangedByUi( const caf::PdmFieldHandle* change
     {
         applyBoundaryDefaults();
     }
-    else if ( ( changedField == &m_boundaryCondition ) || ( changedField == &m_refineGrid ) || ( changedField == &m_enablePadding ) )
+    else if ( ( changedField == &m_boundaryCondition ) || ( changedField == &m_enablePadding ) )
     {
         updateConnectedEditors();
     }
@@ -772,17 +782,9 @@ std::map<QString, QString> RicExportSectorModelUi::validate( const QString& conf
     }
     else if ( configName == m_pageNames[WizardPageEnum::GridRefinement] )
     {
-        if ( m_refineGrid() )
-        {
-            for ( auto& field : { &m_refinementCountI, &m_refinementCountJ, &m_refinementCountK } )
-            {
-                auto errStr = field->validate();
-                if ( !errStr.isEmpty() )
-                {
-                    fieldErrors[field->keyword()] = errStr;
-                }
-            }
-        }
+        m_refinementSettings->setSectorBounds( min(), max() );
+        auto refinementErrors = m_refinementSettings->validateSettings();
+        fieldErrors.insert( refinementErrors.begin(), refinementErrors.end() );
     }
     else if ( configName == m_pageNames[WizardPageEnum::BoundaryConditions] )
     {

ApplicationLibCode/Commands/ExportCommands/RicExportSectorModelUi.h

@@ -19,22 +19,26 @@
 #pragma once
 
 #include "cafFilePath.h"
+#include "cafPdmChildField.h"
 #include "cafPdmField.h"
 #include "cafPdmObject.h"
 #include "cafPdmPtrField.h"
 #include "cafVecIjk.h"
 
 #include "RiaModelExportDefines.h"
+#include "RigRefinement.h"
 
 #include <QString>
 #include <QStringList>
 
 #include <map>
+#include <memory>
 
 class RigModelPaddingSettings;
 class RimKeywordBcprop;
 class RimEclipseCase;
 class RimEclipseView;
+class RicRefinementSettings;
 
 //==================================================================================================
 ///
@@ -61,7 +65,11 @@ class RicExportSectorModelUi : public caf::PdmObject
     void         setMin( const caf::VecIjk0& min );
     void         setMax( const caf::VecIjk0& max );
 
-    cvf::Vec3st refinement() const;
+    RicRefinementSettings* refinementSettings() const;
+
+    std::unique_ptr<RigRefinement> effectiveRefinement() const;
+    cvf::Vec3st                    refinement() const;
+    bool                           hasNonUniformRefinement() const;
 
     std::vector<QString> keywordsToRemove() const;
 
@@ -121,10 +129,7 @@ class RicExportSectorModelUi : public caf::PdmObject
     caf::PdmField<int> m_minK;
     caf::PdmField<int> m_maxK;
 
-    caf::PdmField<bool> m_refineGrid;
-    caf::PdmField<int>  m_refinementCountI;
-    caf::PdmField<int>  m_refinementCountJ;
-    caf::PdmField<int>  m_refinementCountK;
+    caf::PdmChildField<RicRefinementSettings*> m_refinementSettings;
 
     caf::PdmField<BoundaryConditionEnum>       m_boundaryCondition;
     caf::PdmChildArrayField<RimKeywordBcprop*> m_bcpropKeywords;