OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

Grow cell size horizontally, too

Browse Source
This commit is contained in:
jonjenssen 2023-11-26 23:51:14 +01:00 committed by Kristian Bendiksen
parent 4bcfcfb668
commit 6421e09557
6 changed files with 97 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationModel.cpp
View File

@ -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" );
gridModelGrp->add( &m_modelThickness );
auto gridModelGrp = modelGrp->addNewGroup( "Grid Definition" );
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 );

5
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationModel.h
View File

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

59
ApplicationLibCode/ReservoirDataModel/RigFaultReactivationModelGenerator.cpp
View File

@ -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,
int noOfCellsHorzFront,
int noOfCellsHorzBack )
double cellSizeFactorHeight,
double minCellWidth,
double cellSizeFactorWidth )
{
m_maxCellHeight = maxCellHeight;
m_cellSizeFactor = cellSizeFactor;
m_noOfCellsHorzFront = noOfCellsHorzFront;
m_noOfCellsHorzBack = noOfCellsHorzBack;
m_maxCellHeight = maxCellHeight;
m_cellSizeHeightFactor = cellSizeFactorHeight;
m_minCellWidth = minCellWidth;
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_noOfCellsHorzFront,
m_cellSizeHeightFactor,
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 );

12
ApplicationLibCode/ReservoirDataModel/RigFaultReactivationModelGenerator.h
View File

@ -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;
int m_noOfCellsHorzFront;
int m_noOfCellsHorzBack;
double m_cellSizeHeightFactor;
double m_minCellWidth;
double m_cellSizeWidthFactor;
cvf::Vec3d m_topReservoirFront;
cvf::Vec3d m_topReservoirBack;

32
ApplicationLibCode/ReservoirDataModel/RigGriddedPart3d.cpp
View File

@ -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 = stepVector( fromPos, toPos, nHorzCells );
cvf::Vec3d stepHorz = toPos - fromPos;
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 step1to2 = stepVector( cornerPoints[1], cornerPoints[2], numHorzCells );
cvf::Vec3d step0to3 = cornerPoints[3] - cornerPoints[0];
cvf::Vec3d step1to2 = cornerPoints[2] - cornerPoints[1];
auto startP = cornerPoints[0];
auto endP = cornerPoints[1];
int numHorzCells = (int)horzPartition.size();
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;
}
}

4
ApplicationLibCode/ReservoirDataModel/RigGriddedPart3d.h
View File

@ -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