mirror of
https://github.com/OPM/ResInsight.git
synced 2025-01-01 03:37:15 -06:00
b050cac1d2
The building of Octave plugins within main ResInsight build on RHEL8 cause the build to use gcc-12, and gcc-12 is extremely slow when building opm-common. Adjust the CMake configuration so it is possible to build the Octave plugins as an independent build job. The plugin binaries can then be uploaded to an external server. The main ResInsight build can download the binaries and include them in the install package for ResInsight. Use the flag RESINSIGHT_USE_EXTERNAL_OCTAVE_PLUGINS to download external Octave plugin binaries.
266 lines
8.2 KiB
C++
266 lines
8.2 KiB
C++
#include <QtNetwork>
|
||
#include <octave/oct.h>
|
||
#include <octave/oct-map.h>
|
||
|
||
#include "riSettings.h"
|
||
|
||
void getWellCells( std::vector<int>& cellIs,
|
||
std::vector<int>& cellJs,
|
||
std::vector<int>& cellKs,
|
||
std::vector<int>& gridIndices,
|
||
std::vector<int>& cellStatuses,
|
||
std::vector<int>& branchIds,
|
||
std::vector<int>& segmentIds,
|
||
const QString &hostName, quint16 port,
|
||
const qint64& caseId, const QString& wellName, int requestedTimeStep)
|
||
{
|
||
QString serverName = hostName;
|
||
quint16 serverPort = port;
|
||
|
||
QTcpSocket socket;
|
||
socket.connectToHost(serverName, serverPort);
|
||
|
||
if (!socket.waitForConnected(riOctavePlugin::connectTimeOutMilliSecs))
|
||
{
|
||
error("Connection: %s",socket.errorString().toLatin1().data());
|
||
return;
|
||
}
|
||
|
||
// Create command and send it:
|
||
|
||
QString command;
|
||
command += QString("GetWellCells") + " " + QString::number(caseId) + " " + wellName + " " + QString::number(requestedTimeStep) ;
|
||
|
||
QByteArray cmdBytes = command.toLatin1();
|
||
|
||
QDataStream socketStream(&socket);
|
||
socketStream.setVersion(riOctavePlugin::qtDataStreamVersion);
|
||
|
||
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: %s",socket.errorString().toLatin1().data());
|
||
return;
|
||
}
|
||
}
|
||
|
||
quint64 byteCount;
|
||
socketStream >> byteCount;
|
||
|
||
if (byteCount == 0)
|
||
{
|
||
return;
|
||
}
|
||
|
||
while (socket.bytesAvailable() < (int)(byteCount))
|
||
{
|
||
if (!socket.waitForReadyRead(riOctavePlugin::longTimeOutMilliSecs))
|
||
{
|
||
error("Waiting for data: %s",socket.errorString().toLatin1().data());
|
||
return;
|
||
}
|
||
OCTAVE_QUIT;
|
||
}
|
||
|
||
quint64 cellCount;
|
||
socketStream >> cellCount;
|
||
|
||
octave_stdout << "riGetWellCells: Number of cells in well " << wellName.toLatin1().data() << " : " << cellCount << std::endl;
|
||
|
||
cellIs .reserve(cellCount);
|
||
cellJs .reserve(cellCount);
|
||
cellKs .reserve(cellCount);
|
||
gridIndices .reserve(cellCount);
|
||
cellStatuses .reserve(cellCount);
|
||
branchIds .reserve(cellCount);
|
||
segmentIds .reserve(cellCount);
|
||
|
||
qint32 i, j, k, gIdx, cStat, bId, sId;
|
||
|
||
for (size_t cIdx = 0; cIdx < cellCount; cIdx++)
|
||
{
|
||
socketStream >> i;
|
||
socketStream >> j;
|
||
socketStream >> k;
|
||
socketStream >> gIdx;
|
||
socketStream >> cStat;
|
||
socketStream >> bId;
|
||
socketStream >> sId;
|
||
|
||
cellIs.push_back (i);
|
||
cellJs.push_back (j);
|
||
cellKs.push_back (k);
|
||
gridIndices.push_back (gIdx);
|
||
cellStatuses.push_back(cStat);
|
||
branchIds.push_back (bId);
|
||
segmentIds.push_back (sId);
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
|
||
DEFUN_DLD (riGetWellCells, args, nargout,
|
||
"Usage:\n"
|
||
"\n"
|
||
" riGetWellCells ([CaseId], WellName, TimeStep) \n"
|
||
"\n"
|
||
"This function returns the cells defined in the specified well for the time step requested \n"
|
||
"as a vector of Structures. \n"
|
||
"The Structure is defined as:\n"
|
||
"WellCellInfo { \n"
|
||
" I, J, K = int # Index to the cell in the grid\n"
|
||
" GridIndex = int # the index of the grid. Main grid has index 0.\n"
|
||
" CellStatus = int # is either 0 or 1, meaning the cell is closed or open respectively\n"
|
||
" BranchId = int # Branch id of the branch intersecting the cell\n"
|
||
" SegmentId = int # Branch segment id of the branch intersecting the cell\n"
|
||
"}\n"
|
||
"If the CaseId is not defined, ResInsight’s Current Case is used.\n"
|
||
)
|
||
{
|
||
if (nargout != 1)
|
||
{
|
||
error("riGetWellCells: Wrong number of output arguments, this function requires one output argument.\n");
|
||
print_usage();
|
||
return octave_value();
|
||
}
|
||
|
||
int nargin = args.length ();
|
||
if (nargin < 2)
|
||
{
|
||
error("riGetWellCells: Too few arguments, this function needs at least the well name and a timestep as input.\n");
|
||
print_usage();
|
||
return octave_value();
|
||
}
|
||
|
||
if (nargin > 3)
|
||
{
|
||
error("riGetWellCells: Too many arguments, this function takes at most three arguments.\n");
|
||
print_usage();
|
||
return octave_value();
|
||
}
|
||
|
||
std::vector<int> argIndices;
|
||
argIndices.push_back(0); // caseId
|
||
argIndices.push_back(1); // WellName
|
||
argIndices.push_back(2); // TimeStep
|
||
|
||
// Check if we do not have a CaseId:
|
||
if (args(argIndices[0]).is_string()) // Check if first argument is a text. If it is, the caseId is missing
|
||
{
|
||
argIndices[0] = -1;
|
||
for (size_t aIdx = 1; aIdx < argIndices.size(); ++aIdx)
|
||
--argIndices[aIdx];
|
||
}
|
||
|
||
if (!args(argIndices[1]).is_string()) // Check if the WellName argument is actually a string
|
||
{
|
||
error("riGetWellCells: Missing Well Name. this function needs at least the well name and a timestep as input.\n");
|
||
print_usage();
|
||
return octave_value();
|
||
}
|
||
|
||
if (!riOctavePlugin::isOctaveValueNumeric(args(argIndices[2]))) // Check if the TimeStep argument is actually a number
|
||
{
|
||
error("riGetWellCells: The last argument must be a timestep index.\n");
|
||
print_usage();
|
||
return octave_value();
|
||
}
|
||
|
||
// Setup the argument list
|
||
|
||
int caseId = -1;
|
||
std::string wellName = "UNDEFINED";
|
||
int requestedTimeStep = -1;
|
||
|
||
if (argIndices[0] >= 0) caseId = args(argIndices[0]).int_value();
|
||
if (argIndices[1] >= 0) wellName = args(argIndices[1]).char_matrix_value().row_as_string(0);
|
||
if (argIndices[2] >= 0) requestedTimeStep = args(argIndices[2]).int_value();
|
||
|
||
if (wellName == "UNDEFINED")
|
||
{
|
||
error("riGetWellCells: The argument must be a text containing the well name.\n");
|
||
print_usage();
|
||
return octave_value();
|
||
}
|
||
|
||
if (requestedTimeStep == -1)
|
||
{
|
||
error("riGetWellCells: The last argument must be a timestep index (1 - timestepCount).\n");
|
||
print_usage();
|
||
return octave_value();
|
||
}
|
||
|
||
std::vector<int> cellIs, cellJs, cellKs;
|
||
std::vector<int> gridIndices;
|
||
std::vector<int> cellStatuses;
|
||
std::vector<int> branchIds;
|
||
std::vector<int> segmentIds;
|
||
|
||
getWellCells( cellIs, cellJs, cellKs,
|
||
gridIndices,
|
||
cellStatuses,
|
||
branchIds,
|
||
segmentIds,
|
||
"127.0.0.1", riOctavePlugin::portNumber(),
|
||
caseId, QString::fromStdString(wellName), requestedTimeStep);
|
||
|
||
size_t cellCount = cellIs.size();
|
||
|
||
if (cellJs.size() != cellCount
|
||
|| cellKs.size() != cellCount
|
||
|| gridIndices.size() != cellCount
|
||
|| cellStatuses.size() != cellCount
|
||
|| branchIds.size() != cellCount
|
||
|| segmentIds.size() != cellCount )
|
||
{
|
||
error("riGetWellCells: Inconsistent data received from ResInsight.\n");
|
||
return octave_value();
|
||
}
|
||
|
||
|
||
// Create cells with N items for each field in the data structure
|
||
|
||
Cell cellIscv (cellCount, 1);
|
||
Cell cellJscv (cellCount, 1);
|
||
Cell cellKscv (cellCount, 1);
|
||
Cell gridIndicescv (cellCount, 1);
|
||
Cell cellStatusescv (cellCount, 1);
|
||
Cell branchIdscv (cellCount, 1);
|
||
Cell segmentIdscv (cellCount, 1);
|
||
|
||
for (size_t i = 0; i < cellCount; i++)
|
||
{
|
||
cellIscv (i) = cellIs [i];
|
||
cellJscv (i) = cellJs [i];
|
||
cellKscv (i) = cellKs [i];
|
||
gridIndicescv (i) = gridIndices [i];
|
||
cellStatusescv (i) = cellStatuses[i];
|
||
branchIdscv (i) = branchIds [i];
|
||
segmentIdscv (i) = segmentIds [i];
|
||
}
|
||
|
||
// Build a map between the field name and field cell values
|
||
|
||
octave_map m;
|
||
|
||
m.assign(riOctavePlugin::wellCellInfo_I, cellIscv );
|
||
m.assign(riOctavePlugin::wellCellInfo_J, cellJscv );
|
||
m.assign(riOctavePlugin::wellCellInfo_K, cellKscv );
|
||
m.assign(riOctavePlugin::wellCellInfo_GridIndex , gridIndicescv );
|
||
m.assign(riOctavePlugin::wellCellInfo_CellStatus, cellStatusescv);
|
||
m.assign(riOctavePlugin::wellCellInfo_BranchId, branchIdscv );
|
||
m.assign(riOctavePlugin::wellCellInfo_SegmentId, segmentIdscv );
|
||
|
||
return octave_value(m);
|
||
|
||
}
|
||
|