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

Improve NNC memory use

Browse Source
This commit is contained in:
Gaute Lindkvist 2020-05-14 19:11:45 +02:00 committed by Magne Sjaastad
parent 97dd891d38
commit ab0b05b31c
18 changed files with 178 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp
View File

@ -734,9 +734,8 @@ void RifReaderEclipseOutput::transferStaticNNCData( const ecl_grid_type* mainEcl
RigGridBase* grid1 = mainGrid->gridByIndex( geometry_pair->grid_nr1 ); RigGridBase* grid1 = mainGrid->gridByIndex( geometry_pair->grid_nr1 );
RigGridBase* grid2 = mainGrid->gridByIndex( geometry_pair->grid_nr2 ); RigGridBase* grid2 = mainGrid->gridByIndex( geometry_pair->grid_nr2 );
RigConnection nncConnection; RigConnection nncConnection( grid1->reservoirCellIndex( geometry_pair->global_index1 ),
nncConnection.m_c1GlobIdx = grid1->reservoirCellIndex( geometry_pair->global_index1 ); grid2->reservoirCellIndex( geometry_pair->global_index2 ) );
nncConnection.m_c2GlobIdx = grid2->reservoirCellIndex( geometry_pair->global_index2 );
nncConnections.push_back( nncConnection ); nncConnections.push_back( nncConnection );

6
ApplicationCode/GrpcInterface/RiaGrpcNNCPropertiesService.cpp
View File

@ -97,9 +97,9 @@ grpc::Status RiaNNCConnectionsStateHandler::assignReply( rips::NNCConnections* r
reply->mutable_connections()->Reserve( (int)packageSize ); reply->mutable_connections()->Reserve( (int)packageSize );
for ( ; indexInPackage < packageSize && m_currentIdx < connectionCount; ++indexInPackage ) for ( ; indexInPackage < packageSize && m_currentIdx < connectionCount; ++indexInPackage )
{ {
RigConnection connection = connections[m_currentIdx]; const RigConnection& connection = connections[m_currentIdx];
const RigCell& cell1 = mainGrid->globalCellArray()[connection.m_c1GlobIdx]; const RigCell& cell1 = mainGrid->globalCellArray()[connection.c1GlobIdx()];
const RigCell& cell2 = mainGrid->globalCellArray()[connection.m_c2GlobIdx]; const RigCell& cell2 = mainGrid->globalCellArray()[connection.c2GlobIdx()];
NNCConnection* nncConnection = reply->add_connections(); NNCConnection* nncConnection = reply->add_connections();
nncConnection->set_allocated_cell1( createConnectionVec3i( cell1 ) ); nncConnection->set_allocated_cell1( createConnectionVec3i( cell1 ) );

18
ApplicationCode/ModelVisualization/RivNNCGeometryGenerator.cpp
View File

@ -97,7 +97,7 @@ void RivNNCGeometryGenerator::computeArrays()
const RigConnection& conn = m_nncData->connections()[conIdx]; const RigConnection& conn = m_nncData->connections()[conIdx];
if ( conn.m_polygon.size() ) if ( conn.polygon().size() )
{ {
bool isVisible = true; bool isVisible = true;
if ( isVisibilityCalcActive ) if ( isVisibilityCalcActive )
@ -105,15 +105,15 @@ void RivNNCGeometryGenerator::computeArrays()
bool cell1Visible = false; bool cell1Visible = false;
bool cell2Visible = false; bool cell2Visible = false;
if ( ( *allCells )[conn.m_c1GlobIdx].hostGrid() == m_grid.p() ) if ( ( *allCells )[conn.c1GlobIdx()].hostGrid() == m_grid.p() )
{ {
size_t cell1GridLocalIdx = ( *allCells )[conn.m_c1GlobIdx].gridLocalCellIndex(); size_t cell1GridLocalIdx = ( *allCells )[conn.c1GlobIdx()].gridLocalCellIndex();
cell1Visible = ( *m_cellVisibility )[cell1GridLocalIdx]; cell1Visible = ( *m_cellVisibility )[cell1GridLocalIdx];
} }
if ( ( *allCells )[conn.m_c2GlobIdx].hostGrid() == m_grid.p() ) if ( ( *allCells )[conn.c2GlobIdx()].hostGrid() == m_grid.p() )
{ {
size_t cell2GridLocalIdx = ( *allCells )[conn.m_c2GlobIdx].gridLocalCellIndex(); size_t cell2GridLocalIdx = ( *allCells )[conn.c2GlobIdx()].gridLocalCellIndex();
cell2Visible = ( *m_cellVisibility )[cell2GridLocalIdx]; cell2Visible = ( *m_cellVisibility )[cell2GridLocalIdx];
} }
@ -122,14 +122,14 @@ void RivNNCGeometryGenerator::computeArrays()
if ( isVisible ) if ( isVisible )
{ {
cvf::Vec3f vx1 = conn.m_polygon[0] - offset; cvf::Vec3f vx1 = conn.polygon()[0] - offset;
cvf::Vec3f vx2; cvf::Vec3f vx2;
cvf::Vec3f vx3 = conn.m_polygon[1] - offset; cvf::Vec3f vx3 = conn.polygon()[1] - offset;
for ( size_t vxIdx = 2; vxIdx < conn.m_polygon.size(); ++vxIdx ) for ( size_t vxIdx = 2; vxIdx < conn.polygon().size(); ++vxIdx )
{ {
vx2 = vx3; vx2 = vx3;
vx3 = conn.m_polygon[vxIdx] - offset; vx3 = conn.polygon()[vxIdx] - offset;
#pragma omp critical( critical_section_RivNNCGeometryGenerator_computeArrays ) #pragma omp critical( critical_section_RivNNCGeometryGenerator_computeArrays )
{ {
vertices.push_back( vx1 ); vertices.push_back( vx1 );

4
ApplicationCode/ProjectDataModel/RimFaultInViewCollection.cpp
View File

@ -280,7 +280,7 @@ void RimFaultInViewCollection::syncronizeFaults()
{ {
size_t gridLocalCellIndex; size_t gridLocalCellIndex;
const RigGridBase* hostGrid = const RigGridBase* hostGrid =
mainGrid->gridAndGridLocalIdxFromGlobalCellIdx( nncConnections[connIndex].m_c1GlobIdx, mainGrid->gridAndGridLocalIdxFromGlobalCellIdx( nncConnections[connIndex].c1GlobIdx(),
&gridLocalCellIndex ); &gridLocalCellIndex );
size_t i, j, k; size_t i, j, k;
@ -303,7 +303,7 @@ void RimFaultInViewCollection::syncronizeFaults()
{ {
size_t gridLocalCellIndex; size_t gridLocalCellIndex;
const RigGridBase* hostGrid = const RigGridBase* hostGrid =
mainGrid->gridAndGridLocalIdxFromGlobalCellIdx( nncConnections[connIndex].m_c2GlobIdx, mainGrid->gridAndGridLocalIdxFromGlobalCellIdx( nncConnections[connIndex].c2GlobIdx(),
&gridLocalCellIndex ); &gridLocalCellIndex );
size_t i, j, k; size_t i, j, k;

15
ApplicationCode/ReservoirDataModel/RigCaseCellResultsData.cpp
View File

@ -2323,9 +2323,10 @@ void RigCaseCellResultsData::computeNncCombRiTrans()
const RigConnectionContainer& nncConnections = m_ownerMainGrid->nncData()->connections(); const RigConnectionContainer& nncConnections = m_ownerMainGrid->nncData()->connections();
for ( size_t connIdx = 0; connIdx < nncConnections.size(); connIdx++ ) for ( size_t connIdx = 0; connIdx < nncConnections.size(); connIdx++ )
{ {
size_t nativeResvCellIndex = nncConnections[connIdx].m_c1GlobIdx; size_t nativeResvCellIndex = nncConnections[connIdx].c1GlobIdx();
size_t neighborResvCellIdx = nncConnections[connIdx].m_c2GlobIdx; size_t neighborResvCellIdx = nncConnections[connIdx].c2GlobIdx();
cvf::StructGridInterface::FaceType faceId = nncConnections[connIdx].m_c1Face; cvf::StructGridInterface::FaceType faceId =
static_cast<cvf::StructGridInterface::FaceType>( nncConnections[connIdx].face() );
ResultIndexFunction permIdxFunc = nullptr; ResultIndexFunction permIdxFunc = nullptr;
std::vector<double>* permResults = nullptr; std::vector<double>* permResults = nullptr;
@ -2370,7 +2371,7 @@ void RigCaseCellResultsData::computeNncCombRiTrans()
cvf::Vec3f faceCenter = cvf::Vec3f::ZERO; cvf::Vec3f faceCenter = cvf::Vec3f::ZERO;
// Polygon center // Polygon center
const std::vector<cvf::Vec3f>& realPolygon = nncConnections[connIdx].m_polygon; const std::vector<cvf::Vec3f>& realPolygon = nncConnections[connIdx].polygon();
for ( size_t pIdx = 0; pIdx < realPolygon.size(); ++pIdx ) for ( size_t pIdx = 0; pIdx < realPolygon.size(); ++pIdx )
{ {
faceCenter += realPolygon[pIdx]; faceCenter += realPolygon[pIdx];
@ -2686,7 +2687,7 @@ void RigCaseCellResultsData::computeNncCombRiTRANSbyArea()
for ( size_t nncConIdx = 0; nncConIdx < riAreaNormTransResults.size(); ++nncConIdx ) for ( size_t nncConIdx = 0; nncConIdx < riAreaNormTransResults.size(); ++nncConIdx )
{ {
const std::vector<cvf::Vec3f>& realPolygon = connections[nncConIdx].m_polygon; const std::vector<cvf::Vec3f>& realPolygon = connections[nncConIdx].polygon();
cvf::Vec3f faceAreaVec = cvf::GeometryTools::polygonAreaNormal3D( realPolygon ); cvf::Vec3f faceAreaVec = cvf::GeometryTools::polygonAreaNormal3D( realPolygon );
double areaOfOverlap = faceAreaVec.length(); double areaOfOverlap = faceAreaVec.length();
@ -3166,8 +3167,8 @@ void RigCaseCellResultsData::computeAllanResults( RigCaseCellResultsData* cellRe
{ {
const auto& c = nncConnections[i]; const auto& c = nncConnections[i];
size_t globCellIdx1 = c.m_c1GlobIdx; size_t globCellIdx1 = c.c1GlobIdx();
size_t globCellIdx2 = c.m_c2GlobIdx; size_t globCellIdx2 = c.c2GlobIdx();
int formation1 = (int)( fnData[globCellIdx1] ); int formation1 = (int)( fnData[globCellIdx1] );
int formation2 = (int)( fnData[globCellIdx2] ); int formation2 = (int)( fnData[globCellIdx2] );

65
ApplicationCode/ReservoirDataModel/RigCellFaceGeometryTools.cpp
View File

@ -119,23 +119,12 @@ cvf::StructGridInterface::FaceType
return cvf::StructGridInterface::NO_FACE; return cvf::StructGridInterface::NO_FACE;
} }
void assignThreadConnections( std::set<std::pair<unsigned, unsigned>>& existingPairs, void assignThreadConnections( RigConnectionContainer& allConnections, RigConnectionContainer& threadConnections )
RigConnectionContainer& allConnections,
RigConnectionContainer& threadConnections )
{ {
for ( size_t i = 0; i < threadConnections.size(); ++i )
{
#pragma omp critical #pragma omp critical
{ {
RigConnection connection = threadConnections[i]; allConnections.push_back( threadConnections );
auto it = existingPairs.emplace( connection.m_c1GlobIdx, connection.m_c2GlobIdx );
if ( it.second )
{
allConnections.push_back( connection );
}
}
} }
threadConnections.clear();
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -155,7 +144,7 @@ RigConnectionContainer RigCellFaceGeometryTools::computeOtherNncs( const RigMain
for ( size_t i = 0; i < nativeConnections.size(); ++i ) for ( size_t i = 0; i < nativeConnections.size(); ++i )
{ {
RigConnection c = nativeConnections[i]; RigConnection c = nativeConnections[i];
nativeCellPairs.emplace( c.m_c1GlobIdx, c.m_c2GlobIdx ); nativeCellPairs.emplace( static_cast<unsigned>( c.c1GlobIdx() ), static_cast<unsigned>( c.c2GlobIdx() ) );
} }
if ( nativeConnections.size() != nativeCellPairs.size() ) if ( nativeConnections.size() != nativeCellPairs.size() )
@ -168,8 +157,7 @@ RigConnectionContainer RigCellFaceGeometryTools::computeOtherNncs( const RigMain
const cvf::Collection<RigFault>& faults = mainGrid->faults(); const cvf::Collection<RigFault>& faults = mainGrid->faults();
std::set<std::pair<unsigned, unsigned>> existingPairs; RigConnectionContainer otherConnections;
RigConnectionContainer otherConnections;
for ( int faultIdx = 0; faultIdx < (int)faults.size(); faultIdx++ ) for ( int faultIdx = 0; faultIdx < (int)faults.size(); faultIdx++ )
{ {
@ -195,38 +183,39 @@ RigConnectionContainer RigCellFaceGeometryTools::computeOtherNncs( const RigMain
if ( atLeastOneCellActive ) activeFaceIndices.push_back( faceIdx ); if ( atLeastOneCellActive ) activeFaceIndices.push_back( faceIdx );
} }
size_t totalNumberOfConnections = 0u;
#pragma omp parallel #pragma omp parallel
{ {
RigConnectionContainer threadConnections; RigConnectionContainer threadConnections;
#pragma omp for schedule( guided ) #pragma omp for schedule( guided ) reduction( + : totalNumberOfConnections )
for ( int activeFaceIdx = 0; activeFaceIdx < static_cast<int>( activeFaceIndices.size() ); activeFaceIdx++ ) for ( int activeFaceIdx = 0; activeFaceIdx < static_cast<int>( activeFaceIndices.size() ); activeFaceIdx++ )
{ {
size_t faceIdx = activeFaceIndices[activeFaceIdx]; size_t faceIdx = activeFaceIndices[activeFaceIdx];
const RigFault::FaultFace& f = faultFaces[faceIdx]; extractConnectionsForFace( faultFaces[faceIdx], mainGrid, nativeCellPairs, threadConnections );
RigConnectionContainer faceConnections = extractConnectionsForFace( f, mainGrid, nativeCellPairs );
threadConnections.insert( faceConnections );
} }
#pragma omp barrier
otherConnections.reserve( otherConnections.size() + totalNumberOfConnections );
// Merge together connections per thread // Merge together connections per thread
assignThreadConnections( existingPairs, otherConnections, threadConnections ); assignThreadConnections( otherConnections, threadConnections );
} // end parallel region } // end parallel region
} }
otherConnections.remove_duplicates();
return otherConnections; return otherConnections;
} }
RigConnectionContainer void RigCellFaceGeometryTools::extractConnectionsForFace( const RigFault::FaultFace& face,
RigCellFaceGeometryTools::extractConnectionsForFace( const RigFault::FaultFace& face, const RigMainGrid* mainGrid,
const RigMainGrid* mainGrid, const std::set<std::pair<unsigned, unsigned>>& nativeCellPairs,
const std::set<std::pair<unsigned, unsigned>>& nativeCellPairs ) RigConnectionContainer& connections )
{ {
RigConnectionContainer faceConnections;
size_t sourceReservoirCellIndex = face.m_nativeReservoirCellIndex; size_t sourceReservoirCellIndex = face.m_nativeReservoirCellIndex;
cvf::StructGridInterface::FaceType sourceCellFace = face.m_nativeFace; cvf::StructGridInterface::FaceType sourceCellFace = face.m_nativeFace;
if ( sourceReservoirCellIndex >= mainGrid->cellCount() ) if ( sourceReservoirCellIndex >= mainGrid->cellCount() )
{ {
return {}; return;
} }
const std::vector<cvf::Vec3d>& mainGridNodes = mainGrid->nodes(); const std::vector<cvf::Vec3d>& mainGridNodes = mainGrid->nodes();
@ -317,7 +306,8 @@ RigConnectionContainer
} }
} }
std::pair<unsigned, unsigned> candidate( sourceReservoirCellIndex, candidateCellIndex ); std::pair<unsigned, unsigned> candidate( static_cast<unsigned>( sourceReservoirCellIndex ),
static_cast<unsigned>( candidateCellIndex ) );
if ( nativeCellPairs.count( candidate ) > 0 ) if ( nativeCellPairs.count( candidate ) > 0 )
{ {
@ -341,17 +331,14 @@ RigConnectionContainer
if ( foundOverlap ) if ( foundOverlap )
{ {
RigConnection conn; RigConnection conn( sourceReservoirCellIndex,
conn.m_c1GlobIdx = sourceReservoirCellIndex; candidateCellIndex,
conn.m_c2GlobIdx = candidateCellIndex; sourceCellFace,
conn.m_c1Face = sourceCellFace; RigCellFaceGeometryTools::extractPolygon( mainGridNodes, polygon, intersections ) );
conn.m_polygon = RigCellFaceGeometryTools::extractPolygon( mainGridNodes, polygon, intersections ); connections.push_back( conn );
faceConnections.push_back( conn );
} }
} }
return faceConnections;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

6
ApplicationCode/ReservoirDataModel/RigCellFaceGeometryTools.h
View File

@ -51,10 +51,10 @@ public:
const RigActiveCellInfo* activeCellInfo, const RigActiveCellInfo* activeCellInfo,
bool includeInactiveCells ); bool includeInactiveCells );
static RigConnectionContainer static void extractConnectionsForFace( const RigFault::FaultFace& face,
extractConnectionsForFace( const RigFault::FaultFace& face,
const RigMainGrid* mainGrid, const RigMainGrid* mainGrid,
const std::set<std::pair<unsigned, unsigned>>& nativeCellPairs ); const std::set<std::pair<unsigned, unsigned>>& nativeCellPairs,
RigConnectionContainer& connections );
static std::vector<cvf::Vec3f> extractPolygon( const std::vector<cvf::Vec3d>& nativeNodes, static std::vector<cvf::Vec3f> extractPolygon( const std::vector<cvf::Vec3d>& nativeNodes,
const std::vector<size_t>& connectionPolygon, const std::vector<size_t>& connectionPolygon,
const std::vector<cvf::Vec3d>& connectionIntersections ); const std::vector<cvf::Vec3d>& connectionIntersections );

10
ApplicationCode/ReservoirDataModel/RigGridBase.cpp
View File

@ -176,6 +176,16 @@ size_t RigGridBase::cellIndexFromIJK( size_t i, size_t j, size_t k ) const
return ci; return ci;
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RigGridBase::cellIndexFromIJKUnguarded( size_t i, size_t j, size_t k ) const
{
size_t ci = i + j * ( m_gridPointDimensions.x() - 1 ) +
k * ( ( m_gridPointDimensions.x() - 1 ) * ( m_gridPointDimensions.y() - 1 ) );
return ci;
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

1
ApplicationCode/ReservoirDataModel/RigGridBase.h
View File

@ -91,6 +91,7 @@ public:
cvf::Vec3d displayModelOffset() const override; cvf::Vec3d displayModelOffset() const override;
size_t cellIndexFromIJK( size_t i, size_t j, size_t k ) const override; size_t cellIndexFromIJK( size_t i, size_t j, size_t k ) const override;
size_t cellIndexFromIJKUnguarded( size_t i, size_t j, size_t k ) const;
bool ijkFromCellIndex( size_t cellIndex, size_t* i, size_t* j, size_t* k ) const override; bool ijkFromCellIndex( size_t cellIndex, size_t* i, size_t* j, size_t* k ) const override;
bool cellIJKFromCoordinate( const cvf::Vec3d& coord, size_t* i, size_t* j, size_t* k ) const override; bool cellIJKFromCoordinate( const cvf::Vec3d& coord, size_t* i, size_t* j, size_t* k ) const override;

8
ApplicationCode/ReservoirDataModel/RigMainGrid.cpp
View File

@ -579,16 +579,16 @@ void RigMainGrid::distributeNNCsToFaults()
int fIdx1 = RigFaultsPrCellAccumulator::NO_FAULT; int fIdx1 = RigFaultsPrCellAccumulator::NO_FAULT;
int fIdx2 = RigFaultsPrCellAccumulator::NO_FAULT; int fIdx2 = RigFaultsPrCellAccumulator::NO_FAULT;
if ( conn.m_c1Face != StructGridInterface::NO_FACE ) if ( conn.face() != StructGridInterface::NO_FACE )
{ {
fIdx1 = m_faultsPrCellAcc->faultIdx( conn.m_c1GlobIdx, conn.m_c1Face ); fIdx1 = m_faultsPrCellAcc->faultIdx( conn.c1GlobIdx(), conn.face() );
fIdx2 = m_faultsPrCellAcc->faultIdx( conn.m_c2GlobIdx, StructGridInterface::oppositeFace( conn.m_c1Face ) ); fIdx2 = m_faultsPrCellAcc->faultIdx( conn.c2GlobIdx(), StructGridInterface::oppositeFace( conn.face() ) );
} }
if ( fIdx1 < 0 && fIdx2 < 0 ) if ( fIdx1 < 0 && fIdx2 < 0 )
{ {
cvf::String lgrString( "Same Grid" ); cvf::String lgrString( "Same Grid" );
if ( m_cells[conn.m_c1GlobIdx].hostGrid() != m_cells[conn.m_c2GlobIdx].hostGrid() ) if ( m_cells[conn.c1GlobIdx()].hostGrid() != m_cells[conn.c2GlobIdx()].hostGrid() )
{ {
lgrString = "Different Grid"; lgrString = "Different Grid";
} }

25
ApplicationCode/ReservoirDataModel/RigNNCData.cpp
View File

@ -41,8 +41,8 @@ void RigNNCData::processNativeConnections( const RigMainGrid& mainGrid )
for ( size_t cnIdx = 0; cnIdx < m_connections.size(); ++cnIdx ) for ( size_t cnIdx = 0; cnIdx < m_connections.size(); ++cnIdx )
{ {
const RigCell& c1 = mainGrid.globalCellArray()[m_connections[cnIdx].m_c1GlobIdx]; const RigCell& c1 = mainGrid.globalCellArray()[m_connections[cnIdx].c1GlobIdx()];
const RigCell& c2 = mainGrid.globalCellArray()[m_connections[cnIdx].m_c2GlobIdx]; const RigCell& c2 = mainGrid.globalCellArray()[m_connections[cnIdx].c2GlobIdx()];
std::vector<size_t> connectionPolygon; std::vector<size_t> connectionPolygon;
std::vector<cvf::Vec3d> connectionIntersections; std::vector<cvf::Vec3d> connectionIntersections;
@ -53,21 +53,9 @@ void RigNNCData::processNativeConnections( const RigMainGrid& mainGrid )
if ( connectionFace != cvf::StructGridInterface::NO_FACE ) if ( connectionFace != cvf::StructGridInterface::NO_FACE )
{ {
// Found an overlap polygon. Store data about connection m_connections[cnIdx].setFace( connectionFace );
m_connections[cnIdx].setPolygon(
m_connections.face( cnIdx ) = connectionFace; RigCellFaceGeometryTools::extractPolygon( mainGrid.nodes(), connectionPolygon, connectionIntersections ) );
m_connections.polygon( cnIdx ) =
RigCellFaceGeometryTools::extractPolygon( mainGrid.nodes(), connectionPolygon, connectionIntersections );
// Add to search map, possibly not needed
// m_cellIdxToFaceToConnectionIdxMap[m_connections[cnIdx].m_c1GlobIdx][connectionFace].push_back(cnIdx);
// m_cellIdxToFaceToConnectionIdxMap[m_connections[cnIdx].m_c2GlobIdx][cvf::StructGridInterface::oppositeFace(connectionFace].push_back(cnIdx);
}
else
{
// cvf::Trace::show("NNC: No overlap found for : C1: " + cvf::String((int)m_connections[cnIdx].m_c1GlobIdx)
// + "C2: " + cvf::String((int)m_connections[cnIdx].m_c2GlobIdx));
} }
} }
} }
@ -80,13 +68,12 @@ void RigNNCData::computeCompleteSetOfNncs( const RigMainGrid* mainGrid,
bool includeInactiveCells ) bool includeInactiveCells )
{ {
m_nativeConnectionCount = m_connections.size(); m_nativeConnectionCount = m_connections.size();
RigConnectionContainer otherConnections = RigConnectionContainer otherConnections =
RigCellFaceGeometryTools::computeOtherNncs( mainGrid, m_connections, activeCellInfo, includeInactiveCells ); RigCellFaceGeometryTools::computeOtherNncs( mainGrid, m_connections, activeCellInfo, includeInactiveCells );
if ( !otherConnections.empty() ) if ( !otherConnections.empty() )
{ {
m_connections.insert( otherConnections ); m_connections.push_back( otherConnections );
// Transmissibility values from Eclipse has been read into propertyNameCombTrans in // Transmissibility values from Eclipse has been read into propertyNameCombTrans in
// RifReaderEclipseOutput::transferStaticNNCData(). Initialize computed NNCs with zero transmissibility // RifReaderEclipseOutput::transferStaticNNCData(). Initialize computed NNCs with zero transmissibility

97
ApplicationCode/ReservoirDataModel/RigNncConnection.cpp
View File

@ -18,7 +18,7 @@
#include "RigNncConnection.h" #include "RigNncConnection.h"
#include "cvfMath.h" #include "cvfAssert.h"
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
@ -26,7 +26,7 @@
RigConnection::RigConnection() RigConnection::RigConnection()
: m_c1GlobIdx( cvf::UNDEFINED_UINT ) : m_c1GlobIdx( cvf::UNDEFINED_UINT )
, m_c2GlobIdx( cvf::UNDEFINED_UINT ) , m_c2GlobIdx( cvf::UNDEFINED_UINT )
, m_c1Face( cvf::StructGridInterface::NO_FACE ) , m_c1Face( static_cast<unsigned char>( cvf::StructGridInterface::NO_FACE ) )
{ {
} }
@ -39,11 +39,26 @@ RigConnection::RigConnection( unsigned c1GlobIdx,
const std::vector<cvf::Vec3f>& polygon ) const std::vector<cvf::Vec3f>& polygon )
: m_c1GlobIdx( c1GlobIdx ) : m_c1GlobIdx( c1GlobIdx )
, m_c2GlobIdx( c2GlobIdx ) , m_c2GlobIdx( c2GlobIdx )
, m_c1Face( c1Face ) , m_c1Face( static_cast<unsigned char>( c1Face ) )
, m_polygon( polygon ) , m_polygon( polygon )
{ {
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigConnection::RigConnection( size_t c1GlobIdx,
size_t c2GlobIdx,
cvf::StructGridInterface::FaceType c1Face,
const std::vector<cvf::Vec3f>& polygon )
: m_c1GlobIdx( static_cast<unsigned>( c1GlobIdx ) )
, m_c2GlobIdx( static_cast<unsigned>( c2GlobIdx ) )
, m_c1Face( static_cast<unsigned char>( c1Face ) )
, m_polygon( polygon )
{
CVF_ASSERT( c1GlobIdx < std::numeric_limits<unsigned>::max() && c2GlobIdx < std::numeric_limits<unsigned>::max() );
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -58,7 +73,7 @@ RigConnection::RigConnection( const RigConnection& rhs )
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RigConnection& RigConnection::operator=( RigConnection& rhs ) RigConnection& RigConnection::operator=( const RigConnection& rhs )
{ {
m_c1GlobIdx = rhs.m_c1GlobIdx; m_c1GlobIdx = rhs.m_c1GlobIdx;
m_c2GlobIdx = rhs.m_c2GlobIdx; m_c2GlobIdx = rhs.m_c2GlobIdx;
@ -75,6 +90,14 @@ bool RigConnection::hasCommonArea() const
return m_polygon.size() > 0; return m_polygon.size() > 0;
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigConnection::operator==( const RigConnection& rhs )
{
return m_c1GlobIdx == rhs.m_c1GlobIdx && m_c2GlobIdx == rhs.m_c2GlobIdx;
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -91,37 +114,17 @@ bool RigConnection::operator<( const RigConnection& other ) const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RigConnection RigConnectionContainer::operator[]( size_t i ) const const RigConnection& RigConnectionContainer::operator[]( size_t i ) const
{ {
const auto& globIndices = m_globalIndices[i]; return m_connections[i];
return RigConnection( globIndices.first,
globIndices.second,
static_cast<cvf::StructGridInterface::FaceType>( m_faces[i] ),
m_polygons[i] );
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::pair<unsigned, unsigned>& RigConnectionContainer::indexPair( size_t i ) RigConnection& RigConnectionContainer::operator[]( size_t i )
{ {
return m_globalIndices[i]; return m_connections[i];
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
unsigned char& RigConnectionContainer::face( size_t i )
{
return m_faces[i];
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<cvf::Vec3f>& RigConnectionContainer::polygon( size_t i )
{
return m_polygons[i];
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -129,19 +132,15 @@ std::vector<cvf::Vec3f>& RigConnectionContainer::polygon( size_t i )
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RigConnectionContainer::push_back( const RigConnection& connection ) void RigConnectionContainer::push_back( const RigConnection& connection )
{ {
m_globalIndices.push_back( std::make_pair( connection.m_c1GlobIdx, connection.m_c2GlobIdx ) ); m_connections.push_back( connection );
m_faces.push_back( connection.m_c1Face );
m_polygons.push_back( connection.m_polygon );
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RigConnectionContainer::insert( const RigConnectionContainer& other ) void RigConnectionContainer::push_back( const RigConnectionContainer& other )
{ {
m_globalIndices.insert( m_globalIndices.end(), other.m_globalIndices.begin(), other.m_globalIndices.end() ); m_connections.insert( m_connections.end(), other.m_connections.begin(), other.m_connections.end() );
m_faces.insert( m_faces.end(), other.m_faces.begin(), other.m_faces.end() );
m_polygons.insert( m_polygons.end(), other.m_polygons.begin(), other.m_polygons.end() );
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -149,7 +148,7 @@ void RigConnectionContainer::insert( const RigConnectionContainer& other )
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
size_t RigConnectionContainer::size() const size_t RigConnectionContainer::size() const
{ {
return m_globalIndices.size(); return m_connections.size();
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -157,9 +156,7 @@ size_t RigConnectionContainer::size() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RigConnectionContainer::clear() void RigConnectionContainer::clear()
{ {
m_globalIndices.clear(); m_connections.clear();
m_faces.clear();
m_polygons.clear();
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -167,5 +164,25 @@ void RigConnectionContainer::clear()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RigConnectionContainer::empty() const bool RigConnectionContainer::empty() const
{ {
return m_globalIndices.empty(); return m_connections.empty();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigConnectionContainer::remove_duplicates()
{
std::sort( m_connections.begin(), m_connections.end() );
m_connections.erase( std::unique( m_connections.begin(), m_connections.end() ), m_connections.end() );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigConnectionContainer::reserve( size_t requiredSize )
{
if ( m_connections.capacity() < requiredSize )
{
m_connections.reserve( requiredSize );
}
} }

46
ApplicationCode/ReservoirDataModel/RigNncConnection.h
View File

@ -33,38 +33,54 @@ public:
RigConnection(); RigConnection();
RigConnection( unsigned c1GlobIdx, RigConnection( unsigned c1GlobIdx,
unsigned c2GlobIdx, unsigned c2GlobIdx,
cvf::StructGridInterface::FaceType c1Face, cvf::StructGridInterface::FaceType c1Face = cvf::StructGridInterface::NO_FACE,
const std::vector<cvf::Vec3f>& polygon ); const std::vector<cvf::Vec3f>& polygon = {} );
RigConnection( size_t c1GlobIdx,
size_t c2GlobIdx,
cvf::StructGridInterface::FaceType c1Face = cvf::StructGridInterface::NO_FACE,
const std::vector<cvf::Vec3f>& polygon = {} );
RigConnection( const RigConnection& rhs ); RigConnection( const RigConnection& rhs );
RigConnection& operator=( RigConnection& rhs ); RigConnection& operator=( const RigConnection& rhs );
bool operator==( const RigConnection& rhs );
bool operator<( const RigConnection& other ) const; bool operator<( const RigConnection& other ) const;
bool hasCommonArea() const; bool hasCommonArea() const;
unsigned m_c1GlobIdx; inline size_t c1GlobIdx() const { return m_c1GlobIdx; }
unsigned m_c2GlobIdx; inline size_t c2GlobIdx() const { return m_c2GlobIdx; }
cvf::StructGridInterface::FaceType m_c1Face; inline cvf::StructGridInterface::FaceType face() const
std::vector<cvf::Vec3f> m_polygon; {
return static_cast<cvf::StructGridInterface::FaceType>( m_c1Face );
}
inline void setFace( cvf::StructGridInterface::FaceType face ) { m_c1Face = static_cast<unsigned char>( face ); }
inline const std::vector<cvf::Vec3f>& polygon() const { return m_polygon; }
inline void setPolygon( const std::vector<cvf::Vec3f>& polygon ) { m_polygon = polygon; }
private:
unsigned m_c1GlobIdx;
unsigned m_c2GlobIdx;
unsigned char m_c1Face;
std::vector<cvf::Vec3f> m_polygon;
}; };
class RigConnectionContainer class RigConnectionContainer
{ {
public: public:
RigConnection operator[]( size_t i ) const; RigConnectionContainer() = default;
std::pair<unsigned, unsigned>& indexPair( size_t i ); const RigConnection& operator[]( size_t i ) const;
unsigned char& face( size_t i ); RigConnection& operator[]( size_t i );
std::vector<cvf::Vec3f>& polygon( size_t i );
void push_back( const RigConnection& connection ); void push_back( const RigConnection& connection );
void insert( const RigConnectionContainer& other ); void push_back( const RigConnectionContainer& connection );
size_t size() const; size_t size() const;
void clear(); void clear();
bool empty() const; bool empty() const;
void remove_duplicates();
void reserve( size_t requiredSize );
private: private:
std::vector<std::pair<unsigned, unsigned>> m_globalIndices; std::vector<RigConnection> m_connections;
std::vector<unsigned char> m_faces;
std::vector<std::vector<cvf::Vec3f>> m_polygons;
}; };

4
ApplicationCode/ReservoirDataModel/RigNumberOfFloodedPoreVolumesCalculator.cpp
View File

@ -311,10 +311,10 @@ void RigNumberOfFloodedPoreVolumesCalculator::distributeNNCflow( const RigConnec
RigConnection connection = connections[connectionIndex]; RigConnection connection = connections[connectionIndex];
double connectionValue = flowrateNNC->at( connectionIndex ); double connectionValue = flowrateNNC->at( connectionIndex );
size_t cell1Index = connection.m_c1GlobIdx; size_t cell1Index = connection.c1GlobIdx();
size_t cell1ResultIndex = actCellInfo->cellResultIndex( cell1Index ); size_t cell1ResultIndex = actCellInfo->cellResultIndex( cell1Index );
size_t cell2Index = connection.m_c2GlobIdx; size_t cell2Index = connection.c2GlobIdx();
size_t cell2ResultIndex = actCellInfo->cellResultIndex( cell2Index ); size_t cell2ResultIndex = actCellInfo->cellResultIndex( cell2Index );
if ( connectionValue > 0 ) if ( connectionValue > 0 )

4
ApplicationCode/ReservoirDataModel/RigReservoirBuilderMock.cpp
View File

@ -591,9 +591,7 @@ void RigReservoirBuilderMock::addNnc( RigMainGrid* grid,
size_t c1GlobalIndex = grid->cellIndexFromIJK( i1, j1, k1 ); size_t c1GlobalIndex = grid->cellIndexFromIJK( i1, j1, k1 );
size_t c2GlobalIndex = grid->cellIndexFromIJK( i2, j2, k2 ); size_t c2GlobalIndex = grid->cellIndexFromIJK( i2, j2, k2 );
RigConnection conn; RigConnection conn( c1GlobalIndex, c2GlobalIndex );
conn.m_c1GlobIdx = static_cast<unsigned>( c1GlobalIndex );
conn.m_c2GlobIdx = static_cast<unsigned>( c2GlobalIndex );
nncConnections.push_back( conn ); nncConnections.push_back( conn );
} }

4
ApplicationCode/SocketInterface/RiaNNCCommands.cpp
View File

@ -73,8 +73,8 @@ public:
{ {
RigConnection connection = mainGrid->nncData()->connections()[i]; RigConnection connection = mainGrid->nncData()->connections()[i];
const RigCell& cell1 = mainGrid->globalCellArray()[connection.m_c1GlobIdx]; const RigCell& cell1 = mainGrid->globalCellArray()[connection.c1GlobIdx()];
const RigCell& cell2 = mainGrid->globalCellArray()[connection.m_c2GlobIdx]; const RigCell& cell2 = mainGrid->globalCellArray()[connection.c2GlobIdx()];
sendCellInfo( socketStream, cell1 ); sendCellInfo( socketStream, cell1 );
sendCellInfo( socketStream, cell2 ); sendCellInfo( socketStream, cell2 );

10
ApplicationCode/UserInterface/RiuCellAndNncPickEventHandler.cpp
View File

@ -221,7 +221,7 @@ bool RiuCellAndNncPickEventHandler::handle3dPickEvent( const Ric3dPickEvent& eve
RigMainGrid* mainGrid = eclipseView->eclipseCase()->eclipseCaseData()->mainGrid(); RigMainGrid* mainGrid = eclipseView->eclipseCase()->eclipseCaseData()->mainGrid();
const RigConnection& nncConn = mainGrid->nncData()->connections()[nncIndex]; const RigConnection& nncConn = mainGrid->nncData()->connections()[nncIndex];
mainGrid->gridAndGridLocalIdxFromGlobalCellIdx( nncConn.m_c1GlobIdx, &gridLocalCellIndex ); mainGrid->gridAndGridLocalIdxFromGlobalCellIdx( nncConn.c1GlobIdx(), &gridLocalCellIndex );
} }
} }
else else
@ -298,10 +298,10 @@ bool RiuCellAndNncPickEventHandler::handle3dPickEvent( const Ric3dPickEvent& eve
const RigConnection& nncConn = mainGrid->nncData()->connections()[nncIndex]; const RigConnection& nncConn = mainGrid->nncData()->connections()[nncIndex];
size_t c1LocalIdx = cvf::UNDEFINED_SIZE_T; size_t c1LocalIdx = cvf::UNDEFINED_SIZE_T;
const RigGridBase* grid1 = mainGrid->gridAndGridLocalIdxFromGlobalCellIdx(nncConn.m_c1GlobIdx, &c1LocalIdx); const RigGridBase* grid1 = mainGrid->gridAndGridLocalIdxFromGlobalCellIdx(nncConn.c1GlobIdx(), &c1LocalIdx);
size_t c1GridIdx = grid1->gridIndex(); size_t c1GridIdx = grid1->gridIndex();
size_t c2LocalIdx = cvf::UNDEFINED_SIZE_T; size_t c2LocalIdx = cvf::UNDEFINED_SIZE_T;
const RigGridBase* grid2 = mainGrid->gridAndGridLocalIdxFromGlobalCellIdx(nncConn.m_c2GlobIdx, &c2LocalIdx); const RigGridBase* grid2 = mainGrid->gridAndGridLocalIdxFromGlobalCellIdx(nncConn.c2GlobIdx(), &c2LocalIdx);
size_t c2GridIdx = grid2->gridIndex(); size_t c2GridIdx = grid2->gridIndex();
if (gridLocalCellIndex == c1LocalIdx && gridIndex == c1GridIdx) if (gridLocalCellIndex == c1LocalIdx && gridIndex == c1GridIdx)
@ -311,7 +311,7 @@ bool RiuCellAndNncPickEventHandler::handle3dPickEvent( const Ric3dPickEvent& eve
if (face == cvf::StructGridInterface::NO_FACE) if (face == cvf::StructGridInterface::NO_FACE)
{ {
face = nncConn.m_c1Face; face = nncConn.face();
} }
else else
{ {
@ -324,7 +324,7 @@ bool RiuCellAndNncPickEventHandler::handle3dPickEvent( const Ric3dPickEvent& eve
gridIndex = c1GridIdx; gridIndex = c1GridIdx;
if (face == cvf::StructGridInterface::NO_FACE) if (face == cvf::StructGridInterface::NO_FACE)
{ {
face = cvf::StructGridInterface::oppositeFace(nncConn.m_c1Face); face = cvf::StructGridInterface::oppositeFace(nncConn.face());
} }
else else
{ {

12
ApplicationCode/UserInterface/RiuResultTextBuilder.cpp
View File

@ -446,7 +446,7 @@ QString RiuResultTextBuilder::nncResultText()
{ {
const RigConnection& conn = nncData->connections()[m_nncIndex]; const RigConnection& conn = nncData->connections()[m_nncIndex];
cvf::StructGridInterface::FaceEnum face( conn.m_c1Face ); cvf::StructGridInterface::FaceEnum face( conn.face() );
if ( m_viewWithFaultsSettings && m_viewWithFaultsSettings->currentFaultResultColors() ) if ( m_viewWithFaultsSettings && m_viewWithFaultsSettings->currentFaultResultColors() )
{ {
@ -804,12 +804,12 @@ QString RiuResultTextBuilder::nncDetails()
text += "-- NNC details --\n"; text += "-- NNC details --\n";
{ {
const RigConnection& conn = nncData->connections()[m_nncIndex]; const RigConnection& conn = nncData->connections()[m_nncIndex];
cvf::StructGridInterface::FaceEnum face( conn.m_c1Face ); cvf::StructGridInterface::FaceEnum face( conn.face() );
// First cell of NNC // First cell of NNC
{ {
CVF_ASSERT( conn.m_c1GlobIdx < grid->globalCellArray().size() ); CVF_ASSERT( conn.c1GlobIdx() < grid->globalCellArray().size() );
const RigCell& cell = grid->globalCellArray()[conn.m_c1GlobIdx]; const RigCell& cell = grid->globalCellArray()[conn.c1GlobIdx()];
RigGridBase* hostGrid = cell.hostGrid(); RigGridBase* hostGrid = cell.hostGrid();
size_t gridLocalCellIndex = cell.gridLocalCellIndex(); size_t gridLocalCellIndex = cell.gridLocalCellIndex();
@ -834,8 +834,8 @@ QString RiuResultTextBuilder::nncDetails()
// Second cell of NNC // Second cell of NNC
{ {
CVF_ASSERT( conn.m_c2GlobIdx < grid->globalCellArray().size() ); CVF_ASSERT( conn.c2GlobIdx() < grid->globalCellArray().size() );
const RigCell& cell = grid->globalCellArray()[conn.m_c2GlobIdx]; const RigCell& cell = grid->globalCellArray()[conn.c2GlobIdx()];
RigGridBase* hostGrid = cell.hostGrid(); RigGridBase* hostGrid = cell.hostGrid();
size_t gridLocalCellIndex = cell.gridLocalCellIndex(); size_t gridLocalCellIndex = cell.gridLocalCellIndex();