void CommandMaker::Start () { try { tcp::iostream socketStream (ip.c_str(), port.c_str() ); // Trying to connect if (!socketStream.fail() ) { cout << "CommandMaker: Connected!" << endl; // TODO: write in log #ifdef ENABLE_LOGGING RAW_LOG (INFO, "CommandMaker: Connected!"); #endif boost::archive::xml_oarchive oa(socketStream); // We want to send commands in XML Command com; while (!socketStream.fail() ) { // Reading command cout << "input command type (int):" << endl; cin >> com.ComType; cout << "input command condition (int):" << endl; cin >> com.ComCondition; cout << "input condition value (float):" << endl; cin >> com.Value; oa << BOOST_SERIALIZATION_NVP(com); // Sending command } } } catch (exception& e) { cout << "CommandMaker: Exception: " << e.what () << endl; // TODO: write in log #ifdef ENABLE_LOGGING RAW_LOG (INFO, "CommandMaker: Exception: %s", e.what()); #endif } }
void SendReceiver::Start () { try { tcp::iostream socketStream (ip.c_str(), port.c_str() ); // Trying to connect if (!socketStream.fail() ) { cout << "SendReceiver: Connected!" << endl; // TODO: write in log #ifdef ENABLE_LOGGING RAW_LOG (INFO, "SendReceiver: Connected!"); #endif Sleep(6000); while ( true ) { boost::archive::xml_iarchive ia(socketStream); // We will receive Send objects in XML boost::shared_ptr<Send> sendData (new Send); // Creating new Send object ia >> BOOST_SERIALIZATION_NVP(sendData); // Receiving sendBuffer->Enqueue (sendData); // Adding Send in buffer } } } catch (exception& e) { cout << "SendReceiver: Exception: " << e.what () << endl; // TODO: write in log #ifdef ENABLE_LOGGING RAW_LOG (INFO, "SendReceiver: Exception: %s", e.what()); #endif } }
void KinectReceiver::Start () { try { tcp::iostream socketStream (ip.c_str(), port.c_str() ); // Trying to connect if (!socketStream.fail() ) { cout << "KinectReceiver: Connected!" << endl; // TODO: write in log #ifdef ENABLE_LOGGING RAW_LOG (INFO, "KinectReceiver: Connected!"); #endif Sleep (5000); while (true ) { boost::shared_ptr<KinectData> kData (new KinectData); // Creating new KinectData socketStream >> kData->Time; // Receivig time octreeCoder->decodePointCloud (socketStream, kData->Cloud); // Then receiving point cloud kinectBuffer->Enqueue (kData); // adding KinectData in KinectBuffer } } } catch (exception& e) { cout << "KinectReceiver: Exception: " << e.what () << endl; // TODO: write in log #ifdef ENABLE_LOGGING RAW_LOG (INFO, "KinectReceiver: Exception: %s", e.what()); #endif } }
void SMTPClientSession::transportMessage(const MailMessage& message) { SocketOutputStream socketStream(_socket); MailOutputStream mailStream(socketStream); message.write(mailStream); mailStream.close(); socketStream.flush(); std::string response; int status = _socket.receiveStatusMessage(response); if (!isPositiveCompletion(status)) throw SMTPException("The server rejected the message", response, status); }
void SMTPClientSession::sendMessage(std::istream& istr) { std::string response; int status = 0; SocketOutputStream socketStream(_socket); MailOutputStream mailStream(socketStream); StreamCopier::copyStream(istr, mailStream); mailStream.close(); socketStream.flush(); status = _socket.receiveStatusMessage(response); if (!isPositiveCompletion(status)) throw SMTPException("The server rejected the message", response, status); }
void CommandMaker::Start () { try { tcp::iostream socketStream (ip.toStdString().c_str(), port.toStdString().c_str() ); // Trying to connect if (!socketStream.fail() ) { cout << "CommandMaker: Connected!" << endl; // TODO: write in log #ifdef ENABLE_LOGGING RAW_LOG (INFO, "CommandMaker: Connected!"); #endif boost::archive::xml_oarchive oa(socketStream); // We want to send commands in XML Command com; while (!socketStream.fail() ) { // Reading command cout << "input command type (int):" << endl; cin >> com.ComType; cout << "input command condition (int):" << endl; cin >> com.ComCondition; cout << "input condition value (float):" << endl; cin >> com.Value; QByteArray block; QDataStream sendStream(&block, QIODevice::ReadWrite); sendStream << quint16(0) << com; sendStream.device()->seek(0); sendStream << (quint16)(block.size() - sizeof(quint16)); socketStream.write(block,block.size()); //oa << BOOST_SERIALIZATION_NVP(com); // Sending command } } } catch (exception& e) { cout << "CommandMaker: Exception: " << e.what () << endl; // TODO: write in log #ifdef ENABLE_LOGGING RAW_LOG (INFO, "CommandMaker: Exception: %s", e.what()); #endif } }
void MfConnection::setup() { QDataStream socketStream(socket); QString feedbackProtocolVersion; // Get protocol version string from stream socketStream >> feedbackProtocolVersion; if (feedbackProtocolVersion.startsWith(FeedbackProtocolVersionPrefix)) { // String contains protocol version, see if it something // that this version supports. int protocolVersion; bool conversionOk; feedbackProtocolVersion.remove(0, FeedbackProtocolVersionPrefix.length()); protocolVersion = feedbackProtocolVersion.toInt(&conversionOk); if (conversionOk == true && protocolVersion == Version_1) { clientFeedbackProtocolVersion = Version_1; socketStream >> clientName; }
void MfConnection::fetchPlaybackRequest() { QDataStream socketStream(socket); QString feedbackName; socketStream >> feedbackName; if (socketStream.status() != QDataStream::Ok) { terminate(); return; } if (timeStamping()) { writeTimestamp("daemon_play"); } if (!session->feedbackHash.contains(feedbackName)) { // Feedback not found, do nothing return; } session->feedbackHash.value(feedbackName)->emitPlay(getTimestamp()); }
void getEclipseProperty(Matrix& propertyFrames, const QString &hostName, quint16 port, QString caseName, QString propertyName) { QString serverName = hostName; quint16 serverPort = port; const int Timeout = 5 * 1000; QTcpSocket socket; socket.connectToHost(serverName, serverPort); if (!socket.waitForConnected(Timeout)) { error((("Connection: ") + socket.errorString()).toLatin1().data()); return; } // Create command and send it: QString command("GetProperty "); command += caseName + " " + propertyName; QByteArray cmdBytes = command.toLatin1(); QDataStream socketStream(&socket); socketStream.setVersion(QDataStream::Qt_4_0); socketStream << (qint64)(cmdBytes.size()); socket.write(cmdBytes); // Get response. First wait for the header while (socket.bytesAvailable() < (int)(2*sizeof(quint64))) { if (!socket.waitForReadyRead(Timeout)) { error((("Wating for header: ") + socket.errorString()).toLatin1().data()); return; } } // Read timestep count and blocksize quint64 timestepCount; quint64 byteCount; size_t activeCellCount; socketStream >> timestepCount; socketStream >> byteCount; activeCellCount = byteCount / sizeof(double); propertyFrames.resize(activeCellCount, timestepCount); if (!(byteCount && timestepCount)) { error ("Could not find the requested data in ResInsight"); return; } // Wait for available data for each timestep, then read data for each timestep for (size_t tIdx = 0; tIdx < timestepCount; ++tIdx) { while (socket.bytesAvailable() < (int)byteCount) { if (!socket.waitForReadyRead(Timeout)) { error((("Waiting for timestep data number: ") + QString::number(tIdx)+ ": " + socket.errorString()).toLatin1().data()); octave_stdout << "Active cells: " << activeCellCount << ", Timesteps: " << timestepCount << std::endl; return ; } OCTAVE_QUIT; } qint64 bytesRead = 0; double * internalMatrixData = propertyFrames.fortran_vec(); #if 1 // Use raw data transfer. Faster. bytesRead = socket.read((char*)(internalMatrixData + tIdx * activeCellCount), byteCount); #else for (size_t cIdx = 0; cIdx < activeCellCount; ++cIdx) { socketStream >> internalMatrixData[tIdx * activeCellCount + cIdx]; if (socketStream.status() == QDataStream::Ok) bytesRead += sizeof(double); } #endif if ((int)byteCount != bytesRead) { error("Could not read binary double data properly from socket"); octave_stdout << "Active cells: " << activeCellCount << ", Timesteps: " << timestepCount << std::endl; } OCTAVE_QUIT; } QString tmp = QString("riGetActiveCellProperty : Read %1").arg(propertyName); if (caseName.isEmpty()) { tmp += QString(" from active case."); } else { tmp += QString(" from %1.").arg(caseName); } octave_stdout << tmp.toStdString() << " Active cells : " << activeCellCount << ", Timesteps : " << timestepCount << std::endl; return; }
void run(void) { Poco::Net::SocketStream socketStream(this->socket()); Pothos::RemoteServer::runHandler(socketStream, socketStream); }
void getCellCorners(NDArray& cellCornerValues, const QString &hostName, quint16 port, const qint32& caseId, const quint32& gridIndex) { QString serverName = hostName; quint16 serverPort = port; QTcpSocket socket; socket.connectToHost(serverName, serverPort); if (!socket.waitForConnected(riOctavePlugin::connectTimeOutMilliSecs)) { error((("Connection: ") + socket.errorString()).toLatin1().data()); return; } // Create command and send it: QString command = QString("GetCellCorners %1 %2").arg(caseId).arg(gridIndex); 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)(5 * sizeof(quint64))) { if (!socket.waitForReadyRead(riOctavePlugin::shortTimeOutMilliSecs)) { error((("Waiting for header: ") + socket.errorString()).toLatin1().data()); return; } } quint64 cellCountI; quint64 cellCountJ; quint64 cellCountK; quint64 cellCount; quint64 byteCount; socketStream >> cellCount; socketStream >> cellCountI; socketStream >> cellCountJ; socketStream >> cellCountK; socketStream >> byteCount; if (!(byteCount && cellCount)) { error ("Could not find the requested data in ResInsight"); return; } dim_vector dv; dv.resize(5); dv(0) = cellCountI; dv(1) = cellCountJ; dv(2) = cellCountK; dv(3) = 8; dv(4) = 3; cellCornerValues.resize(dv); while (socket.bytesAvailable() < (qint64)(byteCount)) { if (!socket.waitForReadyRead(riOctavePlugin::longTimeOutMilliSecs)) { error((("Waiting for data: ") + socket.errorString()).toLatin1().data()); return; } OCTAVE_QUIT; } double* internalMatrixData = cellCornerValues.fortran_vec(); #if 0 double val; for (octave_idx_type i = 0; i < valueCount; i++) { socketStream >> internalMatrixData[i]; } #else quint64 bytesRead = 0; bytesRead = socket.read((char*)(internalMatrixData), byteCount); if (byteCount != bytesRead) { error("Could not read binary double data properly from socket"); octave_stdout << "Cell count: " << cellCount << std::endl; } #endif return; }
void getActiveCellProperty(Matrix& propertyFrames, const QString &serverName, quint16 serverPort, const qint64& caseId, QString propertyName, const int32NDArray& requestedTimeSteps, QString porosityModel) { 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 += "GetActiveCellProperty " + QString::number(caseId) + " " + propertyName + " " + porosityModel; 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 timestep count and blocksize quint64 timestepCount; quint64 byteCount; size_t activeCellCount; socketStream >> timestepCount; socketStream >> byteCount; activeCellCount = byteCount / sizeof(double); propertyFrames.resize(activeCellCount, timestepCount); if (!(byteCount && timestepCount)) { error ("Could not find the requested data in ResInsight"); return; } // Wait for available data for each timestep, then read data for each timestep for (size_t tIdx = 0; tIdx < timestepCount; ++tIdx) { while (socket.bytesAvailable() < (int)byteCount) { if (!socket.waitForReadyRead(riOctavePlugin::longTimeOutMilliSecs)) { error((("Waiting for timestep data number: ") + QString::number(tIdx)+ ": " + socket.errorString()).toLatin1().data()); octave_stdout << "Active cells: " << activeCellCount << ", Timesteps: " << timestepCount << std::endl; return ; } OCTAVE_QUIT; } qint64 bytesRead = 0; double * internalMatrixData = propertyFrames.fortran_vec(); #if 0 // Raw data transfer. Faster. Not possible when dealing with coarsening // bytesRead = socket.read((char*)(internalMatrixData + tIdx * activeCellCount), byteCount); #else // Compatible transfer. Now the only one working for (size_t cIdx = 0; cIdx < activeCellCount; ++cIdx) { socketStream >> internalMatrixData[tIdx * activeCellCount + cIdx]; if (socketStream.status() == QDataStream::Ok) bytesRead += sizeof(double); } #endif if ((int)byteCount != bytesRead) { error("Could not read binary double data properly from socket"); octave_stdout << "Active cells: " << activeCellCount << ", Timesteps: " << timestepCount << std::endl; } OCTAVE_QUIT; } QString tmp = QString("riGetActiveCellProperty : 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() << " Active cells : " << activeCellCount << ", Timesteps : " << timestepCount << std::endl; return; }
void getPropertyNames(std::vector<QString>& propNames, std::vector<QString>& propTypes, const QString &hostName, quint16 port, const qint64& caseId, QString porosityModel) { QString serverName = hostName; quint16 serverPort = port; QTcpSocket socket; socket.connectToHost(serverName, serverPort); if (!socket.waitForConnected(riOctavePlugin::connectTimeOutMilliSecs)) { error((("Connection: ") + socket.errorString()).toLatin1().data()); return; } // Create command and send it: QString command; command += QString("GetPropertyNames") + " " + QString::number(caseId) + " " + porosityModel; 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::shortTimeOutMilliSecs)) { error((("Waiting for header: ") + socket.errorString()).toLatin1().data()); return; } } quint64 byteCount; socketStream >> byteCount; QString byteCountString = QString::number(byteCount); //error(byteCountString.toLatin1().data()); while (socket.bytesAvailable() < (int)(byteCount)) { if (!socket.waitForReadyRead(riOctavePlugin::shortTimeOutMilliSecs)) { error((("Waiting for data: ") + socket.errorString()).toLatin1().data()); return; } OCTAVE_QUIT; } quint64 propCount; socketStream >> propCount; QString propName; QString propType; for (size_t i = 0; i < propCount; i++) { socketStream >> propName; socketStream >> propType; propNames.push_back(propName); propTypes.push_back(propType); } return; }
void getWellStatus(std::vector<QString>& wellTypes, std::vector<int>& wellStatuses, const QString &hostName, quint16 port, const qint64& caseId, const QString& wellName, const int32NDArray& requestedTimeSteps) { QString serverName = hostName; quint16 serverPort = port; QTcpSocket socket; socket.connectToHost(serverName, serverPort); if (!socket.waitForConnected(riOctavePlugin::connectTimeOutMilliSecs)) { error((("Connection: ") + socket.errorString()).toLatin1().data()); return; } // Create command and send it: QString command; command += QString("GetWellStatus") + " " + QString::number(caseId) + " " + wellName; 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(); 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::shortTimeOutMilliSecs)) { error((("Waiting for header: ") + socket.errorString()).toLatin1().data()); return; } } quint64 byteCount; socketStream >> byteCount; while (socket.bytesAvailable() < (int)(byteCount)) { if (!socket.waitForReadyRead(riOctavePlugin::shortTimeOutMilliSecs)) { error((("Waiting for data: ") + socket.errorString()).toLatin1().data()); return; } OCTAVE_QUIT; } quint64 timeStepCount; socketStream >> timeStepCount; QString wellType; qint32 wellStatus; for (size_t i = 0; i < timeStepCount; i++) { socketStream >> wellType; socketStream >> wellStatus; wellTypes.push_back(wellType); wellStatuses.push_back(wellStatus); } return; }
void getTimeStepDates( std::vector<double>& decimalDays, const qint64& caseId, const QString& hostName, quint16 port) { QString serverName = hostName; quint16 serverPort = port; QTcpSocket socket; socket.connectToHost(serverName, serverPort); if (!socket.waitForConnected(riOctavePlugin::connectTimeOutMilliSecs)) { error((("Connection: ") + socket.errorString()).toLatin1().data()); return; } // Create command and send it: QString command = QString("GetTimeStepDays %1").arg(caseId); 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: ") + socket.errorString()).toLatin1().data()); return; } } quint64 byteCount; socketStream >> byteCount; while (socket.bytesAvailable() < (int)(byteCount)) { if (!socket.waitForReadyRead(riOctavePlugin::longTimeOutMilliSecs)) { error((("Waiting for data: ") + socket.errorString()).toLatin1().data()); return; } OCTAVE_QUIT; } quint64 timeStepCount; socketStream >> timeStepCount; octave_stdout << "byte count: " << byteCount << ", Timesteps: " << timeStepCount << std::endl; for (size_t i = 0; i < timeStepCount; i++) { double doubleValue; socketStream >> doubleValue; decimalDays.push_back(doubleValue); } return; }
void getGridProperty(NDArray& propertyFrames, const QString &serverName, quint16 serverPort, const int& caseId, int gridIdx, QString propertyName, const int32NDArray& requestedTimeSteps, QString porosityModel) { 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 += "GetGridProperty " + QString::number(caseId) + " " + QString::number(gridIdx) + " " + propertyName + " " + porosityModel; 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)(4*sizeof(quint64))) { if (!socket.waitForReadyRead(riOctavePlugin::longTimeOutMilliSecs)) { error((("Waiting for header: ") + socket.errorString()).toLatin1().data()); return; } } // Read sizes quint64 totalByteCount; quint64 cellCountI; quint64 cellCountJ; quint64 cellCountK; quint64 timestepCount; socketStream >> cellCountI; socketStream >> cellCountJ; socketStream >> cellCountK; socketStream >> timestepCount; totalByteCount = cellCountI*cellCountJ*cellCountK*timestepCount*sizeof(double); if (!(totalByteCount)) { error ("Could not find the requested data in ResInsight"); return; } dim_vector dv; dv.resize(4); dv(0) = cellCountI; dv(1) = cellCountJ; dv(2) = cellCountK; dv(3) = timestepCount; propertyFrames.resize(dv); // Wait for available data while (socket.bytesAvailable() < (int)totalByteCount) { if (!socket.waitForReadyRead(riOctavePlugin::longTimeOutMilliSecs)) { error(("Waiting for data : " + socket.errorString()).toLatin1().data()); return ; } OCTAVE_QUIT; } qint64 bytesRead = 0; double * internalMatrixData = propertyFrames.fortran_vec(); // Raw data transfer. Faster. bytesRead = socket.read((char*)(internalMatrixData ), totalByteCount); if ((int)totalByteCount != bytesRead) { error("Could not read binary double data properly from socket"); } QString tmp = QString("riGetGridProperty : Read %1").arg(propertyName); if (caseId < 0) { tmp += QString(" from current case,"); } else { tmp += QString(" from case with Id: %1,").arg(caseId); } tmp += QString(" grid index: %1, ").arg(gridIdx); octave_stdout << tmp.toStdString() << " I, J, K " << cellCountI << ", " << cellCountJ << ", " << cellCountK << ", Timesteps : " << timestepCount << std::endl; return; }
//-------------------------------------------------------------------------------------------------- /// This method reads data from octave and puts it into the resInsight Structures //-------------------------------------------------------------------------------------------------- void RiaSocketServer::slotReadPropertyData() { QDataStream socketStream(m_currentClient); socketStream.setVersion(QDataStream::Qt_4_0); // If we have not read the header and there are data enough: Read it. // Do nothing if we have not enough data if (m_timeStepCountToRead == 0 || m_bytesPerTimeStepToRead == 0) { if (m_currentClient->bytesAvailable() < (int)sizeof(quint64)*2) return; socketStream >> m_timeStepCountToRead; socketStream >> m_bytesPerTimeStepToRead; } // If nothing should be read, or we already have read everything, do nothing if ((m_timeStepCountToRead == 0) || (m_currentTimeStepToRead >= m_timeStepCountToRead) ) return; // Check if a complete timestep is available, return and whait for readyRead() if not if (m_currentClient->bytesAvailable() < (int)m_bytesPerTimeStepToRead) return; size_t cellCountFromOctave = m_bytesPerTimeStepToRead / sizeof(double); size_t gridActiveCellCount = m_currentReservoir->reservoirData()->mainGrid()->numActiveCells(); size_t gridTotalCellCount = m_currentReservoir->reservoirData()->mainGrid()->cellCount(); if (cellCountFromOctave != gridActiveCellCount && cellCountFromOctave != gridTotalCellCount) { m_errorMessageDialog->showMessage(tr("ResInsight SocketServer: \n") + tr("The number of cells in the data coming from octave does not match the case") + ":\"" + m_currentReservoir->caseName() + "\"\n" " Octave: " + QString::number(cellCountFromOctave) + "\n" " " + m_currentReservoir->caseName() + ": Active cell count: " + QString::number(gridActiveCellCount) + " Total cell count: " + QString::number(gridTotalCellCount)) ; cellCountFromOctave = 0; m_invalidActiveCellCountDetected = true; m_currentClient->abort(); return; } // Make sure the size of the retreiving container is correct. // If it is, this is noops m_scalarResultsToAdd->resize(m_timeStepCountToRead); for (size_t tIdx = 0; tIdx < m_timeStepCountToRead; ++tIdx) { m_scalarResultsToAdd->at(tIdx).resize(cellCountFromOctave, HUGE_VAL); } // Read available complete timestepdata while ((m_currentClient->bytesAvailable() >= (int)m_bytesPerTimeStepToRead) && (m_currentTimeStepToRead < m_timeStepCountToRead)) { qint64 bytesRead = 0; double * internalMatrixData = m_scalarResultsToAdd->at(m_currentTimeStepToRead).data(); #if 1 // Use raw data transfer. Faster. bytesRead = m_currentClient->read((char*)(internalMatrixData), m_bytesPerTimeStepToRead); #else for (size_t cIdx = 0; cIdx < cellCountFromOctave; ++cIdx) { socketStream >> internalMatrixData[cIdx]; if (socketStream.status() == QDataStream::Ok) bytesRead += sizeof(double); } #endif if ((int)m_bytesPerTimeStepToRead != bytesRead) { m_errorMessageDialog->showMessage(tr("ResInsight SocketServer: \n") + tr("Could not read binary double data properly from socket")); } ++m_currentTimeStepToRead; } // If we have read all the data, refresh the views if (m_currentTimeStepToRead == m_timeStepCountToRead) { if (m_currentReservoir != NULL) { // Create a new input property if we have an input reservoir RimInputReservoir* inputRes = dynamic_cast<RimInputReservoir*>(m_currentReservoir); if (inputRes) { RimInputProperty* inputProperty = NULL; inputProperty = inputRes->m_inputPropertyCollection->findInputProperty(m_currentPropertyName); if (!inputProperty) { inputProperty = new RimInputProperty; inputProperty->resultName = m_currentPropertyName; inputProperty->eclipseKeyword = ""; inputProperty->fileName = ""; inputRes->m_inputPropertyCollection->inputProperties.push_back(inputProperty); RimUiTreeModelPdm* treeModel = RIMainWindow::instance()->uiPdmModel(); treeModel->rebuildUiSubTree(inputRes->m_inputPropertyCollection()); } inputProperty->resolvedState = RimInputProperty::RESOLVED_NOT_SAVED; } if( m_currentScalarIndex != cvf::UNDEFINED_SIZE_T && m_currentReservoir->reservoirData() && m_currentReservoir->reservoirData()->mainGrid() && m_currentReservoir->reservoirData()->mainGrid()->results() ) { m_currentReservoir->reservoirData()->mainGrid()->results()->recalculateMinMax(m_currentScalarIndex); } for (size_t i = 0; i < m_currentReservoir->reservoirViews.size(); ++i) { if (m_currentReservoir->reservoirViews[i]) { m_currentReservoir->reservoirViews[i]->updateCurrentTimeStepAndRedraw(); } } } } }
void setEclipseProperty(const Matrix& propertyFrames, const QString &hostName, quint16 port, const qint64& caseId, QString propertyName, const int32NDArray& requestedTimeSteps, QString porosityModel) { QTcpSocket socket; socket.connectToHost(hostName, port); 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 += "SetActiveCellProperty " + QString::number(caseId) + " " + propertyName + " " + porosityModel; for (int i = 0; i < requestedTimeSteps.numel(); ++i) { if (i == 0) command += " "; command += QString::number(static_cast<int>(requestedTimeSteps.elem(i)) - 1); // To make the index 0-based if (i != requestedTimeSteps.numel() -1) command += " "; } QByteArray cmdBytes = command.toLatin1(); socketStream << (qint64)(cmdBytes.size()); socket.write(cmdBytes); // Write property data header dim_vector mxDims = propertyFrames.dims(); qint64 cellCount = mxDims.elem(0); qint64 timeStepCount = mxDims.elem(1); qint64 timeStepByteCount = cellCount * sizeof(double); socketStream << (qint64)(timeStepCount); socketStream << (qint64)timeStepByteCount; const double* internalData = propertyFrames.fortran_vec(); QStringList errorMessages; if (!RiaSocketDataTransfer::writeBlockDataToSocket(&socket, (const char *)internalData, timeStepByteCount*timeStepCount, errorMessages)) { for (int i = 0; i < errorMessages.size(); i++) { octave_stdout << errorMessages[i].toStdString(); } return; } QString tmp = QString("riSetActiveCellProperty : Wrote %1").arg(propertyName); if (caseId == -1) { tmp += QString(" to current case."); } else { tmp += QString(" to case with Id = %1.").arg(caseId); } octave_stdout << tmp.toStdString() << " Active Cells : " << cellCount << " Time steps : " << timeStepCount << std::endl; while(socket.bytesToWrite() && socket.state() == QAbstractSocket::ConnectedState) { // octave_stdout << "Bytes to write: " << socket.bytesToWrite() << std::endl; socket.waitForBytesWritten(riOctavePlugin::shortTimeOutMilliSecs); OCTAVE_QUIT; } //octave_stdout << " Socket write completed" << std::endl; if (socket.bytesToWrite() && socket.state() != QAbstractSocket::ConnectedState) { error("riSetActiveCellProperty : ResInsight refused to accept the data. Maybe the dimensions or porosity model is wrong"); } #ifdef WIN32 // TODO: Due to synchronization issues seen on Windows 10, it is required to do a sleep here to be able to catch disconnect // signals from the socket. No sleep causes the server to hang. Sleep(100); #endif //WIN32 return; }
void run(void) { this->socket().setNoDelay(true); Poco::Net::SocketStream socketStream(this->socket()); _handler.runHandler(socketStream, socketStream); }
void getMainGridDimensions(int32NDArray& gridDimensions, const QString &hostName, quint16 port, QString caseName) { QString serverName = hostName; quint16 serverPort = port; const int Timeout = 5 * 1000; QTcpSocket socket; socket.connectToHost(serverName, serverPort); if (!socket.waitForConnected(Timeout)) { error((("Connection: ") + socket.errorString()).toLatin1().data()); return; } // Create command and send it: QString command("GetMainGridDimensions "); command += caseName; QByteArray cmdBytes = command.toLatin1(); QDataStream socketStream(&socket); socketStream.setVersion(QDataStream::Qt_4_0); socketStream << (qint64)(cmdBytes.size()); socket.write(cmdBytes); // Get response. First wait for the header while (socket.bytesAvailable() < (int)(3*sizeof(quint64))) { if (!socket.waitForReadyRead(Timeout)) { error((("Wating for header: ") + socket.errorString()).toLatin1().data()); return; } } // Read timestep count and blocksize quint64 iCount; quint64 jCount; quint64 kCount; socketStream >> iCount; socketStream >> jCount; socketStream >> kCount; dim_vector dv (1, 1); dv(0) = 3; gridDimensions.resize(dv); gridDimensions(0) = iCount; gridDimensions(1) = jCount; gridDimensions(2) = kCount; QString tmp = QString("riGetMainGridDimensions : Read main grid dimensions"); if (caseName.isEmpty()) { tmp += QString(" from active case."); } else { tmp += QString(" from %1.").arg(caseName); } octave_stdout << tmp.toStdString() << " Dimensions: " << iCount << ", " << jCount << ", " << kCount << std::endl; return; }
void getCellCorners(NDArray& cellCornerValues, const QString &hostName, quint16 port, const qint32& caseId, const quint32& gridIndex) { QString serverName = hostName; quint16 serverPort = port; QTcpSocket socket; socket.connectToHost(serverName, serverPort); if (!socket.waitForConnected(riOctavePlugin::connectTimeOutMilliSecs)) { error((("Connection: ") + socket.errorString()).toLatin1().data()); return; } // Create command and send it: QString command = QString("GetCellCorners %1 %2").arg(caseId).arg(gridIndex); 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)(5 * sizeof(quint64))) { if (!socket.waitForReadyRead(riOctavePlugin::longTimeOutMilliSecs)) { error((("Waiting for header: ") + socket.errorString()).toLatin1().data()); return; } } quint64 cellCountI; quint64 cellCountJ; quint64 cellCountK; quint64 cellCount; quint64 byteCount; socketStream >> cellCount; socketStream >> cellCountI; socketStream >> cellCountJ; socketStream >> cellCountK; socketStream >> byteCount; if (!(byteCount && cellCount)) { error ("Could not find the requested data in ResInsight"); return; } dim_vector dv; dv.resize(5); dv(0) = cellCountI; dv(1) = cellCountJ; dv(2) = cellCountK; dv(3) = 8; dv(4) = 3; cellCornerValues.resize(dv); double* internalMatrixData = cellCornerValues.fortran_vec(); QStringList errorMessages; if (!RiaSocketDataTransfer::readBlockDataFromSocket(&socket, (char*)(internalMatrixData), byteCount, errorMessages)) { for (int i = 0; i < errorMessages.size(); i++) { error(errorMessages[i].toLatin1().data()); } OCTAVE_QUIT; } return; }
void getCaseGroups(std::vector<QString>& groupNames, std::vector<int>& groupIds, const QString &hostName, quint16 port) { QString serverName = hostName; quint16 serverPort = port; QTcpSocket socket; socket.connectToHost(serverName, serverPort); if (!socket.waitForConnected(riOctavePlugin::connectTimeOutMilliSecs)) { error((("Connection: ") + socket.errorString()).toLatin1().data()); return; } // Create command and send it: QString command("GetCaseGroups"); 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)(2*sizeof(quint64))) { if (!socket.waitForReadyRead(riOctavePlugin::longTimeOutMilliSecs)) { error((("Waiting for data: ") + socket.errorString()).toLatin1().data()); return; } OCTAVE_QUIT; } quint64 byteCount; socketStream >> byteCount; quint64 groupCount; socketStream >> groupCount; // Get response. Read all data for command while (socket.bytesAvailable() < (int)byteCount) { if (!socket.waitForReadyRead(riOctavePlugin::longTimeOutMilliSecs)) { error((("Waiting for data: ") + socket.errorString()).toLatin1().data()); return; } OCTAVE_QUIT; } quint64 group = 0; while (group < groupCount) { QString caseGroupName; qint64 caseGroupId; socketStream >> caseGroupName; socketStream >> caseGroupId; groupNames.push_back(caseGroupName); groupIds.push_back(caseGroupId); group++; } return; }
void getActiveCellCenters(NDArray& cellCenterValues, const QString &hostName, quint16 port, const qint32& caseId, const QString& porosityModel) { QString serverName = hostName; quint16 serverPort = port; QTcpSocket socket; socket.connectToHost(serverName, serverPort); if (!socket.waitForConnected(riOctavePlugin::connectTimeOutMilliSecs)) { error((("Connection: ") + socket.errorString()).toLatin1().data()); return; } // Create command and send it: QString command = QString("GetActiveCellCenters %1 %2").arg(caseId).arg(porosityModel); 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)(2 * sizeof(quint64))) { if (!socket.waitForReadyRead(riOctavePlugin::shortTimeOutMilliSecs)) { error((("Waiting for header: ") + socket.errorString()).toLatin1().data()); return; } } // Read timestep count and blocksize quint64 activeCellCount; quint64 byteCount; socketStream >> activeCellCount; socketStream >> byteCount; if (!(byteCount && activeCellCount)) { error ("Could not find the requested data in ResInsight"); return; } dim_vector dv; dv.resize(2); dv(0) = activeCellCount; dv(1) = 3; cellCenterValues.resize(dv); while (socket.bytesAvailable() < (qint64)(byteCount)) { if (!socket.waitForReadyRead(riOctavePlugin::longTimeOutMilliSecs)) { error((("Waiting for data: ") + socket.errorString()).toLatin1().data()); return; } OCTAVE_QUIT; } quint64 bytesRead = 0; double* internalMatrixData = cellCenterValues.fortran_vec(); bytesRead = socket.read((char*)(internalMatrixData), byteCount); if (byteCount != bytesRead) { error("Could not read binary double data properly from socket"); octave_stdout << "Active cell count: " << activeCellCount << std::endl; } return; }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiaSocketServer::slotReadCommand() { QDataStream socketStream(m_currentClient); socketStream.setVersion(QDataStream::Qt_4_0); // If we have not read the currentCommandSize // read the size of the command if all the data is available if (m_currentCommandSize == 0) { if (m_currentClient->bytesAvailable() < (int)sizeof(qint64)) return; socketStream >> m_currentCommandSize; } // Check if the complete command is available, return and whait for readyRead() if not if (m_currentClient->bytesAvailable() < m_currentCommandSize) return; // Now we can read the command QByteArray command = m_currentClient->read( m_currentCommandSize); QTextStream commandStream(command); QList<QByteArray> args; while (!commandStream.atEnd()) { QByteArray arg; commandStream >> arg; args.push_back(arg); } CVF_ASSERT(args.size() > 0); // qDebug() << args; bool isGetProperty = args[0] == "GetProperty"; // GetProperty [casename/index] PropertyName bool isSetProperty = args[0] == "SetProperty"; // SetProperty [casename/index] PropertyName bool isGetCellInfo = args[0] == "GetActiveCellInfo"; // GetActiveCellInfo [casename/index] bool isGetGridDim = args[0] == "GetMainGridDimensions"; // GetMainGridDimensions [casename/index] if (!(isGetProperty || isSetProperty || isGetCellInfo || isGetGridDim)) { m_errorMessageDialog->showMessage(tr("ResInsight SocketServer: \n") + tr("Unknown command: %1").arg(args[0].data())); return; } QString caseName; QString propertyName; RimReservoir* reservoir = NULL; // Find the correct arguments if (isGetProperty || isSetProperty) { if (args.size() == 2) { propertyName = args[1]; } else if (args.size() > 2) { caseName = args[1]; propertyName = args[2]; } } else if (isGetCellInfo || isGetGridDim) { if (args.size() > 1) { caseName = args[1]; } } reservoir = this->findReservoir(caseName); if (reservoir == NULL) { m_errorMessageDialog->showMessage(tr("ResInsight SocketServer: \n") + tr("Could not find the eclipse case with name or index: \"%1\"").arg(caseName)); return; } if (isGetProperty || isSetProperty) { // Find the requested data, Or create a set if we are setting data and it is not found size_t scalarResultIndex = cvf::UNDEFINED_SIZE_T; std::vector< std::vector<double> >* scalarResultFrames = NULL; if (reservoir && reservoir->reservoirData() && reservoir->reservoirData()->mainGrid() && reservoir->reservoirData()->mainGrid()->results()) { scalarResultIndex = reservoir->reservoirData()->mainGrid()->results()->findOrLoadScalarResult(propertyName); if (scalarResultIndex == cvf::UNDEFINED_SIZE_T && isSetProperty) { scalarResultIndex = reservoir->reservoirData()->mainGrid()->results()->addEmptyScalarResult(RimDefines::GENERATED, propertyName); } if (scalarResultIndex != cvf::UNDEFINED_SIZE_T) { scalarResultFrames = &(reservoir->reservoirData()->mainGrid()->results()->cellScalarResults(scalarResultIndex)); m_currentScalarIndex = scalarResultIndex; m_currentPropertyName = propertyName; } } if (scalarResultFrames == NULL) { m_errorMessageDialog->showMessage(tr("ResInsight SocketServer: \n") + tr("Could not find the property named: \"%1\"").arg(propertyName)); } if (isGetProperty ) { // Write data back : timeStepCount, bytesPrTimestep, dataForTimestep0 ... dataForTimestepN if ( scalarResultFrames == NULL) { // No data available socketStream << (quint64)0 << (quint64)0 ; } else { // First write timestep count quint64 timestepCount = (quint64)scalarResultFrames->size(); socketStream << timestepCount; // then the byte-size of the result values in one timestep size_t timestepResultCount = scalarResultFrames->front().size(); quint64 timestepByteCount = (quint64)(timestepResultCount*sizeof(double)); socketStream << timestepByteCount ; // qDebug() << "Trying to read " << (quint64)(scalarResultFrames->front().size()*sizeof(double)) << "bytes of data"; // Then write the data. for (size_t tIdx = 0; tIdx < scalarResultFrames->size(); ++tIdx) { #if 1 // Write data as raw bytes, fast but does not handle byteswapping m_currentClient->write((const char *)scalarResultFrames->at(tIdx).data(), timestepByteCount); // Raw print of data. Fast but no platform conversion #else // Write data using QDataStream, does byteswapping for us. Must use QDataStream on client as well for (size_t cIdx = 0; cIdx < scalarResultFrames->at(tIdx).size(); ++cIdx) { socketStream << scalarResultFrames->at(tIdx)[cIdx]; } #endif } } } else // Set property { // Disconnect the socket from calling this slot again. m_currentClient->disconnect(SIGNAL(readyRead())); m_currentReservoir = reservoir; if ( scalarResultFrames != NULL) { m_scalarResultsToAdd = scalarResultFrames; if (m_currentClient->bytesAvailable()) { this->slotReadPropertyData(); } connect(m_currentClient, SIGNAL(readyRead()), this, SLOT(slotReadPropertyData())); } } } else if (isGetCellInfo ) { // Write data back to octave: columnCount, bytesPrTimestep, GridNr I J K ParentGridNr PI PJ PK caf::FixedArray<std::vector<qint32>, 8> activeCellInfo; if (!(reservoir && reservoir->reservoirData() && reservoir->reservoirData()->mainGrid()) ) { // No data available socketStream << (quint64)0 << (quint64)0 ; return; } reservoir->reservoirData()->mainGrid()->calculateActiveCellInfo(activeCellInfo[0], activeCellInfo[1], activeCellInfo[2], activeCellInfo[3], activeCellInfo[4], activeCellInfo[5], activeCellInfo[6], activeCellInfo[7]); // First write timestep count quint64 timestepCount = (quint64)8; socketStream << timestepCount; // then the byte-size of the result values in one timestep size_t timestepResultCount = activeCellInfo[0].size(); quint64 timestepByteCount = (quint64)(timestepResultCount*sizeof(qint32)); socketStream << timestepByteCount ; // Then write the data. for (size_t tIdx = 0; tIdx < 8; ++tIdx) { #if 1 // Write data as raw bytes, fast but does not handle byteswapping m_currentClient->write((const char *)activeCellInfo[tIdx].data(), timestepByteCount); #else // Write data using QDataStream, does byteswapping for us. Must use QDataStream on client as well for (size_t cIdx = 0; cIdx < activeCellInfo[tIdx].size(); ++cIdx) { socketStream << activeCellInfo[tIdx][cIdx]; } #endif } } else if (isGetGridDim) { // Write data back to octave: I, J, K dimensions size_t iCount = 0; size_t jCount = 0; size_t kCount = 0; if (reservoir && reservoir->reservoirData() && reservoir->reservoirData()->mainGrid()) { iCount = reservoir->reservoirData()->mainGrid()->cellCountI(); jCount = reservoir->reservoirData()->mainGrid()->cellCountJ(); kCount = reservoir->reservoirData()->mainGrid()->cellCountK(); } socketStream << (quint64)iCount << (quint64)jCount << (quint64)kCount; } }
void getCases(std::vector<qint64>& caseIds, std::vector<QString>& caseNames, std::vector<QString>& caseTypes, std::vector<qint64>& caseGroupIds, const qint64& caseGroupId, const QString &hostName, quint16 port) { QString serverName = hostName; quint16 serverPort = port; QTcpSocket socket; socket.connectToHost(serverName, serverPort); if (!socket.waitForConnected(riOctavePlugin::connectTimeOutMilliSecs)) { error((("Connection: ") + socket.errorString()).toLatin1().data()); return; } // Create command and send it: QString command = QString("GetCases %1").arg(caseGroupId); 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::shortTimeOutMilliSecs)) { error((("Waiting for header: ") + socket.errorString()).toLatin1().data()); return; } } quint64 byteCount; socketStream >> byteCount; while (socket.bytesAvailable() < (int)(byteCount)) { if (!socket.waitForReadyRead(riOctavePlugin::shortTimeOutMilliSecs)) { error((("Waiting for data: ") + socket.errorString()).toLatin1().data()); return; } OCTAVE_QUIT; } quint64 caseCount; socketStream >> caseCount; qint64 caseId = -1; QString caseName; QString caseType; qint64 caseGroupIdFromSocket = -1; for (size_t i = 0; i < caseCount; i++) { socketStream >> caseId; socketStream >> caseName; socketStream >> caseType; socketStream >> caseGroupIdFromSocket; caseIds.push_back(caseId); caseNames.push_back(caseName); caseTypes.push_back(caseType); caseGroupIds.push_back(caseGroupIdFromSocket); } return; }
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; }
virtual bool interpretMore(RiaSocketServer* server, QTcpSocket* currentClient) { // std::cout << "RiaSetActiveCellProperty, interpretMore: scalarIndex : " << m_currentScalarIndex; if (m_invalidActiveCellCountDetected) return true; // If nothing should be read, or we already have read everything, do nothing if ((m_timeStepCountToRead == 0) || (m_currentTimeStepNumberToRead >= m_timeStepCountToRead) ) return true; if (!currentClient->bytesAvailable()) return false; if (m_timeStepCountToRead != m_requestedTimesteps.size()) { CVF_ASSERT(false); } // Check if a complete timestep is available, return and whait for readyRead() if not if (currentClient->bytesAvailable() < (int)m_bytesPerTimeStepToRead) return false; size_t cellCountFromOctave = m_bytesPerTimeStepToRead / sizeof(double); RigActiveCellInfo* activeCellInfo = m_currentReservoir->reservoirData()->activeCellInfo(m_porosityModelEnum); size_t globalActiveCellCount = activeCellInfo->globalActiveCellCount(); size_t totalCellCount = activeCellInfo->globalCellCount(); size_t globalCellResultCount = activeCellInfo->globalCellResultCount(); bool isCoarseningActive = globalCellResultCount != globalActiveCellCount; if (cellCountFromOctave != globalActiveCellCount ) { server->errorMessageDialog()->showMessage(RiaSocketServer::tr("ResInsight SocketServer: \n") + RiaSocketServer::tr("The number of cells in the data coming from octave does not match the case") + ":\"" + m_currentReservoir->caseUserDescription() + "\"\n" " Octave: " + QString::number(cellCountFromOctave) + "\n" " " + m_currentReservoir->caseUserDescription() + ": Active cell count: " + QString::number(globalActiveCellCount) + " Total cell count: " + QString::number(totalCellCount)) ; cellCountFromOctave = 0; m_invalidActiveCellCountDetected = true; currentClient->abort(); return true; } // Make sure the size of the retreiving container is correct. // If it is, this is noops for (size_t tIdx = 0; tIdx < m_timeStepCountToRead; ++tIdx) { size_t tsId = m_requestedTimesteps[tIdx]; m_scalarResultsToAdd->at(tsId).resize(globalCellResultCount, HUGE_VAL); } std::vector<double> readBuffer; double * internalMatrixData = NULL; if (isCoarseningActive) { readBuffer.resize(cellCountFromOctave, HUGE_VAL); internalMatrixData = readBuffer.data(); } QDataStream socketStream(currentClient); socketStream.setVersion(riOctavePlugin::qtDataStreamVersion); // Read available complete timestepdata while ((currentClient->bytesAvailable() >= (int)m_bytesPerTimeStepToRead) && (m_currentTimeStepNumberToRead < m_timeStepCountToRead)) { qint64 bytesRead = 0; if ( !isCoarseningActive) { internalMatrixData = m_scalarResultsToAdd->at(m_requestedTimesteps[m_currentTimeStepNumberToRead]).data(); } #if 1 // Use raw data transfer. Faster. bytesRead = currentClient->read((char*)(internalMatrixData), m_bytesPerTimeStepToRead); #else for (size_t cIdx = 0; cIdx < cellCountFromOctave; ++cIdx) { socketStream >> internalMatrixData[cIdx]; if (socketStream.status() == QDataStream::Ok) bytesRead += sizeof(double); } #endif // Map data from active to result index based container ( Coarsening is active) if (isCoarseningActive) { size_t acIdx = 0; for (size_t gcIdx = 0; gcIdx < totalCellCount; ++gcIdx) { if (activeCellInfo->isActive(gcIdx)) { m_scalarResultsToAdd->at(m_requestedTimesteps[m_currentTimeStepNumberToRead])[activeCellInfo->cellResultIndex(gcIdx)] = readBuffer[acIdx]; ++acIdx; } } } if ((int)m_bytesPerTimeStepToRead != bytesRead) { server->errorMessageDialog()->showMessage(RiaSocketServer::tr("ResInsight SocketServer: \n") + RiaSocketServer::tr("Could not read binary double data properly from socket")); } ++m_currentTimeStepNumberToRead; } // If we have read all the data, refresh the views if (m_currentTimeStepNumberToRead == m_timeStepCountToRead) { if (m_currentReservoir != NULL) { // Create a new input property if we have an input reservoir RimInputCase* inputRes = dynamic_cast<RimInputCase*>(m_currentReservoir); if (inputRes) { RimInputProperty* inputProperty = NULL; inputProperty = inputRes->m_inputPropertyCollection->findInputProperty(m_currentPropertyName); if (!inputProperty) { inputProperty = new RimInputProperty; inputProperty->resultName = m_currentPropertyName; inputProperty->eclipseKeyword = ""; inputProperty->fileName = ""; inputRes->m_inputPropertyCollection->inputProperties.push_back(inputProperty); RimUiTreeModelPdm* treeModel = RiuMainWindow::instance()->uiPdmModel(); treeModel->updateUiSubTree(inputRes->m_inputPropertyCollection()); } inputProperty->resolvedState = RimInputProperty::RESOLVED_NOT_SAVED; } if( m_currentScalarIndex != cvf::UNDEFINED_SIZE_T && m_currentReservoir->reservoirData() && m_currentReservoir->reservoirData()->results(m_porosityModelEnum) ) { m_currentReservoir->reservoirData()->results(m_porosityModelEnum)->recalculateMinMax(m_currentScalarIndex); } for (size_t i = 0; i < m_currentReservoir->reservoirViews.size(); ++i) { if (m_currentReservoir->reservoirViews[i]) { // As new result might have been introduced, update all editors connected m_currentReservoir->reservoirViews[i]->cellResult->updateConnectedEditors(); // It is usually not needed to create new display model, but if any derived geometry based on generated data (from Octave) // a full display model rebuild is required m_currentReservoir->reservoirViews[i]->scheduleCreateDisplayModelAndRedraw(); } } } return true; } return false; }
void getCoarseningInfo(int32NDArray& coarseningInfo, const QString &hostName, quint16 port, const qint64& caseId) { QString serverName = hostName; quint16 serverPort = port; QTcpSocket socket; socket.connectToHost(serverName, serverPort); if (!socket.waitForConnected(riOctavePlugin::connectTimeOutMilliSecs)) { error((("Connection: ") + socket.errorString()).toLatin1().data()); return; } // Create command and send it: QString command = QString("GetCoarseningInfo %1").arg(caseId); 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: ") + socket.errorString()).toLatin1().data()); return; } } quint64 byteCount; socketStream >> byteCount; quint64 boxCount = byteCount / (6 * sizeof(qint32)); dim_vector dv (1, 1); dv(0) = boxCount; dv(1) = 6; coarseningInfo.resize(dv); for (size_t i = 0; i < boxCount; i++) { qint32 i1; qint32 i2; qint32 j1; qint32 j2; qint32 k1; qint32 k2; socketStream >> i1; socketStream >> i2; socketStream >> j1; socketStream >> j2; socketStream >> k1; socketStream >> k2; coarseningInfo(i, 0) = i1; coarseningInfo(i, 1) = i2; coarseningInfo(i, 2) = j1; coarseningInfo(i, 3) = j2; coarseningInfo(i, 4) = k1; coarseningInfo(i, 5) = k2; } return; }