OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Bjørnar Grip Fjær 2017-06-29 11:19:07 +02:00
parent 9bea767cdf
commit 44f0234096
10 changed files with 526 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp
View File

@ -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> >& oilFluxData = mainGrid->nncData()->makeDynamicConnectionScalarResult(RigNNCData::FLUX_OIL, timeStepCount);
std::vector< std::vector<double> >& gasFluxData = mainGrid->nncData()->makeDynamicConnectionScalarResult(RigNNCData::FLUX_GAS, timeStepCount);
std::vector< std::vector<double> >& waterFluxData = mainGrid->nncData()->makeDynamicConnectionScalarResult(RigNNCData::propertyNameFluxWat(), timeStepCount);
std::vector< std::vector<double> >& oilFluxData = mainGrid->nncData()->makeDynamicConnectionScalarResult(RigNNCData::propertyNameFluxOil(), timeStepCount);
std::vector< std::vector<double> >& gasFluxData = mainGrid->nncData()->makeDynamicConnectionScalarResult(RigNNCData::propertyNameFluxGas(), timeStepCount);
for (size_t timeStep = 0; timeStep < timeStepCount; ++timeStep)
{

8
ApplicationCode/ProjectDataModel/RimEclipseCase.cpp
View File

@ -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);
}
}

18
ApplicationCode/ProjectDataModel/RimReservoirCellResultsStorage.cpp
View File

@ -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);
m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::RI_COMB_TRANS, riCombTransScalarResultIndex);
std::vector<double> & riCombTransResults = m_ownerMainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::propertyNameRiCombTrans());
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);
const std::vector<double> * riTransResults = m_ownerMainGrid->nncData()->staticConnectionScalarResult(RigNNCData::RI_COMB_TRANS);
const std::vector<double> * 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<double> & riMultResults = m_ownerMainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::propertyNameRiCombMult());
const std::vector<double> * riTransResults = m_ownerMainGrid->nncData()->staticConnectionScalarResult(riCombTransScalarResultIndex);
const std::vector<double> * 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<double> & riAreaNormTransResults = m_ownerMainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::RI_COMB_TRANS_BY_AREA);
m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::RI_COMB_TRANS_BY_AREA, riCombTransByAreaScResIdx);
std::vector<double> & riAreaNormTransResults = m_ownerMainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::propertyNameRiCombTransByArea());
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();

87
ApplicationCode/ReservoirDataModel/RigNNCData.cpp
View File

@ -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);
if (!nncDataType) return nullptr;
QString nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex);
if (nncDataType.isNull()) return nullptr;
std::map<NNCDataType, std::vector< std::vector<double> > >::const_iterator it = m_connectionResults.find(*nncDataType);
CVF_ASSERT(it->second.size() == 1);
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
@ -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);
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<double> >* RigNNCData::dynamicConnectionScalarRes
//--------------------------------------------------------------------------------------------------
const std::vector<double>* 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<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);
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();
}
/*

33
ApplicationCode/ReservoirDataModel/RigNNCData.h
View File

@ -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<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<size_t, NNCDataType> m_resultIndexToNNCDataType;
std::map<QString, std::vector< std::vector<double> > > m_connectionResults;
std::map<size_t, QString> m_resultIndexToNNCDataType;
};

2
ApplicationCode/ReservoirDataModel/RigReservoirBuilderMock.cpp
View File

@ -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;

129
ApplicationCode/SocketInterface/RiaNNCCommands.cpp
View File

@ -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());

4
OctavePlugin/CMakeLists.txt
View File

@ -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"

156
OctavePlugin/riGetDynamicNNCValues.cpp Normal file
View File

@ -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);
}

141
OctavePlugin/riGetStaticNNCValues.cpp Normal file
View File

@ -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);
}