From 44f02340966e535dd259dac19813dbfa08ab6eb6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B8rnar=20Grip=20Fj=C3=A6r?= Date: Thu, 29 Jun 2017 11:19:07 +0200 Subject: [PATCH] #1661 Octave interface for getting static and dynamic NNC result values from ResInsight --- .../FileInterface/RifReaderEclipseOutput.cpp | 8 +- .../ProjectDataModel/RimEclipseCase.cpp | 8 +- .../RimReservoirCellResultsStorage.cpp | 18 +- .../ReservoirDataModel/RigNNCData.cpp | 87 +++++++--- .../ReservoirDataModel/RigNNCData.h | 33 ++-- .../RigReservoirBuilderMock.cpp | 2 +- .../SocketInterface/RiaNNCCommands.cpp | 129 ++++++++++++++- OctavePlugin/CMakeLists.txt | 4 + OctavePlugin/riGetDynamicNNCValues.cpp | 156 ++++++++++++++++++ OctavePlugin/riGetStaticNNCValues.cpp | 141 ++++++++++++++++ 10 files changed, 526 insertions(+), 60 deletions(-) create mode 100644 OctavePlugin/riGetDynamicNNCValues.cpp create mode 100644 OctavePlugin/riGetStaticNNCValues.cpp diff --git a/ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp b/ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp index 0d133d06bc..ca4cb02940 100644 --- a/ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp +++ b/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& transmissibilityValues = mainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::COMB_TRANS); + std::vector& 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 >& waterFluxData = mainGrid->nncData()->makeDynamicConnectionScalarResult(RigNNCData::FLUX_WAT, timeStepCount); - std::vector< std::vector >& oilFluxData = mainGrid->nncData()->makeDynamicConnectionScalarResult(RigNNCData::FLUX_OIL, timeStepCount); - std::vector< std::vector >& gasFluxData = mainGrid->nncData()->makeDynamicConnectionScalarResult(RigNNCData::FLUX_GAS, timeStepCount); + std::vector< std::vector >& waterFluxData = mainGrid->nncData()->makeDynamicConnectionScalarResult(RigNNCData::propertyNameFluxWat(), timeStepCount); + std::vector< std::vector >& oilFluxData = mainGrid->nncData()->makeDynamicConnectionScalarResult(RigNNCData::propertyNameFluxOil(), timeStepCount); + std::vector< std::vector >& gasFluxData = mainGrid->nncData()->makeDynamicConnectionScalarResult(RigNNCData::propertyNameFluxGas(), timeStepCount); for (size_t timeStep = 0; timeStep < timeStepCount; ++timeStep) { diff --git a/ApplicationCode/ProjectDataModel/RimEclipseCase.cpp b/ApplicationCode/ProjectDataModel/RimEclipseCase.cpp index b227f872e9..a962518f43 100644 --- a/ApplicationCode/ProjectDataModel/RimEclipseCase.cpp +++ b/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); } } diff --git a/ApplicationCode/ProjectDataModel/RimReservoirCellResultsStorage.cpp b/ApplicationCode/ProjectDataModel/RimReservoirCellResultsStorage.cpp index 9a0dbba6da..71a15d7bbe 100644 --- a/ApplicationCode/ProjectDataModel/RimReservoirCellResultsStorage.cpp +++ b/ApplicationCode/ProjectDataModel/RimReservoirCellResultsStorage.cpp @@ -1006,8 +1006,8 @@ void RimReservoirCellResultsStorage::computeNncCombRiTrans() std::vector & permXResults = m_cellResults->cellScalarResults(permXResultIdx)[0]; std::vector & permYResults = m_cellResults->cellScalarResults(permYResultIdx)[0]; std::vector & permZResults = m_cellResults->cellScalarResults(permZResultIdx)[0]; - std::vector & riCombTransResults = m_ownerMainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::RI_COMB_TRANS); - m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::RI_COMB_TRANS, riCombTransScalarResultIndex); + std::vector & riCombTransResults = m_ownerMainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::propertyNameRiCombTrans()); + m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::propertyNameRiCombTrans(), riCombTransScalarResultIndex); std::vector * ntgResults = NULL; if (hasNTGResults) @@ -1250,12 +1250,10 @@ void RimReservoirCellResultsStorage::computeNncCombRiMULT() if (m_ownerMainGrid->nncData()->staticConnectionScalarResult(riCombMultScalarResultIndex)) return; - std::vector & riMultResults = m_ownerMainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::RI_COMB_MULT); - const std::vector * riTransResults = m_ownerMainGrid->nncData()->staticConnectionScalarResult(RigNNCData::RI_COMB_TRANS); - const std::vector * transResults = m_ownerMainGrid->nncData()->staticConnectionScalarResult(RigNNCData::COMB_TRANS); - m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::RI_COMB_MULT, riCombMultScalarResultIndex); - m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::RI_COMB_TRANS, riCombTransScalarResultIndex); - m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::COMB_TRANS, combTransScalarResultIndex); + std::vector & riMultResults = m_ownerMainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::propertyNameRiCombMult()); + const std::vector * riTransResults = m_ownerMainGrid->nncData()->staticConnectionScalarResult(riCombTransScalarResultIndex); + const std::vector * transResults = m_ownerMainGrid->nncData()->staticConnectionScalarResult(combTransScalarResultIndex); + m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::propertyNameRiCombMult(), riCombMultScalarResultIndex); 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 & riAreaNormTransResults = m_ownerMainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::RI_COMB_TRANS_BY_AREA); - m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::RI_COMB_TRANS_BY_AREA, riCombTransByAreaScResIdx); + std::vector & riAreaNormTransResults = m_ownerMainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::propertyNameRiCombTransByArea()); + m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::propertyNameRiCombTransByArea(), riCombTransByAreaScResIdx); const std::vector * transResults = m_ownerMainGrid->nncData()->staticConnectionScalarResult(combTransScalarResultIndex); const std::vector& connections = m_ownerMainGrid->nncData()->connections(); diff --git a/ApplicationCode/ReservoirDataModel/RigNNCData.cpp b/ApplicationCode/ReservoirDataModel/RigNNCData.cpp index e26c741608..939a5ec967 100644 --- a/ApplicationCode/ReservoirDataModel/RigNNCData.cpp +++ b/ApplicationCode/ReservoirDataModel/RigNNCData.cpp @@ -166,7 +166,7 @@ void RigNNCData::processConnections(const RigMainGrid& mainGrid) //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- -std::vector& RigNNCData::makeStaticConnectionScalarResult(NNCDataType nncDataType) +std::vector& RigNNCData::makeStaticConnectionScalarResult(QString nncDataType) { std::vector< std::vector >& results = m_connectionResults[nncDataType]; results.resize(1); @@ -179,15 +179,14 @@ std::vector& RigNNCData::makeStaticConnectionScalarResult(NNCDataType nn //-------------------------------------------------------------------------------------------------- const std::vector* RigNNCData::staticConnectionScalarResult(size_t scalarResultIndex) const { - const NNCDataType* nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex); - if (!nncDataType) return nullptr; + QString nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex); + if (nncDataType.isNull()) return nullptr; - std::map > >::const_iterator it = m_connectionResults.find(*nncDataType); - - CVF_ASSERT(it->second.size() == 1); + std::map > >::const_iterator it = m_connectionResults.find(nncDataType); if (it != m_connectionResults.end()) { + CVF_ASSERT(it->second.size() == 1); return &(it->second[0]); } else @@ -199,7 +198,26 @@ const std::vector* RigNNCData::staticConnectionScalarResult(size_t scala //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- -std::vector< std::vector >& RigNNCData::makeDynamicConnectionScalarResult(NNCDataType nncDataType, size_t timeStepCount) +const std::vector* RigNNCData::staticConnectionScalarResultByName(const QString& nncDataType) const +{ + std::map > >::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 >& RigNNCData::makeDynamicConnectionScalarResult(QString nncDataType, size_t timeStepCount) { auto& results = m_connectionResults[nncDataType]; results.resize(timeStepCount); @@ -211,10 +229,10 @@ std::vector< std::vector >& RigNNCData::makeDynamicConnectionScalarResul //-------------------------------------------------------------------------------------------------- const std::vector< std::vector >* RigNNCData::dynamicConnectionScalarResult(size_t scalarResultIndex) const { - const NNCDataType* nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex); - if (!nncDataType) return nullptr; + QString nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex); + 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 >* RigNNCData::dynamicConnectionScalarRes //-------------------------------------------------------------------------------------------------- const std::vector* RigNNCData::dynamicConnectionScalarResult(size_t scalarResultIndex, size_t timeStep) const { - const NNCDataType* nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex); - if (!nncDataType) return nullptr; + QString nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex); + 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* RigNNCData::dynamicConnectionScalarResult(size_t scal //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- -void RigNNCData::setScalarResultIndex(NNCDataType nncDataType, size_t scalarResultIndex) +const std::vector>* 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* 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); - if (!nncDataType) return false; + QString nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex); + 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(); } /* diff --git a/ApplicationCode/ReservoirDataModel/RigNNCData.h b/ApplicationCode/ReservoirDataModel/RigNNCData.h index 50904e9e5b..c7fe6f3dc3 100644 --- a/ApplicationCode/ReservoirDataModel/RigNNCData.h +++ b/ApplicationCode/ReservoirDataModel/RigNNCData.h @@ -58,30 +58,31 @@ public: class RigNNCData : public cvf::Object { public: - enum NNCDataType { - FLUX_WAT, - FLUX_OIL, - FLUX_GAS, - COMB_TRANS, - RI_COMB_TRANS, - RI_COMB_MULT, - RI_COMB_TRANS_BY_AREA, - }; + static QString propertyNameFluxWat() { return "FLRWAT"; } + static QString propertyNameFluxOil() { return "FLROIL"; } + static QString propertyNameFluxGas() { return "FLRGAS"; } + static QString propertyNameCombTrans() { return "TRAN"; } + static QString propertyNameRiCombTrans() { return "riTRAN"; } + static QString propertyNameRiCombTransByArea() { return "riTRANbyArea"; } + static QString propertyNameRiCombMult() { return "riMULT"; } RigNNCData(); void processConnections(const RigMainGrid& mainGrid); std::vector& connections() { return m_connections; } - const std::vector& connections() const { return m_connections; }; + const std::vector& connections() const { return m_connections; } - std::vector& makeStaticConnectionScalarResult(NNCDataType nncDataType); + std::vector& makeStaticConnectionScalarResult(QString nncDataType); const std::vector* staticConnectionScalarResult(size_t scalarResultIndex) const; - std::vector< std::vector >& makeDynamicConnectionScalarResult(NNCDataType nncDataType, size_t timeStepCount); + const std::vector* staticConnectionScalarResultByName(const QString& nncDataType) const; + std::vector< std::vector >& makeDynamicConnectionScalarResult(QString nncDataType, size_t timeStepCount); const std::vector< std::vector >* dynamicConnectionScalarResult(size_t scalarResultIndex) const; const std::vector* dynamicConnectionScalarResult(size_t scalarResultIndex, size_t timeStep) const; + const std::vector< std::vector >* dynamicConnectionScalarResultByName(const QString& nncDataType) const; + const std::vector* 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, 7 > > ConnectionSearchMap; //ConnectionSearchMap m_cellIdxToFaceToConnectionIdxMap; - const NNCDataType* getNNCDataTypeFromScalarResultIndex(size_t scalarResultIndex) const; + const QString getNNCDataTypeFromScalarResultIndex(size_t scalarResultIndex) const; private: std::vector m_connections; - std::map > > m_connectionResults; - std::map m_resultIndexToNNCDataType; + std::map > > m_connectionResults; + std::map m_resultIndexToNNCDataType; }; diff --git a/ApplicationCode/ReservoirDataModel/RigReservoirBuilderMock.cpp b/ApplicationCode/ReservoirDataModel/RigReservoirBuilderMock.cpp index b726b20254..ec240ab2ab 100644 --- a/ApplicationCode/ReservoirDataModel/RigReservoirBuilderMock.cpp +++ b/ApplicationCode/ReservoirDataModel/RigReservoirBuilderMock.cpp @@ -542,7 +542,7 @@ void RigReservoirBuilderMock::addFaults(RigEclipseCaseData* eclipseCase) addNnc(grid, i1, j1, k1, i2, j2, k2, nncConnections); } - std::vector& tranVals = grid->nncData()->makeStaticConnectionScalarResult(RigNNCData::COMB_TRANS); + std::vector& tranVals = grid->nncData()->makeStaticConnectionScalarResult(RigNNCData::propertyNameCombTrans()); for (size_t cIdx = 0; cIdx < tranVals.size(); ++cIdx) { tranVals[cIdx] = 0.2; diff --git a/ApplicationCode/SocketInterface/RiaNNCCommands.cpp b/ApplicationCode/SocketInterface/RiaNNCCommands.cpp index 65d7094b0e..2c461cc3ca 100644 --- a/ApplicationCode/SocketInterface/RiaNNCCommands.cpp +++ b/ApplicationCode/SocketInterface/RiaNNCCommands.cpp @@ -39,9 +39,7 @@ #include "RimReservoirCellResultsStorage.h" #include - - - +#include //-------------------------------------------------------------------------------------------------- /// @@ -54,8 +52,6 @@ public: virtual bool interpretCommand(RiaSocketServer* server, const QList& 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::commandName()); + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +class RiaGetDynamicNNCValues: public RiaSocketCommand +{ +public: + static QString commandName () { return QString("GetDynamicNNCValues"); } + + virtual bool interpretCommand(RiaSocketServer* server, const QList& 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 >* nncValues = mainGrid->nncData()->dynamicConnectionScalarResultByName(propertyName); + + if (nncValues == nullptr) + { + socketStream << (quint64)0 << (quint64)0; + return true; + } + + std::vector 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& 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::commandName()); + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +class RiaGetStaticNNCValues: public RiaSocketCommand +{ +public: + static QString commandName () { return QString("GetStaticNNCValues"); } + + virtual bool interpretCommand(RiaSocketServer* server, const QList& 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* 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::commandName()); diff --git a/OctavePlugin/CMakeLists.txt b/OctavePlugin/CMakeLists.txt index 954899eef8..3745004132 100644 --- a/OctavePlugin/CMakeLists.txt +++ b/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" diff --git a/OctavePlugin/riGetDynamicNNCValues.cpp b/OctavePlugin/riGetDynamicNNCValues.cpp new file mode 100644 index 0000000000..a150dffc39 --- /dev/null +++ b/OctavePlugin/riGetDynamicNNCValues.cpp @@ -0,0 +1,156 @@ +#include +#include + +#include + +#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(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 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); +} diff --git a/OctavePlugin/riGetStaticNNCValues.cpp b/OctavePlugin/riGetStaticNNCValues.cpp new file mode 100644 index 0000000000..42d92e834e --- /dev/null +++ b/OctavePlugin/riGetStaticNNCValues.cpp @@ -0,0 +1,141 @@ +#include +#include + +#include + +#include "riSettings.h" + +#include "RiaSocketDataTransfer.cpp" // NB! Include cpp-file to avoid linking of additional file in oct-compile configuration + +void getStaticNNCValues(std::vector& 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 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 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); +}