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

GeoMech Intersection updates: support multiple parts (#8160)

Browse Source 
* Rearrange intersection classes, split single file into one-per-class

* Support multi-part geomech case intersections
This commit is contained in:
jonjenssen 2021-10-15 16:57:18 +02:00 committed by GitHub
parent afadaf27d5
commit b169900c41
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
44 changed files with 741 additions and 397 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
ApplicationLibCode/GeoMech/GeoMechDataModel/RigFemPart.cpp
View File

@ -92,6 +92,14 @@ int RigFemPart::elementCount() const
return static_cast<int>( m_elementId.size() ); return static_cast<int>( m_elementId.size() );
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
int RigFemPart::allConnectivitiesCount() const
{
return static_cast<int>( m_allElementConnectivities.size() );
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

1
ApplicationLibCode/GeoMech/GeoMechDataModel/RigFemPart.h
View File

@ -57,6 +57,7 @@ public:
void appendElement( RigElementType elmType, int elementId, const int* connectivities ); void appendElement( RigElementType elmType, int elementId, const int* connectivities );
int elementCount() const; int elementCount() const;
int allConnectivitiesCount() const;
int elmId( size_t elementIdx ) const; int elmId( size_t elementIdx ) const;
RigElementType elementType( size_t elementIdx ) const; RigElementType elementType( size_t elementIdx ) const;

88
ApplicationLibCode/GeoMech/GeoMechDataModel/RigFemPartCollection.cpp
View File

@ -39,7 +39,24 @@ RigFemPartCollection::~RigFemPartCollection()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RigFemPartCollection::addFemPart( RigFemPart* part ) void RigFemPartCollection::addFemPart( RigFemPart* part )
{ {
size_t globalElementOffset = 0;
size_t globalNodeOffset = 0;
size_t globalConnectivityOffset = 0;
if ( m_femParts.size() > 0 )
{
size_t lastIndex = m_femParts.size() - 1;
globalElementOffset += m_femParts[lastIndex]->elementCount();
globalElementOffset += m_partElementOffset[lastIndex];
globalNodeOffset += m_femParts[lastIndex]->nodes().nodeIds.size();
globalNodeOffset += m_partNodeOffset[lastIndex];
globalConnectivityOffset += m_femParts[lastIndex]->allConnectivitiesCount();
globalConnectivityOffset += m_partConnectivityOffset[lastIndex];
}
m_femParts.push_back( part ); m_femParts.push_back( part );
m_partElementOffset.push_back( globalElementOffset );
m_partNodeOffset.push_back( globalNodeOffset );
m_partConnectivityOffset.push_back( globalConnectivityOffset );
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -108,3 +125,74 @@ cvf::BoundingBox RigFemPartCollection::boundingBox() const
} }
return bBox; return bBox;
} }
//--------------------------------------------------------------------------------------------------
/// convert from global element index to part and part-local index
//--------------------------------------------------------------------------------------------------
std::pair<int, size_t> RigFemPartCollection::partIdAndElementIndex( size_t globalIndex ) const
{
const size_t nParts = m_partElementOffset.size();
CVF_ASSERT( nParts > 0 );
for ( size_t i = 1; i < nParts; i++ )
{
if ( globalIndex < m_partElementOffset[i] )
{
return std::make_pair( (int)( i - 1 ), globalIndex - m_partElementOffset[i - 1] );
}
}
return std::make_pair( (int)( nParts - 1 ), globalIndex - m_partElementOffset.back() );
}
//--------------------------------------------------------------------------------------------------
/// convert from global element index to part and part-local index
//--------------------------------------------------------------------------------------------------
std::pair<const RigFemPart*, size_t> RigFemPartCollection::partAndElementIndex( size_t globalIndex ) const
{
auto [partId, elementIdx] = partIdAndElementIndex( globalIndex );
return std::make_pair( part( partId ), elementIdx );
}
//--------------------------------------------------------------------------------------------------
/// convert from part and part-local index to global index
//--------------------------------------------------------------------------------------------------
size_t RigFemPartCollection::globalIndex( int partId, size_t localIndex ) const
{
return localIndex + m_partElementOffset[partId];
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
int RigFemPartCollection::nodeIdxFromElementNodeResultIdx( size_t globalIndex ) const
{
const size_t nParts = m_partConnectivityOffset.size();
CVF_ASSERT( nParts > 0 );
int partId = (int)( nParts - 1 );
size_t partIdx = globalIndex - m_partConnectivityOffset.back();
for ( size_t i = 1; i < nParts; i++ )
{
if ( globalIndex < m_partConnectivityOffset[i] )
{
partId = (int)( i - 1 );
partIdx = globalIndex - m_partConnectivityOffset[i - 1];
break;
}
}
const RigFemPart* part = this->part( partId );
return (int)m_partNodeOffset[partId] + part->nodeIdxFromElementNodeResultIdx( partIdx );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RigFemPartCollection::globalElementNodeResultIdx( int partId, int elementIdx, int elmLocalNodeIdx ) const
{
return m_partElementOffset[partId] * 8 + part( partId )->elementNodeResultIdx( elementIdx, elmLocalNodeIdx );
}

13
ApplicationLibCode/GeoMech/GeoMechDataModel/RigFemPartCollection.h
View File

@ -38,6 +38,19 @@ public:
float characteristicElementSize() const; float characteristicElementSize() const;
cvf::BoundingBox boundingBox() const; cvf::BoundingBox boundingBox() const;
std::pair<int, size_t> partIdAndElementIndex( size_t globalIndex ) const;
std::pair<const RigFemPart*, size_t> partAndElementIndex( size_t globalIndex ) const;
size_t globalIndex( int partId, size_t localIndex ) const;
std::pair<int, size_t> partIdAndNodeIndex( size_t globalNodeIndex ) const;
int nodeIdxFromElementNodeResultIdx( size_t globalResultIdx ) const;
size_t globalElementNodeResultIdx( int part, int elementIdx, int elmLocalNodeIdx ) const;
private: private:
cvf::Collection<RigFemPart> m_femParts; cvf::Collection<RigFemPart> m_femParts;
std::vector<size_t> m_partElementOffset;
std::vector<size_t> m_partNodeOffset;
std::vector<size_t> m_partConnectivityOffset;
}; };

2
ApplicationLibCode/GeoMech/GeoMechDataModel/RigFemPartResultCalculatorSurfaceAlignedStress.cpp
View File

@ -146,6 +146,8 @@ RigFemScalarResultFrames*
for ( int fIdx = 0; fIdx < frameCount; ++fIdx ) for ( int fIdx = 0; fIdx < frameCount; ++fIdx )
{ {
const std::vector<float>& s11 = s11Frames->frameData( fIdx ); const std::vector<float>& s11 = s11Frames->frameData( fIdx );
if ( s11.empty() ) continue;
const std::vector<float>& s22 = s22Frames->frameData( fIdx ); const std::vector<float>& s22 = s22Frames->frameData( fIdx );
const std::vector<float>& s33 = s33Frames->frameData( fIdx ); const std::vector<float>& s33 = s33Frames->frameData( fIdx );
const std::vector<float>& s12 = s12Frames->frameData( fIdx ); const std::vector<float>& s12 = s12Frames->frameData( fIdx );

48
ApplicationLibCode/GeoMech/GeoMechDataModel/RigFemPartResultsCollection.cpp
View File

@ -1043,6 +1043,54 @@ const std::vector<float>&
return scalarResults->frameData( frameIndex ); return scalarResults->frameData( frameIndex );
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigFemPartResultsCollection::globalResultValues( const RigFemResultAddress& resVarAddr,
int timeStepIndex,
std::vector<float>& resultValues )
{
CVF_ASSERT( resVarAddr.isValid() );
for ( int i = 0; i < partCount(); i++ )
{
const std::vector<float>& partResults = this->resultValues( resVarAddr, i, (int)timeStepIndex );
if ( partResults.empty() )
{
size_t expectedSize = 0;
switch ( resVarAddr.resultPosType )
{
case RIG_NODAL:
expectedSize = m_femParts->part( i )->nodes().nodeIds.size();
break;
case RIG_ELEMENT_NODAL:
case RIG_INTEGRATION_POINT:
expectedSize = m_femParts->part( i )->elementNodeResultCount();
break;
case RIG_ELEMENT_NODAL_FACE:
expectedSize = m_femParts->part( i )->elementCount() * 6;
break;
case RIG_ELEMENT:
expectedSize = m_femParts->part( i )->elementCount();
break;
default:
break;
}
resultValues.resize( resultValues.size() + expectedSize, NAN );
}
else
{
resultValues.insert( resultValues.end(), partResults.begin(), partResults.end() );
}
}
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

4
ApplicationLibCode/GeoMech/GeoMechDataModel/RigFemPartResultsCollection.h
View File

@ -125,7 +125,9 @@ public:
std::vector<RigFemResultAddress> loadedResults() const; std::vector<RigFemResultAddress> loadedResults() const;
const std::vector<float>& resultValues( const RigFemResultAddress& resVarAddr, int partIndex, int frameIndex ); const std::vector<float>& resultValues( const RigFemResultAddress& resVarAddr, int partIndex, int frameIndex );
std::vector<caf::Ten3f> tensors( const RigFemResultAddress& resVarAddr, int partIndex, int frameIndex ); void globalResultValues( const RigFemResultAddress& resVarAddr, int timeStepIndex, std::vector<float>& resultValues );
std::vector<caf::Ten3f> tensors( const RigFemResultAddress& resVarAddr, int partIndex, int frameIndex );
const RigFemPartCollection* parts() const; const RigFemPartCollection* parts() const;
int partCount() const; int partCount() const;

6
ApplicationLibCode/ModelVisualization/Intersections/CMakeLists_files.cmake
View File

@ -8,6 +8,9 @@ set(SOURCE_GROUP_HEADER_FILES
${CMAKE_CURRENT_LIST_DIR}/RivBoxIntersectionPartMgr.h ${CMAKE_CURRENT_LIST_DIR}/RivBoxIntersectionPartMgr.h
${CMAKE_CURRENT_LIST_DIR}/RivBoxIntersectionSourceInfo.h ${CMAKE_CURRENT_LIST_DIR}/RivBoxIntersectionSourceInfo.h
${CMAKE_CURRENT_LIST_DIR}/RivSectionFlattener.h ${CMAKE_CURRENT_LIST_DIR}/RivSectionFlattener.h
${CMAKE_CURRENT_LIST_DIR}/RivEclipseIntersectionGrid.h
${CMAKE_CURRENT_LIST_DIR}/RivFemIntersectionGrid.h
${CMAKE_CURRENT_LIST_DIR}/RivIntersectionGeometryGeneratorInterface.h
) )
set(SOURCE_GROUP_SOURCE_FILES set(SOURCE_GROUP_SOURCE_FILES
@ -15,11 +18,12 @@ set(SOURCE_GROUP_SOURCE_FILES
${CMAKE_CURRENT_LIST_DIR}/RivExtrudedCurveIntersectionPartMgr.cpp ${CMAKE_CURRENT_LIST_DIR}/RivExtrudedCurveIntersectionPartMgr.cpp
${CMAKE_CURRENT_LIST_DIR}/RivExtrudedCurveIntersectionSourceInfo.cpp ${CMAKE_CURRENT_LIST_DIR}/RivExtrudedCurveIntersectionSourceInfo.cpp
${CMAKE_CURRENT_LIST_DIR}/RivIntersectionResultsColoringTools.cpp ${CMAKE_CURRENT_LIST_DIR}/RivIntersectionResultsColoringTools.cpp
${CMAKE_CURRENT_LIST_DIR}/RivHexGridIntersectionTools.cpp
${CMAKE_CURRENT_LIST_DIR}/RivBoxIntersectionGeometryGenerator.cpp ${CMAKE_CURRENT_LIST_DIR}/RivBoxIntersectionGeometryGenerator.cpp
${CMAKE_CURRENT_LIST_DIR}/RivBoxIntersectionPartMgr.cpp ${CMAKE_CURRENT_LIST_DIR}/RivBoxIntersectionPartMgr.cpp
${CMAKE_CURRENT_LIST_DIR}/RivBoxIntersectionSourceInfo.cpp ${CMAKE_CURRENT_LIST_DIR}/RivBoxIntersectionSourceInfo.cpp
${CMAKE_CURRENT_LIST_DIR}/RivSectionFlattener.cpp ${CMAKE_CURRENT_LIST_DIR}/RivSectionFlattener.cpp
${CMAKE_CURRENT_LIST_DIR}/RivEclipseIntersectionGrid.cpp
${CMAKE_CURRENT_LIST_DIR}/RivFemIntersectionGrid.cpp
) )
list(APPEND CODE_HEADER_FILES ${SOURCE_GROUP_HEADER_FILES}) list(APPEND CODE_HEADER_FILES ${SOURCE_GROUP_HEADER_FILES})

2
ApplicationLibCode/ModelVisualization/Intersections/RivBoxIntersectionGeometryGenerator.cpp
View File

@ -18,6 +18,8 @@
#include "RivBoxIntersectionGeometryGenerator.h" #include "RivBoxIntersectionGeometryGenerator.h"
#include "RivIntersectionHexGridInterface.h"
#include "RimBoxIntersection.h" #include "RimBoxIntersection.h"
#include "RimCase.h" #include "RimCase.h"
#include "RimGridView.h" #include "RimGridView.h"

5
ApplicationLibCode/ModelVisualization/Intersections/RivBoxIntersectionGeometryGenerator.h
View File

@ -18,7 +18,7 @@
#pragma once #pragma once
#include "RivHexGridIntersectionTools.h" #include "RivIntersectionGeometryGeneratorInterface.h"
#include "cafPdmPointer.h" #include "cafPdmPointer.h"
@ -30,6 +30,7 @@
#include <vector> #include <vector>
class RimBoxIntersection; class RimBoxIntersection;
class RivIntersectionHexGridInterface;
namespace cvf namespace cvf
{ {
@ -37,7 +38,7 @@ class ScalarMapper;
class DrawableGeo; class DrawableGeo;
} // namespace cvf } // namespace cvf
class RivBoxIntersectionGeometryGenerator : public cvf::Object, public RivIntersectionGeometryGeneratorIF class RivBoxIntersectionGeometryGenerator : public cvf::Object, public RivIntersectionGeometryGeneratorInterface
{ {
public: public:
RivBoxIntersectionGeometryGenerator( RimBoxIntersection* intersectionBox, const RivIntersectionHexGridInterface* grid ); RivBoxIntersectionGeometryGenerator( RimBoxIntersection* intersectionBox, const RivIntersectionHexGridInterface* grid );

4
ApplicationLibCode/ModelVisualization/Intersections/RivBoxIntersectionPartMgr.cpp
View File

@ -36,6 +36,8 @@
#include "RivBoxIntersectionSourceInfo.h" #include "RivBoxIntersectionSourceInfo.h"
#include "RivExtrudedCurveIntersectionPartMgr.h" #include "RivExtrudedCurveIntersectionPartMgr.h"
#include "RivIntersectionGeometryGeneratorInterface.h"
#include "RivIntersectionHexGridInterface.h"
#include "RivIntersectionResultsColoringTools.h" #include "RivIntersectionResultsColoringTools.h"
#include "RivMeshLinesSourceInfo.h" #include "RivMeshLinesSourceInfo.h"
#include "RivPartPriority.h" #include "RivPartPriority.h"
@ -219,7 +221,7 @@ void RivBoxIntersectionPartMgr::appendMeshLinePartsToModel( cvf::ModelBasicList*
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
const RivIntersectionGeometryGeneratorIF* RivBoxIntersectionPartMgr::intersectionGeometryGenerator() const const RivIntersectionGeometryGeneratorInterface* RivBoxIntersectionPartMgr::intersectionGeometryGenerator() const
{ {
if ( m_intersectionBoxGenerator.notNull() ) return m_intersectionBoxGenerator.p(); if ( m_intersectionBoxGenerator.notNull() ) return m_intersectionBoxGenerator.p();

3
ApplicationLibCode/ModelVisualization/Intersections/RivBoxIntersectionPartMgr.h
View File

@ -34,6 +34,7 @@ class RigMainGrid;
class RigResultAccessor; class RigResultAccessor;
class RivTernaryScalarMapper; class RivTernaryScalarMapper;
class RivIntersectionGeometryGeneratorInterface;
class RimCellEdgeColors; class RimCellEdgeColors;
class RimEclipseCellColors; class RimEclipseCellColors;
@ -60,7 +61,7 @@ public:
void appendNativeIntersectionFacesToModel( cvf::ModelBasicList* model, cvf::Transform* scaleTransform ); void appendNativeIntersectionFacesToModel( cvf::ModelBasicList* model, cvf::Transform* scaleTransform );
void appendMeshLinePartsToModel( cvf::ModelBasicList* model, cvf::Transform* scaleTransform ); void appendMeshLinePartsToModel( cvf::ModelBasicList* model, cvf::Transform* scaleTransform );
const RivIntersectionGeometryGeneratorIF* intersectionGeometryGenerator() const; const RivIntersectionGeometryGeneratorInterface* intersectionGeometryGenerator() const;
private: private:
void updatePartEffect(); void updatePartEffect();

102
ApplicationLibCode/ModelVisualization/Intersections/RivEclipseIntersectionGrid.cpp Normal file
View File

@ -0,0 +1,102 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2021 - Equinor ASA
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#include "RivEclipseIntersectionGrid.h"
#include "RigActiveCellInfo.h"
#include "RigFemPart.h"
#include "RigMainGrid.h"
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RivEclipseIntersectionGrid::RivEclipseIntersectionGrid( const RigMainGrid* mainGrid,
const RigActiveCellInfo* activeCellInfo,
bool showInactiveCells )
: m_mainGrid( mainGrid )
, m_activeCellInfo( activeCellInfo )
, m_showInactiveCells( showInactiveCells )
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Vec3d RivEclipseIntersectionGrid::displayOffset() const
{
return m_mainGrid->displayModelOffset();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::BoundingBox RivEclipseIntersectionGrid::boundingBox() const
{
return m_mainGrid->boundingBox();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivEclipseIntersectionGrid::findIntersectingCells( const cvf::BoundingBox& intersectingBB,
std::vector<size_t>* intersectedCells ) const
{
m_mainGrid->findIntersectingCells( intersectingBB, intersectedCells );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RivEclipseIntersectionGrid::useCell( size_t cellIndex ) const
{
const RigCell& cell = m_mainGrid->globalCellArray()[cellIndex];
if ( m_showInactiveCells )
return !( cell.isInvalid() || ( cell.subGrid() != nullptr ) );
else
return m_activeCellInfo->isActive( cellIndex ) && ( cell.subGrid() == nullptr );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivEclipseIntersectionGrid::cellCornerVertices( size_t cellIndex, cvf::Vec3d cellCorners[8] ) const
{
m_mainGrid->cellCornerVertices( cellIndex, cellCorners );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivEclipseIntersectionGrid::cellCornerIndices( size_t cellIndex, size_t cornerIndices[8] ) const
{
const std::array<size_t, 8>& cornerIndicesSource = m_mainGrid->globalCellArray()[cellIndex].cornerIndices();
for ( size_t i = 0; i < 8; i++ )
{
cornerIndices[i] = cornerIndicesSource[i];
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RigFault* RivEclipseIntersectionGrid::findFaultFromCellIndexAndCellFace( size_t reservoirCellIndex,
cvf::StructGridInterface::FaceType face ) const
{
return m_mainGrid->findFaultFromCellIndexAndCellFace( reservoirCellIndex, face );
}

55
ApplicationLibCode/ModelVisualization/Intersections/RivEclipseIntersectionGrid.h Normal file
View File

@ -0,0 +1,55 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2021 - Equinor ASA
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "RivIntersectionHexGridInterface.h"
#include "cvfBoundingBox.h"
#include "cvfObject.h"
#include "cvfVector3.h"
#include "cvfStructGrid.h"
#include <array>
#include <vector>
class RigActiveCellInfo;
class RigMainGrid;
class RigFault;
class RivEclipseIntersectionGrid : public RivIntersectionHexGridInterface
{
public:
RivEclipseIntersectionGrid( const RigMainGrid* mainGrid, const RigActiveCellInfo* activeCellInfo, bool showInactiveCells );
cvf::Vec3d displayOffset() const override;
cvf::BoundingBox boundingBox() const override;
void findIntersectingCells( const cvf::BoundingBox& intersectingBB,
std::vector<size_t>* intersectedCells ) const override;
bool useCell( size_t cellIndex ) const override;
void cellCornerVertices( size_t cellIndex, cvf::Vec3d cellCorners[8] ) const override;
void cellCornerIndices( size_t cellIndex, size_t cornerIndices[8] ) const override;
const RigFault* findFaultFromCellIndexAndCellFace( size_t reservoirCellIndex,
cvf::StructGridInterface::FaceType face ) const override;
private:
cvf::cref<RigMainGrid> m_mainGrid;
cvf::cref<RigActiveCellInfo> m_activeCellInfo;
bool m_showInactiveCells;
};

2
ApplicationLibCode/ModelVisualization/Intersections/RivExtrudedCurveIntersectionGeometryGenerator.cpp
View File

@ -34,7 +34,7 @@
#include "RimSurfaceIntersectionCurve.h" #include "RimSurfaceIntersectionCurve.h"
#include "RivExtrudedCurveIntersectionPartMgr.h" #include "RivExtrudedCurveIntersectionPartMgr.h"
#include "RivHexGridIntersectionTools.h" #include "RivIntersectionHexGridInterface.h"
#include "RivPolylineGenerator.h" #include "RivPolylineGenerator.h"
#include "RivSectionFlattener.h" #include "RivSectionFlattener.h"

4
ApplicationLibCode/ModelVisualization/Intersections/RivExtrudedCurveIntersectionGeometryGenerator.h
View File

@ -21,7 +21,7 @@
#include "cafPdmPointer.h" #include "cafPdmPointer.h"
#include "RivHexGridIntersectionTools.h" #include "RivIntersectionGeometryGeneratorInterface.h"
#include "cvfArray.h" #include "cvfArray.h"
@ -47,7 +47,7 @@ class ScalarMapper;
class DrawableGeo; class DrawableGeo;
} // namespace cvf } // namespace cvf
class RivExtrudedCurveIntersectionGeometryGenerator : public cvf::Object, public RivIntersectionGeometryGeneratorIF class RivExtrudedCurveIntersectionGeometryGenerator : public cvf::Object, public RivIntersectionGeometryGeneratorInterface
{ {
public: public:
RivExtrudedCurveIntersectionGeometryGenerator( RimExtrudedCurveIntersection* intersection, RivExtrudedCurveIntersectionGeometryGenerator( RimExtrudedCurveIntersection* intersection,

8
ApplicationLibCode/ModelVisualization/Intersections/RivExtrudedCurveIntersectionPartMgr.cpp
View File

@ -53,7 +53,7 @@
#include "RivExtrudedCurveIntersectionGeometryGenerator.h" #include "RivExtrudedCurveIntersectionGeometryGenerator.h"
#include "RivExtrudedCurveIntersectionSourceInfo.h" #include "RivExtrudedCurveIntersectionSourceInfo.h"
#include "RivHexGridIntersectionTools.h" #include "RivIntersectionHexGridInterface.h"
#include "RivIntersectionResultsColoringTools.h" #include "RivIntersectionResultsColoringTools.h"
#include "RivMeshLinesSourceInfo.h" #include "RivMeshLinesSourceInfo.h"
#include "RivObjectSourceInfo.h" #include "RivObjectSourceInfo.h"
@ -176,7 +176,7 @@ void RivIntersectionResultsColoringTools::calculateNodeOrElementNodeBasedGeoMech
const std::vector<RivIntersectionVertexWeights>& vertexWeights, const std::vector<RivIntersectionVertexWeights>& vertexWeights,
const std::vector<float>& resultValues, const std::vector<float>& resultValues,
bool isElementNodalResult, bool isElementNodalResult,
const RigFemPart* femPart, const RigFemPartCollection* femParts,
const cvf::ScalarMapper* mapper ) const cvf::ScalarMapper* mapper )
{ {
textureCoords->resize( vertexWeights.size() ); textureCoords->resize( vertexWeights.size() );
@ -210,7 +210,7 @@ void RivIntersectionResultsColoringTools::calculateNodeOrElementNodeBasedGeoMech
} }
else else
{ {
resIdx = femPart->nodeIdxFromElementNodeResultIdx( vertexWeights[triangleVxIdx].vxId( wIdx ) ); resIdx = femParts->nodeIdxFromElementNodeResultIdx( vertexWeights[triangleVxIdx].vxId( wIdx ) );
} }
resValue += resultValues[resIdx] * vertexWeights[triangleVxIdx].weight( wIdx ); resValue += resultValues[resIdx] * vertexWeights[triangleVxIdx].weight( wIdx );
@ -895,7 +895,7 @@ cvf::Mat4d RivExtrudedCurveIntersectionPartMgr::unflattenTransformMatrix( const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
const RivIntersectionGeometryGeneratorIF* RivExtrudedCurveIntersectionPartMgr::intersectionGeometryGenerator() const const RivIntersectionGeometryGeneratorInterface* RivExtrudedCurveIntersectionPartMgr::intersectionGeometryGenerator() const
{ {
if ( m_intersectionGenerator.notNull() ) return m_intersectionGenerator.p(); if ( m_intersectionGenerator.notNull() ) return m_intersectionGenerator.p();

4
ApplicationLibCode/ModelVisualization/Intersections/RivExtrudedCurveIntersectionPartMgr.h
View File

@ -56,7 +56,7 @@ class RivExtrudedCurveIntersectionGeometryGenerator;
class RivIntersectionHexGridInterface; class RivIntersectionHexGridInterface;
class RivIntersectionVertexWeights; class RivIntersectionVertexWeights;
class RivPipeGeometryGenerator; class RivPipeGeometryGenerator;
class RivIntersectionGeometryGeneratorIF; class RivIntersectionGeometryGeneratorInterface;
//================================================================================================== //==================================================================================================
/// ///
@ -79,7 +79,7 @@ public:
cvf::Mat4d unflattenTransformMatrix( const cvf::Vec3d& intersectionPointFlat ) const; cvf::Mat4d unflattenTransformMatrix( const cvf::Vec3d& intersectionPointFlat ) const;
const RivIntersectionGeometryGeneratorIF* intersectionGeometryGenerator() const; const RivIntersectionGeometryGeneratorInterface* intersectionGeometryGenerator() const;
private: private:
void generatePartGeometry(); void generatePartGeometry();

121
ApplicationLibCode/ModelVisualization/Intersections/RivFemIntersectionGrid.cpp Normal file
View File

@ -0,0 +1,121 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2021 - Equinor ASA
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#include "RivFemIntersectionGrid.h"
#include "RigFemPart.h"
#include "RigFemPartCollection.h"
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RivFemIntersectionGrid::RivFemIntersectionGrid( const RigFemPartCollection* femParts )
: m_femParts( femParts )
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Vec3d RivFemIntersectionGrid::displayOffset() const
{
return m_femParts->boundingBox().min();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::BoundingBox RivFemIntersectionGrid::boundingBox() const
{
return m_femParts->boundingBox();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivFemIntersectionGrid::findIntersectingCells( const cvf::BoundingBox& intersectingBB,
std::vector<size_t>* intersectedCells ) const
{
for ( int i = 0; i < m_femParts->partCount(); i++ )
{
const RigFemPart* part = m_femParts->part( i );
std::vector<size_t> foundElements;
part->findIntersectingCells( intersectingBB, &foundElements );
for ( size_t t = 0; t < foundElements.size(); t++ )
{
size_t globalIdx = m_femParts->globalIndex( i, foundElements[t] );
intersectedCells->push_back( globalIdx );
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RivFemIntersectionGrid::useCell( size_t globalCellIndex ) const
{
auto [part, elementIdx] = m_femParts->partAndElementIndex( globalCellIndex );
return ( ( part->elementType( elementIdx ) == RigElementType::HEX8 ) ||
( part->elementType( elementIdx ) == RigElementType::HEX8P ) );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivFemIntersectionGrid::cellCornerVertices( size_t globalCellIndex, cvf::Vec3d cellCorners[8] ) const
{
auto [part, elementIdx] = m_femParts->partAndElementIndex( globalCellIndex );
const std::vector<cvf::Vec3f>& nodeCoords = part->nodes().coordinates;
const int* cornerIndices = part->connectivities( elementIdx );
for ( int i = 0; i < 8; i++ )
{
cellCorners[i] = cvf::Vec3d( nodeCoords[cornerIndices[i]] );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivFemIntersectionGrid::cellCornerIndices( size_t globalCellIndex, size_t cornerIndices[8] ) const
{
auto [part, elementIdx] = m_femParts->partAndElementIndex( globalCellIndex );
RigElementType elmType = part->elementType( elementIdx );
if ( !( elmType == HEX8 || elmType == HEX8P ) ) return;
int elmIdx = static_cast<int>( elementIdx );
const int partId = part->elementPartId();
for ( int i = 0; i < 8; i++ )
{
cornerIndices[i] = m_femParts->globalElementNodeResultIdx( partId, elmIdx, i );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RigFault* RivFemIntersectionGrid::findFaultFromCellIndexAndCellFace( size_t reservoirCellIndex,
cvf::StructGridInterface::FaceType face ) const
{
return nullptr;
}

52
ApplicationLibCode/ModelVisualization/Intersections/RivFemIntersectionGrid.h Normal file
View File

@ -0,0 +1,52 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2021 - Equinor ASA
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "RivIntersectionHexGridInterface.h"
#include "cvfBoundingBox.h"
#include "cvfObject.h"
#include "cvfVector3.h"
#include "cvfStructGrid.h"
#include <vector>
class RigFemPart;
class RigFemPartCollection;
class RigFault;
class RivFemIntersectionGrid : public RivIntersectionHexGridInterface
{
public:
explicit RivFemIntersectionGrid( const RigFemPartCollection* femParts );
cvf::Vec3d displayOffset() const override;
cvf::BoundingBox boundingBox() const override;
void findIntersectingCells( const cvf::BoundingBox& intersectingBB,
std::vector<size_t>* intersectedCells ) const override;
bool useCell( size_t cellIndex ) const override;
void cellCornerVertices( size_t cellIndex, cvf::Vec3d cellCorners[8] ) const override;
void cellCornerIndices( size_t cellIndex, size_t cornerIndices[8] ) const override;
const RigFault* findFaultFromCellIndexAndCellFace( size_t reservoirCellIndex,
cvf::StructGridInterface::FaceType face ) const override;
private:
cvf::cref<RigFemPartCollection> m_femParts;
};

195
ApplicationLibCode/ModelVisualization/Intersections/RivHexGridIntersectionTools.cpp
View File

@ -1,195 +0,0 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) Statoil ASA
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#include "RivHexGridIntersectionTools.h"
#include "RigActiveCellInfo.h"
#include "RigFemPart.h"
#include "RigMainGrid.h"
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RivEclipseIntersectionGrid::RivEclipseIntersectionGrid( const RigMainGrid* mainGrid,
const RigActiveCellInfo* activeCellInfo,
bool showInactiveCells )
: m_mainGrid( mainGrid )
, m_activeCellInfo( activeCellInfo )
, m_showInactiveCells( showInactiveCells )
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Vec3d RivEclipseIntersectionGrid::displayOffset() const
{
return m_mainGrid->displayModelOffset();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::BoundingBox RivEclipseIntersectionGrid::boundingBox() const
{
return m_mainGrid->boundingBox();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivEclipseIntersectionGrid::findIntersectingCells( const cvf::BoundingBox& intersectingBB,
std::vector<size_t>* intersectedCells ) const
{
m_mainGrid->findIntersectingCells( intersectingBB, intersectedCells );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RivEclipseIntersectionGrid::useCell( size_t cellIndex ) const
{
const RigCell& cell = m_mainGrid->globalCellArray()[cellIndex];
if ( m_showInactiveCells )
return !( cell.isInvalid() || ( cell.subGrid() != nullptr ) );
else
return m_activeCellInfo->isActive( cellIndex ) && ( cell.subGrid() == nullptr );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivEclipseIntersectionGrid::cellCornerVertices( size_t cellIndex, cvf::Vec3d cellCorners[8] ) const
{
m_mainGrid->cellCornerVertices( cellIndex, cellCorners );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivEclipseIntersectionGrid::cellCornerIndices( size_t cellIndex, size_t cornerIndices[8] ) const
{
const std::array<size_t, 8>& cornerIndicesSource = m_mainGrid->globalCellArray()[cellIndex].cornerIndices();
for ( size_t i = 0; i < 8; i++ )
{
cornerIndices[i] = cornerIndicesSource[i];
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RigFault* RivEclipseIntersectionGrid::findFaultFromCellIndexAndCellFace( size_t reservoirCellIndex,
cvf::StructGridInterface::FaceType face ) const
{
return m_mainGrid->findFaultFromCellIndexAndCellFace( reservoirCellIndex, face );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RivFemIntersectionGrid::RivFemIntersectionGrid( const RigFemPart* femPart )
: m_femPart( femPart )
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Vec3d RivFemIntersectionGrid::displayOffset() const
{
return m_femPart->boundingBox().min();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::BoundingBox RivFemIntersectionGrid::boundingBox() const
{
return m_femPart->boundingBox();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivFemIntersectionGrid::findIntersectingCells( const cvf::BoundingBox& intersectingBB,
std::vector<size_t>* intersectedCells ) const
{
m_femPart->findIntersectingCells( intersectingBB, intersectedCells );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RivFemIntersectionGrid::useCell( size_t cellIndex ) const
{
RigElementType elmType = m_femPart->elementType( cellIndex );
if ( !( elmType == HEX8 || elmType == HEX8P ) ) return false;
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivFemIntersectionGrid::cellCornerVertices( size_t cellIndex, cvf::Vec3d cellCorners[8] ) const
{
RigElementType elmType = m_femPart->elementType( cellIndex );
if ( !( elmType == HEX8 || elmType == HEX8P ) ) return;
const std::vector<cvf::Vec3f>& nodeCoords = m_femPart->nodes().coordinates;
const int* cornerIndices = m_femPart->connectivities( cellIndex );
cellCorners[0] = cvf::Vec3d( nodeCoords[cornerIndices[0]] );
cellCorners[1] = cvf::Vec3d( nodeCoords[cornerIndices[1]] );
cellCorners[2] = cvf::Vec3d( nodeCoords[cornerIndices[2]] );
cellCorners[3] = cvf::Vec3d( nodeCoords[cornerIndices[3]] );
cellCorners[4] = cvf::Vec3d( nodeCoords[cornerIndices[4]] );
cellCorners[5] = cvf::Vec3d( nodeCoords[cornerIndices[5]] );
cellCorners[6] = cvf::Vec3d( nodeCoords[cornerIndices[6]] );
cellCorners[7] = cvf::Vec3d( nodeCoords[cornerIndices[7]] );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivFemIntersectionGrid::cellCornerIndices( size_t cellIndex, size_t cornerIndices[8] ) const
{
RigElementType elmType = m_femPart->elementType( cellIndex );
if ( !( elmType == HEX8 || elmType == HEX8P ) ) return;
int elmIdx = static_cast<int>( cellIndex );
cornerIndices[0] = m_femPart->elementNodeResultIdx( elmIdx, 0 );
cornerIndices[1] = m_femPart->elementNodeResultIdx( elmIdx, 1 );
cornerIndices[2] = m_femPart->elementNodeResultIdx( elmIdx, 2 );
cornerIndices[3] = m_femPart->elementNodeResultIdx( elmIdx, 3 );
cornerIndices[4] = m_femPart->elementNodeResultIdx( elmIdx, 4 );
cornerIndices[5] = m_femPart->elementNodeResultIdx( elmIdx, 5 );
cornerIndices[6] = m_femPart->elementNodeResultIdx( elmIdx, 6 );
cornerIndices[7] = m_femPart->elementNodeResultIdx( elmIdx, 7 );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RigFault* RivFemIntersectionGrid::findFaultFromCellIndexAndCellFace( size_t reservoirCellIndex,
cvf::StructGridInterface::FaceType face ) const
{
return nullptr;
}

34
ApplicationLibCode/ModelVisualization/Intersections/RivIntersectionGeometryGeneratorInterface.h Normal file
View File

@ -0,0 +1,34 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2021 - Equinor ASA
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "RivIntersectionVertexWeights.h"
#include "cvfArray.h"
#include <vector>
class RivIntersectionGeometryGeneratorInterface
{
public:
virtual bool isAnyGeometryPresent() const = 0;
virtual const std::vector<size_t>& triangleToCellIndex() const = 0;
virtual const std::vector<RivIntersectionVertexWeights>& triangleVxToCellCornerInterpolationWeights() const = 0;
virtual const cvf::Vec3fArray* triangleVxes() const = 0;
};

46
ApplicationLibCode/ModelVisualization/Intersections/RivIntersectionHexGridInterface.h Normal file
View File

@ -0,0 +1,46 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2021 - Equinor ASA
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "cvfBoundingBox.h"
#include "cvfObject.h"
#include "cvfVector3.h"
#include "cvfStructGrid.h"
#include <vector>
class RigFault;
//--------------------------------------------------------------------------------------------------
/// Interface definition used to compute the geometry for planes intersecting a grid
//--------------------------------------------------------------------------------------------------
class RivIntersectionHexGridInterface : public cvf::Object
{
public:
virtual cvf::Vec3d displayOffset() const = 0;
virtual cvf::BoundingBox boundingBox() const = 0;
virtual void findIntersectingCells( const cvf::BoundingBox& intersectingBB,
std::vector<size_t>* intersectedCells ) const = 0;
virtual bool useCell( size_t cellIndex ) const = 0;
virtual void cellCornerVertices( size_t cellIndex, cvf::Vec3d cellCorners[8] ) const = 0;
virtual void cellCornerIndices( size_t cellIndex, size_t cornerIndices[8] ) const = 0;
virtual const RigFault* findFaultFromCellIndexAndCellFace( size_t reservoirCellIndex,
cvf::StructGridInterface::FaceType face ) const = 0;
};

125
ApplicationLibCode/ModelVisualization/Intersections/RivIntersectionResultsColoringTools.cpp
View File

@ -37,6 +37,8 @@
#include "RigGeoMechCaseData.h" #include "RigGeoMechCaseData.h"
#include "RigResultAccessorFactory.h" #include "RigResultAccessorFactory.h"
#include "RivIntersectionGeometryGeneratorInterface.h"
#include "RivIntersectionVertexWeights.h"
#include "RivScalarMapperUtils.h" #include "RivScalarMapperUtils.h"
#include "RivTernaryTextureCoordsCreator.h" #include "RivTernaryTextureCoordsCreator.h"
@ -49,14 +51,14 @@
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RivIntersectionResultsColoringTools::calculateIntersectionResultColors( void RivIntersectionResultsColoringTools::calculateIntersectionResultColors(
size_t timeStepIndex, size_t timeStepIndex,
bool useSeparateIntersectionResDefTimeStep, bool useSeparateIntersectionResDefTimeStep,
RimIntersection* rimIntersectionHandle, RimIntersection* rimIntersectionHandle,
const RivIntersectionGeometryGeneratorIF* intersectionGeomGenIF, const RivIntersectionGeometryGeneratorInterface* intersectionGeomGenIF,
const cvf::ScalarMapper* explicitScalarColorMapper, const cvf::ScalarMapper* explicitScalarColorMapper,
const RivTernaryScalarMapper* explicitTernaryColorMapper, const RivTernaryScalarMapper* explicitTernaryColorMapper,
cvf::Part* intersectionFacesPart, cvf::Part* intersectionFacesPart,
cvf::Vec2fArray* intersectionFacesTextureCoords ) cvf::Vec2fArray* intersectionFacesTextureCoords )
{ {
if ( !intersectionGeomGenIF || !intersectionGeomGenIF->isAnyGeometryPresent() ) return; if ( !intersectionGeomGenIF || !intersectionGeomGenIF->isAnyGeometryPresent() ) return;
@ -223,13 +225,14 @@ void RivIntersectionResultsColoringTools::updateEclipseTernaryCellResultColors(
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RivIntersectionResultsColoringTools::updateGeoMechCellResultColors( const RimGeoMechResultDefinition* geomResultDef, void RivIntersectionResultsColoringTools::updateGeoMechCellResultColors(
size_t timeStepIndex, const RimGeoMechResultDefinition* geomResultDef,
const cvf::ScalarMapper* scalarColorMapper, size_t timeStepIndex,
bool isLightingDisabled, const cvf::ScalarMapper* scalarColorMapper,
const RivIntersectionGeometryGeneratorIF* geomGenerator, bool isLightingDisabled,
cvf::Part* intersectionFacesPart, const RivIntersectionGeometryGeneratorInterface* geomGenerator,
cvf::Vec2fArray* intersectionFacesTextureCoords ) cvf::Part* intersectionFacesPart,
cvf::Vec2fArray* intersectionFacesTextureCoords )
{ {
RigGeoMechCaseData* caseData = nullptr; RigGeoMechCaseData* caseData = nullptr;
RigFemResultAddress resVarAddress; RigFemResultAddress resVarAddress;
@ -247,35 +250,53 @@ void RivIntersectionResultsColoringTools::updateGeoMechCellResultColors( const R
if ( resVarAddress.resultPosType == RIG_ELEMENT ) if ( resVarAddress.resultPosType == RIG_ELEMENT )
{ {
const std::vector<float>& resultValues = if ( caseData->femPartResults()->partCount() == 1 )
caseData->femPartResults()->resultValues( resVarAddress, 0, (int)timeStepIndex ); {
const std::vector<float>& resultValues =
caseData->femPartResults()->resultValues( resVarAddress, 0, (int)timeStepIndex );
RivIntersectionResultsColoringTools::calculateElementBasedGeoMechTextureCoords( intersectionFacesTextureCoords, RivIntersectionResultsColoringTools::calculateElementBasedGeoMechTextureCoords( intersectionFacesTextureCoords,
resultValues, resultValues,
triangleToCellIdx, triangleToCellIdx,
scalarColorMapper ); scalarColorMapper );
}
else
{
std::vector<float> resultValues;
caseData->femPartResults()->globalResultValues( resVarAddress, (int)timeStepIndex, resultValues );
RivIntersectionResultsColoringTools::calculateElementBasedGeoMechTextureCoords( intersectionFacesTextureCoords,
resultValues,
triangleToCellIdx,
scalarColorMapper );
}
} }
else if ( resVarAddress.resultPosType == RIG_ELEMENT_NODAL_FACE ) else if ( resVarAddress.resultPosType == RIG_ELEMENT_NODAL_FACE )
{ {
// Special direction sensitive result calculation // Special direction sensitive result calculation
if ( resVarAddress.componentName == "Pazi" || resVarAddress.componentName == "Pinc" ) if ( caseData->femPartResults()->partCount() == 1 ) // only supported for single-part geomech cases
{ {
RivIntersectionResultsColoringTools::calculatePlaneAngleTextureCoords( intersectionFacesTextureCoords, if ( resVarAddress.componentName == "Pazi" || resVarAddress.componentName == "Pinc" )
triangelVxes, {
resVarAddress, RivIntersectionResultsColoringTools::calculatePlaneAngleTextureCoords( intersectionFacesTextureCoords,
scalarColorMapper ); triangelVxes,
resVarAddress,
scalarColorMapper );
}
else
{
RivIntersectionResultsColoringTools::calculateGeoMechTensorXfTextureCoords( intersectionFacesTextureCoords,
triangelVxes,
vertexWeights,
caseData,
resVarAddress,
(int)timeStepIndex,
scalarColorMapper );
}
} }
else else
{ return;
RivIntersectionResultsColoringTools::calculateGeoMechTensorXfTextureCoords( intersectionFacesTextureCoords,
triangelVxes,
vertexWeights,
caseData,
resVarAddress,
(int)timeStepIndex,
scalarColorMapper );
}
} }
else else
{ {
@ -285,19 +306,31 @@ void RivIntersectionResultsColoringTools::updateGeoMechCellResultColors( const R
{ {
resVarAddress.resultPosType = RIG_ELEMENT_NODAL; resVarAddress.resultPosType = RIG_ELEMENT_NODAL;
} }
bool isElementNodalResult = !( resVarAddress.resultPosType == RIG_NODAL );
const std::vector<float>& resultValues = if ( caseData->femPartResults()->partCount() == 1 )
caseData->femPartResults()->resultValues( resVarAddress, 0, (int)timeStepIndex ); {
const std::vector<float>& resultValues =
caseData->femPartResults()->resultValues( resVarAddress, 0, (int)timeStepIndex );
RivIntersectionResultsColoringTools::calculateNodeOrElementNodeBasedGeoMechTextureCoords( intersectionFacesTextureCoords,
vertexWeights,
resultValues,
isElementNodalResult,
caseData->femParts(),
scalarColorMapper );
}
else
{
std::vector<float> resultValues;
caseData->femPartResults()->globalResultValues( resVarAddress, (int)timeStepIndex, resultValues );
RigFemPart* femPart = caseData->femParts()->part( 0 ); RivIntersectionResultsColoringTools::calculateNodeOrElementNodeBasedGeoMechTextureCoords( intersectionFacesTextureCoords,
bool isElementNodalResult = !( resVarAddress.resultPosType == RIG_NODAL ); vertexWeights,
resultValues,
RivIntersectionResultsColoringTools::calculateNodeOrElementNodeBasedGeoMechTextureCoords( intersectionFacesTextureCoords, isElementNodalResult,
vertexWeights, caseData->femParts(),
resultValues, scalarColorMapper );
isElementNodalResult, }
femPart,
scalarColorMapper );
} }
RivScalarMapperUtils::applyTextureResultsToPart( intersectionFacesPart, RivScalarMapperUtils::applyTextureResultsToPart( intersectionFacesPart,

37
ApplicationLibCode/ModelVisualization/Intersections/RivIntersectionResultsColoringTools.h
View File

@ -20,17 +20,16 @@
#include "cvfArray.h" #include "cvfArray.h"
#include "RivHexGridIntersectionTools.h"
class RimEclipseResultDefinition; class RimEclipseResultDefinition;
class RimGeoMechResultDefinition; class RimGeoMechResultDefinition;
class RimIntersection; class RimIntersection;
class RivIntersectionGeometryGeneratorIF; class RivIntersectionGeometryGeneratorInterface;
class RivIntersectionVertexWeights;
class RivTernaryScalarMapper; class RivTernaryScalarMapper;
class RigResultAccessor; class RigResultAccessor;
class RigFemPart; class RigFemPartCollection;
class RigGeoMechCaseData; class RigGeoMechCaseData;
class RigFemResultAddress; class RigFemResultAddress;
@ -46,11 +45,11 @@ public:
static void calculateIntersectionResultColors( size_t timeStepIndex, static void calculateIntersectionResultColors( size_t timeStepIndex,
bool useSeparateIntersectionResDefTimeStep, bool useSeparateIntersectionResDefTimeStep,
RimIntersection* rimIntersectionHandle, RimIntersection* rimIntersectionHandle,
const RivIntersectionGeometryGeneratorIF* intersectionGeomGenIF, const RivIntersectionGeometryGeneratorInterface* intersectionGeomGenIF,
const cvf::ScalarMapper* explicitScalarColorMapper, const cvf::ScalarMapper* explicitScalarColorMapper,
const RivTernaryScalarMapper* explicitTernaryColorMapper, const RivTernaryScalarMapper* explicitTernaryColorMapper,
cvf::Part* intersectionFacesPart, cvf::Part* intersectionFacesPart,
cvf::Vec2fArray* intersectionFacesTextureCoords ); cvf::Vec2fArray* intersectionFacesTextureCoords );
private: private:
static void updateEclipseCellResultColors( const RimEclipseResultDefinition* eclipseResDef, static void updateEclipseCellResultColors( const RimEclipseResultDefinition* eclipseResDef,
@ -69,12 +68,12 @@ private:
cvf::Part* m_intersectionBoxFaces, cvf::Part* m_intersectionBoxFaces,
cvf::Vec2fArray* m_intersectionBoxFacesTextureCoords ); cvf::Vec2fArray* m_intersectionBoxFacesTextureCoords );
static void updateGeoMechCellResultColors( const RimGeoMechResultDefinition* geomResultDef, static void updateGeoMechCellResultColors( const RimGeoMechResultDefinition* geomResultDef,
size_t timeStepIndex, size_t timeStepIndex,
const cvf::ScalarMapper* scalarColorMapper, const cvf::ScalarMapper* scalarColorMapper,
bool isLightingDisabled, bool isLightingDisabled,
const RivIntersectionGeometryGeneratorIF* geomGenerator, const RivIntersectionGeometryGeneratorInterface* geomGenerator,
cvf::Part* m_intersectionBoxFaces, cvf::Part* m_intersectionBoxFaces,
cvf::Vec2fArray* m_intersectionBoxFacesTextureCoords ); cvf::Vec2fArray* m_intersectionBoxFacesTextureCoords );
static void calculateEclipseTextureCoordinates( cvf::Vec2fArray* textureCoords, static void calculateEclipseTextureCoordinates( cvf::Vec2fArray* textureCoords,
@ -85,10 +84,10 @@ private:
static void static void
calculateNodeOrElementNodeBasedGeoMechTextureCoords( cvf::Vec2fArray* textureCoords, calculateNodeOrElementNodeBasedGeoMechTextureCoords( cvf::Vec2fArray* textureCoords,
const std::vector<RivIntersectionVertexWeights>& vertexWeights, const std::vector<RivIntersectionVertexWeights>& vertexWeights,
const std::vector<float>& resultValues, const std::vector<float>& resultValues,
bool isElementNodalResult, bool isElementNodalResult,
const RigFemPart* femPart, const RigFemPartCollection* femParts,
const cvf::ScalarMapper* mapper ); const cvf::ScalarMapper* mapper );
static void calculateElementBasedGeoMechTextureCoords( cvf::Vec2fArray* textureCoords, static void calculateElementBasedGeoMechTextureCoords( cvf::Vec2fArray* textureCoords,
const std::vector<float>& resultValues, const std::vector<float>& resultValues,

87
ApplicationLibCode/ModelVisualization/Intersections/RivHexGridIntersectionTools.h → ApplicationLibCode/ModelVisualization/Intersections/RivIntersectionVertexWeights.h
View File

@ -1,6 +1,6 @@
///////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////
// //
// Copyright (C) Statoil ASA // Copyright (C) 2021 - Equinor ASA
// //
// ResInsight is free software: you can redistribute it and/or modify // ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by // it under the terms of the GNU General Public License as published by
@ -18,82 +18,8 @@
#pragma once #pragma once
#include "cvfBoundingBox.h"
#include "cvfObject.h"
#include "cvfVector3.h"
#include "cvfStructGrid.h"
#include <array> #include <array>
#include <vector> #include <cstddef>
class RigActiveCellInfo;
class RigFemPart;
class RigMainGrid;
class RigFault;
//--------------------------------------------------------------------------------------------------
/// Interface definition used to compute the geometry for planes intersecting a grid
//--------------------------------------------------------------------------------------------------
class RivIntersectionHexGridInterface : public cvf::Object
{
public:
virtual cvf::Vec3d displayOffset() const = 0;
virtual cvf::BoundingBox boundingBox() const = 0;
virtual void findIntersectingCells( const cvf::BoundingBox& intersectingBB,
std::vector<size_t>* intersectedCells ) const = 0;
virtual bool useCell( size_t cellIndex ) const = 0;
virtual void cellCornerVertices( size_t cellIndex, cvf::Vec3d cellCorners[8] ) const = 0;
virtual void cellCornerIndices( size_t cellIndex, size_t cornerIndices[8] ) const = 0;
virtual const RigFault* findFaultFromCellIndexAndCellFace( size_t reservoirCellIndex,
cvf::StructGridInterface::FaceType face ) const = 0;
};
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
class RivEclipseIntersectionGrid : public RivIntersectionHexGridInterface
{
public:
RivEclipseIntersectionGrid( const RigMainGrid* mainGrid, const RigActiveCellInfo* activeCellInfo, bool showInactiveCells );
cvf::Vec3d displayOffset() const override;
cvf::BoundingBox boundingBox() const override;
void findIntersectingCells( const cvf::BoundingBox& intersectingBB,
std::vector<size_t>* intersectedCells ) const override;
bool useCell( size_t cellIndex ) const override;
void cellCornerVertices( size_t cellIndex, cvf::Vec3d cellCorners[8] ) const override;
void cellCornerIndices( size_t cellIndex, size_t cornerIndices[8] ) const override;
const RigFault* findFaultFromCellIndexAndCellFace( size_t reservoirCellIndex,
cvf::StructGridInterface::FaceType face ) const override;
private:
cvf::cref<RigMainGrid> m_mainGrid;
cvf::cref<RigActiveCellInfo> m_activeCellInfo;
bool m_showInactiveCells;
};
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
class RivFemIntersectionGrid : public RivIntersectionHexGridInterface
{
public:
explicit RivFemIntersectionGrid( const RigFemPart* femPart );
cvf::Vec3d displayOffset() const override;
cvf::BoundingBox boundingBox() const override;
void findIntersectingCells( const cvf::BoundingBox& intersectingBB,
std::vector<size_t>* intersectedCells ) const override;
bool useCell( size_t cellIndex ) const override;
void cellCornerVertices( size_t cellIndex, cvf::Vec3d cellCorners[8] ) const override;
void cellCornerIndices( size_t cellIndex, size_t cornerIndices[8] ) const override;
const RigFault* findFaultFromCellIndexAndCellFace( size_t reservoirCellIndex,
cvf::StructGridInterface::FaceType face ) const override;
private:
cvf::cref<RigFemPart> m_femPart;
};
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
@ -222,12 +148,3 @@ private:
std::array<float, 8> m_weights; std::array<float, 8> m_weights;
int m_count; int m_count;
}; };
class RivIntersectionGeometryGeneratorIF
{
public:
virtual bool isAnyGeometryPresent() const = 0;
virtual const std::vector<size_t>& triangleToCellIndex() const = 0;
virtual const std::vector<RivIntersectionVertexWeights>& triangleVxToCellCornerInterpolationWeights() const = 0;
virtual const cvf::Vec3fArray* triangleVxes() const = 0;
};

2
ApplicationLibCode/ModelVisualization/Intersections/RivSectionFlattener.cpp
View File

@ -39,7 +39,7 @@ size_t RivSectionFlattener::indexToNextValidPoint( const std::vector<cvf::Vec3d>
cvf::Vec3d p2 = polyLine[lIdx]; cvf::Vec3d p2 = polyLine[lIdx];
cvf::Vec3d p1p2 = p2 - p1; cvf::Vec3d p1p2 = p2 - p1;
if ( ( p1p2 - ( p1p2 * extrDir ) * extrDir ).length() > 0.1 ) if ( ( p1p2 - ( p1p2 * extrDir ) * extrDir ).length() > 0.001 )
{ {
return lIdx; return lIdx;
} }

3
ApplicationLibCode/ModelVisualization/Surfaces/RivSurfaceIntersectionGeometryGenerator.cpp
View File

@ -32,7 +32,8 @@
#include "RimSurfaceInView.h" #include "RimSurfaceInView.h"
#include "RivExtrudedCurveIntersectionPartMgr.h" #include "RivExtrudedCurveIntersectionPartMgr.h"
#include "RivHexGridIntersectionTools.h" #include "RivIntersectionHexGridInterface.h"
#include "RivIntersectionVertexWeights.h"
#include "RivPolylineGenerator.h" #include "RivPolylineGenerator.h"
#include "RivSectionFlattener.h" #include "RivSectionFlattener.h"

4
ApplicationLibCode/ModelVisualization/Surfaces/RivSurfaceIntersectionGeometryGenerator.h
View File

@ -21,7 +21,7 @@
#include "cafPdmPointer.h" #include "cafPdmPointer.h"
#include "RivHexGridIntersectionTools.h" #include "RivIntersectionGeometryGeneratorInterface.h"
#include "cvfArray.h" #include "cvfArray.h"
#include "cvfBoundingBox.h" #include "cvfBoundingBox.h"
@ -47,7 +47,7 @@ class ScalarMapper;
class DrawableGeo; class DrawableGeo;
} // namespace cvf } // namespace cvf
class RivSurfaceIntersectionGeometryGenerator : public cvf::Object, public RivIntersectionGeometryGeneratorIF class RivSurfaceIntersectionGeometryGenerator : public cvf::Object, public RivIntersectionGeometryGeneratorInterface
{ {
public: public:
RivSurfaceIntersectionGeometryGenerator( RimSurfaceInView* surfInView, const RivIntersectionHexGridInterface* grid ); RivSurfaceIntersectionGeometryGenerator( RimSurfaceInView* surfInView, const RivIntersectionHexGridInterface* grid );

4
ApplicationLibCode/ModelVisualization/Surfaces/RivSurfacePartMgr.cpp
View File

@ -28,6 +28,8 @@
#include "RimSurfaceInView.h" #include "RimSurfaceInView.h"
#include "RimSurfaceResultDefinition.h" #include "RimSurfaceResultDefinition.h"
#include "RivIntersectionGeometryGeneratorInterface.h"
#include "RivIntersectionHexGridInterface.h"
#include "RivIntersectionResultsColoringTools.h" #include "RivIntersectionResultsColoringTools.h"
#include "RivMeshLinesSourceInfo.h" #include "RivMeshLinesSourceInfo.h"
#include "RivPartPriority.h" #include "RivPartPriority.h"
@ -271,7 +273,7 @@ QString RivSurfacePartMgr::resultInfoText( Rim3dView* view, uint hitPart, cvf::V
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
const RivIntersectionGeometryGeneratorIF* RivSurfacePartMgr::intersectionGeometryGenerator() const const RivIntersectionGeometryGeneratorInterface* RivSurfacePartMgr::intersectionGeometryGenerator() const
{ {
if ( m_intersectionGenerator.notNull() ) return m_intersectionGenerator.p(); if ( m_intersectionGenerator.notNull() ) return m_intersectionGenerator.p();

4
ApplicationLibCode/ModelVisualization/Surfaces/RivSurfacePartMgr.h
View File

@ -36,7 +36,7 @@ class RigResultAccessor;
class Rim3dView; class Rim3dView;
class RivSurfaceIntersectionGeometryGenerator; class RivSurfaceIntersectionGeometryGenerator;
class RivIntersectionGeometryGeneratorIF; class RivIntersectionGeometryGeneratorInterface;
class RivSurfacePartMgr : public cvf::Object class RivSurfacePartMgr : public cvf::Object
{ {
@ -51,7 +51,7 @@ public:
QString resultInfoText( Rim3dView* view, uint hitPart, cvf::Vec3d hitPoint ); QString resultInfoText( Rim3dView* view, uint hitPart, cvf::Vec3d hitPoint );
const RivIntersectionGeometryGeneratorIF* intersectionGeometryGenerator() const; const RivIntersectionGeometryGeneratorInterface* intersectionGeometryGenerator() const;
private: private:
void generatePartGeometry(); void generatePartGeometry();

2
ApplicationLibCode/ProjectDataModel/RimBoxIntersection.cpp
View File

@ -51,7 +51,7 @@ CAF_PDM_SOURCE_INIT( RimBoxIntersection, "IntersectionBox" );
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
const RivIntersectionGeometryGeneratorIF* RimBoxIntersection::intersectionGeometryGenerator() const const RivIntersectionGeometryGeneratorInterface* RimBoxIntersection::intersectionGeometryGenerator() const
{ {
if ( m_intersectionBoxPartMgr.notNull() ) return m_intersectionBoxPartMgr->intersectionGeometryGenerator(); if ( m_intersectionBoxPartMgr.notNull() ) return m_intersectionBoxPartMgr->intersectionGeometryGenerator();

2
ApplicationLibCode/ProjectDataModel/RimBoxIntersection.h
View File

@ -78,7 +78,7 @@ public:
void setToDefaultSizeBox(); void setToDefaultSizeBox();
void setToDefaultSizeSlice( SinglePlaneState plane, const cvf::Vec3d& position ); void setToDefaultSizeSlice( SinglePlaneState plane, const cvf::Vec3d& position );
const RivIntersectionGeometryGeneratorIF* intersectionGeometryGenerator() const override; const RivIntersectionGeometryGeneratorInterface* intersectionGeometryGenerator() const override;
protected: protected:
caf::PdmFieldHandle* userDescriptionField() final; caf::PdmFieldHandle* userDescriptionField() final;

2
ApplicationLibCode/ProjectDataModel/RimExtrudedCurveIntersection.cpp
View File

@ -86,7 +86,7 @@ CAF_PDM_SOURCE_INIT( RimExtrudedCurveIntersection, "CrossSection" );
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
const RivIntersectionGeometryGeneratorIF* RimExtrudedCurveIntersection::intersectionGeometryGenerator() const const RivIntersectionGeometryGeneratorInterface* RimExtrudedCurveIntersection::intersectionGeometryGenerator() const
{ {
if ( m_crossSectionPartMgr.notNull() ) return m_crossSectionPartMgr->intersectionGeometryGenerator(); if ( m_crossSectionPartMgr.notNull() ) return m_crossSectionPartMgr->intersectionGeometryGenerator();

8
ApplicationLibCode/ProjectDataModel/RimExtrudedCurveIntersection.h
View File

@ -91,10 +91,10 @@ public:
std::vector<std::vector<cvf::Vec3d>> polyLines( cvf::Vec3d* flattenedPolylineStartPoint = nullptr ) const; std::vector<std::vector<cvf::Vec3d>> polyLines( cvf::Vec3d* flattenedPolylineStartPoint = nullptr ) const;
void appendPointToPolyLine( const cvf::Vec3d& point ); void appendPointToPolyLine( const cvf::Vec3d& point );
Rim2dIntersectionView* correspondingIntersectionView() const; Rim2dIntersectionView* correspondingIntersectionView() const;
RivExtrudedCurveIntersectionPartMgr* intersectionPartMgr(); RivExtrudedCurveIntersectionPartMgr* intersectionPartMgr();
void rebuildGeometry(); void rebuildGeometry();
const RivIntersectionGeometryGeneratorIF* intersectionGeometryGenerator() const override; const RivIntersectionGeometryGeneratorInterface* intersectionGeometryGenerator() const override;
std::vector<cvf::Vec3d> polyLinesForExtrusionDirection() const; std::vector<cvf::Vec3d> polyLinesForExtrusionDirection() const;
void appendPointToExtrusionDirection( const cvf::Vec3d& point ); void appendPointToExtrusionDirection( const cvf::Vec3d& point );

13
ApplicationLibCode/ProjectDataModel/RimIntersection.cpp
View File

@ -29,7 +29,9 @@
#include "RimGridView.h" #include "RimGridView.h"
#include "RimIntersectionResultDefinition.h" #include "RimIntersectionResultDefinition.h"
#include "RimIntersectionResultsDefinitionCollection.h" #include "RimIntersectionResultsDefinitionCollection.h"
#include "RivHexGridIntersectionTools.h"
#include "RivEclipseIntersectionGrid.h"
#include "RivFemIntersectionGrid.h"
CAF_PDM_ABSTRACT_SOURCE_INIT( RimIntersection, "RimIntersectionHandle" ); CAF_PDM_ABSTRACT_SOURCE_INIT( RimIntersection, "RimIntersectionHandle" );
@ -203,8 +205,7 @@ cvf::ref<RivIntersectionHexGridInterface> RimIntersection::createHexGridInterfac
if ( geomCase && geomCase->geoMechData() && geomCase->geoMechData()->femParts() ) if ( geomCase && geomCase->geoMechData() && geomCase->geoMechData()->femParts() )
{ {
RigFemPart* femPart = geomCase->geoMechData()->femParts()->part( 0 ); return new RivFemIntersectionGrid( geomCase->geoMechData()->femParts() );
return new RivFemIntersectionGrid( femPart );
} }
} }
@ -219,11 +220,9 @@ cvf::ref<RivIntersectionHexGridInterface> RimIntersection::createHexGridInterfac
RimGeoMechView* geoView; RimGeoMechView* geoView;
this->firstAncestorOrThisOfType( geoView ); this->firstAncestorOrThisOfType( geoView );
if ( geoView && geoView->femParts() && geoView->femParts()->partCount() ) if ( geoView && geoView->femParts() )
{ {
RigFemPart* femPart = geoView->femParts()->part( 0 ); return new RivFemIntersectionGrid( geoView->femParts() );
return new RivFemIntersectionGrid( femPart );
} }
return nullptr; return nullptr;

4
ApplicationLibCode/ProjectDataModel/RimIntersection.h
View File

@ -27,7 +27,7 @@
class RimIntersectionResultDefinition; class RimIntersectionResultDefinition;
class RivIntersectionHexGridInterface; class RivIntersectionHexGridInterface;
class RimIntersectionResultsDefinitionCollection; class RimIntersectionResultsDefinitionCollection;
class RivIntersectionGeometryGeneratorIF; class RivIntersectionGeometryGeneratorInterface;
class RimIntersection : public caf::PdmObject class RimIntersection : public caf::PdmObject
{ {
@ -46,7 +46,7 @@ public:
RimIntersectionResultDefinition* activeSeparateResultDefinition(); RimIntersectionResultDefinition* activeSeparateResultDefinition();
cvf::ref<RivIntersectionHexGridInterface> createHexGridInterface(); cvf::ref<RivIntersectionHexGridInterface> createHexGridInterface();
virtual const RivIntersectionGeometryGeneratorIF* intersectionGeometryGenerator() const = 0; virtual const RivIntersectionGeometryGeneratorInterface* intersectionGeometryGenerator() const = 0;
protected: protected:
virtual RimIntersectionResultsDefinitionCollection* findSeparateResultsCollection(); virtual RimIntersectionResultsDefinitionCollection* findSeparateResultsCollection();

3
ApplicationLibCode/ProjectDataModel/Surfaces/RimSurfaceInView.cpp
View File

@ -30,7 +30,6 @@
#include "RiuViewer.h" #include "RiuViewer.h"
#include "RivHexGridIntersectionTools.h"
#include "RivSurfacePartMgr.h" #include "RivSurfacePartMgr.h"
#include "cafPdmUiDoubleSliderEditor.h" #include "cafPdmUiDoubleSliderEditor.h"
@ -144,7 +143,7 @@ RivSurfacePartMgr* RimSurfaceInView::surfacePartMgr()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
const RivIntersectionGeometryGeneratorIF* RimSurfaceInView::intersectionGeometryGenerator() const const RivIntersectionGeometryGeneratorInterface* RimSurfaceInView::intersectionGeometryGenerator() const
{ {
if ( m_surfacePartMgr.notNull() ) return m_surfacePartMgr->intersectionGeometryGenerator(); if ( m_surfacePartMgr.notNull() ) return m_surfacePartMgr->intersectionGeometryGenerator();

6
ApplicationLibCode/ProjectDataModel/Surfaces/RimSurfaceInView.h
View File

@ -51,9 +51,9 @@ public:
bool isNativeSurfaceResultsActive() const; bool isNativeSurfaceResultsActive() const;
RimSurfaceResultDefinition* surfaceResultDefinition(); RimSurfaceResultDefinition* surfaceResultDefinition();
void clearGeometry(); void clearGeometry();
RivSurfacePartMgr* surfacePartMgr(); RivSurfacePartMgr* surfacePartMgr();
const RivIntersectionGeometryGeneratorIF* intersectionGeometryGenerator() const override; const RivIntersectionGeometryGeneratorInterface* intersectionGeometryGenerator() const override;
void loadDataAndUpdate(); void loadDataAndUpdate();

4
ApplicationLibCode/ProjectDataModel/Surfaces/RimSurfaceInViewCollection.cpp
View File

@ -516,9 +516,9 @@ std::vector<RimRegularLegendConfig*> RimSurfaceInViewCollection::legendConfigs()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::vector<const RivIntersectionGeometryGeneratorIF*> RimSurfaceInViewCollection::intersectionGeometryGenerators() const std::vector<const RivIntersectionGeometryGeneratorInterface*> RimSurfaceInViewCollection::intersectionGeometryGenerators() const
{ {
std::vector<const RivIntersectionGeometryGeneratorIF*> generators; std::vector<const RivIntersectionGeometryGeneratorInterface*> generators;
for ( auto surf : m_surfacesInView ) for ( auto surf : m_surfacesInView )
{ {

7
ApplicationLibCode/ProjectDataModel/Surfaces/RimSurfaceInViewCollection.h
View File

@ -38,7 +38,7 @@ class RimSurfaceCollection;
class RimEnsembleSurface; class RimEnsembleSurface;
class RimRegularLegendConfig; class RimRegularLegendConfig;
class RiuViewer; class RiuViewer;
class RivIntersectionGeometryGeneratorIF; class RivIntersectionGeometryGeneratorInterface;
class RimSurfaceInViewCollection : public RimCheckableNamedObject class RimSurfaceInViewCollection : public RimCheckableNamedObject
{ {
@ -66,14 +66,13 @@ public:
std::vector<RimRegularLegendConfig*> legendConfigs(); std::vector<RimRegularLegendConfig*> legendConfigs();
std::vector<const RivIntersectionGeometryGeneratorIF*> intersectionGeometryGenerators() const; std::vector<const RivIntersectionGeometryGeneratorInterface*> intersectionGeometryGenerators() const;
protected: protected:
void initAfterRead() override; void initAfterRead() override;
caf::PdmFieldHandle* userDescriptionField() override; caf::PdmFieldHandle* userDescriptionField() override;
void defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName = "" ) override;
void defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName = "") override;
private: private:
void fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue ) override; void fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue ) override;

4
ApplicationLibCode/ReservoirDataModel/RigVisibleCategoriesCalculator.cpp
View File

@ -45,7 +45,7 @@
#include "RimSurfaceInView.h" #include "RimSurfaceInView.h"
#include "RimSurfaceInViewCollection.h" #include "RimSurfaceInViewCollection.h"
#include "RivHexGridIntersectionTools.h" #include "RivIntersectionGeometryGeneratorInterface.h"
#include <cmath> #include <cmath>
@ -199,7 +199,7 @@ void RigVisibleCategoriesCalculator::appendVisibleFaultCells( RimEclipseView* ec
void RigVisibleCategoriesCalculator::appendVisibleIntersectionCells( RimEclipseView* eclView, std::set<size_t>& visibleCells ) void RigVisibleCategoriesCalculator::appendVisibleIntersectionCells( RimEclipseView* eclView, std::set<size_t>& visibleCells )
{ {
// Intersections // Intersections
std::vector<const RivIntersectionGeometryGeneratorIF*> intersectionGeoGenerators; std::vector<const RivIntersectionGeometryGeneratorInterface*> intersectionGeoGenerators;
if ( !eclView->separateIntersectionResultsCollection()->isActive() ) if ( !eclView->separateIntersectionResultsCollection()->isActive() )
{ {

2
ApplicationLibCode/UserInterface/RiuGeoMechXfTensorResultAccessor.cpp
View File

@ -18,7 +18,7 @@
#include "RiuGeoMechXfTensorResultAccessor.h" #include "RiuGeoMechXfTensorResultAccessor.h"
#include "RigFemPartResultsCollection.h" #include "RigFemPartResultsCollection.h"
#include "RivHexGridIntersectionTools.h" #include "RivIntersectionVertexWeights.h"
#include "cvfAssert.h" #include "cvfAssert.h"
#include "cvfGeometryTools.h" #include "cvfGeometryTools.h"

8
ApplicationLibCode/UserInterface/RiuViewerCommands.cpp
View File

@ -1077,6 +1077,7 @@ void RiuViewerCommands::findCellAndGridIndex( Rim3dView* m
{ {
CVF_ASSERT( cellIndex && gridIndex ); CVF_ASSERT( cellIndex && gridIndex );
RimEclipseCase* eclipseCase = nullptr; RimEclipseCase* eclipseCase = nullptr;
RimGeoMechCase* geomechCase = dynamic_cast<RimGeoMechCase*>( mainOrComparisonView->ownerCase() );
if ( sepInterResDef ) if ( sepInterResDef )
{ {
@ -1096,6 +1097,13 @@ void RiuViewerCommands::findCellAndGridIndex( Rim3dView* m
*cellIndex = cell.gridLocalCellIndex(); *cellIndex = cell.gridLocalCellIndex();
*gridIndex = cell.hostGrid()->gridIndex(); *gridIndex = cell.hostGrid()->gridIndex();
} }
else if ( geomechCase )
{
RigFemPartCollection* parts = geomechCase->geoMechData()->femParts();
auto [partId, elementIdx] = parts->partIdAndElementIndex( globalCellIndex );
*cellIndex = elementIdx;
*gridIndex = (size_t)partId;
}
else else
{ {
*cellIndex = globalCellIndex; *cellIndex = globalCellIndex;