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

Refactor: Extract getPartIndexFromPoint to avoid duplication.

Browse Source
This commit is contained in:
Kristian Bendiksen 2024-01-03 09:00:32 +01:00
parent 62c7007654
commit ffa117e736
6 changed files with 46 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -18,6 +18,9 @@
/////////////////////////////////////////////////////////////////////////////////
#include "RigFemPartCollection.h"
#include "RigHexIntersectionTools.h"
#include "cvfBoundingBox.h"
//--------------------------------------------------------------------------------------------------
@ -181,6 +184,40 @@ void RigFemPartCollection::findIntersectingGlobalElementIndices( const cvf::Boun
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
int RigFemPartCollection::getPartIndexFromPoint( const cvf::Vec3d& point ) const
{
const int idx = -1;
// Find candidates for intersected global elements
const cvf::BoundingBox intersectingBb( point, point );
std::vector<size_t> intersectedGlobalElementIndexCandidates;
findIntersectingGlobalElementIndices( intersectingBb, &intersectedGlobalElementIndexCandidates );
if ( intersectedGlobalElementIndexCandidates.empty() ) return idx;
// Iterate through global element candidates and check if point is in hexCorners
for ( const auto& globalElementIndex : intersectedGlobalElementIndexCandidates )
{
const auto [part, elementIndex] = partAndElementIndex( globalElementIndex );
// Find nodes from element
std::array<cvf::Vec3d, 8> coordinates;
if ( part->fillElementCoordinates( elementIndex, coordinates ) )
{
if ( RigHexIntersectionTools::isPointInCell( point, coordinates.data() ) )
{
return part->elementPartId();
}
}
}
// Utilize first part to have an id
return idx;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

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

@ -49,6 +49,8 @@ public:
size_t globalElementNodeResultIdx( int part, int elementIdx, int elmLocalNodeIdx ) const;
int getPartIndexFromPoint( const cvf::Vec3d& point ) const;
private:
cvf::Collection<RigFemPart> m_femParts;
std::vector<size_t> m_partElementOffset;

40
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorStress.cpp
View File

@ -99,50 +99,18 @@ void RimFaultReactivationDataAccessorStress::updateResultAccessor()
{
std::vector<cvf::Vec3d> wellPoints = generateWellPoints( faultTopPosition, faultBottomPosition, faultNormal * distanceFromFault );
m_faceAWellPath = new RigWellPath( wellPoints, generateMds( wellPoints ) );
m_partIndexA = getPartIndexFromPoint( *geoMechPartCollection, wellPoints[1] );
m_partIndexA = geoMechPartCollection->getPartIndexFromPoint( wellPoints[1] );
m_extractorA = new RigGeoMechWellLogExtractor( m_geoMechCaseData, partIndex, m_faceAWellPath.p(), errorName );
}
{
std::vector<cvf::Vec3d> wellPoints = generateWellPoints( faultTopPosition, faultBottomPosition, -faultNormal * distanceFromFault );
m_faceBWellPath = new RigWellPath( wellPoints, generateMds( wellPoints ) );
m_partIndexB = getPartIndexFromPoint( *geoMechPartCollection, wellPoints[1] );
m_partIndexB = geoMechPartCollection->getPartIndexFromPoint( wellPoints[1] );
m_extractorB = new RigGeoMechWellLogExtractor( m_geoMechCaseData, partIndex, m_faceBWellPath.p(), errorName );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
int RimFaultReactivationDataAccessorStress::getPartIndexFromPoint( const RigFemPartCollection& partCollection, const cvf::Vec3d& point )
{
const int idx = 0;
// Find candidates for intersected global elements
const cvf::BoundingBox intersectingBb( point, point );
std::vector<size_t> intersectedGlobalElementIndexCandidates;
partCollection.findIntersectingGlobalElementIndices( intersectingBb, &intersectedGlobalElementIndexCandidates );
if ( intersectedGlobalElementIndexCandidates.empty() ) return idx;
// Iterate through global element candidates and check if point is in hexCorners
for ( const auto& globalElementIndex : intersectedGlobalElementIndexCandidates )
{
const auto [part, elementIndex] = partCollection.partAndElementIndex( globalElementIndex );
// Find nodes from element
std::array<cvf::Vec3d, 8> coordinates;
const bool isSuccess = part->fillElementCoordinates( elementIndex, coordinates );
if ( !isSuccess ) continue;
const bool isPointInCell = RigHexIntersectionTools::isPointInCell( point, coordinates.data() );
if ( isPointInCell ) return part->elementPartId();
}
// Utilize first part to have an id
return idx;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -255,8 +223,8 @@ std::pair<double, cvf::Vec3d> RimFaultReactivationDataAccessorStress::getPorBar(
int frameIndex ) const
{
RigFemPartCollection* partCollection = m_geoMechCaseData->femParts();
cvf::ref<RigGeoMechWellLogExtractor> extractor = m_partIndexA == getPartIndexFromPoint( *partCollection, position ) ? m_extractorA
: m_extractorB;
cvf::ref<RigGeoMechWellLogExtractor> extractor = m_partIndexA == partCollection->getPartIndexFromPoint( position ) ? m_extractorA
: m_extractorB;
if ( !extractor->valid() )
{
RiaLogging::error( "Invalid extractor when extracting PorBar" );

1
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationDataAccessorStress.h
View File

@ -82,7 +82,6 @@ private:
findElementSetContainingElement( const std::map<RimFaultReactivation::ElementSets, std::vector<unsigned int>>& elementSets,
unsigned int elmIdx );
static int getPartIndexFromPoint( const RigFemPartCollection& partCollection, const cvf::Vec3d& point );
static std::pair<int, int> findIntersectionsForTvd( const std::vector<cvf::Vec3d>& intersections, double tvd );
static std::pair<int, int> findOverburdenAndUnderburdenIndex( const std::vector<double>& values );
static double computePorBarWithGradient( const std::vector<cvf::Vec3d>& intersections,

40
ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechFaultReactivationResult.cpp
View File

@ -29,7 +29,6 @@
#include "RigFemPartCollection.h"
#include "RigGeoMechCaseData.h"
#include "RigHexIntersectionTools.h"
#include "RigReservoirGridTools.h"
#include "RimFaultReactivationTools.h"
@ -253,8 +252,8 @@ void RimGeoMechFaultReactivationResult::createWellGeometry()
m_faceBWellPath->createWellPathGeometry();
// Detect which part well path centers are in
m_faceAWellPathPartIndex = getPartIndexFromPoint( geoMechPartCollection, partATop );
m_faceBWellPathPartIndex = getPartIndexFromPoint( geoMechPartCollection, partBTop );
m_faceAWellPathPartIndex = geoMechPartCollection->getPartIndexFromPoint( partATop );
m_faceBWellPathPartIndex = geoMechPartCollection->getPartIndexFromPoint( partBTop );
// Update UI
wellPathCollection->uiCapability()->updateConnectedEditors();
@ -328,40 +327,7 @@ void RimGeoMechFaultReactivationResult::createWellLogCurves()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
int RimGeoMechFaultReactivationResult::getPartIndexFromPoint( const RigFemPartCollection* const partCollection, const cvf::Vec3d& point ) const
{
const int idx = 0;
if ( !partCollection ) return idx;
// Find candidates for intersected global elements
const cvf::BoundingBox intersectingBb( point, point );
std::vector<size_t> intersectedGlobalElementIndexCandidates;
partCollection->findIntersectingGlobalElementIndices( intersectingBb, &intersectedGlobalElementIndexCandidates );
if ( intersectedGlobalElementIndexCandidates.empty() ) return idx;
// Iterate through global element candidates and check if point is in hexCorners
for ( const auto& globalElementIndex : intersectedGlobalElementIndexCandidates )
{
const auto [part, elementIndex] = partCollection->partAndElementIndex( globalElementIndex );
// Find nodes from element
std::array<cvf::Vec3d, 8> coordinates;
const bool isSuccess = part->fillElementCoordinates( elementIndex, coordinates );
if ( !isSuccess ) continue;
const bool isPointInCell = RigHexIntersectionTools::isPointInCell( point, coordinates.data() );
if ( isPointInCell ) return part->elementPartId();
}
// Utilize first part to have an id
return idx;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimWellLogExtractionCurve* RimGeoMechFaultReactivationResult::createWellLogExtractionCurveAndAddToTrack( RimWellLogTrack* track,
RimWellLogExtractionCurve* RimGeoMechFaultReactivationResult::createWellLogExtractionCurveAndAddToTrack( RimWellLogTrack* track,
const RigFemResultAddress& resultAddress,
RimModeledWellPath* wellPath,
int partId )

2
ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechFaultReactivationResult.h
View File

@ -58,8 +58,6 @@ private:
void createWellGeometry();
void createWellLogCurves();
int getPartIndexFromPoint( const RigFemPartCollection* const partCollection, const cvf::Vec3d& point ) const;
RimWellLogExtractionCurve* createWellLogExtractionCurveAndAddToTrack( RimWellLogTrack* track,
const RigFemResultAddress& resultAddress,
RimModeledWellPath* wellPath,