Grow cell size horizontally, too

ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationModel.cpp

@@ -79,10 +79,10 @@ RimFaultReactivationModel::RimFaultReactivationModel()
 
     CAF_PDM_InitField( &m_userDescription, "UserDescription", QString( "Model" ), "Name" );
     CAF_PDM_InitFieldNoDefault( &m_geomechCase, "GeoMechCase", "Global GeoMech Model" );
-    CAF_PDM_InitFieldNoDefault( &m_baseDir, "BaseDirectory", "Working folder" );
+    CAF_PDM_InitFieldNoDefault( &m_baseDir, "BaseDirectory", "Working Folder" );
     CAF_PDM_InitField( &m_modelThickness, "ModelThickness", 100.0, "Model Cell Thickness" );
 
-    CAF_PDM_InitField( &m_modelExtentFromAnchor, "ModelExtentFromAnchor", 1000.0, "Horz. Extent from Anchor" );
+    CAF_PDM_InitField( &m_modelExtentFromAnchor, "ModelExtentFromAnchor", 2000.0, "Horz. Extent from Anchor" );
     CAF_PDM_InitField( &m_modelMinZ, "ModelMinZ", 0.0, "Start Depth" );
     CAF_PDM_InitField( &m_modelBelowSize, "ModelBelowSize", 500.0, "Depth Below Fault" );
 
@@ -91,9 +91,9 @@ RimFaultReactivationModel::RimFaultReactivationModel()
     m_startCellIndex = 0;
     m_startCellFace  = cvf::StructGridInterface::FaceType::NO_FACE;
 
-    CAF_PDM_InitField( &m_faultExtendUpwards, "FaultExtendUpwards", 100.0, "Fault Extension Above Reservoir" );
+    CAF_PDM_InitField( &m_faultExtendUpwards, "FaultExtendUpwards", 100.0, "Above Reservoir" );
     m_faultExtendUpwards.uiCapability()->setUiEditorTypeName( caf::PdmUiDoubleSliderEditor::uiEditorTypeName() );
-    CAF_PDM_InitField( &m_faultExtendDownwards, "FaultExtendDownwards", 100.0, "Fault Extension Below Reservoir" );
+    CAF_PDM_InitField( &m_faultExtendDownwards, "FaultExtendDownwards", 100.0, "Below Reservoir" );
     m_faultExtendDownwards.uiCapability()->setUiEditorTypeName( caf::PdmUiDoubleSliderEditor::uiEditorTypeName() );
 
     CAF_PDM_InitField( &m_showModelPlane, "ShowModelPlane", true, "Show 2D Model" );
@@ -104,11 +104,11 @@ RimFaultReactivationModel::RimFaultReactivationModel()
     CAF_PDM_InitField( &m_modelPart1Color, "ModelPart1Color", cvf::Color3f( cvf::Color3f::GREEN ), "Part 1 Color" );
     CAF_PDM_InitField( &m_modelPart2Color, "ModelPart2Color", cvf::Color3f( cvf::Color3f::BLUE ), "Part 2 Color" );
 
-    CAF_PDM_InitField( &m_numberOfCellsHorzPart1, "NumberOfCellsHorzPart1", 20, "Horizontal Number of Cells, Part 1" );
-    CAF_PDM_InitField( &m_numberOfCellsHorzPart2, "NumberOfCellsHorzPart2", 20, "Horizontal Number of Cells, Part 2" );
-
     CAF_PDM_InitField( &m_maxReservoirCellHeight, "MaxReservoirCellHeight", 20.0, "Max. Reservoir Cell Height" );
-    CAF_PDM_InitField( &m_cellHeightGrowFactor, "CellHeightGrowFactor", 1.05, "Cell Height Grow Factor Outside Reservoir" );
+    CAF_PDM_InitField( &m_cellHeightGrowFactor, "CellHeightGrowFactor", 1.05, "Cell Height Grow Factor" );
+
+    CAF_PDM_InitField( &m_minReservoirCellWidth, "MinReservoirCellWidth", 20.0, "Reservoir Cell Width" );
+    CAF_PDM_InitField( &m_cellWidthGrowFactor, "CellWidthGrowFactor", 1.05, "Cell Width Grow Factor" );
 
     CAF_PDM_InitField( &m_useLocalCoordinates, "UseLocalCoordinates", false, "Export Using Local Coordinates" );
 
@@ -314,7 +314,7 @@ void RimFaultReactivationModel::updateVisualization()
     generator->setModelSize( m_modelMinZ, m_modelBelowSize, m_modelExtentFromAnchor );
     generator->setFaultBufferDepth( m_faultExtendUpwards, m_faultExtendDownwards );
     generator->setModelThickness( m_modelThickness );
-    generator->setModelGriddingOptions( m_maxReservoirCellHeight, m_cellHeightGrowFactor, m_numberOfCellsHorzPart1, m_numberOfCellsHorzPart2 );
+    generator->setModelGriddingOptions( m_maxReservoirCellHeight, m_cellHeightGrowFactor, m_minReservoirCellWidth, m_cellWidthGrowFactor );
     generator->setupLocalCoordinateTransform();
     generator->setUseLocalCoordinates( m_useLocalCoordinates );
 
@@ -433,16 +433,23 @@ void RimFaultReactivationModel::defineUiOrdering( QString uiConfigName, caf::Pdm
         m_modelMinZ.uiCapability()->setUiReadOnly( false );
     }
 
-    auto faultGrp = modelGrp->addNewGroup( "Fault" );
+    auto faultGrp = modelGrp->addNewGroup( "Fault Extension" );
     faultGrp->add( &m_faultExtendUpwards );
     faultGrp->add( &m_faultExtendDownwards );
 
-    auto gridModelGrp = modelGrp->addNewGroup( "Grid" );
+    auto gridModelGrp = modelGrp->addNewGroup( "Grid Definition" );
-    gridModelGrp->add( &m_modelThickness );
     gridModelGrp->add( &m_maxReservoirCellHeight );
     gridModelGrp->add( &m_cellHeightGrowFactor );
-    gridModelGrp->add( &m_numberOfCellsHorzPart1 );
+
-    gridModelGrp->add( &m_numberOfCellsHorzPart2 );
+    gridModelGrp->add( &m_minReservoirCellWidth );
+    gridModelGrp->add( &m_cellWidthGrowFactor );
+
+    gridModelGrp->add( &m_modelThickness );
+
+    auto appModelGrp = modelGrp->addNewGroup( "Appearance" );
+    appModelGrp->setCollapsedByDefault();
+    appModelGrp->add( &m_modelPart1Color );
+    appModelGrp->add( &m_modelPart2Color );
 
     auto timeStepGrp = uiOrdering.addNewGroup( "Time Steps" );
     timeStepGrp->add( &m_timeStepFilter );
@@ -456,10 +463,6 @@ void RimFaultReactivationModel::defineUiOrdering( QString uiConfigName, caf::Pdm
     propertiesGrp->add( &m_useGridDensity );
     propertiesGrp->add( &m_useGridElasticProperties );
 
-    auto appModelGrp = modelGrp->addNewGroup( "Appearance" );
-    appModelGrp->add( &m_modelPart1Color );
-    appModelGrp->add( &m_modelPart2Color );
-
     auto trgGroup = uiOrdering.addNewGroup( "Debug" );
     trgGroup->setCollapsedByDefault();
     trgGroup->add( &m_targets );

ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationModel.h

@@ -168,9 +168,8 @@ private:
 
     caf::PdmField<double> m_maxReservoirCellHeight;
     caf::PdmField<double> m_cellHeightGrowFactor;
-
+    caf::PdmField<double> m_minReservoirCellWidth;
-    caf::PdmField<int> m_numberOfCellsHorzPart1;
+    caf::PdmField<double> m_cellWidthGrowFactor;
-    caf::PdmField<int> m_numberOfCellsHorzPart2;
 
     caf::PdmField<bool> m_useLocalCoordinates;
 

ApplicationLibCode/ReservoirDataModel/RigFaultReactivationModelGenerator.cpp

@@ -46,6 +46,10 @@ RigFaultReactivationModelGenerator::RigFaultReactivationModelGenerator( cvf::Vec
     , m_horzExtentFromFault( 1000.0 )
     , m_modelThickness( 100.0 )
     , m_useLocalCoordinates( false )
+    , m_cellSizeHeightFactor( 1.0 )
+    , m_cellSizeWidthFactor( 1.0 )
+    , m_maxCellHeight( 20.0 )
+    , m_minCellWidth( 20.0 )
 {
 }
 
@@ -119,14 +123,14 @@ void RigFaultReactivationModelGenerator::setUseLocalCoordinates( bool useLocalCo
 ///
 //--------------------------------------------------------------------------------------------------
 void RigFaultReactivationModelGenerator::setModelGriddingOptions( double maxCellHeight,
-                                                                  double cellSizeFactor,
+                                                                  double cellSizeFactorHeight,
-                                                                  int    noOfCellsHorzFront,
+                                                                  double minCellWidth,
-                                                                  int    noOfCellsHorzBack )
+                                                                  double cellSizeFactorWidth )
 {
-    m_maxCellHeight      = maxCellHeight;
+    m_maxCellHeight        = maxCellHeight;
-    m_cellSizeFactor     = cellSizeFactor;
+    m_cellSizeHeightFactor = cellSizeFactorHeight;
-    m_noOfCellsHorzFront = noOfCellsHorzFront;
+    m_minCellWidth         = minCellWidth;
-    m_noOfCellsHorzBack  = noOfCellsHorzBack;
+    m_cellSizeWidthFactor  = cellSizeFactorWidth;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -330,6 +334,35 @@ void RigFaultReactivationModelGenerator::generatePointsFrontBack()
         m_frontPoints[i] = points[frontMap[i]];
         m_backPoints[i]  = points[backMap[i]];
     }
+
+    m_horizontalPartition = partition( m_startPosition.pointDistance( edge_front ), m_minCellWidth, m_cellSizeWidthFactor );
+    // we start gridding from the far edges of the model, reverse the partition
+    std::reverse( m_horizontalPartition.begin(), m_horizontalPartition.end() );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+const std::vector<double> RigFaultReactivationModelGenerator::partition( double distance, double startSize, double sizeFactor )
+{
+    std::vector<double> parts;
+
+    double d    = 0;
+    double step = startSize;
+
+    while ( d < distance )
+    {
+        parts.push_back( d / distance );
+        d += step;
+        step *= sizeFactor;
+    }
+
+    // get rid of outermost cell column if too small
+    if ( distance * ( 1.0 - parts.back() ) < startSize ) parts.pop_back();
+
+    parts.push_back( 1.0 );
+
+    return parts;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -442,10 +475,16 @@ void RigFaultReactivationModelGenerator::generateGeometry( size_t
                                  frontReservoirLayers,
                                  kLayersFront,
                                  m_maxCellHeight,
-                                 m_cellSizeFactor,
+                                 m_cellSizeHeightFactor,
-                                 m_noOfCellsHorzFront,
+                                 m_horizontalPartition,
                                  m_modelThickness );
-    backPart->generateGeometry( m_backPoints, backReservoirLayers, kLayersBack, m_maxCellHeight, m_cellSizeFactor, m_noOfCellsHorzBack, m_modelThickness );
+    backPart->generateGeometry( m_backPoints,
+                                backReservoirLayers,
+                                kLayersBack,
+                                m_maxCellHeight,
+                                m_cellSizeHeightFactor,
+                                m_horizontalPartition,
+                                m_modelThickness );
 
     frontPart->generateLocalNodes( m_localCoordTransform );
     backPart->generateLocalNodes( m_localCoordTransform );

ApplicationLibCode/ReservoirDataModel/RigFaultReactivationModelGenerator.h

@@ -46,7 +46,7 @@ public:
     void setFaultBufferDepth( double aboveFault, double belowFault );
     void setModelSize( double startDepth, double depthBelowFault, double horzExtentFromFault );
     void setModelThickness( double thickness );
-    void setModelGriddingOptions( double maxCellHeight, double cellSizeFactor, int noOfCellsHorzFront, int noOfCellsHorzBack );
+    void setModelGriddingOptions( double maxCellHeight, double cellSizeFactorHeight, double minCellWidth, double cellSizeFactorWidth );
 
     void setUseLocalCoordinates( bool useLocalCoordinates );
     void setupLocalCoordinateTransform();
@@ -66,6 +66,7 @@ public:
 protected:
     static const std::array<int, 4>      faceIJCornerIndexes( cvf::StructGridInterface::FaceType face );
     static const std::vector<cvf::Vec3d> interpolateExtraPoints( cvf::Vec3d from, cvf::Vec3d to, double maxStep );
+    static const std::vector<double>     partition( double distance, double startSize, double sizeFactor );
 
     static cvf::Vec3d lineIntersect( const cvf::Plane& plane, cvf::Vec3d lineA, cvf::Vec3d lineB );
     static cvf::Vec3d extrapolatePoint( cvf::Vec3d startPoint, cvf::Vec3d endPoint, double stopDepth );
@@ -85,6 +86,8 @@ private:
     std::array<cvf::Vec3d, 12> m_frontPoints;
     std::array<cvf::Vec3d, 12> m_backPoints;
 
+    std::vector<double> m_horizontalPartition;
+
     cvf::cref<RigFault>          m_fault;
     cvf::cref<RigMainGrid>       m_grid;
     cvf::cref<RigActiveCellInfo> m_activeCellInfo;
@@ -98,10 +101,9 @@ private:
     double m_modelThickness;
 
     double m_maxCellHeight;
-    double m_cellSizeFactor;
+    double m_cellSizeHeightFactor;
-
+    double m_minCellWidth;
-    int m_noOfCellsHorzFront;
+    double m_cellSizeWidthFactor;
-    int m_noOfCellsHorzBack;
 
     cvf::Vec3d m_topReservoirFront;
     cvf::Vec3d m_topReservoirBack;

ApplicationLibCode/ReservoirDataModel/RigGriddedPart3d.cpp

@@ -192,7 +192,7 @@ void RigGriddedPart3d::generateGeometry( const std::array<cvf::Vec3d, 12>& input
                                          const std::vector<int>&           kLayers,
                                          const double                      maxCellHeight,
                                          double                            cellSizeFactor,
-                                         int                               nHorzCells,
+                                         const std::vector<double>&        horizontalPartition,
                                          double                            modelThickness )
 {
     reset();
@@ -206,6 +206,7 @@ void RigGriddedPart3d::generateGeometry( const std::array<cvf::Vec3d, 12>& input
     layersPerRegion[Regions::UpperOverburden] = generateGrowingLayers( inputPoints[4].z(), inputPoints[5].z(), maxCellHeight, cellSizeFactor );
 
     size_t nVertCells = 0;
+    size_t nHorzCells = horizontalPartition.size() - 1;
 
     for ( auto region : allRegions() )
     {
@@ -214,7 +215,7 @@ void RigGriddedPart3d::generateGeometry( const std::array<cvf::Vec3d, 12>& input
 
     const std::vector<double> m_thicknessFactors = { -1.0, 0.0, 1.0 };
     const int                 nThicknessCells    = 2;
-    cvf::Vec3d                tVec               = stepVector( inputPoints[0], inputPoints[6], nHorzCells ) ^ cvf::Vec3d::Z_AXIS;
+    cvf::Vec3d                tVec               = stepVector( inputPoints[0], inputPoints[6], 1 ) ^ cvf::Vec3d::Z_AXIS;
     tVec.normalize();
     tVec *= modelThickness;
 
@@ -274,13 +275,15 @@ void RigGriddedPart3d::generateGeometry( const std::array<cvf::Vec3d, 12>& input
                 toPos.z()   = layersPerRegion[region][v];
             }
 
-            cvf::Vec3d p        = fromPos;
+            cvf::Vec3d stepHorz = toPos - fromPos;
-            cvf::Vec3d stepHorz = stepVector( fromPos, toPos, nHorzCells );
+            cvf::Vec3d p;
 
             m_meshLines.push_back( { fromPos, toPos } );
 
             for ( int h = 0; h <= nHorzCells; h++ )
             {
+                p = toPos - horizontalPartition[h] * stepHorz;
+
                 for ( int t = 0; t <= nThicknessCells; t++, nodeIndex++ )
                 {
                     m_nodes.push_back( p + m_thicknessFactors[t] * tVec );
@@ -293,8 +296,6 @@ void RigGriddedPart3d::generateGeometry( const std::array<cvf::Vec3d, 12>& input
                         m_boundaryNodes[Boundary::FarSide].push_back( nodeIndex );
                     }
                 }
-
-                p += stepHorz;
             }
 
             if ( region == Regions::Reservoir )
@@ -343,7 +344,7 @@ void RigGriddedPart3d::generateGeometry( const std::array<cvf::Vec3d, 12>& input
     RimFaultReactivation::BorderSurface currentSurfaceRegion = RimFaultReactivation::BorderSurface::LowerSurface;
     RimFaultReactivation::ElementSets   currentElementSet    = RimFaultReactivation::ElementSets::UnderBurden;
 
-    const int nextLayerIdxOff = ( nHorzCells + 1 ) * ( nThicknessCells + 1 );
+    const int nextLayerIdxOff = ( (int)nHorzCells + 1 ) * ( nThicknessCells + 1 );
     const int nThicknessOff   = nThicknessCells + 1;
 
     for ( int v = 0; v < (int)nVertCells - 1; v++, layer++ )
@@ -415,7 +416,7 @@ void RigGriddedPart3d::generateGeometry( const std::array<cvf::Vec3d, 12>& input
     // vertical mesh lines for 2d display
     for ( int i = 0; i < 5; i++ )
     {
-        generateVerticalMeshlines( { inputPoints[i], inputPoints[i + 1], inputPoints[i + 7], inputPoints[i + 6] }, nHorzCells );
+        generateVerticalMeshlines( { inputPoints[i], inputPoints[i + 1], inputPoints[i + 7], inputPoints[i + 6] }, horizontalPartition );
     }
 }
 
@@ -432,19 +433,18 @@ void RigGriddedPart3d::generateGeometry( const std::array<cvf::Vec3d, 12>& input
 ///
 /// Assumes 0->3 and 1->2 is parallel
 //--------------------------------------------------------------------------------------------------
-void RigGriddedPart3d::generateVerticalMeshlines( const std::vector<cvf::Vec3d>& cornerPoints, int numHorzCells )
+void RigGriddedPart3d::generateVerticalMeshlines( const std::vector<cvf::Vec3d>& cornerPoints, const std::vector<double>& horzPartition )
 {
-    cvf::Vec3d step0to3 = stepVector( cornerPoints[0], cornerPoints[3], numHorzCells );
+    cvf::Vec3d step0to3 = cornerPoints[3] - cornerPoints[0];
-    cvf::Vec3d step1to2 = stepVector( cornerPoints[1], cornerPoints[2], numHorzCells );
+    cvf::Vec3d step1to2 = cornerPoints[2] - cornerPoints[1];
 
-    auto startP = cornerPoints[0];
+    int numHorzCells = (int)horzPartition.size();
-    auto endP   = cornerPoints[1];
 
-    for ( int h = 0; h <= numHorzCells; h++ )
+    for ( int h = 0; h < numHorzCells; h++ )
     {
+        auto startP = cornerPoints[3] - horzPartition[h] * step0to3;
+        auto endP   = cornerPoints[2] - horzPartition[h] * step1to2;
         m_meshLines.push_back( { startP, endP } );
-        startP += step0to3;
-        endP += step1to2;
     }
 }
 

ApplicationLibCode/ReservoirDataModel/RigGriddedPart3d.h

@@ -48,7 +48,7 @@ public:
                            const std::vector<int>&           kLayers,
                            double                            maxCellHeight,
                            double                            cellSizeFactor,
-                           int                               nHorzCells,
+                           const std::vector<double>&        horizontalPartition,
                            double                            modelThickness );
 
     void generateLocalNodes( const cvf::Mat4d transform );
@@ -74,7 +74,7 @@ protected:
     static std::vector<double> generateGrowingLayers( double zFrom, double zTo, double maxSize, double growfactor );
     static std::vector<double> extractZValues( std::vector<cvf::Vec3d> );
 
-    void generateVerticalMeshlines( const std::vector<cvf::Vec3d>& cornerPoints, int numHorzCells );
+    void generateVerticalMeshlines( const std::vector<cvf::Vec3d>& cornerPoints, const std::vector<double>& horzPartition );
 
 private:
     enum class Regions