#8375 Flow Vectors : Avoid recomputing NNCs when accessing flow data

Avoid include of RigNNCData.h in header files.

ApplicationLibCode/FileInterface/RifReaderEclipseOutput.cpp

@@ -41,6 +41,7 @@
 #include "RigEclipseResultInfo.h"
 #include "RigEquil.h"
 #include "RigMainGrid.h"
+#include "RigNNCData.h"
 #include "RigSimWellData.h"
 #include "RigWellResultPoint.h"
 
@@ -769,7 +770,7 @@ void RifReaderEclipseOutput::transferStaticNNCData( const ecl_grid_type* mainEcl
                     transmissibilityValuesTemp.push_back( transValues[nIdx] );
                 }
 
-                mainGrid->nncData()->setNativeConnections( nncConnections );
+                mainGrid->nncData()->setEclipseConnections( nncConnections );
                 mainGrid->nncData()->makeScalarResultAndSetValues( RiaDefines::propertyNameCombTrans(),
                                                                    transmissibilityValuesTemp );
             }

ApplicationLibCode/ModelVisualization/RivElementVectorResultPartMgr.cpp

@@ -29,6 +29,7 @@
 #include "RigEclipseCaseData.h"
 #include "RigEclipseResultAddress.h"
 #include "RigMainGrid.h"
+#include "RigNNCData.h"
 
 #include "cafDisplayCoordTransform.h"
 
@@ -224,11 +225,11 @@ void RivElementVectorResultPartMgr::appendDynamicGeometryPartsToModel( cvf::Mode
         }
     }
 
-    RigNNCData* nncData           = eclipseCaseData->mainGrid()->nncData();
-    size_t      numNncConnections = nncData->connections().size();
-
     if ( result->showNncData() )
     {
+        RigNNCData* nncData = eclipseCaseData->mainGrid()->nncData();
+        nncData->buildPolygonsForEclipseConnections();
+
         std::vector<const std::vector<std::vector<double>>*> nncResultVals;
         std::vector<RigEclipseResultAddress>                 combinedAddresses;
         result->resultAddressesCombined( combinedAddresses );
@@ -244,9 +245,9 @@ void RivElementVectorResultPartMgr::appendDynamicGeometryPartsToModel( cvf::Mode
             }
         }
 
-        for ( size_t nIdx = 0; nIdx < numNncConnections; ++nIdx )
+        for ( size_t nIdx = 0; nIdx < nncData->eclipseConnectionCount(); ++nIdx )
         {
-            const RigConnection& conn = nncData->connections()[nIdx];
+            const RigConnection& conn = nncData->eclipseConnections()[nIdx];
             if ( conn.polygon().size() )
             {
                 double resultValue = 0.0;

ApplicationLibCode/ModelVisualization/RivNNCGeometryGenerator.cpp

@@ -76,7 +76,7 @@ void RivNNCGeometryGenerator::computeArrays()
 
     const cvf::Vec3f offset( m_offset );
     long long        numConnections =
-        static_cast<long long>( m_nncIndexes.isNull() ? m_nncData->connections().size() : m_nncIndexes->size() );
+        static_cast<long long>( m_nncIndexes.isNull() ? m_nncData->allConnections().size() : m_nncIndexes->size() );
 
     bool                  isVisibilityCalcActive = m_cellVisibility.notNull() && m_grid.notNull();
     std::vector<RigCell>* allCells               = nullptr;
@@ -90,12 +90,12 @@ void RivNNCGeometryGenerator::computeArrays()
     {
         size_t conIdx = m_nncIndexes.isNull() ? nIdx : ( *m_nncIndexes )[nIdx];
 
-        if ( !m_includeAllanDiagramGeometry && conIdx >= m_nncData->nativeConnectionCount() )
+        if ( !m_includeAllanDiagramGeometry && conIdx >= m_nncData->eclipseConnectionCount() )
         {
             continue;
         }
 
-        const RigConnection& conn = m_nncData->connections()[conIdx];
+        const RigConnection& conn = m_nncData->allConnections()[conIdx];
 
         if ( conn.polygon().size() )
         {

ApplicationLibCode/ModelVisualization/RivReservoirFaultsPartMgr.cpp

@@ -20,6 +20,7 @@
 #include "RivReservoirFaultsPartMgr.h"
 
 #include "RigMainGrid.h"
+#include "RigNNCData.h"
 
 #include "RimEclipseCase.h"
 #include "RimEclipseCellColors.h"
@@ -200,7 +201,7 @@ void RivReservoirFaultsPartMgr::appendPartsToModel( cvf::ModelBasicList* model )
                 if ( showNncs )
                 {
                     RigMainGrid* mainGrid = m_reservoirView->mainGrid();
-                    mainGrid->nncData()->ensureConnectionDataIsProcessed();
+                    mainGrid->nncData()->ensureAllConnectionDataIsProcessed();
 
                     if ( showCompleteNncGeo )
                     {

ApplicationLibCode/ModelVisualization/RivWellConnectionsPartMgr.cpp

@@ -37,6 +37,8 @@
 #include "cvfModelBasicList.h"
 #include "cvfPart.h"
 
+#include <cmath>
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/Completions/RimFractureContainmentTools.cpp

@@ -33,6 +33,7 @@
 #include "cvfStructGrid.h"
 
 #include <array>
+#include <cmath>
 
 //--------------------------------------------------------------------------------------------------
 ///

ApplicationLibCode/ProjectDataModel/RimEclipseCase.cpp

@@ -35,6 +35,7 @@
 #include "RigCaseCellResultsData.h"
 #include "RigEclipseCaseData.h"
 #include "RigMainGrid.h"
+#include "RigNNCData.h"
 #include "RigSimWellData.h"
 #include "RigVirtualPerforationTransmissibilities.h"
 #include "RigWellResultPoint.h"
@@ -711,7 +712,7 @@ bool RimEclipseCase::ensureNncDataIsComputed()
     RigEclipseCaseData* rigEclipseCase = eclipseCaseData();
     if ( rigEclipseCase && rigEclipseCase->mainGrid() )
     {
-        computedData = rigEclipseCase->mainGrid()->nncData()->ensureConnectionDataIsProcessed();
+        computedData = rigEclipseCase->mainGrid()->nncData()->ensureAllConnectionDataIsProcessed();
     }
 
     return computedData;

ApplicationLibCode/ProjectDataModel/Streamlines/RimStreamlineGenerator.cpp

@@ -24,6 +24,8 @@
 #include "RimStreamline.h"
 #include "RimStreamlineDataAccess.h"
 
+#include <cmath>
+
 //--------------------------------------------------------------------------------------------------
 /// Helper class for prioritizing streamline seed points
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ReservoirDataModel/RigAccWellFlowCalculator.cpp

@@ -25,6 +25,8 @@
 #include "RigSimulationWellCoordsAndMD.h"
 #include "RigWellResultPoint.h"
 
+#include <cmath>
+
 //==================================================================================================
 ///
 ///

ApplicationLibCode/ReservoirDataModel/RigCaseCellResultsData.cpp

@@ -2465,7 +2465,7 @@ void RigCaseCellResultsData::computeNncCombRiTrans()
     bool                     isFaceNormalsOutwards = m_ownerMainGrid->isFaceNormalsOutwards();
 
     // NNC calculation
-    const RigConnectionContainer& nncConnections = m_ownerMainGrid->nncData()->connections();
+    const RigConnectionContainer& nncConnections = m_ownerMainGrid->nncData()->allConnections();
     for ( size_t connIdx = 0; connIdx < nncConnections.size(); connIdx++ )
     {
         size_t                             nativeResvCellIndex = nncConnections[connIdx].c1GlobIdx();
@@ -2829,7 +2829,7 @@ void RigCaseCellResultsData::computeNncCombRiTRANSbyArea()
 
     if ( transResults->size() != riAreaNormTransResults.size() ) return;
 
-    const RigConnectionContainer& connections = m_ownerMainGrid->nncData()->connections();
+    const RigConnectionContainer& connections = m_ownerMainGrid->nncData()->allConnections();
 
     for ( size_t nncConIdx = 0; nncConIdx < riAreaNormTransResults.size(); ++nncConIdx )
     {
@@ -3299,7 +3299,7 @@ void RigCaseCellResultsData::computeAllanResults( RigCaseCellResultsData* cellRe
             formationCount = cellResultsData->activeFormationNames()->formationNames().size();
         }
 
-        const RigConnectionContainer& nncConnections = mainGrid->nncData()->connections();
+        const RigConnectionContainer& nncConnections = mainGrid->nncData()->allConnections();
 
         std::map<std::pair<int, int>, int> formationCombinationToCategory;
         for ( size_t i = 0; i < nncConnections.size(); i++ )

ApplicationLibCode/ReservoirDataModel/RigCaseToCaseCellMapperTools.cpp

@@ -24,6 +24,8 @@
 #include "RigFemPartGrid.h"
 #include "RigMainGrid.h"
 
+#include <cmath>
+
 //==================================================================================================
 ///
 //==================================================================================================

ApplicationLibCode/ReservoirDataModel/RigCaseToCaseRangeFilterMapper.cpp

@@ -27,6 +27,8 @@
 
 #include "RimCellRangeFilter.h"
 
+#include <cmath>
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ReservoirDataModel/RigCellFaceGeometryTools.cpp

@@ -213,6 +213,9 @@ RigConnectionContainer RigCellFaceGeometryTools::computeOtherNncs( const RigMain
     return otherConnections;
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
 void RigCellFaceGeometryTools::extractConnectionsForFace( const RigFault::FaultFace&                     face,
                                                           const RigMainGrid*                             mainGrid,
                                                           const std::set<std::pair<unsigned, unsigned>>& nativeCellPairs,

ApplicationLibCode/ReservoirDataModel/RigMainGrid.cpp

@@ -22,8 +22,10 @@
 
 #include "RiaLogging.h"
 #include "RiaResultNames.h"
+
 #include "RigActiveCellInfo.h"
 #include "RigHexIntersectionTools.h"
+#include "RigNNCData.h"
 
 #include "cvfAssert.h"
 #include "cvfBoundingBoxTree.h"
@@ -591,7 +593,7 @@ void RigMainGrid::distributeNNCsToFaults()
 {
     if ( m_faultsPrCellAcc.isNull() ) return;
 
-    const RigConnectionContainer& nncs = this->nncData()->connections();
+    const RigConnectionContainer& nncs = this->nncData()->allConnections();
     for ( size_t nncIdx = 0; nncIdx < nncs.size(); ++nncIdx )
     {
         // Find the fault for each side of the nnc

ApplicationLibCode/ReservoirDataModel/RigMainGrid.h

@@ -23,7 +23,6 @@
 #include "RigCell.h"
 #include "RigGridBase.h"
 #include "RigLocalGrid.h"
-#include "RigNNCData.h"
 
 #include "cvfBoundingBox.h"
 #include "cvfCollection.h"
@@ -31,6 +30,7 @@
 #include <vector>
 
 class RigActiveCellInfo;
+class RigNNCData;
 
 namespace cvf
 {

ApplicationLibCode/ReservoirDataModel/RigNNCData.cpp

@@ -35,8 +35,9 @@
 ///
 //--------------------------------------------------------------------------------------------------
 RigNNCData::RigNNCData()
-    : m_nativeConnectionCount( 0 )
+    : m_eclipseConnectionCount( 0 )
-    , m_connectionsAreProcessed( false )
+    , m_havePolygonsForEclipseConnections( false )
+    , m_haveGeneratedConnections( false )
     , m_mainGrid( nullptr )
     , m_activeCellInfo( nullptr )
     , m_computeNncForInactiveCells( false )
@@ -54,44 +55,52 @@ void RigNNCData::setSourceDataForProcessing( RigMainGrid*             mainGrid,
     m_activeCellInfo             = activeCellInfo;
     m_computeNncForInactiveCells = includeInactiveCells;
 
-    m_connectionsAreProcessed = false;
+    m_havePolygonsForEclipseConnections = false;
+    m_haveGeneratedConnections          = false;
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RigNNCData::processNativeConnections( const RigMainGrid& mainGrid )
+void RigNNCData::buildPolygonsForEclipseConnections()
 {
-    // cvf::Trace::show("NNC: Total number: " + cvf::String((int)m_connections.size()));
+    if ( m_havePolygonsForEclipseConnections ) return;
+    if ( !m_mainGrid ) return;
 
 #pragma omp parallel for
-    for ( int cnIdx = 0; cnIdx < (int)m_connections.size(); ++cnIdx )
+    for ( int cnIdx = 0; cnIdx < static_cast<int>( eclipseConnectionCount() ); ++cnIdx )
     {
-        const RigCell& c1 = mainGrid.globalCellArray()[m_connections[cnIdx].c1GlobIdx()];
+        const RigCell& c1 = m_mainGrid->globalCellArray()[m_connections[cnIdx].c1GlobIdx()];
-        const RigCell& c2 = mainGrid.globalCellArray()[m_connections[cnIdx].c2GlobIdx()];
+        const RigCell& c2 = m_mainGrid->globalCellArray()[m_connections[cnIdx].c2GlobIdx()];
 
         std::vector<size_t>                connectionPolygon;
         std::vector<cvf::Vec3d>            connectionIntersections;
         cvf::StructGridInterface::FaceType connectionFace = cvf::StructGridInterface::NO_FACE;
 
-        connectionFace =
+        connectionFace = RigCellFaceGeometryTools::calculateCellFaceOverlap( c1,
-            RigCellFaceGeometryTools::calculateCellFaceOverlap( c1, c2, mainGrid, &connectionPolygon, &connectionIntersections );
+                                                                             c2,
+                                                                             *m_mainGrid,
+                                                                             &connectionPolygon,
+                                                                             &connectionIntersections );
 
         if ( connectionFace != cvf::StructGridInterface::NO_FACE )
         {
             m_connections[cnIdx].setFace( connectionFace );
-            m_connections[cnIdx].setPolygon(
+            m_connections[cnIdx].setPolygon( RigCellFaceGeometryTools::extractPolygon( m_mainGrid->nodes(),
-                RigCellFaceGeometryTools::extractPolygon( mainGrid.nodes(), connectionPolygon, connectionIntersections ) );
+                                                                                       connectionPolygon,
+                                                                                       connectionIntersections ) );
         }
     }
+
+    m_havePolygonsForEclipseConnections = true;
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RigNNCData::computeCompleteSetOfNncs( const RigMainGrid*       mainGrid,
+void RigNNCData::computeAdditionalNncs( const RigMainGrid*       mainGrid,
-                                           const RigActiveCellInfo* activeCellInfo,
+                                        const RigActiveCellInfo* activeCellInfo,
-                                           bool                     includeInactiveCells )
+                                        bool                     includeInactiveCells )
 {
     RigConnectionContainer otherConnections =
         RigCellFaceGeometryTools::computeOtherNncs( mainGrid, m_connections, activeCellInfo, includeInactiveCells );
@@ -188,9 +197,9 @@ size_t RigNNCData::connectionsWithNoCommonArea( QStringList& connectionTextFirst
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RigNNCData::ensureConnectionDataIsProcessed()
+bool RigNNCData::ensureAllConnectionDataIsProcessed()
 {
-    if ( m_connectionsAreProcessed ) return false;
+    if ( m_haveGeneratedConnections ) return false;
 
     if ( m_mainGrid )
     {
@@ -198,13 +207,13 @@ bool RigNNCData::ensureConnectionDataIsProcessed()
 
         RiaLogging::info( "NNC geometry computation - starting process" );
 
-        processNativeConnections( *m_mainGrid );
+        buildPolygonsForEclipseConnections();
         progressInfo.incrementProgress();
 
-        computeCompleteSetOfNncs( m_mainGrid, m_activeCellInfo, m_computeNncForInactiveCells );
+        computeAdditionalNncs( m_mainGrid, m_activeCellInfo, m_computeNncForInactiveCells );
         progressInfo.incrementProgress();
 
-        m_connectionsAreProcessed = true;
+        m_haveGeneratedConnections = true;
 
         m_mainGrid->distributeNNCsToFaults();
 
@@ -215,7 +224,7 @@ bool RigNNCData::ensureConnectionDataIsProcessed()
 
         RiaLogging::info( "NNC geometry computation - completed process" );
 
-        RiaLogging::info( QString( "Native NNC count : %1" ).arg( nativeConnectionCount() ) );
+        RiaLogging::info( QString( "Native NNC count : %1" ).arg( eclipseConnectionCount() ) );
         RiaLogging::info( QString( "Computed NNC count : %1" ).arg( m_connections.size() ) );
 
         RiaLogging::info( QString( "NNCs with no common area count : %1" ).arg( noCommonAreaCount ) );
@@ -237,28 +246,41 @@ bool RigNNCData::ensureConnectionDataIsProcessed()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RigNNCData::setNativeConnections( RigConnectionContainer& connections )
+void RigNNCData::setEclipseConnections( RigConnectionContainer& eclipseConnections )
 {
-    m_connections           = connections;
+    m_connections            = eclipseConnections;
-    m_nativeConnectionCount = m_connections.size();
+    m_eclipseConnectionCount = m_connections.size();
 
-    m_connectionsAreProcessed = false;
+    m_haveGeneratedConnections = false;
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-size_t RigNNCData::nativeConnectionCount() const
+size_t RigNNCData::eclipseConnectionCount() const
 {
-    return m_nativeConnectionCount;
+    return m_eclipseConnectionCount;
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RigConnectionContainer& RigNNCData::connections()
+const RigConnectionContainer& RigNNCData::eclipseConnections() const
 {
-    ensureConnectionDataIsProcessed();
+    // Return connections without calling ensureConnectionDataIsProcessed() to avoid potential heavy computations
+    // Relevant if only native connection data is required
+    // NB: If computeAdditionalNncs() is called before this method, the size of this collection is larger than
+    // nativeConnectionCount()
+
+    return m_connections;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RigConnectionContainer& RigNNCData::allConnections()
+{
+    ensureAllConnectionDataIsProcessed();
 
     return m_connections;
 }
@@ -268,7 +290,7 @@ RigConnectionContainer& RigNNCData::connections()
 //--------------------------------------------------------------------------------------------------
 std::vector<double>& RigNNCData::makeStaticConnectionScalarResult( QString nncDataType )
 {
-    ensureConnectionDataIsProcessed();
+    ensureAllConnectionDataIsProcessed();
 
     std::vector<std::vector<double>>& results = m_connectionResults[nncDataType];
     results.resize( 1 );

ApplicationLibCode/ReservoirDataModel/RigNNCData.h

@@ -50,15 +50,17 @@ public:
 
     RigNNCData();
 
-    bool ensureConnectionDataIsProcessed();
     void setSourceDataForProcessing( RigMainGrid*             mainGrid,
                                      const RigActiveCellInfo* activeCellInfo,
                                      bool                     includeInactiveCells );
 
-    void   setNativeConnections( RigConnectionContainer& connections );
+    void                          setEclipseConnections( RigConnectionContainer& eclipseConnections );
-    size_t nativeConnectionCount() const;
+    void                          buildPolygonsForEclipseConnections();
+    size_t                        eclipseConnectionCount() const;
+    const RigConnectionContainer& eclipseConnections() const;
 
-    RigConnectionContainer& connections();
+    bool                    ensureAllConnectionDataIsProcessed();
+    RigConnectionContainer& allConnections();
 
     std::vector<double>&       makeStaticConnectionScalarResult( QString nncDataType );
     const std::vector<double>* staticConnectionScalarResult( const RigEclipseResultAddress& resVarAddr ) const;
@@ -95,20 +97,20 @@ private:
     const QString getNNCDataTypeFromScalarResultIndex( const RigEclipseResultAddress& resVarAddr ) const;
     bool          isNative( QString nncDataType ) const;
 
-    void processNativeConnections( const RigMainGrid& mainGrid );
+    void computeAdditionalNncs( const RigMainGrid*       mainGrid,
-    void computeCompleteSetOfNncs( const RigMainGrid*       mainGrid,
+                                const RigActiveCellInfo* activeCellInfo,
-                                   const RigActiveCellInfo* activeCellInfo,
+                                bool                     includeInactiveCells );
-                                   bool                     includeInactiveCells );
 
     size_t connectionsWithNoCommonArea( QStringList& connectionTextFirstItems, size_t maxItemCount );
 
 private:
     RigConnectionContainer                              m_connections;
-    size_t                                              m_nativeConnectionCount;
+    size_t                                              m_eclipseConnectionCount;
     std::map<QString, std::vector<std::vector<double>>> m_connectionResults;
     std::map<RigEclipseResultAddress, QString>          m_resultAddrToNNCDataType;
 
-    bool                     m_connectionsAreProcessed;
+    bool                     m_havePolygonsForEclipseConnections;
+    bool                     m_haveGeneratedConnections;
     RigMainGrid*             m_mainGrid;
     const RigActiveCellInfo* m_activeCellInfo;
     bool                     m_computeNncForInactiveCells;

ApplicationLibCode/ReservoirDataModel/RigNumberOfFloodedPoreVolumesCalculator.cpp

@@ -24,6 +24,7 @@
 #include "RigCaseCellResultsData.h"
 #include "RigEclipseCaseData.h"
 #include "RigMainGrid.h"
+#include "RigNNCData.h"
 #include "RigReservoirBuilderMock.h"
 
 #include "RimEclipseCase.h"
@@ -101,7 +102,7 @@ RigNumberOfFloodedPoreVolumesCalculator::RigNumberOfFloodedPoreVolumesCalculator
     std::vector<const std::vector<double>*> flowrateKatAllTimeSteps;
 
     RigNNCData*                  nncData     = eclipseCaseData->mainGrid()->nncData();
-    const RigConnectionContainer connections = nncData->connections();
+    const RigConnectionContainer connections = nncData->allConnections();
 
     progress.incrementProgress();
 

ApplicationLibCode/ReservoirDataModel/RigReservoirBuilderMock.cpp

@@ -24,6 +24,7 @@
 #include "RigCell.h"
 #include "RigEclipseCaseData.h"
 #include "RigMainGrid.h"
+#include "RigNNCData.h"
 #include "RigSimWellData.h"
 
 /* rand example: guess the number */
@@ -557,7 +558,7 @@ void RigReservoirBuilderMock::addFaults( RigEclipseCaseData* eclipseCase )
         addNnc( grid, i1, j1, k1, i2, j2, k2, nncConnections );
     }
 
-    grid->nncData()->setNativeConnections( nncConnections );
+    grid->nncData()->setEclipseConnections( nncConnections );
 
     std::vector<double>& tranVals =
         grid->nncData()->makeStaticConnectionScalarResult( RiaDefines::propertyNameCombTrans() );

ApplicationLibCode/SocketInterface/RiaNNCCommands.cpp

@@ -27,6 +27,7 @@
 #include "RigCaseCellResultsData.h"
 #include "RigEclipseCaseData.h"
 #include "RigMainGrid.h"
+#include "RigNNCData.h"
 
 #include "Rim3dOverlayInfoConfig.h"
 #include "RimCellEdgeColors.h"
@@ -64,13 +65,13 @@ public:
 
         RigMainGrid* mainGrid = rimCase->eclipseCaseData()->mainGrid();
 
-        size_t connectionCount = mainGrid->nncData()->connections().size();
+        size_t connectionCount = mainGrid->nncData()->allConnections().size();
 
         socketStream << (quint64)connectionCount;
 
-        for ( size_t i = 0; i < mainGrid->nncData()->connections().size(); ++i )
+        for ( size_t i = 0; i < mainGrid->nncData()->allConnections().size(); ++i )
         {
-            RigConnection connection = mainGrid->nncData()->connections()[i];
+            RigConnection connection = mainGrid->nncData()->allConnections()[i];
 
             const RigCell& cell1 = mainGrid->globalCellArray()[connection.c1GlobIdx()];
             const RigCell& cell2 = mainGrid->globalCellArray()[connection.c2GlobIdx()];
@@ -163,7 +164,7 @@ public:
         }
 
         // then the connection count and time step count.
-        size_t connectionCount = mainGrid->nncData()->connections().size();
+        size_t connectionCount = mainGrid->nncData()->allConnections().size();
         size_t timeStepCount   = requestedTimeSteps.size();
 
         socketStream << (quint64)connectionCount;
@@ -216,7 +217,7 @@ public:
         }
 
         // connection count
-        size_t connectionCount = mainGrid->nncData()->connections().size();
+        size_t connectionCount = mainGrid->nncData()->allConnections().size();
         socketStream << (quint64)connectionCount;
 
         RiaSocketTools::writeBlockData( server,
@@ -479,7 +480,7 @@ public:
         RigNNCData* nncData = m_currentReservoir->eclipseCaseData()->mainGrid()->nncData();
 
         size_t                            connectionCountFromOctave = m_bytesPerTimeStepToRead / sizeof( double );
-        size_t                            connectionCount           = nncData->connections().size();
+        size_t                            connectionCount           = nncData->allConnections().size();
         std::vector<std::vector<double>>* resultsToAdd =
             nncData->generatedConnectionScalarResultByName( m_currentPropertyName );
 

ApplicationLibCode/UnitTests/RigCellGeometryTools-Test.cpp

@@ -21,6 +21,8 @@
 #include "RigCellGeometryTools.h"
 #include "RigMainGrid.h"
 
+#include <cmath> // Needed for HUGE_VAL on Linux
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/UserInterface/RiuCellAndNncPickEventHandler.cpp

@@ -217,7 +217,7 @@ bool RiuCellAndNncPickEventHandler::handle3dPickEvent( const Ric3dPickEvent& eve
             if ( eclipseView )
             {
                 RigMainGrid*         mainGrid = eclipseView->eclipseCase()->eclipseCaseData()->mainGrid();
-                const RigConnection& nncConn  = mainGrid->nncData()->connections()[nncIndex];
+                const RigConnection& nncConn  = mainGrid->nncData()->allConnections()[nncIndex];
 
                 mainGrid->gridAndGridLocalIdxFromGlobalCellIdx( nncConn.c1GlobIdx(), &gridLocalCellIndex );
             }
@@ -308,7 +308,7 @@ bool RiuCellAndNncPickEventHandler::handle3dPickEvent( const Ric3dPickEvent& eve
                      selectedItem->m_nncIndex == nncIndex )
                 {
                     RigMainGrid* mainGrid = eclipseView->eclipseCase()->eclipseCaseData()->mainGrid();
-                    const RigConnection& nncConn = mainGrid->nncData()->connections()[nncIndex];
+                    const RigConnection& nncConn = mainGrid->nncData()->allConnections()[nncIndex];
 
                     size_t c1LocalIdx = cvf::UNDEFINED_SIZE_T;
                     const RigGridBase* grid1 = mainGrid->gridAndGridLocalIdxFromGlobalCellIdx(nncConn.c1GlobIdx(), &c1LocalIdx);

ApplicationLibCode/UserInterface/RiuResultTextBuilder.cpp

@@ -23,6 +23,7 @@
 #include "RigEclipseCaseData.h"
 #include "RigFormationNames.h"
 #include "RigMainGrid.h"
+#include "RigNNCData.h"
 #include "RigResultAccessor.h"
 #include "RigResultAccessorFactory.h"
 #include "RigSimWellData.h"
@@ -444,9 +445,9 @@ QString RiuResultTextBuilder::nncResultText()
             RigNNCData* nncData = grid->nncData();
             CVF_ASSERT( nncData );
 
-            if ( nncData && m_nncIndex < nncData->connections().size() )
+            if ( nncData && m_nncIndex < nncData->allConnections().size() )
             {
-                const RigConnection& conn = nncData->connections()[m_nncIndex];
+                const RigConnection& conn = nncData->allConnections()[m_nncIndex];
 
                 cvf::StructGridInterface::FaceEnum face( conn.face() );
 
@@ -800,11 +801,11 @@ QString RiuResultTextBuilder::nncDetails()
             RigNNCData* nncData = grid->nncData();
             CVF_ASSERT( nncData );
 
-            if ( nncData && m_nncIndex < nncData->connections().size() )
+            if ( nncData && m_nncIndex < nncData->allConnections().size() )
             {
                 text += "-- NNC details --\n";
                 {
-                    const RigConnection&               conn = nncData->connections()[m_nncIndex];
+                    const RigConnection&               conn = nncData->allConnections()[m_nncIndex];
                     cvf::StructGridInterface::FaceEnum face( conn.face() );
 
                     // First cell of NNC

GrpcInterface/RiaGrpcNNCPropertiesService.cpp

@@ -25,6 +25,7 @@
 #include "RigEclipseResultAddress.h"
 #include "RigEclipseResultInfo.h"
 #include "RigMainGrid.h"
+#include "RigNNCData.h"
 
 #include "RimEclipseCase.h"
 #include "RimEclipseCellColors.h"
@@ -89,7 +90,7 @@ rips::Vec3i* createConnectionVec3i( const RigCell& cell )
 grpc::Status RiaNNCConnectionsStateHandler::assignReply( rips::NNCConnections* reply )
 {
     RigMainGrid*                  mainGrid    = m_eclipseCase->eclipseCaseData()->mainGrid();
-    const RigConnectionContainer& connections = mainGrid->nncData()->connections();
+    const RigConnectionContainer& connections = mainGrid->nncData()->allConnections();
 
     size_t       connectionCount = connections.size();
     const size_t packageSize     = RiaGrpcServiceInterface::numberOfDataUnitsInPackage( sizeof( rips::NNCConnection ) );
@@ -189,7 +190,7 @@ const std::vector<double>* getScalarResultByName( const RigNNCData*         nncD
 grpc::Status RiaNNCValuesStateHandler::assignReply( rips::NNCValues* reply )
 {
     RigMainGrid* mainGrid    = m_eclipseCase->eclipseCaseData()->mainGrid();
-    auto         connections = mainGrid->nncData()->connections();
+    auto         connections = mainGrid->nncData()->allConnections();
 
     QString                   propertyName = QString::fromStdString( m_request->property_name() );
     RigNNCData::NNCResultType propertyType = static_cast<RigNNCData::NNCResultType>( m_request->property_type() );
@@ -362,7 +363,7 @@ grpc::Status RiaNNCInputValuesStateHandler::init( const NNCValuesInputRequest* r
         m_eclipseCase->results( m_porosityModel )->ensureKnownResultLoaded( resAddr );
         nncData->setEclResultAddress( m_propertyName, resAddr );
 
-        m_cellCount = caseData->mainGrid()->nncData()->connections().size();
+        m_cellCount = caseData->mainGrid()->nncData()->allConnections().size();
 
         resultsToAdd->resize( m_cellCount, HUGE_VAL );