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

Stop ResInsight from crashing when calculating cell volume (#8374)

Browse Source 
* Stop ResInsight from crashing when calculating cell volume
This commit is contained in:
jonjenssen 2021-12-17 16:10:24 +01:00 committed by Magne Sjaastad
parent 985a2c8f30
commit 3bb6642900
6 changed files with 13 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
ApplicationLibCode/ReservoirDataModel/RigActiveCellInfo.cpp
View File

@ -25,7 +25,6 @@
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RigActiveCellInfo::RigActiveCellInfo() RigActiveCellInfo::RigActiveCellInfo()
: m_reservoirActiveCellCount( 0 ) : m_reservoirActiveCellCount( 0 )
, m_reservoirCellResultCount( 0 )
, m_activeCellPositionMin( cvf::Vec3d::ZERO ) , m_activeCellPositionMin( cvf::Vec3d::ZERO )
, m_activeCellPositionMax( cvf::Vec3d::ZERO ) , m_activeCellPositionMax( cvf::Vec3d::ZERO )
{ {
@ -47,14 +46,6 @@ size_t RigActiveCellInfo::reservoirCellCount() const
return m_cellIndexToResultIndex.size(); return m_cellIndexToResultIndex.size();
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RigActiveCellInfo::reservoirCellResultCount() const
{
return m_reservoirCellResultCount;
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -75,11 +66,6 @@ bool RigActiveCellInfo::isActive( size_t reservoirCellIndex ) const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
size_t RigActiveCellInfo::cellResultIndex( size_t reservoirCellIndex ) const size_t RigActiveCellInfo::cellResultIndex( size_t reservoirCellIndex ) const
{ {
if ( m_cellIndexToResultIndex.size() == 0 )
{
return reservoirCellIndex;
}
CVF_TIGHT_ASSERT( reservoirCellIndex < m_cellIndexToResultIndex.size() ); CVF_TIGHT_ASSERT( reservoirCellIndex < m_cellIndexToResultIndex.size() );
return m_cellIndexToResultIndex[reservoirCellIndex]; return m_cellIndexToResultIndex[reservoirCellIndex];
@ -94,11 +80,11 @@ void RigActiveCellInfo::setCellResultIndex( size_t reservoirCellIndex, size_t re
m_cellIndexToResultIndex[reservoirCellIndex] = reservoirCellResultIndex; m_cellIndexToResultIndex[reservoirCellIndex] = reservoirCellResultIndex;
if ( reservoirCellResultIndex >= m_reservoirCellResultCount ) // if ( reservoirCellResultIndex >= m_reservoirActiveCellCount )
{ // {
#pragma omp critical //#pragma omp critical
m_reservoirCellResultCount = reservoirCellResultIndex + 1; // m_reservoirActiveCellCount = reservoirCellResultIndex + 1;
} // }
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -215,14 +201,6 @@ void RigActiveCellInfo::addLgr( size_t cellCount )
} }
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigActiveCellInfo::isCoarseningActive() const
{
return m_reservoirCellResultCount != m_reservoirActiveCellCount;
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

3
ApplicationLibCode/ReservoirDataModel/RigActiveCellInfo.h
View File

@ -34,8 +34,6 @@ public:
void setReservoirCellCount( size_t reservoirCellCount ); void setReservoirCellCount( size_t reservoirCellCount );
size_t reservoirCellCount() const; size_t reservoirCellCount() const;
size_t reservoirActiveCellCount() const; size_t reservoirActiveCellCount() const;
size_t reservoirCellResultCount() const;
bool isCoarseningActive() const;
bool isActive( size_t reservoirCellIndex ) const; bool isActive( size_t reservoirCellIndex ) const;
size_t cellResultIndex( size_t reservoirCellIndex ) const; size_t cellResultIndex( size_t reservoirCellIndex ) const;
@ -75,7 +73,6 @@ private:
std::vector<size_t> m_cellIndexToResultIndex; std::vector<size_t> m_cellIndexToResultIndex;
size_t m_reservoirActiveCellCount; size_t m_reservoirActiveCellCount;
size_t m_reservoirCellResultCount;
cvf::Vec3st m_activeCellPositionMin; cvf::Vec3st m_activeCellPositionMin;
cvf::Vec3st m_activeCellPositionMax; cvf::Vec3st m_activeCellPositionMax;

6
ApplicationLibCode/ReservoirDataModel/RigCaseCellResultsData.cpp
View File

@ -820,7 +820,7 @@ const std::vector<double>*
QString resultName, QString resultName,
std::vector<double>& activeCellsResultsTempContainer ) std::vector<double>& activeCellsResultsTempContainer )
{ {
size_t resultCellCount = actCellInfo->reservoirCellResultCount(); size_t resultCellCount = actCellInfo->reservoirActiveCellCount();
size_t reservoirCellCount = actCellInfo->reservoirCellCount(); size_t reservoirCellCount = actCellInfo->reservoirCellCount();
RigEclipseResultAddress resVarAddr( RiaDefines::ResultCatType::STATIC_NATIVE, resultName ); RigEclipseResultAddress resVarAddr( RiaDefines::ResultCatType::STATIC_NATIVE, resultName );
@ -2897,7 +2897,7 @@ void RigCaseCellResultsData::computeCellVolumes()
} }
std::vector<double>& cellVolumeResults = m_cellScalarResults[cellVolIdx][0]; std::vector<double>& cellVolumeResults = m_cellScalarResults[cellVolIdx][0];
size_t cellResultCount = m_activeCellInfo->reservoirCellResultCount(); size_t cellResultCount = m_activeCellInfo->reservoirActiveCellCount();
cellVolumeResults.resize( cellResultCount, std::numeric_limits<double>::infinity() ); cellVolumeResults.resize( cellResultCount, std::numeric_limits<double>::infinity() );
#pragma omp parallel for #pragma omp parallel for
@ -2938,7 +2938,7 @@ void RigCaseCellResultsData::computeOilVolumes()
false ); false );
m_cellScalarResults[oilVolIdx].resize( this->maxTimeStepCount() ); m_cellScalarResults[oilVolIdx].resize( this->maxTimeStepCount() );
size_t cellResultCount = m_activeCellInfo->reservoirCellResultCount(); size_t cellResultCount = m_activeCellInfo->reservoirActiveCellCount();
for ( size_t timeStepIdx = 0; timeStepIdx < this->maxTimeStepCount(); timeStepIdx++ ) for ( size_t timeStepIdx = 0; timeStepIdx < this->maxTimeStepCount(); timeStepIdx++ )
{ {
const std::vector<double>& soilResults = m_cellScalarResults[soilIdx][timeStepIdx]; const std::vector<double>& soilResults = m_cellScalarResults[soilIdx][timeStepIdx];

4
ApplicationLibCode/ReservoirDataModel/RigNumberOfFloodedPoreVolumesCalculator.cpp
View File

@ -46,7 +46,7 @@ RigNumberOfFloodedPoreVolumesCalculator::RigNumberOfFloodedPoreVolumesCalculator
RigActiveCellInfo* actCellInfo = RigActiveCellInfo* actCellInfo =
caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL ); caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
size_t resultCellCount = actCellInfo->reservoirCellResultCount(); size_t resultCellCount = actCellInfo->reservoirActiveCellCount();
size_t timeStepCount = size_t timeStepCount =
caseToApply->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->maxTimeStepCount(); caseToApply->eclipseCaseData()->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->maxTimeStepCount();
@ -207,7 +207,7 @@ void RigNumberOfFloodedPoreVolumesCalculator::calculate( RigMainGrid*
// size_t totalNumberOfCells = mainGrid->globalCellArray().size(); // size_t totalNumberOfCells = mainGrid->globalCellArray().size();
RigActiveCellInfo* actCellInfo = RigActiveCellInfo* actCellInfo =
caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL ); caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
size_t resultCellCount = actCellInfo->reservoirCellResultCount(); size_t resultCellCount = actCellInfo->reservoirActiveCellCount();
caf::ProgressInfo progress( 2 * daysSinceSimulationStart.size(), "" ); caf::ProgressInfo progress( 2 * daysSinceSimulationStart.size(), "" );

38
ApplicationLibCode/SocketInterface/RiaPropertyDataCommands.cpp
View File

@ -468,9 +468,6 @@ public:
socketStream >> m_bytesPerTimeStepToRead; socketStream >> m_bytesPerTimeStepToRead;
} }
// std::cout << "RiaSetActiveCellProperty: " << propertyName.data() << " timeStepCount " <<
// m_timeStepCountToRead << " bytesPerTimeStep " << m_bytesPerTimeStepToRead;
// Create a list of all the requested timesteps // Create a list of all the requested timesteps
m_requestedTimesteps.clear(); m_requestedTimesteps.clear();
@ -531,8 +528,6 @@ public:
bool interpretMore( RiaSocketServer* server, QTcpSocket* currentClient ) override bool interpretMore( RiaSocketServer* server, QTcpSocket* currentClient ) override
{ {
// std::cout << "RiaSetActiveCellProperty, interpretMore: scalarIndex : " << m_currentScalarIndex;
if ( m_invalidActiveCellCountDetected ) return true; if ( m_invalidActiveCellCountDetected ) return true;
// If nothing should be read, or we already have read everything, do nothing // If nothing should be read, or we already have read everything, do nothing
@ -555,9 +550,6 @@ public:
size_t activeCellCountReservoir = activeCellInfo->reservoirActiveCellCount(); size_t activeCellCountReservoir = activeCellInfo->reservoirActiveCellCount();
size_t totalCellCount = activeCellInfo->reservoirCellCount(); size_t totalCellCount = activeCellInfo->reservoirCellCount();
size_t reservoirCellResultCount = activeCellInfo->reservoirCellResultCount();
bool isCoarseningActive = reservoirCellResultCount != activeCellCountReservoir;
if ( cellCountFromOctave != activeCellCountReservoir ) if ( cellCountFromOctave != activeCellCountReservoir )
{ {
@ -602,18 +594,12 @@ public:
for ( size_t tIdx = 0; tIdx < m_timeStepCountToRead; ++tIdx ) for ( size_t tIdx = 0; tIdx < m_timeStepCountToRead; ++tIdx )
{ {
size_t tsId = m_requestedTimesteps[tIdx]; size_t tsId = m_requestedTimesteps[tIdx];
m_scalarResultsToAdd->at( tsId ).resize( reservoirCellResultCount, HUGE_VAL ); m_scalarResultsToAdd->at( tsId ).resize( activeCellCountReservoir, HUGE_VAL );
} }
std::vector<double> readBuffer; std::vector<double> readBuffer;
double* internalMatrixData = nullptr; double* internalMatrixData = nullptr;
if ( isCoarseningActive )
{
readBuffer.resize( cellCountFromOctave, HUGE_VAL );
internalMatrixData = readBuffer.data();
}
QDataStream socketStream( currentClient ); QDataStream socketStream( currentClient );
socketStream.setVersion( riOctavePlugin::qtDataStreamVersion ); socketStream.setVersion( riOctavePlugin::qtDataStreamVersion );
@ -622,11 +608,7 @@ public:
while ( ( currentClient->bytesAvailable() >= (int)m_bytesPerTimeStepToRead ) && while ( ( currentClient->bytesAvailable() >= (int)m_bytesPerTimeStepToRead ) &&
( m_currentTimeStepNumberToRead < m_timeStepCountToRead ) ) ( m_currentTimeStepNumberToRead < m_timeStepCountToRead ) )
{ {
if ( !isCoarseningActive ) internalMatrixData = m_scalarResultsToAdd->at( m_requestedTimesteps[m_currentTimeStepNumberToRead] ).data();
{
internalMatrixData =
m_scalarResultsToAdd->at( m_requestedTimesteps[m_currentTimeStepNumberToRead] ).data();
}
QStringList errorMessages; QStringList errorMessages;
if ( !RiaSocketDataTransfer::readBlockDataFromSocket( currentClient, if ( !RiaSocketDataTransfer::readBlockDataFromSocket( currentClient,
@ -643,22 +625,6 @@ public:
return true; return true;
} }
// 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;
}
}
}
++m_currentTimeStepNumberToRead; ++m_currentTimeStepNumberToRead;
} }

2
GrpcInterface/RiaGrpcPropertiesService.cpp
View File

@ -251,7 +251,7 @@ protected:
m_resultValues = caseData->results( porosityModel )->modifiableCellScalarResult( resVarAddr, timeStepIndex ); m_resultValues = caseData->results( porosityModel )->modifiableCellScalarResult( resVarAddr, timeStepIndex );
if ( m_resultValues->empty() ) if ( m_resultValues->empty() )
{ {
m_resultValues->resize( activeCellInfo->reservoirCellResultCount() ); m_resultValues->resize( activeCellInfo->reservoirActiveCellCount() );
} }
m_cellCount = activeCellInfo->reservoirActiveCellCount(); m_cellCount = activeCellInfo->reservoirActiveCellCount();
} }