mirror of
https://github.com/OPM/ResInsight.git
synced 2026-10-25 14:40:26 -05:00
Magne Sjaastad
56e98ba1c4
Migrate all assert macros in ApplicationLibCode to CAF_ASSERT and remove every use of cvfAssert.h. CVF_ASSERT is replaced one to one. CVF_TIGHT_ASSERT is also replaced by CAF_ASSERT, which is semantically exact: CVF_ENABLE_TIGHT_ASSERTS is 1 only under _DEBUG, and that is what CAF_ASSERT now does. The two CVF_FAIL_MSG sites become CAF_ASSERT( false && "message" ), preserving the message with the idiom already used elsewhere in the code base. Counts before and after: CVF_ASSERT 1044 to 0, CVF_TIGHT_ASSERT 66 to 0, CVF_FAIL_MSG 2 to 0, cvfAssert.h references 154 to 0. Include handling: files that included cvfAssert.h directly now include cafAssert.h instead, includes left dead by the migration are removed, and files that were relying on cvfAssert.h transitively get an explicit cafAssert.h. Files that reach cafAssert.h through another caf header are left unchanged; a missing include here is a compile error, not a silently disabled assert. ResultStatisticsCache links only LibCore and therefore had no path to cafAssert.h. Add the cafPdmCore directory as a private include path rather than linking the library, since cafAssert.h is header only. Note that this stops these asserts from firing in Release and RelWithDebInfo, where CVF_ASSERT was previously active.
592 lines
23 KiB
C++
592 lines
23 KiB
C++
/////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (C) 2017 Statoil ASA
|
|
//
|
|
// ResInsight is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
// FITNESS FOR A PARTICULAR PURPOSE.
|
|
//
|
|
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
|
|
// for more details.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "RiaSocketCommand.h"
|
|
|
|
#include "RiaPreferences.h"
|
|
#include "RiaSocketDataTransfer.h"
|
|
#include "RiaSocketServer.h"
|
|
#include "RiaSocketTools.h"
|
|
|
|
#include "RigActiveCellInfo.h"
|
|
#include "RigCaseCellResultsData.h"
|
|
#include "RigEclipseCaseData.h"
|
|
#include "RigMainGrid.h"
|
|
#include "RigNNCData.h"
|
|
|
|
#include "Rim3dOverlayInfoConfig.h"
|
|
#include "RimCellEdgeColors.h"
|
|
#include "RimEclipseCase.h"
|
|
#include "RimEclipseCellColors.h"
|
|
#include "RimEclipseInputCase.h"
|
|
#include "RimEclipseInputProperty.h"
|
|
#include "RimEclipseInputPropertyCollection.h"
|
|
#include "RimEclipsePropertyFilterCollection.h"
|
|
#include "RimEclipseView.h"
|
|
#include "RimIntersectionCollection.h"
|
|
#include "RimReservoirCellResultsStorage.h"
|
|
#include "RimSimWellInViewCollection.h"
|
|
|
|
#include "cafAssert.h"
|
|
|
|
#include <QTcpSocket>
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
class RiaGetNNCConnections : public RiaSocketCommand
|
|
{
|
|
public:
|
|
static QString commandName() { return QString( "GetNNCConnections" ); }
|
|
|
|
bool interpretCommand( RiaSocketServer* server, const QList<QByteArray>& args, QDataStream& socketStream ) override
|
|
{
|
|
RimEclipseCase* rimCase = RiaSocketTools::findCaseFromArgs( server, args );
|
|
// Write data back to octave: columnCount, GridNr I J K GridNr I J K
|
|
if ( !( rimCase && rimCase->eclipseCaseData() && rimCase->eclipseCaseData()->mainGrid() ) )
|
|
{
|
|
// No data available
|
|
socketStream << (quint64)0;
|
|
return true;
|
|
}
|
|
|
|
RigMainGrid* mainGrid = rimCase->eclipseCaseData()->mainGrid();
|
|
|
|
size_t connectionCount = mainGrid->nncData()->allConnections().size();
|
|
|
|
socketStream << (quint64)connectionCount;
|
|
|
|
for ( size_t i = 0; i < mainGrid->nncData()->allConnections().size(); ++i )
|
|
{
|
|
RigConnection connection = mainGrid->nncData()->allConnections()[i];
|
|
|
|
const RigCell& cell1 = mainGrid->cell( connection.c1GlobIdx() );
|
|
const RigCell& cell2 = mainGrid->cell( connection.c2GlobIdx() );
|
|
|
|
sendCellInfo( socketStream, cell1 );
|
|
sendCellInfo( socketStream, cell2 );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static void sendCellInfo( QDataStream& socketStream, const RigCell& cell )
|
|
{
|
|
RigGridBase* hostGrid = cell.hostGrid();
|
|
size_t gridLocalCellIndex = cell.gridLocalCellIndex();
|
|
size_t i, j, k;
|
|
hostGrid->ijkFromCellIndex( gridLocalCellIndex, &i, &j, &k );
|
|
|
|
socketStream << (qint32)hostGrid->gridIndex();
|
|
socketStream << (qint32)( i + 1 ) << (qint32)( j + 1 ) << (qint32)( k + 1 );
|
|
}
|
|
};
|
|
|
|
static bool RiaGetNNCConnections_init =
|
|
RiaSocketCommandFactory::instance()->registerCreator<RiaGetNNCConnections>( RiaGetNNCConnections::commandName() );
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
class RiaGetDynamicNNCValues : public RiaSocketCommand
|
|
{
|
|
public:
|
|
static QString commandName() { return QString( "GetDynamicNNCValues" ); }
|
|
|
|
bool interpretCommand( RiaSocketServer* server, const QList<QByteArray>& args, QDataStream& socketStream ) override
|
|
{
|
|
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->showErrorMessage( 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()->allConnections().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" ); }
|
|
|
|
bool interpretCommand( RiaSocketServer* server, const QList<QByteArray>& args, QDataStream& socketStream ) override
|
|
{
|
|
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()->allConnections().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() );
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
class RiaGetNNCPropertyNames : public RiaSocketCommand
|
|
{
|
|
public:
|
|
static QString commandName() { return QString( "GetNNCPropertyNames" ); }
|
|
|
|
bool interpretCommand( RiaSocketServer* server, const QList<QByteArray>& args, QDataStream& socketStream ) override
|
|
{
|
|
RimEclipseCase* rimCase = RiaSocketTools::findCaseFromArgs( server, args );
|
|
|
|
if ( !( rimCase && rimCase->eclipseCaseData() && rimCase->eclipseCaseData()->mainGrid() ) )
|
|
{
|
|
// No data available
|
|
socketStream << (quint64)0;
|
|
return true;
|
|
}
|
|
|
|
RigNNCData* nncData = rimCase->eclipseCaseData()->mainGrid()->nncData();
|
|
|
|
std::vector<QString> propertyTypes;
|
|
std::vector<QString> propertyNames;
|
|
|
|
std::vector<RigNNCData::NNCResultType> resultTypes;
|
|
std::vector<QString> resultTypeNames;
|
|
|
|
resultTypes.push_back( RigNNCData::NNCResultType::NNC_DYNAMIC );
|
|
resultTypeNames.push_back( "DynamicNative" );
|
|
resultTypes.push_back( RigNNCData::NNCResultType::NNC_STATIC );
|
|
resultTypeNames.push_back( "StaticNative" );
|
|
resultTypes.push_back( RigNNCData::NNCResultType::NNC_GENERATED );
|
|
resultTypeNames.push_back( "Generated" );
|
|
|
|
for ( size_t rtIdx = 0; rtIdx < resultTypes.size(); ++rtIdx )
|
|
{
|
|
std::vector<QString> availableParameters = nncData->availableProperties( resultTypes[rtIdx] );
|
|
|
|
for ( const QString& parameter : availableParameters )
|
|
{
|
|
propertyNames.push_back( parameter );
|
|
propertyTypes.push_back( resultTypeNames[rtIdx] );
|
|
}
|
|
}
|
|
|
|
qint64 byteCount = 0;
|
|
|
|
for ( size_t ptIdx = 0; ptIdx < propertyNames.size(); ++ptIdx )
|
|
{
|
|
byteCount += propertyNames[ptIdx].size() * sizeof( QChar );
|
|
byteCount += propertyTypes[ptIdx].size() * sizeof( QChar );
|
|
}
|
|
|
|
// Byte count
|
|
socketStream << byteCount;
|
|
|
|
// Parameter count
|
|
socketStream << (quint64)propertyNames.size();
|
|
|
|
for ( size_t ptIdx = 0; ptIdx < propertyNames.size(); ++ptIdx )
|
|
{
|
|
socketStream << propertyNames[ptIdx];
|
|
socketStream << propertyTypes[ptIdx];
|
|
}
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
static bool RiaGetNNCPropertyNames_init =
|
|
RiaSocketCommandFactory::instance()->registerCreator<RiaGetNNCPropertyNames>( RiaGetNNCPropertyNames::commandName() );
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
class RiaSetNNCProperty : public RiaSocketCommand
|
|
{
|
|
public:
|
|
RiaSetNNCProperty()
|
|
: m_currentReservoir( nullptr )
|
|
, m_currentEclResultAddress()
|
|
, m_timeStepCountToRead( 0 )
|
|
, m_bytesPerTimeStepToRead( 0 )
|
|
, m_currentTimeStepNumberToRead( 0 )
|
|
, m_invalidConnectionCountDetected( false )
|
|
, m_porosityModelEnum( RiaDefines::PorosityModelType::MATRIX_MODEL )
|
|
{
|
|
}
|
|
|
|
static QString commandName() { return QString( "SetNNCProperty" ); }
|
|
|
|
bool interpretCommand( RiaSocketServer* server, const QList<QByteArray>& args, QDataStream& socketStream ) override
|
|
{
|
|
RimEclipseCase* rimCase = RiaSocketTools::findCaseFromArgs( server, args );
|
|
|
|
QString propertyName = args[2];
|
|
|
|
// Find the requested data, or create a set if we are setting data and it is not found
|
|
if ( !( rimCase && rimCase->eclipseCaseData() && rimCase->eclipseCaseData()->mainGrid() ) )
|
|
{
|
|
QString caseId = args[1];
|
|
server->showErrorMessage( RiaSocketServer::tr( "ResInsight SocketServer: \n" ) +
|
|
RiaSocketServer::tr( "Could not find case with id %1" ).arg( caseId ) );
|
|
return true;
|
|
}
|
|
|
|
// 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 ( server->currentClient()->bytesAvailable() < (int)sizeof( quint64 ) * 2 ) return true;
|
|
|
|
socketStream >> m_timeStepCountToRead;
|
|
socketStream >> m_bytesPerTimeStepToRead;
|
|
}
|
|
|
|
RigNNCData* nncData = rimCase->eclipseCaseData()->mainGrid()->nncData();
|
|
|
|
auto nncResults = nncData->generatedConnectionScalarResultByName( propertyName );
|
|
|
|
if ( nncResults == nullptr )
|
|
{
|
|
nncData->makeGeneratedConnectionScalarResult( propertyName, m_timeStepCountToRead );
|
|
}
|
|
|
|
if ( rimCase && rimCase->results( m_porosityModelEnum ) )
|
|
{
|
|
bool ok = createIJKCellResults( rimCase->results( m_porosityModelEnum ), propertyName );
|
|
if ( !ok )
|
|
{
|
|
server->showErrorMessage( RiaSocketServer::tr( "ResInsight SocketServer: \n" ) +
|
|
RiaSocketServer::tr( "Could not find the property named: \"%2\"" ).arg( propertyName ) );
|
|
return true;
|
|
}
|
|
RigEclipseResultAddress resAddr( QString( "%1IJK" ).arg( propertyName ) );
|
|
rimCase->results( m_porosityModelEnum )->ensureKnownResultLoaded( resAddr );
|
|
nncData->setEclResultAddress( propertyName, resAddr );
|
|
}
|
|
|
|
// Create a list of all the requested time steps
|
|
m_requestedTimesteps.clear();
|
|
|
|
if ( args.size() <= 4 )
|
|
{
|
|
// Select all
|
|
for ( size_t tsIdx = 0; tsIdx < m_timeStepCountToRead; ++tsIdx )
|
|
{
|
|
m_requestedTimesteps.push_back( tsIdx );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool timeStepReadError = false;
|
|
for ( int argIdx = 4; argIdx < args.size(); ++argIdx )
|
|
{
|
|
bool conversionOk = false;
|
|
int tsIdx = args[argIdx].toInt( &conversionOk );
|
|
|
|
if ( conversionOk )
|
|
{
|
|
m_requestedTimesteps.push_back( tsIdx );
|
|
}
|
|
else
|
|
{
|
|
timeStepReadError = true;
|
|
}
|
|
}
|
|
|
|
if ( timeStepReadError )
|
|
{
|
|
server->showErrorMessage( RiaSocketServer::tr( "ResInsight SocketServer: riSetNNCProperty : \n" ) +
|
|
RiaSocketServer::tr( "An error occurred while interpreting the requested time steps." ) );
|
|
}
|
|
}
|
|
|
|
if ( m_requestedTimesteps.empty() )
|
|
{
|
|
server->showErrorMessage( RiaSocketServer::tr( "ResInsight SocketServer: \n" ) +
|
|
RiaSocketServer::tr( "No time steps specified" ) );
|
|
|
|
return true;
|
|
}
|
|
|
|
m_currentReservoir = rimCase;
|
|
m_currentPropertyName = propertyName;
|
|
|
|
if ( server->currentClient()->bytesAvailable() )
|
|
{
|
|
return interpretMore( server, server->currentClient() );
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private:
|
|
static bool createIJKCellResults( RigCaseCellResultsData* results, QString propertyName )
|
|
{
|
|
bool ok;
|
|
ok = scalarResultExistsOrCreate( results, QString( "%1IJK" ).arg( propertyName ) );
|
|
if ( !ok ) return false;
|
|
ok = scalarResultExistsOrCreate( results, QString( "%1I" ).arg( propertyName ) );
|
|
if ( !ok ) return false;
|
|
ok = scalarResultExistsOrCreate( results, QString( "%1J" ).arg( propertyName ) );
|
|
if ( !ok ) return false;
|
|
ok = scalarResultExistsOrCreate( results, QString( "%1K" ).arg( propertyName ) );
|
|
|
|
return ok;
|
|
}
|
|
|
|
static bool scalarResultExistsOrCreate( RigCaseCellResultsData* results, QString propertyName )
|
|
{
|
|
RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::GENERATED, propertyName );
|
|
|
|
if ( !results->ensureKnownResultLoaded( resAddr ) )
|
|
{
|
|
results->createResultEntry( resAddr, true );
|
|
}
|
|
|
|
std::vector<std::vector<double>>* scalarResultFrames = results->modifiableCellScalarResultTimesteps( resAddr );
|
|
size_t timeStepCount = results->maxTimeStepCount();
|
|
scalarResultFrames->resize( timeStepCount );
|
|
|
|
return true;
|
|
}
|
|
|
|
public:
|
|
bool interpretMore( RiaSocketServer* server, QTcpSocket* currentClient ) override
|
|
{
|
|
if ( m_invalidConnectionCountDetected ) 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() )
|
|
{
|
|
CAF_ASSERT( false );
|
|
}
|
|
|
|
// Check if a complete timestep is available, return and whait for readyRead() if not
|
|
if ( currentClient->bytesAvailable() < (int)m_bytesPerTimeStepToRead ) return false;
|
|
|
|
RigNNCData* nncData = m_currentReservoir->eclipseCaseData()->mainGrid()->nncData();
|
|
|
|
size_t connectionCountFromOctave = m_bytesPerTimeStepToRead / sizeof( double );
|
|
size_t connectionCount = nncData->allConnections().size();
|
|
std::vector<std::vector<double>>* resultsToAdd = nncData->generatedConnectionScalarResultByName( m_currentPropertyName );
|
|
|
|
if ( connectionCountFromOctave != connectionCount )
|
|
{
|
|
server->showErrorMessage(
|
|
RiaSocketServer::tr( "ResInsight SocketServer: \n" ) +
|
|
RiaSocketServer::tr( "The number of connections in the data coming from octave "
|
|
"does not match the case: '%1'\n" )
|
|
.arg( m_currentReservoir->caseUserDescription() ) +
|
|
RiaSocketServer::tr( " Octave: %1\n" ).arg( connectionCountFromOctave ) +
|
|
RiaSocketServer::tr( " %1: Connection count: %2" ).arg( m_currentReservoir->caseUserDescription() ).arg( connectionCount ) );
|
|
|
|
connectionCountFromOctave = 0;
|
|
m_invalidConnectionCountDetected = true;
|
|
currentClient->abort();
|
|
|
|
return true;
|
|
}
|
|
|
|
for ( size_t tIdx = 0; tIdx < m_timeStepCountToRead; ++tIdx )
|
|
{
|
|
size_t tsId = m_requestedTimesteps[tIdx];
|
|
resultsToAdd->at( tsId ).resize( connectionCount, HUGE_VAL );
|
|
}
|
|
|
|
double* internalMatrixData = nullptr;
|
|
|
|
QDataStream socketStream( currentClient );
|
|
socketStream.setVersion( riOctavePlugin::qtDataStreamVersion );
|
|
|
|
// Read available complete time step data
|
|
while ( ( currentClient->bytesAvailable() >= (int)m_bytesPerTimeStepToRead ) &&
|
|
( m_currentTimeStepNumberToRead < m_timeStepCountToRead ) )
|
|
{
|
|
internalMatrixData = resultsToAdd->at( m_requestedTimesteps[m_currentTimeStepNumberToRead] ).data();
|
|
|
|
QStringList errorMessages;
|
|
if ( !RiaSocketDataTransfer::readBlockDataFromSocket( currentClient, (char*)( internalMatrixData ), m_bytesPerTimeStepToRead, errorMessages ) )
|
|
{
|
|
for ( int i = 0; i < errorMessages.size(); i++ )
|
|
{
|
|
server->showErrorMessage( errorMessages[i] );
|
|
}
|
|
|
|
currentClient->abort();
|
|
return true;
|
|
}
|
|
++m_currentTimeStepNumberToRead;
|
|
}
|
|
|
|
// If we have read all the data, refresh the views
|
|
|
|
if ( m_currentTimeStepNumberToRead == m_timeStepCountToRead )
|
|
{
|
|
if ( m_currentReservoir != nullptr )
|
|
{
|
|
// Create a new input property if we have an input reservoir
|
|
RimEclipseInputCase* inputRes = dynamic_cast<RimEclipseInputCase*>( m_currentReservoir );
|
|
if ( inputRes )
|
|
{
|
|
RimEclipseInputProperty* inputProperty = inputRes->inputPropertyCollection()->findInputProperty( m_currentPropertyName );
|
|
if ( !inputProperty )
|
|
{
|
|
inputProperty = new RimEclipseInputProperty;
|
|
inputProperty->resultName = m_currentPropertyName;
|
|
inputProperty->eclipseKeyword = "";
|
|
inputProperty->fileName = QString( "" );
|
|
inputRes->inputPropertyCollection()->addItem( inputProperty );
|
|
}
|
|
inputProperty->resolvedState = RimEclipseInputProperty::RESOLVED_NOT_SAVED;
|
|
}
|
|
|
|
if ( m_currentEclResultAddress.isValid() && // Will never be valid because it is never set. What is
|
|
// correct behaviour ?
|
|
m_currentReservoir->eclipseCaseData() && m_currentReservoir->eclipseCaseData()->results( m_porosityModelEnum ) )
|
|
{
|
|
m_currentReservoir->eclipseCaseData()->results( m_porosityModelEnum )->recalculateStatistics( m_currentEclResultAddress );
|
|
}
|
|
|
|
for ( RimEclipseView* view : m_currentReservoir->reservoirViews() )
|
|
{
|
|
// As new result might have been introduced, update all editors connected
|
|
view->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
|
|
view->scheduleCreateDisplayModelAndRedraw();
|
|
view->intersectionCollection()->scheduleCreateDisplayModelAndRedraw2dIntersectionViews();
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private:
|
|
RimEclipseCase* m_currentReservoir;
|
|
RigEclipseResultAddress m_currentEclResultAddress;
|
|
QString m_currentPropertyName;
|
|
std::vector<size_t> m_requestedTimesteps;
|
|
RiaDefines::PorosityModelType m_porosityModelEnum;
|
|
|
|
quint64 m_timeStepCountToRead;
|
|
quint64 m_bytesPerTimeStepToRead;
|
|
size_t m_currentTimeStepNumberToRead;
|
|
|
|
bool m_invalidConnectionCountDetected;
|
|
};
|
|
|
|
static bool RiaSetNNCProperty_init =
|
|
RiaSocketCommandFactory::instance()->registerCreator<RiaSetNNCProperty>( RiaSetNNCProperty::commandName() );
|