#1661 Octave interface for getting static and dynamic NNC result values from ResInsight

ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp

@@ -596,7 +596,7 @@ void RifReaderEclipseOutput::transferStaticNNCData(const ecl_grid_type* mainEclG
         // Transform to our own data structures
 
         mainGrid->nncData()->connections().resize(numNNC);
-        std::vector<double>& transmissibilityValues = mainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::COMB_TRANS);
+        std::vector<double>& transmissibilityValues = mainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::propertyNameCombTrans());
         const double* transValues = ecl_nnc_data_get_values(tran_data);
 
         for (int nIdx = 0; nIdx < numNNC; ++nIdx)
@@ -624,9 +624,9 @@ void RifReaderEclipseOutput::transferDynamicNNCData(const ecl_grid_type* mainEcl
 
     size_t timeStepCount = m_dynamicResultsAccess->timeStepCount();
 
-    std::vector< std::vector<double> >& waterFluxData = mainGrid->nncData()->makeDynamicConnectionScalarResult(RigNNCData::FLUX_WAT, timeStepCount);
+    std::vector< std::vector<double> >& waterFluxData = mainGrid->nncData()->makeDynamicConnectionScalarResult(RigNNCData::propertyNameFluxWat(), timeStepCount);
-    std::vector< std::vector<double> >& oilFluxData = mainGrid->nncData()->makeDynamicConnectionScalarResult(RigNNCData::FLUX_OIL, timeStepCount);
+    std::vector< std::vector<double> >& oilFluxData = mainGrid->nncData()->makeDynamicConnectionScalarResult(RigNNCData::propertyNameFluxOil(), timeStepCount);
-    std::vector< std::vector<double> >& gasFluxData = mainGrid->nncData()->makeDynamicConnectionScalarResult(RigNNCData::FLUX_GAS, timeStepCount);
+    std::vector< std::vector<double> >& gasFluxData = mainGrid->nncData()->makeDynamicConnectionScalarResult(RigNNCData::propertyNameFluxGas(), timeStepCount);
 
     for (size_t timeStep = 0; timeStep < timeStepCount; ++timeStep)
     {

ApplicationCode/ProjectDataModel/RimEclipseCase.cpp

@@ -582,22 +582,22 @@ bool RimEclipseCase::openReserviorCase()
             size_t combinedTransResIdx = results->cellResults()->findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::combinedTransmissibilityResultName());
             if (combinedTransResIdx != cvf::UNDEFINED_SIZE_T)
             {
-                eclipseCaseData()->mainGrid()->nncData()->setScalarResultIndex(RigNNCData::COMB_TRANS, combinedTransResIdx);
+                eclipseCaseData()->mainGrid()->nncData()->setScalarResultIndex(RigNNCData::propertyNameCombTrans(), combinedTransResIdx);
             }
             size_t combinedWatFluxResIdx = results->cellResults()->findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, RimDefines::combinedWaterFluxResultName());
             if (combinedWatFluxResIdx != cvf::UNDEFINED_SIZE_T)
             {
-                eclipseCaseData()->mainGrid()->nncData()->setScalarResultIndex(RigNNCData::FLUX_WAT, combinedWatFluxResIdx);
+                eclipseCaseData()->mainGrid()->nncData()->setScalarResultIndex(RigNNCData::propertyNameFluxWat(), combinedWatFluxResIdx);
             }
             size_t combinedOilFluxResIdx = results->cellResults()->findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, RimDefines::combinedOilFluxResultName());
             if (combinedOilFluxResIdx != cvf::UNDEFINED_SIZE_T)
             {
-                eclipseCaseData()->mainGrid()->nncData()->setScalarResultIndex(RigNNCData::FLUX_OIL, combinedOilFluxResIdx);
+                eclipseCaseData()->mainGrid()->nncData()->setScalarResultIndex(RigNNCData::propertyNameFluxOil(), combinedOilFluxResIdx);
             }
             size_t combinedGasFluxResIdx = results->cellResults()->findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, RimDefines::combinedGasFluxResultName());
             if (combinedGasFluxResIdx != cvf::UNDEFINED_SIZE_T)
             {
-                eclipseCaseData()->mainGrid()->nncData()->setScalarResultIndex(RigNNCData::FLUX_GAS, combinedGasFluxResIdx);
+                eclipseCaseData()->mainGrid()->nncData()->setScalarResultIndex(RigNNCData::propertyNameFluxGas(), combinedGasFluxResIdx);
             }
         }
 

ApplicationCode/ProjectDataModel/RimReservoirCellResultsStorage.cpp

@@ -1006,8 +1006,8 @@ void RimReservoirCellResultsStorage::computeNncCombRiTrans()
     std::vector<double> & permXResults = m_cellResults->cellScalarResults(permXResultIdx)[0];
     std::vector<double> & permYResults = m_cellResults->cellScalarResults(permYResultIdx)[0];
     std::vector<double> & permZResults = m_cellResults->cellScalarResults(permZResultIdx)[0];
-    std::vector<double> & riCombTransResults = m_ownerMainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::RI_COMB_TRANS);
+    std::vector<double> & riCombTransResults = m_ownerMainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::propertyNameRiCombTrans());
-    m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::RI_COMB_TRANS, riCombTransScalarResultIndex);
+    m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::propertyNameRiCombTrans(), riCombTransScalarResultIndex);
 
     std::vector<double> * ntgResults     = NULL;
     if (hasNTGResults)
@@ -1250,12 +1250,10 @@ void RimReservoirCellResultsStorage::computeNncCombRiMULT()
 
     if (m_ownerMainGrid->nncData()->staticConnectionScalarResult(riCombMultScalarResultIndex)) return;
 
-    std::vector<double> & riMultResults = m_ownerMainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::RI_COMB_MULT);
+    std::vector<double> & riMultResults = m_ownerMainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::propertyNameRiCombMult());
-    const std::vector<double> * riTransResults = m_ownerMainGrid->nncData()->staticConnectionScalarResult(RigNNCData::RI_COMB_TRANS);
+    const std::vector<double> * riTransResults = m_ownerMainGrid->nncData()->staticConnectionScalarResult(riCombTransScalarResultIndex);
-    const std::vector<double> * transResults = m_ownerMainGrid->nncData()->staticConnectionScalarResult(RigNNCData::COMB_TRANS);
+    const std::vector<double> * transResults = m_ownerMainGrid->nncData()->staticConnectionScalarResult(combTransScalarResultIndex);
-    m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::RI_COMB_MULT, riCombMultScalarResultIndex);
+    m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::propertyNameRiCombMult(), riCombMultScalarResultIndex);
-    m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::RI_COMB_TRANS, riCombTransScalarResultIndex);
-    m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::COMB_TRANS, combTransScalarResultIndex);
 
     for (size_t nncConIdx = 0; nncConIdx < riMultResults.size(); ++nncConIdx)
     {
@@ -1386,8 +1384,8 @@ void RimReservoirCellResultsStorage::computeNncCombRiTRANSbyArea()
 
     if (m_ownerMainGrid->nncData()->staticConnectionScalarResult(riCombTransByAreaScResIdx)) return;
 
-    std::vector<double> & riAreaNormTransResults = m_ownerMainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::RI_COMB_TRANS_BY_AREA);
+    std::vector<double> & riAreaNormTransResults = m_ownerMainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::propertyNameRiCombTransByArea());
-    m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::RI_COMB_TRANS_BY_AREA, riCombTransByAreaScResIdx);
+    m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::propertyNameRiCombTransByArea(), riCombTransByAreaScResIdx);
     const std::vector<double> * transResults = m_ownerMainGrid->nncData()->staticConnectionScalarResult(combTransScalarResultIndex);
 
     const std::vector<RigConnection>& connections = m_ownerMainGrid->nncData()->connections();

ApplicationCode/ReservoirDataModel/RigNNCData.cpp

@@ -166,7 +166,7 @@ void RigNNCData::processConnections(const RigMainGrid& mainGrid)
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-std::vector<double>& RigNNCData::makeStaticConnectionScalarResult(NNCDataType nncDataType)
+std::vector<double>& RigNNCData::makeStaticConnectionScalarResult(QString nncDataType)
 {
     std::vector< std::vector<double> >& results = m_connectionResults[nncDataType];
     results.resize(1);
@@ -179,15 +179,14 @@ std::vector<double>& RigNNCData::makeStaticConnectionScalarResult(NNCDataType nn
 //--------------------------------------------------------------------------------------------------
 const std::vector<double>* RigNNCData::staticConnectionScalarResult(size_t scalarResultIndex) const
 {
-    const NNCDataType* nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex);
+    QString nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex);
-    if (!nncDataType) return nullptr;
+    if (nncDataType.isNull()) return nullptr;
 
-    std::map<NNCDataType, std::vector< std::vector<double> > >::const_iterator it = m_connectionResults.find(*nncDataType);
+    std::map<QString, std::vector< std::vector<double> > >::const_iterator it = m_connectionResults.find(nncDataType);
-
-    CVF_ASSERT(it->second.size() == 1);
 
     if (it != m_connectionResults.end())
     {
+        CVF_ASSERT(it->second.size() == 1);
         return &(it->second[0]);
     }
     else
@@ -199,7 +198,26 @@ const std::vector<double>* RigNNCData::staticConnectionScalarResult(size_t scala
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-std::vector< std::vector<double> >& RigNNCData::makeDynamicConnectionScalarResult(NNCDataType nncDataType, size_t timeStepCount)
+const std::vector<double>* RigNNCData::staticConnectionScalarResultByName(const QString& nncDataType) const
+{
+    std::map<QString, std::vector< std::vector<double> > >::const_iterator it = m_connectionResults.find(nncDataType);
+
+
+    if (it != m_connectionResults.end())
+    {
+        CVF_ASSERT(it->second.size() == 1);
+        return &(it->second[0]);
+    }
+    else
+    {
+        return nullptr;
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+std::vector< std::vector<double> >& RigNNCData::makeDynamicConnectionScalarResult(QString nncDataType, size_t timeStepCount)
 {
     auto& results = m_connectionResults[nncDataType];
     results.resize(timeStepCount);
@@ -211,10 +229,10 @@ std::vector< std::vector<double> >& RigNNCData::makeDynamicConnectionScalarResul
 //--------------------------------------------------------------------------------------------------
 const std::vector< std::vector<double> >* RigNNCData::dynamicConnectionScalarResult(size_t scalarResultIndex) const
 {
-    const NNCDataType* nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex);
+    QString nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex);
-    if (!nncDataType) return nullptr;
+    if (nncDataType.isNull()) return nullptr;
 
-    auto it = m_connectionResults.find(*nncDataType);
+    auto it = m_connectionResults.find(nncDataType);
 
     if (it != m_connectionResults.end())
     {
@@ -231,10 +249,10 @@ const std::vector< std::vector<double> >* RigNNCData::dynamicConnectionScalarRes
 //--------------------------------------------------------------------------------------------------
 const std::vector<double>* RigNNCData::dynamicConnectionScalarResult(size_t scalarResultIndex, size_t timeStep) const
 {
-    const NNCDataType* nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex);
+    QString nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex);
-    if (!nncDataType) return nullptr;
+    if (nncDataType.isNull()) return nullptr;
 
-    auto it = m_connectionResults.find(*nncDataType);
+    auto it = m_connectionResults.find(nncDataType);
 
     if (it != m_connectionResults.end())
     {
@@ -249,7 +267,36 @@ const std::vector<double>* RigNNCData::dynamicConnectionScalarResult(size_t scal
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RigNNCData::setScalarResultIndex(NNCDataType nncDataType, size_t scalarResultIndex)
+const std::vector<std::vector<double>>* RigNNCData::dynamicConnectionScalarResultByName(const QString& nncDataType) const
+{
+    auto it = m_connectionResults.find(nncDataType);
+    if (it != m_connectionResults.end())
+    {
+        return &(it->second);
+    }
+    return nullptr;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+const std::vector<double>* RigNNCData::dynamicConnectionScalarResultByName(const QString& nncDataType, size_t timeStep) const
+{
+    auto it = m_connectionResults.find(nncDataType);
+    if (it != m_connectionResults.end())
+    {
+        if (it->second.size() > timeStep)
+        {
+            return &(it->second[timeStep]);
+        }
+    }
+    return nullptr;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigNNCData::setScalarResultIndex(const QString& nncDataType, size_t scalarResultIndex)
 {
     m_resultIndexToNNCDataType[scalarResultIndex] = nncDataType;
 }
@@ -259,24 +306,24 @@ void RigNNCData::setScalarResultIndex(NNCDataType nncDataType, size_t scalarResu
 //--------------------------------------------------------------------------------------------------
 bool RigNNCData::hasScalarValues(size_t scalarResultIndex)
 {
-    const NNCDataType* nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex);
+    QString nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex);
-    if (!nncDataType) return false;
+    if (nncDataType.isNull()) return false;
 
-    auto it = m_connectionResults.find(*nncDataType);
+    auto it = m_connectionResults.find(nncDataType);
     return (it != m_connectionResults.end());
 }
 
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-const RigNNCData::NNCDataType* RigNNCData::getNNCDataTypeFromScalarResultIndex(size_t scalarResultIndex) const
+const QString RigNNCData::getNNCDataTypeFromScalarResultIndex(size_t scalarResultIndex) const
 {
     auto it = m_resultIndexToNNCDataType.find(scalarResultIndex);
     if (it != m_resultIndexToNNCDataType.end())
     {
-        return &it->second;
+        return it->second;
     }
-    return nullptr;
+    return QString();
 }
 
 /*

ApplicationCode/ReservoirDataModel/RigNNCData.h

@@ -58,30 +58,31 @@ public:
 class RigNNCData : public cvf::Object
 {
 public:
-    enum NNCDataType {
+    static QString propertyNameFluxWat()           { return "FLRWAT"; }
-        FLUX_WAT,
+    static QString propertyNameFluxOil()           { return "FLROIL"; }
-        FLUX_OIL,
+    static QString propertyNameFluxGas()           { return "FLRGAS"; }
-        FLUX_GAS,
+    static QString propertyNameCombTrans()         { return "TRAN"; }
-        COMB_TRANS,
+    static QString propertyNameRiCombTrans()       { return "riTRAN"; }
-        RI_COMB_TRANS,
+    static QString propertyNameRiCombTransByArea() { return "riTRANbyArea"; }
-        RI_COMB_MULT,
+    static QString propertyNameRiCombMult()        { return "riMULT"; }
-        RI_COMB_TRANS_BY_AREA,
-    };
    
     RigNNCData();
 
     void processConnections(const RigMainGrid& mainGrid);
   
     std::vector<RigConnection>&         connections()        { return m_connections; }
-    const std::vector<RigConnection>&   connections() const  { return m_connections; };
+    const std::vector<RigConnection>&   connections() const  { return m_connections; }
 
-    std::vector<double>&                      makeStaticConnectionScalarResult(NNCDataType nncDataType);
+    std::vector<double>&                      makeStaticConnectionScalarResult(QString nncDataType);
     const std::vector<double>*                staticConnectionScalarResult(size_t scalarResultIndex) const;
-    std::vector< std::vector<double> >&       makeDynamicConnectionScalarResult(NNCDataType nncDataType, size_t timeStepCount);
+    const std::vector<double>*                staticConnectionScalarResultByName(const QString& nncDataType) const;
+    std::vector< std::vector<double> >&       makeDynamicConnectionScalarResult(QString nncDataType, size_t timeStepCount);
     const std::vector< std::vector<double> >* dynamicConnectionScalarResult(size_t scalarResultIndex) const;
     const std::vector<double>*                dynamicConnectionScalarResult(size_t scalarResultIndex, size_t timeStep) const;
+    const std::vector< std::vector<double> >* dynamicConnectionScalarResultByName(const QString& nncDataType) const;
+    const std::vector<double>*                dynamicConnectionScalarResultByName(const QString& nncDataType, size_t timeStep) const;
 
-    void setScalarResultIndex(NNCDataType nncDataType, size_t scalarResultIndex);
+    void setScalarResultIndex(const QString& nncDataType, size_t scalarResultIndex);
 
     bool hasScalarValues(size_t scalarResultIndex);
 
@@ -90,10 +91,10 @@ private: // This section is possibly not needed
     //typedef std::map<size_t, caf::FixedArray<std::vector<size_t>, 7 > > ConnectionSearchMap;
     //ConnectionSearchMap m_cellIdxToFaceToConnectionIdxMap;
 
-    const NNCDataType* getNNCDataTypeFromScalarResultIndex(size_t scalarResultIndex) const;
+    const QString getNNCDataTypeFromScalarResultIndex(size_t scalarResultIndex) const;
 
 private:
     std::vector<RigConnection>                                 m_connections; 
-    std::map<NNCDataType, std::vector< std::vector<double> > > m_connectionResults;
+    std::map<QString, std::vector< std::vector<double> > >     m_connectionResults;
-    std::map<size_t, NNCDataType>                              m_resultIndexToNNCDataType;
+    std::map<size_t, QString>                                  m_resultIndexToNNCDataType;
 };

ApplicationCode/ReservoirDataModel/RigReservoirBuilderMock.cpp

@@ -542,7 +542,7 @@ void RigReservoirBuilderMock::addFaults(RigEclipseCaseData* eclipseCase)
         addNnc(grid, i1, j1, k1, i2, j2, k2, nncConnections);
     }
 
-    std::vector<double>& tranVals = grid->nncData()->makeStaticConnectionScalarResult(RigNNCData::COMB_TRANS);
+    std::vector<double>& tranVals = grid->nncData()->makeStaticConnectionScalarResult(RigNNCData::propertyNameCombTrans());
     for (size_t cIdx = 0; cIdx < tranVals.size(); ++cIdx)
     {
         tranVals[cIdx] = 0.2;

ApplicationCode/SocketInterface/RiaNNCCommands.cpp

@@ -39,9 +39,7 @@
 #include "RimReservoirCellResultsStorage.h"
 
 #include <QTcpSocket>
-
+#include <QErrorMessage>
-
-
 
 //--------------------------------------------------------------------------------------------------
 ///
@@ -54,8 +52,6 @@ public:
     virtual bool interpretCommand(RiaSocketServer* server, const QList<QByteArray>&  args, QDataStream& socketStream)
     {
         RimEclipseCase* rimCase = RiaSocketTools::findCaseFromArgs(server, args);
-        if (!rimCase) return true;
-
         // Write data back to octave: columnCount, GridNr I J K GridNr I J K
         if (!(rimCase && rimCase->eclipseCaseData() && rimCase->eclipseCaseData()->mainGrid()))
         {
@@ -95,3 +91,126 @@ public:
 };
 
 static bool RiaGetNNCConnections_init = RiaSocketCommandFactory::instance()->registerCreator<RiaGetNNCConnections>(RiaGetNNCConnections::commandName());
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+class RiaGetDynamicNNCValues: public RiaSocketCommand
+{
+public:
+    static QString commandName () { return QString("GetDynamicNNCValues"); }
+
+    virtual bool interpretCommand(RiaSocketServer* server, const QList<QByteArray>&  args, QDataStream& socketStream)
+    {
+        RimEclipseCase* rimCase = RiaSocketTools::findCaseFromArgs(server, args);
+        // Write data back to octave: connectionCount, timeStepCount, property values
+        if (!(rimCase && rimCase->eclipseCaseData() && rimCase->eclipseCaseData()->mainGrid()))
+        {
+            // No data available
+            socketStream << (quint64)0 << (quint64)0;
+            return true;
+        }
+
+        QString propertyName = args[2];
+
+        RigMainGrid* mainGrid = rimCase->eclipseCaseData()->mainGrid();
+        const std::vector< std::vector<double> >* nncValues = mainGrid->nncData()->dynamicConnectionScalarResultByName(propertyName);
+
+        if (nncValues == nullptr)
+        {
+            socketStream << (quint64)0 << (quint64)0;
+            return true;
+        }
+
+        std::vector<size_t> requestedTimeSteps;
+        if (args.size() > 3)
+        {
+            bool timeStepReadError = false;
+            for (int argIdx = 3; argIdx < args.size(); ++argIdx)
+            {
+                bool conversionOk = false;
+                int tsIdx = args[argIdx].toInt(&conversionOk);
+
+                if (conversionOk)
+                {
+                    requestedTimeSteps.push_back(tsIdx);
+                }
+                else
+                {
+                    timeStepReadError = true;
+                }
+            }
+
+            if (timeStepReadError)
+            {
+                server->errorMessageDialog()->showMessage(RiaSocketServer::tr("ResInsight SocketServer: riGetDynamicNNCValues : \n") + RiaSocketServer::tr("An error occurred while interpreting the requested time steps."));
+            }
+        }
+        else
+        {
+            for (size_t timeStep = 0; timeStep < nncValues->size(); ++timeStep)
+            {
+                requestedTimeSteps.push_back(timeStep);
+            }
+        }
+
+        // then the connection count and time step count.
+        size_t connectionCount = mainGrid->nncData()->connections().size();
+        size_t timeStepCount = requestedTimeSteps.size();
+
+        socketStream << (quint64)connectionCount;
+        socketStream << (quint64)timeStepCount;
+
+        for (size_t timeStep : requestedTimeSteps)
+        {
+            const std::vector<double>& timeStepValues = nncValues->at(timeStep);
+            RiaSocketTools::writeBlockData(server, server->currentClient(), (const char *)timeStepValues.data(), sizeof(double) * timeStepValues.size());
+        }
+
+        return true;
+    }
+};
+
+static bool RiaGetDynamicNNCValues_init = RiaSocketCommandFactory::instance()->registerCreator<RiaGetDynamicNNCValues>(RiaGetDynamicNNCValues::commandName());
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+class RiaGetStaticNNCValues: public RiaSocketCommand
+{
+public:
+    static QString commandName () { return QString("GetStaticNNCValues"); }
+
+    virtual bool interpretCommand(RiaSocketServer* server, const QList<QByteArray>&  args, QDataStream& socketStream)
+    {
+        RimEclipseCase* rimCase = RiaSocketTools::findCaseFromArgs(server, args);
+        QString propertyName = args[2];
+
+        // Write data back to octave: connectionCount, property values
+        if (!(rimCase && rimCase->eclipseCaseData() && rimCase->eclipseCaseData()->mainGrid()))
+        {
+            // No data available
+            socketStream << (quint64)0;
+            return true;
+        }
+
+        RigMainGrid* mainGrid = rimCase->eclipseCaseData()->mainGrid();
+        const std::vector<double>* nncValues = mainGrid->nncData()->staticConnectionScalarResultByName(propertyName);
+
+        if (nncValues == nullptr)
+        {
+            socketStream << (quint64)0;
+            return true;
+        }
+
+        // connection count
+        size_t connectionCount = mainGrid->nncData()->connections().size();
+        socketStream << (quint64)connectionCount;
+
+        RiaSocketTools::writeBlockData(server, server->currentClient(), (const char *)nncValues->data(), sizeof(double) * nncValues->size());
+
+        return true;
+    }
+};
+
+static bool RiaGetStaticNNCValues_init = RiaSocketCommandFactory::instance()->registerCreator<RiaGetStaticNNCValues>(RiaGetStaticNNCValues::commandName());

OctavePlugin/CMakeLists.txt

@@ -11,6 +11,8 @@ set(CPP_SOURCES
     riGetNNCConnections.cpp
     riGetCurrentCase.cpp
     riGetCaseGroups.cpp
+    riGetDynamicNNCValues.cpp
+    riGetStaticNNCValues.cpp
     riGetSelectedCases.cpp
     riGetCases.cpp
     riGetTimeStepDates.cpp
@@ -174,6 +176,8 @@ if (RESINSIGHT_OCTAVE_PLUGIN_QMAKE AND RESINSIGHT_OCTAVE_PLUGIN_MKOCTFILE)
       "${CMAKE_CURRENT_BINARY_DIR}/riGetActiveCellInfo.oct"
       "${CMAKE_CURRENT_BINARY_DIR}/riGetMainGridDimensions.oct"
       "${CMAKE_CURRENT_BINARY_DIR}/riGetNNCConnections.oct"
+      "${CMAKE_CURRENT_BINARY_DIR}/riGetDynamicNNCValues.oct"
+      "${CMAKE_CURRENT_BINARY_DIR}/riGetStaticNNCValues.oct"
       "${CMAKE_CURRENT_BINARY_DIR}/riGetCurrentCase.oct"
       "${CMAKE_CURRENT_BINARY_DIR}/riGetCaseGroups.oct"
       "${CMAKE_CURRENT_BINARY_DIR}/riGetSelectedCases.oct"

OctavePlugin/riGetDynamicNNCValues.cpp

@@ -0,0 +1,156 @@
+#include <QtNetwork>
+#include <QStringList>
+
+#include <octave/oct.h>
+
+#include "riSettings.h"
+
+#include "RiaSocketDataTransfer.cpp"  // NB! Include cpp-file to avoid linking of additional file in oct-compile configuration
+
+void getDynamicNNCValues(Matrix& propertyFrames, const QString &serverName, quint16 serverPort,
+                         const qint64& caseId, QString propertyName, const int32NDArray& requestedTimeSteps)
+{
+    QTcpSocket socket;
+    socket.connectToHost(serverName, serverPort);
+
+    if (!socket.waitForConnected(riOctavePlugin::connectTimeOutMilliSecs))
+    {
+        error((("Connection: ") + socket.errorString()).toLatin1().data());
+        return;
+    }
+
+    QDataStream socketStream(&socket);
+    socketStream.setVersion(riOctavePlugin::qtDataStreamVersion);
+
+    // Create command as a string with arguments , and send it:
+    QString command;
+    command += "GetDynamicNNCValues " + QString::number(caseId) + " " + propertyName;
+
+    for (int i = 0; i < requestedTimeSteps.length(); ++i)
+    {
+        if (i == 0) command += " ";
+        command += QString::number(static_cast<int>(requestedTimeSteps.elem(i)) - 1); // To make the index 0-based
+        if (i != requestedTimeSteps.length() -1) command += " ";
+    }
+
+    QByteArray cmdBytes = command.toLatin1();
+
+    socketStream << (qint64)(cmdBytes.size());
+    socket.write(cmdBytes);
+
+    // Get response. First wait for the header
+
+    while (socket.bytesAvailable() < (int)(2*sizeof(quint64)))
+    {
+        if (!socket.waitForReadyRead(riOctavePlugin::longTimeOutMilliSecs))
+        {
+            error((("Waiting for header: ") + socket.errorString()).toLatin1().data());
+            return;
+        }
+    }
+
+    // Read connection count and timestep count
+    quint64 connectionCount;
+    quint64 timestepCount;
+
+    socketStream >> connectionCount;
+    socketStream >> timestepCount;
+
+    propertyFrames.resize(connectionCount, timestepCount);
+
+    if (!(connectionCount && timestepCount))
+    {
+        error ("Could not find the requested data in ResInsight");
+        return;
+    }
+
+    quint64 totalByteCount = timestepCount * connectionCount * sizeof(double);
+
+    double* internalMatrixData = propertyFrames.fortran_vec();
+    QStringList errorMessages;
+    if (!RiaSocketDataTransfer::readBlockDataFromSocket(&socket, (char*)(internalMatrixData), totalByteCount, errorMessages))
+    {
+        for (int i = 0; i < errorMessages.size(); i++)
+        {
+            error(errorMessages[i].toLatin1().data());
+        }
+
+        return;
+    }
+
+    QString tmp = QString("riGetDynamicNNCValues : Read %1").arg(propertyName);
+
+    if (caseId < 0)
+    {
+        tmp += QString(" from current case.");
+    }
+    else
+    {
+        tmp += QString(" from case with Id: %1.").arg(caseId);
+    }
+    octave_stdout << tmp.toStdString() << " Connections: " << connectionCount << ", Time steps : " << timestepCount << std::endl;
+
+    return;
+}
+
+
+DEFUN_DLD (riGetDynamicNNCValues, args, nargout,
+           "Usage:\n"
+           "\n"
+           "   riGetDynamicNNCValues([CaseId], PropertyName, [RequestedTimeSteps])\n"
+           "\n"
+           "This function retrieves the dynamic NNC values for each connection for the requested time steps."
+           )
+{
+    int nargin = args.length ();
+    if (nargin < 1)
+    {
+        error("riGetDynamicNNCValues: Too few arguments. The name of the property requested is necessary.\n");
+        print_usage();
+        return octave_value_list();
+    }
+    else if (nargin > 3)
+    {
+        error("riGetDynamicNNCValues: Too many arguments.\n");
+        print_usage();
+        return octave_value_list();
+    }
+    else if (nargout < 1)
+    {
+        error("riGetDynamicNNCValues: Missing output argument.\n");
+        print_usage();
+        return octave_value_list();
+    }
+
+    std::vector<int> argIndices;
+    argIndices.push_back(0);
+    argIndices.push_back(1);
+    argIndices.push_back(2);
+
+    // Check if we have a CaseId:
+    if (!args(argIndices[0]).is_numeric_type())
+    {
+        argIndices[0] = -1;
+        for (size_t aIdx = 1; aIdx < argIndices.size(); ++aIdx)
+            --argIndices[aIdx];
+    }
+
+    // Check if we have a Requested TimeSteps
+    if (!(nargin > argIndices[2] && args(argIndices[2]).is_matrix_type()))
+    {
+        argIndices[2] = -1;
+    }
+
+    Matrix propertyFrames;
+    qint32 caseId = -1;
+    int32NDArray requestedTimeSteps;
+    std::string propertyName;
+
+    if (argIndices[0] >= 0) caseId             = args(argIndices[0]).int_value();
+    if (argIndices[1] >= 0) propertyName       = args(argIndices[1]).char_matrix_value().row_as_string(0);
+    if (argIndices[2] >= 0) requestedTimeSteps = args(argIndices[2]).int32_array_value();
+
+    getDynamicNNCValues(propertyFrames, "127.0.0.1", 40001, caseId, propertyName.c_str(), requestedTimeSteps);
+
+    return octave_value(propertyFrames);
+}

OctavePlugin/riGetStaticNNCValues.cpp

@@ -0,0 +1,141 @@
+#include <QtNetwork>
+#include <QStringList>
+
+#include <octave/oct.h>
+
+#include "riSettings.h"
+
+#include "RiaSocketDataTransfer.cpp"  // NB! Include cpp-file to avoid linking of additional file in oct-compile configuration
+
+void getStaticNNCValues(std::vector<double>& propertyValues, const QString &serverName, quint16 serverPort,
+                         const qint64& caseId, QString propertyName)
+{
+    QTcpSocket socket;
+    socket.connectToHost(serverName, serverPort);
+
+    if (!socket.waitForConnected(riOctavePlugin::connectTimeOutMilliSecs))
+    {
+        error((("Connection: ") + socket.errorString()).toLatin1().data());
+        return;
+    }
+
+    QDataStream socketStream(&socket);
+    socketStream.setVersion(riOctavePlugin::qtDataStreamVersion);
+
+    // Create command as a string with arguments , and send it:
+    QString command;
+    command += "GetStaticNNCValues " + QString::number(caseId) + " " + propertyName;
+
+    QByteArray cmdBytes = command.toLatin1();
+
+    socketStream << (qint64)(cmdBytes.size());
+    socket.write(cmdBytes);
+
+    // Get response. First wait for the header
+
+    while (socket.bytesAvailable() < (int)sizeof(quint64))
+    {
+        if (!socket.waitForReadyRead(riOctavePlugin::longTimeOutMilliSecs))
+        {
+            error((("Waiting for header: ") + socket.errorString()).toLatin1().data());
+            return;
+        }
+    }
+
+    // Read connection count and timestep count
+    quint64 connectionCount;
+
+    socketStream >> connectionCount;
+
+    if (!(connectionCount))
+    {
+        error ("Could not find the requested data in ResInsight");
+        return;
+    }
+
+    propertyValues.reserve(connectionCount);
+
+    for (size_t i = 0; i < connectionCount; ++i)
+    {
+        double val;
+        socketStream >> val;
+        propertyValues.push_back(val);
+    }
+
+    QString tmp = QString("riGetStaticNNCValues : Read %1").arg(propertyName);
+
+    if (caseId < 0)
+    {
+        tmp += QString(" from current case.");
+    }
+    else
+    {
+        tmp += QString(" from case with Id: %1.").arg(caseId);
+    }
+    octave_stdout << tmp.toStdString() << " Connections: " << connectionCount << std::endl;
+
+    return;
+}
+
+
+DEFUN_DLD (riGetStaticNNCValues, args, nargout,
+           "Usage:\n"
+           "\n"
+           "   riGetStaticNNCValues([CaseId], PropertyName)\n"
+           "\n"
+           "This function retrieves the static NNC values for each connection."
+           )
+{
+    int nargin = args.length ();
+    if (nargin < 1)
+    {
+        error("riGetStaticNNCValues: Too few arguments. The name of the property requested is necessary.\n");
+        print_usage();
+        return octave_value();
+    }
+    else if (nargin > 2)
+    {
+        error("riGetStaticNNCValues: Too many arguments.\n");
+        print_usage();
+        return octave_value();
+    }
+    else if (nargout < 1)
+    {
+        error("riGetStaticNNCValues: Missing output argument.\n");
+        print_usage();
+        return octave_value();
+    }
+
+    std::vector<int> argIndices;
+    argIndices.push_back(0);
+    argIndices.push_back(1);
+
+    // Check if we have a CaseId:
+    if (!args(argIndices[0]).is_numeric_type())
+    {
+        argIndices[0] = -1;
+        for (size_t aIdx = 1; aIdx < argIndices.size(); ++aIdx)
+            --argIndices[aIdx];
+    }
+
+    std::vector<double> propertyValues;
+    qint32 caseId = -1;
+    std::string propertyName;
+
+    if (argIndices[0] >= 0) caseId       = args(argIndices[0]).int_value();
+    if (argIndices[1] >= 0) propertyName = args(argIndices[1]).char_matrix_value().row_as_string(0);
+
+    getStaticNNCValues(propertyValues, "127.0.0.1", 40001, caseId, propertyName.c_str());
+
+    dim_vector dv(2, 1);
+    dv(0) = propertyValues.size();
+    dv(1) = 1;
+    NDArray oct_propertyValues(dv);
+
+    for (size_t i = 0; i < propertyValues.size(); ++i)
+    {
+        oct_propertyValues(i) = propertyValues[i];
+    }
+
+    return octave_value(oct_propertyValues);
+}