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

Fault Reactivation: Update element sets (#11191)

Browse Source 
* Update element sets based on active cells
* Bonus: Fix viewer crash
This commit is contained in:
jonjenssen 2024-02-12 14:52:15 +01:00 committed by GitHub
parent fa8d8e3d05
commit 336dc575db
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
5 changed files with 139 additions and 205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
ApplicationLibCode/ReservoirDataModel/RigFaultReactivationModelGenerator.cpp
View File

@ -361,33 +361,6 @@ const std::vector<double> RigFaultReactivationModelGenerator::partition( double
return parts;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<int> RigFaultReactivationModelGenerator::elementKLayers( const std::vector<size_t>& cellIndexColumn )
{
std::vector<int> kLayers;
size_t i, j, k;
for ( auto idx : cellIndexColumn )
{
m_grid->ijkFromCellIndexUnguarded( idx, &i, &j, &k );
if ( m_activeCellInfo->isActive( idx ) )
{
kLayers.push_back( (int)k );
}
else
{
kLayers.push_back( -1 * (int)k );
}
}
std::reverse( kLayers.begin(), kLayers.end() );
return kLayers;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -543,11 +516,6 @@ void RigFaultReactivationModelGenerator::generateGeometry( size_t sta
std::map<double, cvf::Vec3d> layersFront;
std::vector<size_t> cellColumnFront = buildCellColumn( oppositeStartCellIdx, oppositeStartFace, layersFront );
// identify k layers used to classify reservoir/inter-reservoir
auto kLayersBack = elementKLayers( cellColumnBack );
auto kLayersFront = elementKLayers( cellColumnFront );
// add extra fault buffer below the fault, starting at the deepest bottom-most cell on either side of the fault
double front_bottom = layersFront.begin()->first;
@ -588,11 +556,11 @@ void RigFaultReactivationModelGenerator::generateGeometry( size_t sta
// make sure layers aren't too small or too thick
mergeTinyLayers( layersFront, kLayersFront, m_minCellHeight );
mergeTinyLayers( layersBack, kLayersBack, m_minCellHeight );
mergeTinyLayers( layersFront, m_minCellHeight );
mergeTinyLayers( layersBack, m_minCellHeight );
splitLargeLayers( layersFront, kLayersFront, m_maxCellHeight );
splitLargeLayers( layersBack, kLayersBack, m_maxCellHeight );
splitLargeLayers( layersFront, m_maxCellHeight );
splitLargeLayers( layersBack, m_maxCellHeight );
std::vector<cvf::Vec3d> frontReservoirLayers;
for ( auto& kvp : layersFront )
@ -608,7 +576,6 @@ void RigFaultReactivationModelGenerator::generateGeometry( size_t sta
frontPart->generateGeometry( m_frontPoints,
frontReservoirLayers,
kLayersFront,
m_maxCellHeight,
m_cellSizeHeightFactor,
m_horizontalPartition,
@ -618,7 +585,6 @@ void RigFaultReactivationModelGenerator::generateGeometry( size_t sta
m_faultZoneCells );
backPart->generateGeometry( m_backPoints,
backReservoirLayers,
kLayersBack,
m_maxCellHeight,
m_cellSizeHeightFactor,
m_horizontalPartition,
@ -674,9 +640,8 @@ cvf::Vec3d RigFaultReactivationModelGenerator::extrapolatePoint( cvf::Vec3d star
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigFaultReactivationModelGenerator::mergeTinyLayers( std::map<double, cvf::Vec3d>& layers, std::vector<int>& kLayers, double minHeight )
void RigFaultReactivationModelGenerator::mergeTinyLayers( std::map<double, cvf::Vec3d>& layers, double minHeight )
{
std::vector<int> newKLayers;
std::vector<cvf::Vec3d> newLayers;
const int nLayers = (int)layers.size();
@ -692,7 +657,6 @@ void RigFaultReactivationModelGenerator::mergeTinyLayers( std::map<double, cvf::
// bottom layer must always be included
newLayers.push_back( vals.front() );
newKLayers.push_back( kLayers.front() );
// remove any layer that is less than minHeight above the previous layer, starting at the bottom
for ( int k = 1; k < nLayers - 1; k++ )
@ -701,7 +665,6 @@ void RigFaultReactivationModelGenerator::mergeTinyLayers( std::map<double, cvf::
{
continue;
}
newKLayers.push_back( kLayers[k] );
newLayers.push_back( vals[k] );
}
// top layer must always be included
@ -713,7 +676,6 @@ void RigFaultReactivationModelGenerator::mergeTinyLayers( std::map<double, cvf::
{
if ( std::abs( newLayers[nNewLayers - 1].z() - newLayers[nNewLayers - 2].z() ) < minHeight )
{
newKLayers.pop_back();
newLayers.pop_back();
newLayers.pop_back();
newLayers.push_back( vals.back() );
@ -725,25 +687,16 @@ void RigFaultReactivationModelGenerator::mergeTinyLayers( std::map<double, cvf::
{
layers[p.z()] = p;
}
kLayers.clear();
for ( auto k : newKLayers )
{
kLayers.push_back( k );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigFaultReactivationModelGenerator::splitLargeLayers( std::map<double, cvf::Vec3d>& layers, std::vector<int>& kLayers, double maxHeight )
void RigFaultReactivationModelGenerator::splitLargeLayers( std::map<double, cvf::Vec3d>& layers, double maxHeight )
{
std::vector<cvf::Vec3d> additionalPoints;
std::vector<int> newKLayers;
const int nLayers = (int)layers.size();
const int nKLayers = (int)kLayers.size();
const int nLayers = (int)layers.size();
std::vector<double> keys;
std::vector<cvf::Vec3d> vals;
@ -764,23 +717,15 @@ void RigFaultReactivationModelGenerator::splitLargeLayers( std::map<double, cvf:
for ( auto& p : points )
{
additionalPoints.push_back( p );
newKLayers.push_back( kLayers[k - 1] );
}
}
}
if ( k < nKLayers ) newKLayers.push_back( kLayers[k] );
}
for ( auto& p : additionalPoints )
{
layers[p.z()] = p;
}
kLayers.clear();
for ( auto k : newKLayers )
{
kLayers.push_back( k );
}
}
//--------------------------------------------------------------------------------------------------

6
ApplicationLibCode/ReservoirDataModel/RigFaultReactivationModelGenerator.h
View File

@ -75,10 +75,8 @@ protected:
static std::pair<FaceType, FaceType> sideFacesIJ( FaceType face );
static cvf::Vec3d extrapolatePoint( cvf::Vec3d startPoint, cvf::Vec3d endPoint, double stopDepth );
static void splitLargeLayers( std::map<double, cvf::Vec3d>& layers, std::vector<int>& kLayers, double maxHeight );
static void mergeTinyLayers( std::map<double, cvf::Vec3d>& layers, std::vector<int>& kLayers, double minHeight );
std::vector<int> elementKLayers( const std::vector<size_t>& cellIndexColumn );
static void splitLargeLayers( std::map<double, cvf::Vec3d>& layers, double maxHeight );
static void mergeTinyLayers( std::map<double, cvf::Vec3d>& layers, double minHeight );
std::vector<size_t> buildCellColumn( size_t startCell, FaceType startFace, std::map<double, cvf::Vec3d>& layers );

225
ApplicationLibCode/ReservoirDataModel/RigGriddedPart3d.cpp
View File

@ -37,6 +37,8 @@ RigGriddedPart3d::RigGriddedPart3d()
: m_useLocalCoordinates( false )
, m_topHeight( 0.0 )
, m_faultSafetyDistance( 1.0 )
, m_nVertElements( 0 )
, m_nHorzElements( 0 )
{
}
@ -61,8 +63,9 @@ void RigGriddedPart3d::reset()
m_elementIndices.clear();
m_meshLines.clear();
m_elementSets.clear();
m_elementKLayer.clear();
m_elementLayers.clear();
m_nVertElements = 0;
m_nHorzElements = 0;
m_topHeight = 0.0;
}
//--------------------------------------------------------------------------------------------------
@ -174,37 +177,6 @@ std::vector<double> RigGriddedPart3d::extractZValues( std::vector<cvf::Vec3d> po
return layers;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigGriddedPart3d::updateReservoirElementLayers( const std::vector<cvf::Vec3d>& reservoirLayers, const std::vector<int>& kLayers )
{
const int nLayers = (int)reservoirLayers.size();
if ( nLayers < 2 ) return;
int prevLayer = kLayers[0];
double start = reservoirLayers[0].z();
for ( int l = 1; l < nLayers; l++ )
{
auto currentZone = ( prevLayer >= 0 ) ? ElementSets::Reservoir : ElementSets::IntraReservoir;
if ( l == nLayers - 1 )
{
m_elementLayers[currentZone].push_back( std::make_pair( start, reservoirLayers[l].z() ) );
continue;
}
if ( ( ( prevLayer < 0 ) && ( kLayers[l] >= 0 ) ) || ( ( prevLayer >= 0 ) && ( kLayers[l] < 0 ) ) )
{
m_elementLayers[currentZone].push_back( std::make_pair( start, reservoirLayers[l].z() ) );
start = reservoirLayers[l].z();
}
prevLayer = kLayers[l];
}
}
//--------------------------------------------------------------------------------------------------
/// Point index in input
///
@ -226,11 +198,9 @@ void RigGriddedPart3d::updateReservoirElementLayers( const std::vector<cvf::Vec3
///
/// Assumes horizontal lines are parallel
///
///
//--------------------------------------------------------------------------------------------------
void RigGriddedPart3d::generateGeometry( const std::array<cvf::Vec3d, 12>& inputPoints,
const std::vector<cvf::Vec3d>& reservoirLayers,
const std::vector<int>& kLayers,
const double maxCellHeight,
double cellSizeFactor,
const std::vector<double>& horizontalPartition,
@ -254,17 +224,12 @@ void RigGriddedPart3d::generateGeometry( const std::array<cvf::Vec3d, 12>& input
layersPerRegion[Regions::LowerUnderburden].pop_back(); // to avoid overlap with bottom of next region
layersPerRegion[Regions::Reservoir].pop_back(); // to avoid overlap with bottom of next region
m_elementLayers[ElementSets::OverBurden] = { std::make_pair( inputPoints[3].z(), inputPoints[5].z() ) };
m_elementLayers[ElementSets::UnderBurden] = { std::make_pair( inputPoints[0].z(), inputPoints[2].z() ) };
m_boundaryNodes[Boundary::Bottom] = {};
m_boundaryNodes[Boundary::FarSide] = {};
m_boundaryNodes[Boundary::Fault] = {};
updateReservoirElementLayers( reservoirLayers, kLayers );
size_t nVertCells = 0;
size_t nHorzCells = horizontalPartition.size() - 1;
size_t nVertCells = 0;
const size_t nHorzCells = horizontalPartition.size() - 1;
for ( auto region : allRegions() )
{
@ -279,6 +244,9 @@ void RigGriddedPart3d::generateGeometry( const std::array<cvf::Vec3d, 12>& input
m_nodes.reserve( reserveSize );
m_dataNodes.reserve( reserveSize );
m_nHorzElements = (int)nHorzCells;
m_nVertElements = (int)nVertCells - 1;
unsigned int nodeIndex = 0;
unsigned int layer = 0;
@ -389,7 +357,6 @@ void RigGriddedPart3d::generateGeometry( const std::array<cvf::Vec3d, 12>& input
// ** generate elements of type hex8
m_elementIndices.resize( (size_t)( ( nVertCells - 1 ) * nHorzCells * nThicknessCells ) );
m_elementKLayer.resize( (size_t)( ( nVertCells - 1 ) * nHorzCells * nThicknessCells ) );
m_borderSurfaceElements[RimFaultReactivation::BorderSurface::Seabed] = {};
m_borderSurfaceElements[RimFaultReactivation::BorderSurface::UpperSurface] = {};
@ -409,18 +376,12 @@ void RigGriddedPart3d::generateGeometry( const std::array<cvf::Vec3d, 12>& input
int layerIndexOffset = 0;
int elementIdx = 0;
layer = 0;
int kLayer = 0;
const int nVertCellsLower = (int)layersPerRegion[Regions::LowerUnderburden].size();
const int nVertCellsFault = (int)( layersPerRegion[Regions::UpperUnderburden].size() + layersPerRegion[Regions::Reservoir].size() +
layersPerRegion[Regions::LowerOverburden].size() );
const int nVertCellsUnderburden =
(int)( layersPerRegion[Regions::LowerUnderburden].size() + layersPerRegion[Regions::UpperUnderburden].size() );
const int nVertCellsReservoir = nVertCellsUnderburden + (int)( layersPerRegion[Regions::Reservoir].size() );
RimFaultReactivation::BorderSurface currentSurfaceRegion = RimFaultReactivation::BorderSurface::LowerSurface;
RimFaultReactivation::ElementSets currentElementSet = RimFaultReactivation::ElementSets::UnderBurden;
const int nextLayerIdxOff = ( (int)nHorzCells + 1 ) * ( nThicknessCells + 1 );
const int nThicknessOff = nThicknessCells + 1;
@ -433,9 +394,6 @@ void RigGriddedPart3d::generateGeometry( const std::array<cvf::Vec3d, 12>& input
if ( v >= nVertCellsLower ) currentSurfaceRegion = RimFaultReactivation::BorderSurface::FaultSurface;
if ( v >= nVertCellsLower + nVertCellsFault ) currentSurfaceRegion = RimFaultReactivation::BorderSurface::UpperSurface;
if ( v >= nVertCellsUnderburden ) currentElementSet = RimFaultReactivation::ElementSets::Reservoir;
if ( v >= nVertCellsReservoir ) currentElementSet = RimFaultReactivation::ElementSets::OverBurden;
int i = layerIndexOffset;
for ( int h = 0; h < (int)nHorzCells; h++ )
@ -468,27 +426,6 @@ void RigGriddedPart3d::generateGeometry( const std::array<cvf::Vec3d, 12>& input
bool inFaultZone = ( currentSurfaceRegion == RimFaultReactivation::BorderSurface::FaultSurface ) && ( h > nFaultZoneStart );
if ( inFaultZone ) m_elementSets[RimFaultReactivation::ElementSets::FaultZone].push_back( elementIdx );
if ( currentElementSet == RimFaultReactivation::ElementSets::Reservoir )
{
m_elementKLayer[elementIdx] = kLayers[kLayer];
if ( !inFaultZone )
{
if ( kLayers[kLayer] < 0 )
{
m_elementSets[RimFaultReactivation::ElementSets::IntraReservoir].push_back( elementIdx );
}
else
{
m_elementSets[currentElementSet].push_back( elementIdx );
}
}
}
else
{
if ( !inFaultZone ) m_elementSets[currentElementSet].push_back( elementIdx );
m_elementKLayer[elementIdx] = -2000;
}
}
i += nThicknessOff;
}
@ -497,11 +434,6 @@ void RigGriddedPart3d::generateGeometry( const std::array<cvf::Vec3d, 12>& input
m_borderSurfaceElements[currentSurfaceRegion].push_back( elementIdx - 2 );
m_borderSurfaceElements[currentSurfaceRegion].push_back( elementIdx - 1 );
if ( currentElementSet == RimFaultReactivation::ElementSets::Reservoir )
{
kLayer++;
}
layerIndexOffset += nextLayerIdxOff;
}
@ -628,7 +560,7 @@ const std::vector<std::vector<unsigned int>>& RigGriddedPart3d::elementIndices()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<cvf::Vec3d> RigGriddedPart3d::elementCorners( size_t elementIndex ) const
const std::vector<cvf::Vec3d> RigGriddedPart3d::elementCorners( size_t elementIndex ) const
{
return extractCornersForElement( m_elementIndices, m_nodes, elementIndex );
}
@ -636,11 +568,19 @@ std::vector<cvf::Vec3d> RigGriddedPart3d::elementCorners( size_t elementIndex )
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<cvf::Vec3d> RigGriddedPart3d::elementDataCorners( size_t elementIndex ) const
const std::vector<cvf::Vec3d> RigGriddedPart3d::elementDataCorners( size_t elementIndex ) const
{
return extractCornersForElement( m_elementIndices, m_dataNodes, elementIndex );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::pair<int, int> RigGriddedPart3d::elementCountHorzVert() const
{
return { m_nHorzElements, m_nVertElements };
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -677,23 +617,6 @@ const std::vector<std::vector<cvf::Vec3d>>& RigGriddedPart3d::meshLines() const
return m_meshLines;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<int> RigGriddedPart3d::elementKLayer() const
{
return m_elementKLayer;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<std::pair<double, double>> RigGriddedPart3d::layers( RigGriddedPart3d::ElementSets elementSet ) const
{
if ( m_elementLayers.count( elementSet ) == 0 ) return {};
return m_elementLayers.at( elementSet );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -739,52 +662,108 @@ void RigGriddedPart3d::generateLocalNodes( const cvf::Mat4d transform )
}
//--------------------------------------------------------------------------------------------------
/// Make sure any active cells outside the flat reservoir zone is added to the reservoir element set
///
//--------------------------------------------------------------------------------------------------
void RigGriddedPart3d::postProcessElementSets( const RigMainGrid* mainGrid, const RigActiveCellInfo* cellInfo )
{
std::map<ElementSets, std::vector<unsigned int>> newElementSets;
std::set<unsigned int> usedElements;
for ( auto elSet : { ElementSets::OverBurden, ElementSets::UnderBurden, ElementSets::IntraReservoir } )
// fault zone elements are already assigned
for ( auto elIdx : m_elementSets[ElementSets::FaultZone] )
{
newElementSets[elSet] = {};
usedElements.insert( elIdx );
}
for ( auto element : m_elementSets[elSet] )
// look for overburden, starting at top going down
updateElementSet( ElementSets::OverBurden, usedElements, mainGrid, cellInfo, m_nVertElements - 1, -1, -1 );
// look for underburden, starting at bottom going up
updateElementSet( ElementSets::UnderBurden, usedElements, mainGrid, cellInfo, 0, m_nVertElements, 1 );
// remaining elements are in the reservoir
m_elementSets[ElementSets::IntraReservoir] = {};
m_elementSets[ElementSets::Reservoir] = {};
for ( unsigned int element = 0; element < m_elementIndices.size(); element++ )
{
if ( usedElements.contains( element ) ) continue;
auto corners = elementCorners( element );
bool bActive = false;
size_t cellIdx = 0;
for ( const auto& p : corners )
{
auto corners = elementCorners( element );
int nFound = 0;
cellIdx = mainGrid->findReservoirCellIndexFromPoint( p );
size_t cellIdx = 0;
for ( const auto& p : corners )
bActive = ( cellIdx != cvf::UNDEFINED_SIZE_T ) && ( cellInfo->isActive( cellIdx ) );
if ( bActive ) break;
}
if ( bActive )
{
m_elementSets[ElementSets::Reservoir].push_back( element );
}
else
{
m_elementSets[ElementSets::IntraReservoir].push_back( element );
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigGriddedPart3d::updateElementSet( ElementSets elSet,
std::set<unsigned int>& usedElements,
const RigMainGrid* mainGrid,
const RigActiveCellInfo* cellInfo,
int rowStart,
int rowEnd,
int rowInc )
{
for ( int col = 0; col < m_nHorzElements; col++ )
{
for ( int row = rowStart; row != rowEnd; row += rowInc )
{
const unsigned int elIdx = (unsigned int)( 2 * ( ( row * m_nHorzElements ) + col ) );
bool bStop = false;
for ( unsigned int t = 0; t < 2; t++ )
{
cellIdx = mainGrid->findReservoirCellIndexFromPoint( p );
if ( cellIdx != cvf::UNDEFINED_SIZE_T )
if ( usedElements.contains( elIdx + t ) )
{
if ( cellInfo->isActive( cellIdx ) )
bStop = true;
break;
}
auto corners = elementCorners( elIdx + t );
size_t cellIdx = 0;
for ( const auto& p : corners )
{
cellIdx = mainGrid->findReservoirCellIndexFromPoint( p );
if ( ( cellIdx != cvf::UNDEFINED_SIZE_T ) && ( cellInfo->isActive( cellIdx ) ) )
{
nFound++;
bStop = true;
break;
}
}
}
if ( nFound > 0 )
if ( bStop )
{
m_elementSets[ElementSets::Reservoir].push_back( element );
break;
}
else
{
newElementSets[elSet].push_back( element );
m_elementSets[elSet].push_back( elIdx );
m_elementSets[elSet].push_back( elIdx + 1 );
usedElements.insert( elIdx );
usedElements.insert( elIdx + 1 );
}
}
}
for ( auto elSet : { ElementSets::OverBurden, ElementSets::UnderBurden, ElementSets::IntraReservoir } )
{
m_elementSets[elSet].clear();
for ( auto element : newElementSets[elSet] )
{
m_elementSets[elSet].push_back( element );
}
}
}

23
ApplicationLibCode/ReservoirDataModel/RigGriddedPart3d.h
View File

@ -26,6 +26,7 @@
#include <array>
#include <map>
#include <set>
#include <vector>
class RigMainGrid;
@ -48,7 +49,6 @@ public:
void generateGeometry( const std::array<cvf::Vec3d, 12>& inputPoints,
const std::vector<cvf::Vec3d>& reservoirLayers,
const std::vector<int>& kLayers,
double maxCellHeight,
double cellSizeFactor,
const std::vector<double>& horizontalPartition,
@ -79,10 +79,9 @@ public:
const std::map<Boundary, std::vector<unsigned int>>& boundaryElements() const;
const std::map<Boundary, std::vector<unsigned int>>& boundaryNodes() const;
const std::map<ElementSets, std::vector<unsigned int>>& elementSets() const;
const std::vector<int> elementKLayer() const;
std::vector<cvf::Vec3d> elementCorners( size_t elementIndex ) const;
std::vector<cvf::Vec3d> elementDataCorners( size_t elementIndex ) const;
const std::vector<std::pair<double, double>> layers( ElementSets elementSet ) const;
const std::vector<cvf::Vec3d> elementCorners( size_t elementIndex ) const;
const std::vector<cvf::Vec3d> elementDataCorners( size_t elementIndex ) const;
const std::pair<int, int> elementCountHorzVert() const;
protected:
static cvf::Vec3d stepVector( cvf::Vec3d start, cvf::Vec3d stop, int nSteps );
@ -91,7 +90,14 @@ protected:
static std::vector<double> extractZValues( std::vector<cvf::Vec3d> );
void generateVerticalMeshlines( const std::vector<cvf::Vec3d>& cornerPoints, const std::vector<double>& horzPartition );
void updateReservoirElementLayers( const std::vector<cvf::Vec3d>& reservoirLayers, const std::vector<int>& kLayers );
void updateElementSet( ElementSets elSet,
std::set<unsigned int>& usedElements,
const RigMainGrid* mainGrid,
const RigActiveCellInfo* cellInfo,
int rowStart,
int rowEnd,
int rowInc );
private:
enum class Regions
@ -114,15 +120,16 @@ private:
double m_topHeight;
double m_faultSafetyDistance;
int m_nVertElements;
int m_nHorzElements;
std::vector<cvf::Vec3d> m_nodes;
std::vector<cvf::Vec3d> m_dataNodes;
std::vector<cvf::Vec3d> m_localNodes;
std::vector<std::vector<unsigned int>> m_elementIndices;
std::vector<int> m_elementKLayer;
std::map<RimFaultReactivation::BorderSurface, std::vector<unsigned int>> m_borderSurfaceElements;
std::vector<std::vector<cvf::Vec3d>> m_meshLines;
std::map<Boundary, std::vector<unsigned int>> m_boundaryElements;
std::map<Boundary, std::vector<unsigned int>> m_boundaryNodes;
std::map<ElementSets, std::vector<unsigned int>> m_elementSets;
std::map<ElementSets, std::vector<std::pair<double, double>>> m_elementLayers;
};

21
ApplicationLibCode/UserInterface/RiuViewer.cpp
View File

@ -482,17 +482,20 @@ void RiuViewer::paintOverlayItems( QPainter* painter )
{
Rim3dView* view = dynamic_cast<Rim3dView*>( m_rimView.p() );
QString stepName = view->timeStepName( view->currentTimeStep() );
if ( view )
{
QString stepName = view->timeStepName( view->currentTimeStep() );
m_animationProgress->setFormat( "Time Step: %v/%m " + stepName );
m_animationProgress->setMinimum( 0 );
m_animationProgress->setMaximum( static_cast<int>( view->timeStepCount() ) - 1 );
m_animationProgress->setValue( view->currentTimeStep() );
m_animationProgress->setFormat( "Time Step: %v/%m " + stepName );
m_animationProgress->setMinimum( 0 );
m_animationProgress->setMaximum( static_cast<int>( view->timeStepCount() ) - 1 );
m_animationProgress->setValue( view->currentTimeStep() );
m_animationProgress->resize( columnWidth, m_animationProgress->sizeHint().height() );
m_animationProgress->render( painter, QPoint( columnPos, yPos ) );
m_animationProgress->resize( columnWidth, m_animationProgress->sizeHint().height() );
m_animationProgress->render( painter, QPoint( columnPos, yPos ) );
yPos += m_animationProgress->height() + margin;
yPos += m_animationProgress->height() + margin;
}
}
if ( m_showInfoText && !isComparisonViewActive() )
@ -1037,6 +1040,8 @@ RimViewWindow* RiuViewer::ownerViewWindow() const
//--------------------------------------------------------------------------------------------------
void RiuViewer::optimizeClippingPlanes()
{
if ( m_rimView == nullptr ) return;
if ( m_showWindowEdgeAxes )
{
m_windowEdgeAxisOverlay->setDisplayCoordTransform( m_rimView->displayCoordTransform().p() );