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

Work in progress, updating cell indexing

Browse Source
This commit is contained in:
Jon Jenssen 2024-09-04 18:17:19 +02:00 committed by jonjenssen
parent 9483c9054d
commit 2d5cedb5d9
28 changed files with 201 additions and 136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ApplicationLibCode/Application/Tools/RiaImportEclipseCaseTools.cpp
View File

@ -214,7 +214,7 @@ bool RiaImportEclipseCaseTools::openEclipseCasesFromFile( const QStringList& fil
// Call process events to clear the queue. This make sure that we are able raise the 3D window on top of the
// plot window. Otherwise the event processing ends up with the plot window on top.
QApplication::processEvents();
// QApplication::processEvents();
RiuMainWindow::instance()->activateWindow();
}

2
ApplicationLibCode/Commands/CompletionExportCommands/RicWellPathExportMswCompletionsImpl.cpp
View File

@ -694,7 +694,7 @@ void RicWellPathExportMswCompletionsImpl::generateFishbonesMswExportInfo( const
for ( auto intersectionIndex : indices )
{
auto intersection = filteredIntersections[intersectionIndex];
if ( intersection.globCellIndex >= mainGrid->globalCellArray().size() ) continue;
// if ( intersection.globCellIndex >= mainGrid->globalCellArray().size() ) continue;
size_t localGridCellIndex = 0u;
const RigGridBase* localGrid =

10
ApplicationLibCode/Commands/RicCreateTemporaryLgrFeature.cpp
View File

@ -190,7 +190,7 @@ void RicCreateTemporaryLgrFeature::setupActionLook( QAction* actionToSetup )
void RicCreateTemporaryLgrFeature::createLgr( const LgrInfo& lgrInfo, RigMainGrid* mainGrid )
{
int lgrId = lgrInfo.id;
size_t totalCellCount = mainGrid->globalCellArray().size();
size_t totalCellCount = mainGrid->cellCount();
size_t lgrCellCount = lgrInfo.cellCount();
// Create local grid and set properties
@ -203,14 +203,14 @@ void RicCreateTemporaryLgrFeature::createLgr( const LgrInfo& lgrInfo, RigMainGri
localGrid->setGridPointDimensions( cvf::Vec3st( lgrInfo.sizes.i() + 1, lgrInfo.sizes.j() + 1, lgrInfo.sizes.k() + 1 ) );
mainGrid->addLocalGrid( localGrid );
size_t cellStartIndex = mainGrid->globalCellArray().size();
size_t cellStartIndex = mainGrid->cellCount();
size_t nodeStartIndex = mainGrid->nodes().size();
// Resize global cell and node arrays
{
RigCell defaultCell;
defaultCell.setHostGrid( localGrid );
mainGrid->globalCellArray().resize( cellStartIndex + lgrCellCount, defaultCell );
mainGrid->reservoirCells().resize( cellStartIndex + lgrCellCount, defaultCell );
mainGrid->nodes().resize( nodeStartIndex + lgrCellCount * 8, cvf::Vec3d( 0, 0, 0 ) );
}
@ -231,10 +231,10 @@ void RicCreateTemporaryLgrFeature::createLgr( const LgrInfo& lgrInfo, RigMainGri
size_t mainI = lgrInfo.mainGridStartCell.i() + lgrI / lgrSizePerMainCell.i();
size_t mainCellIndex = mainGrid->cellIndexFromIJK( mainI, mainJ, mainK );
auto& mainGridCell = mainGrid->globalCellArray()[mainCellIndex];
auto& mainGridCell = mainGrid->reservoirCells()[mainCellIndex];
mainGridCell.setSubGrid( localGrid );
RigCell& cell = mainGrid->globalCellArray()[cellStartIndex + gridLocalCellIndex];
RigCell& cell = mainGrid->reservoirCells()[cellStartIndex + gridLocalCellIndex];
cell.setGridLocalCellIndex( gridLocalCellIndex );
cell.setParentCellIndex( mainCellIndex );

2
ApplicationLibCode/FileInterface/RifEclipseOutputFileTools.cpp
View File

@ -668,7 +668,7 @@ bool RifEclipseOutputFileTools::assignActiveCellData( std::vector<std::vector<in
}
// Check if number of cells is matching
if ( eclipseCaseData->mainGrid()->globalCellArray().size() != reservoirCellCount )
if ( eclipseCaseData->mainGrid()->cellCount() != reservoirCellCount )
{
return false;
}

8
ApplicationLibCode/FileInterface/RifReaderEclipseOutput.cpp
View File

@ -161,12 +161,12 @@ bool RifReaderEclipseOutput::transferGridCellData( RigMainGrid* mainGrid
CVF_ASSERT( activeCellInfo && fractureActiveCellInfo );
int cellCount = ecl_grid_get_global_size( localEclGrid );
size_t cellStartIndex = mainGrid->globalCellArray().size();
size_t cellStartIndex = mainGrid->reservoirCells().size();
size_t nodeStartIndex = mainGrid->nodes().size();
RigCell defaultCell;
defaultCell.setHostGrid( localGrid );
mainGrid->globalCellArray().resize( cellStartIndex + cellCount, defaultCell );
mainGrid->reservoirCells().resize( cellStartIndex + cellCount, defaultCell );
mainGrid->nodes().resize( nodeStartIndex + cellCount * 8, cvf::Vec3d( 0, 0, 0 ) );
@ -175,7 +175,7 @@ bool RifReaderEclipseOutput::transferGridCellData( RigMainGrid* mainGrid
#pragma omp parallel for
for ( int gridLocalCellIndex = 0; gridLocalCellIndex < cellCount; ++gridLocalCellIndex )
{
RigCell& cell = mainGrid->globalCellArray()[cellStartIndex + gridLocalCellIndex];
RigCell& cell = mainGrid->reservoirCells()[cellStartIndex + gridLocalCellIndex];
cell.setGridLocalCellIndex( gridLocalCellIndex );
@ -303,7 +303,7 @@ bool RifReaderEclipseOutput::transferGeometry( const ecl_grid_type* mainEclGrid,
// Reserve room for the cells and nodes and fill them with data
mainGrid->globalCellArray().reserve( totalCellCount );
mainGrid->reservoirCells().reserve( totalCellCount );
mainGrid->nodes().reserve( 8 * totalCellCount );
caf::ProgressInfo progInfo( 3 + numLGRs, "" );

8
ApplicationLibCode/FileInterface/RifReaderOpmCommon.cpp
View File

@ -197,7 +197,7 @@ bool RifReaderOpmCommon::importGrid( RigMainGrid* mainGrid, RigEclipseCaseData*
activeCellInfo->setReservoirCellCount( totalCellCount );
fractureActiveCellInfo->setReservoirCellCount( totalCellCount );
mainGrid->globalCellArray().reserve( (size_t)totalCellCount );
mainGrid->reservoirCells().reserve( (size_t)totalCellCount );
mainGrid->nodes().reserve( (size_t)totalCellCount * 8 );
activeCellInfo->setGridCount( 1 + numLGRs );
@ -411,7 +411,7 @@ void RifReaderOpmCommon::transferGeometry( Opm::EclIO::EGrid& opmMainGrid,
RigEclipseCaseData* eclipseCaseData )
{
int cellCount = opmGrid.totalNumberOfCells();
size_t cellStartIndex = mainGrid->globalCellArray().size();
size_t cellStartIndex = mainGrid->reservoirCells().size();
size_t nodeStartIndex = mainGrid->nodes().size();
const bool invalidateLongPyramidCells = invalidateLongThinCells();
@ -419,7 +419,7 @@ void RifReaderOpmCommon::transferGeometry( Opm::EclIO::EGrid& opmMainGrid,
RigCell defaultCell;
defaultCell.setHostGrid( localGrid );
mainGrid->globalCellArray().resize( cellStartIndex + cellCount, defaultCell );
mainGrid->reservoirCells().resize( cellStartIndex + cellCount, defaultCell );
mainGrid->nodes().resize( nodeStartIndex + cellCount * 8, cvf::Vec3d( 0, 0, 0 ) );
@ -456,7 +456,7 @@ void RifReaderOpmCommon::transferGeometry( Opm::EclIO::EGrid& opmMainGrid,
}
auto riReservoirIndex = localGrid->cellIndexFromIJK( opmIJK[0], opmIJK[1], opmIJK[2] );
RigCell& cell = mainGrid->globalCellArray()[cellStartIndex + riReservoirIndex];
RigCell& cell = mainGrid->reservoirCells()[cellStartIndex + riReservoirIndex];
cell.setGridLocalCellIndex( riReservoirIndex );
// parent cell index

16
ApplicationLibCode/FileInterface/RifReaderOpmCommonActive.cpp
View File

@ -123,7 +123,8 @@ bool RifReaderOpmCommonActive::importGrid( RigMainGrid* /* mainGrid*/, RigEclips
// TODO - loop over all grids
activeGrid->transferActiveInformation( eclipseCaseData,
activeGrid->transferActiveInformation( 0,
eclipseCaseData,
opmGrid.totalActiveCells(),
opmGrid.activeCells(),
opmGrid.activeFracCells(),
@ -194,8 +195,8 @@ void RifReaderOpmCommonActive::transferActiveGeometry( Opm::EclIO::EGrid& opmMa
for ( size_t i = 0; i < 8; i++ )
defaultCell.cornerIndices()[i] = 0;
activeGrid->globalCellArray().resize( cellCount + 1, defaultCell );
activeGrid->globalCellArray()[cellCount].setInvalid( true );
activeGrid->reservoirCells().resize( cellCount + 1, defaultCell );
activeGrid->reservoirCells()[cellCount].setInvalid( true );
activeGrid->nodes().resize( ( cellCount + 1 ) * 8, cvf::Vec3d( 0, 0, 0 ) );
@ -236,7 +237,8 @@ void RifReaderOpmCommonActive::transferActiveGeometry( Opm::EclIO::EGrid& opmMa
}
auto riReservoirIndex = activeGrid->cellIndexFromIJK( opmIJK[0], opmIJK[1], opmIJK[2] );
RigCell& cell = activeGrid->globalCellArray()[riReservoirIndex];
RigCell& cell = activeGrid->cell( riReservoirIndex );
auto actualIndex = activeGrid->globalToActualCellIndex( riReservoirIndex );
cell.setGridLocalCellIndex( riReservoirIndex );
cell.setParentCellIndex( cvf::UNDEFINED_SIZE_T );
@ -246,8 +248,8 @@ void RifReaderOpmCommonActive::transferActiveGeometry( Opm::EclIO::EGrid& opmMa
std::array<double, 8> opmZ{};
opmMainGrid.getCellCorners( opmCellIndex, opmX, opmY, opmZ );
// Each cell has 8 nodes, use reservoir cell index and multiply to find first node index for cell
auto riNodeStartIndex = riReservoirIndex * 8;
// Each cell has 8 nodes, use active cell index and multiply to find first node index for cell
auto riNodeStartIndex = actualIndex * 8;
for ( size_t opmNodeIndex = 0; opmNodeIndex < 8; opmNodeIndex++ )
{
@ -267,4 +269,6 @@ void RifReaderOpmCommonActive::transferActiveGeometry( Opm::EclIO::EGrid& opmMa
cell.setInvalid( cell.isLongPyramidCell() );
}
}
if ( riNodes.size() > 1 ) riNodes[riNodes.size() - 1] = riNodes[0];
}

8
ApplicationLibCode/FileInterface/RifRoffFileTools.cpp
View File

@ -188,19 +188,19 @@ bool RifRoffFileTools::openGridFile( const QString& fileName, RigEclipseCaseData
fractureActiveCellInfo->setReservoirCellCount( totalCellCount );
// Reserve room for the cells and nodes and fill them with data
mainGrid->globalCellArray().reserve( totalCellCount );
mainGrid->reservoirCells().reserve( totalCellCount );
mainGrid->nodes().reserve( 8 * totalCellCount );
int progTicks = 100;
caf::ProgressInfo progInfo( progTicks, "" );
int cellCount = static_cast<int>( totalCellCount );
size_t cellStartIndex = mainGrid->globalCellArray().size();
size_t cellStartIndex = mainGrid->reservoirCells().size();
size_t nodeStartIndex = mainGrid->nodes().size();
RigCell defaultCell;
defaultCell.setHostGrid( mainGrid );
mainGrid->globalCellArray().resize( cellStartIndex + cellCount, defaultCell );
mainGrid->reservoirCells().resize( cellStartIndex + cellCount, defaultCell );
mainGrid->nodes().resize( nodeStartIndex + static_cast<size_t>( cellCount ) * 8, cvf::Vec3d( 0, 0, 0 ) );
@ -220,7 +220,7 @@ bool RifRoffFileTools::openGridFile( const QString& fileName, RigEclipseCaseData
#pragma omp for
for ( int gridLocalCellIndex = 0; gridLocalCellIndex < cellCount; ++gridLocalCellIndex )
{
RigCell& cell = mainGrid->globalCellArray()[cellStartIndex + gridLocalCellIndex];
RigCell& cell = mainGrid->reservoirCells()[cellStartIndex + gridLocalCellIndex];
cell.setGridLocalCellIndex( gridLocalCellIndex );

4
ApplicationLibCode/ModelVisualization/Intersections/RivEclipseIntersectionGrid.cpp
View File

@ -66,7 +66,7 @@ bool RivEclipseIntersectionGrid::useCell( size_t cellIndex ) const
if ( m_intervalTool.isNumberIncluded( k ) )
{
const RigCell& cell = m_mainGrid->globalCellArray()[cellIndex];
const RigCell& cell = m_mainGrid->cell( cellIndex );
if ( m_showInactiveCells )
return !cell.isInvalid() && ( cell.subGrid() == nullptr );
else
@ -88,7 +88,7 @@ void RivEclipseIntersectionGrid::cellCornerVertices( size_t cellIndex, cvf::Vec3
//--------------------------------------------------------------------------------------------------
void RivEclipseIntersectionGrid::cellCornerIndices( size_t cellIndex, size_t cornerIndices[8] ) const
{
const std::array<size_t, 8>& cornerIndicesSource = m_mainGrid->globalCellArray()[cellIndex].cornerIndices();
const std::array<size_t, 8>& cornerIndicesSource = m_mainGrid->cell( cellIndex ).cornerIndices();
for ( size_t i = 0; i < 8; i++ )
{

16
ApplicationLibCode/ModelVisualization/RivElementVectorResultPartMgr.cpp
View File

@ -150,18 +150,20 @@ void RivElementVectorResultPartMgr::appendDynamicGeometryPartsToModel( cvf::Mode
RigActiveCellInfo* activeCellInfo = eclipseCaseData->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
const std::vector<RigCell>& cells = eclipseCase->mainGrid()->globalCellArray();
const auto grid = eclipseCase->mainGrid();
auto getFaceCenterAndNormal = [cells, arrowScaling, displayCordXf]( size_t globalCellIdx,
cvf::StructGridInterface::FaceType faceType,
cvf::Vec3d& faceCenter,
cvf::Vec3d& faceNormal )
auto getFaceCenterAndNormal = [arrowScaling, displayCordXf, grid]( size_t globalCellIdx,
cvf::StructGridInterface::FaceType faceType,
cvf::Vec3d& faceCenter,
cvf::Vec3d& faceNormal )
{
faceCenter = displayCordXf->transformToDisplayCoord( cells[globalCellIdx].faceCenter( faceType ) );
cvf::Vec3d cellCenter = displayCordXf->transformToDisplayCoord( cells[globalCellIdx].center() );
faceCenter = displayCordXf->transformToDisplayCoord( grid->cell( globalCellIdx ).faceCenter( faceType ) );
cvf::Vec3d cellCenter = displayCordXf->transformToDisplayCoord( grid->cell( globalCellIdx ).center() );
faceNormal = ( faceCenter - cellCenter ).getNormalized() * arrowScaling;
};
const std::vector<RigCell>& cells = eclipseCase->mainGrid()->reservoirCells();
if ( !resultAddresses.empty() && !directions.empty() )
{
#pragma omp parallel for

16
ApplicationLibCode/ModelVisualization/RivNNCGeometryGenerator.cpp
View File

@ -77,12 +77,8 @@ void RivNNCGeometryGenerator::computeArrays()
const cvf::Vec3f offset( m_offset );
long long numConnections = static_cast<long long>( m_nncIndexes.empty() ? m_nncData->allConnections().size() : m_nncIndexes.size() );
bool isVisibilityCalcActive = m_cellVisibility.notNull() && m_grid.notNull();
std::vector<RigCell>* allCells = nullptr;
if ( isVisibilityCalcActive )
{
allCells = &( m_grid->mainGrid()->globalCellArray() );
}
bool isVisibilityCalcActive = m_cellVisibility.notNull() && m_grid.notNull();
const auto mainGrid = m_grid->mainGrid();
#pragma omp parallel for ordered
for ( long long nIdx = 0; nIdx < numConnections; ++nIdx )
@ -104,15 +100,15 @@ void RivNNCGeometryGenerator::computeArrays()
bool cell1Visible = false;
bool cell2Visible = false;
if ( ( *allCells )[conn.c1GlobIdx()].hostGrid() == m_grid.p() )
if ( mainGrid->cell( conn.c1GlobIdx() ).hostGrid() == m_grid.p() )
{
size_t cell1GridLocalIdx = ( *allCells )[conn.c1GlobIdx()].gridLocalCellIndex();
size_t cell1GridLocalIdx = mainGrid->cell( conn.c1GlobIdx() ).gridLocalCellIndex();
cell1Visible = ( *m_cellVisibility )[cell1GridLocalIdx];
}
if ( ( *allCells )[conn.c2GlobIdx()].hostGrid() == m_grid.p() )
if ( mainGrid->cell( conn.c2GlobIdx() ).hostGrid() == m_grid.p() )
{
size_t cell2GridLocalIdx = ( *allCells )[conn.c2GlobIdx()].gridLocalCellIndex();
size_t cell2GridLocalIdx = mainGrid->cell( conn.c2GlobIdx() ).gridLocalCellIndex();
cell2Visible = ( *m_cellVisibility )[cell2GridLocalIdx];
}

4
ApplicationLibCode/ProjectDataModel/Completions/RimFractureContainment.cpp
View File

@ -93,9 +93,9 @@ bool RimFractureContainment::isEclipseCellOpenForFlow( const RigMainGrid* m
{
CVF_ASSERT( mainGrid );
if ( globalCellIndex >= mainGrid->globalCellArray().size() ) return false;
// if ( globalCellIndex >= mainGrid->globalCellArray().size() ) return false;
auto cell = mainGrid->globalCellArray()[globalCellIndex];
auto cell = mainGrid->cell( globalCellIndex );
auto mainGridCellIndex = cell.mainGridCellIndex();
size_t i, j, k;

3
ApplicationLibCode/ProjectDataModel/Rim3dOverlayInfoConfig.cpp
View File

@ -332,8 +332,7 @@ QString Rim3dOverlayInfoConfig::caseInfoText( RimEclipseView* eclipseView )
}
else if ( eclipseView->mainGrid() )
{
QString totCellCount =
localeWithSpaceAsGroupSeparator.toString( static_cast<int>( eclipseView->mainGrid()->globalCellArray().size() ) );
QString totCellCount = localeWithSpaceAsGroupSeparator.toString( static_cast<int>( eclipseView->mainGrid()->cellCount() ) );
size_t mxActCellCount =
eclipseView->eclipseCase()->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL )->reservoirActiveCellCount();

6
ApplicationLibCode/ProjectDataModel/RimEclipseContourMapProjection.cpp
View File

@ -413,7 +413,7 @@ std::vector<size_t> RimEclipseContourMapProjection::findIntersectingCells( const
//--------------------------------------------------------------------------------------------------
size_t RimEclipseContourMapProjection::kLayer( size_t globalCellIdx ) const
{
const RigCell& cell = m_mainGrid->globalCellArray()[globalCellIdx];
const RigCell& cell = m_mainGrid->cell( globalCellIdx );
size_t mainGridCellIdx = cell.mainGridCellIndex();
size_t i, j, k;
m_mainGrid->ijkFromCellIndex( mainGridCellIdx, &i, &j, &k );
@ -435,7 +435,7 @@ double RimEclipseContourMapProjection::calculateOverlapVolume( size_t globalCell
{
std::array<cvf::Vec3d, 8> hexCorners;
const RigCell& cell = m_mainGrid->globalCellArray()[globalCellIdx];
const RigCell& cell = m_mainGrid->cell( globalCellIdx );
size_t localCellIdx = cell.gridLocalCellIndex();
RigGridBase* localGrid = cell.hostGrid();
@ -461,7 +461,7 @@ double RimEclipseContourMapProjection::calculateRayLengthInCell( size_t
{
std::array<cvf::Vec3d, 8> hexCorners;
RigCell cell = m_mainGrid->globalCellArray()[globalCellIdx];
RigCell cell = m_mainGrid->cell( globalCellIdx );
size_t localCellIdx = cell.gridLocalCellIndex();
RigGridBase* localGrid = cell.hostGrid();

2
ApplicationLibCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.cpp
View File

@ -401,7 +401,7 @@ RimEclipseStatisticsCaseEvaluator::RimEclipseStatisticsCaseEvaluator( const std:
{
if ( !sourceCases.empty() )
{
m_reservoirCellCount = sourceCases[0]->eclipseCaseData()->mainGrid()->globalCellArray().size();
m_reservoirCellCount = sourceCases[0]->eclipseCaseData()->mainGrid()->cellCount();
}
CVF_ASSERT( m_destinationCase );

5
ApplicationLibCode/ProjectDataModel/RimEclipseView.cpp
View File

@ -2334,7 +2334,7 @@ void RimEclipseView::setOverridePropertyFilterCollection( RimEclipsePropertyFilt
//--------------------------------------------------------------------------------------------------
void RimEclipseView::calculateCurrentTotalCellVisibility( cvf::UByteArray* totalVisibility, int timeStep )
{
size_t cellCount = mainGrid()->globalCellArray().size();
size_t cellCount = mainGrid()->cellCount();
totalVisibility->resize( cellCount );
totalVisibility->setAll( false );
@ -2364,8 +2364,7 @@ void RimEclipseView::calculateCurrentTotalCellVisibility( cvf::UByteArray* total
void RimEclipseView::calculateCellVisibility( cvf::UByteArray* visibility, std::vector<RivCellSetEnum> geomTypes, int timeStep )
{
if ( !mainGrid() ) return;
size_t cellCount = mainGrid()->globalCellArray().size();
size_t cellCount = mainGrid()->cellCount();
visibility->resize( cellCount );
visibility->setAll( false );

4
ApplicationLibCode/ProjectDataModel/RimIdenticalGridCaseGroup.cpp
View File

@ -267,8 +267,8 @@ void RimIdenticalGridCaseGroup::computeUnionOfActiveCells()
return;
}
m_unionOfMatrixActiveCells->setReservoirCellCount( m_mainGrid->globalCellArray().size() );
m_unionOfFractureActiveCells->setReservoirCellCount( m_mainGrid->globalCellArray().size() );
m_unionOfMatrixActiveCells->setReservoirCellCount( m_mainGrid->cellCount() );
m_unionOfFractureActiveCells->setReservoirCellCount( m_mainGrid->cellCount() );
m_unionOfMatrixActiveCells->setGridCount( m_mainGrid->gridCount() );
m_unionOfFractureActiveCells->setGridCount( m_mainGrid->gridCount() );

6
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryCaseMainCollection.cpp
View File

@ -474,7 +474,7 @@ void RimSummaryCaseMainCollection::loadFileSummaryCaseData( std::vector<RimFileS
RifOpmCommonEclipseSummary::resetEnhancedSummaryFileCount();
RiaThreadSafeLogger threadSafeLogger;
QCoreApplication::processEvents( QEventLoop::ExcludeUserInputEvents );
// QCoreApplication::processEvents( QEventLoop::ExcludeUserInputEvents );
// The HDF5 reader requires a special configuration to be thread safe. Disable threading for HDF reader.
bool canUseMultipleTreads = ( prefs->summaryDataReader() != RiaPreferencesSummary::SummaryReaderMode::HDF5_OPM_COMMON );
@ -554,7 +554,7 @@ std::vector<RimSummaryCase*>
for ( const RifSummaryCaseFileResultInfo& fileInfo : summaryHeaderFileInfos )
{
QCoreApplication::processEvents( QEventLoop::ExcludeUserInputEvents );
// QCoreApplication::processEvents( QEventLoop::ExcludeUserInputEvents );
auto existingSummaryCase = findTopLevelSummaryCaseFromFileName( fileInfo.summaryFileName() );
if ( !existingSummaryCase )
@ -597,7 +597,7 @@ std::vector<RimSummaryCase*>
if ( progress != nullptr ) progress->incrementProgress();
}
QCoreApplication::processEvents( QEventLoop::ExcludeUserInputEvents );
// QCoreApplication::processEvents( QEventLoop::ExcludeUserInputEvents );
}
RimSummaryCaseMainCollection::loadSummaryCaseData( sumCases );

4
ApplicationLibCode/ReservoirDataModel/Completions/RigEclipseToStimPlanCellTransmissibilityCalculator.cpp
View File

@ -276,7 +276,7 @@ void RigEclipseToStimPlanCellTransmissibilityCalculator::calculateStimPlanCellsM
{
// Use main grid cell to evaluate if a cell is active or not.
// All cells in temporary grids are active
const RigCell& cell = mainGrid->globalCellArray()[reservoirCellIndex];
const RigCell& cell = mainGrid->cell( reservoirCellIndex );
size_t mainGridReservoirIndex = cell.mainGridCellIndex();
if ( !activeCellInfo->isActive( mainGridReservoirIndex ) )
@ -358,7 +358,7 @@ std::vector<size_t>
std::vector<size_t> cellIndicesToLeafCells;
for ( const size_t& index : cellIndices )
{
const RigCell& cell = mainGrid->globalCellArray()[index];
const RigCell& cell = mainGrid->cell( index );
if ( !cell.subGrid() )
{
cellIndicesToLeafCells.push_back( index );

4
ApplicationLibCode/ReservoirDataModel/ResultCalculators/RigCellVolumeResultCalculator.cpp
View File

@ -73,13 +73,13 @@ void RigCellVolumeResultCalculator::calculate( const RigEclipseResultAddress& re
cellVolumeResults.resize( cellResultCount, std::numeric_limits<double>::infinity() );
#pragma omp parallel for
for ( int nativeResvCellIndex = 0; nativeResvCellIndex < static_cast<int>( m_resultsData->m_ownerMainGrid->globalCellArray().size() );
for ( int nativeResvCellIndex = 0; nativeResvCellIndex < static_cast<int>( m_resultsData->m_ownerMainGrid->cellCount() );
nativeResvCellIndex++ )
{
size_t resultIndex = m_resultsData->activeCellInfo()->cellResultIndex( nativeResvCellIndex );
if ( resultIndex != cvf::UNDEFINED_SIZE_T )
{
const RigCell& cell = m_resultsData->m_ownerMainGrid->globalCellArray()[nativeResvCellIndex];
const RigCell& cell = m_resultsData->m_ownerMainGrid->cell( nativeResvCellIndex );
if ( !cell.subGrid() )
{
cellVolumeResults[resultIndex] = cell.volume();

3
ApplicationLibCode/ReservoirDataModel/ResultCalculators/RigFaultDistanceResultCalculator.cpp
View File

@ -79,8 +79,9 @@ void RigFaultDistanceResultCalculator::calculate( const RigEclipseResultAddress&
if ( !shouldCompute ) return;
const std::vector<RigCell>& globalCellArray = m_resultsData->m_ownerMainGrid->globalCellArray();
const auto grid = m_resultsData->m_ownerMainGrid;
long long numCells = static_cast<long long>( globalCellArray.size() );
long long numCells = static_cast<long long>( m_resultsData->m_ownerMainGrid->cellCount() );
std::vector<cvf::StructGridInterface::FaceType> faceTypes = cvf::StructGridInterface::validFaceTypes();

98
ApplicationLibCode/ReservoirDataModel/RigActiveCellGrid.cpp
View File

@ -110,52 +110,53 @@ void RigActiveCellGrid::transferActiveInformation( int gridI
fractureActiveCellInfo->computeDerivedData();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RigActiveCellGrid::cellIndexFromIJK( size_t i, size_t j, size_t k ) const
{
auto index = RigGridBase::cellIndexFromIJK( i, j, k );
return m_globalToActiveMap[index];
}
////--------------------------------------------------------------------------------------------------
/////
////--------------------------------------------------------------------------------------------------
// size_t RigActiveCellGrid::cellIndexFromIJK( size_t i, size_t j, size_t k ) const
//{
// auto index = RigGridBase::cellIndexFromIJK( i, j, k );
// return m_globalToActiveMap[index];
// }
//
////--------------------------------------------------------------------------------------------------
/////
////--------------------------------------------------------------------------------------------------
// size_t RigActiveCellGrid::cellIndexFromIJKUnguarded( size_t i, size_t j, size_t k ) const
//{
// auto index = RigGridBase::cellIndexFromIJKUnguarded( i, j, k );
// return m_globalToActiveMap[index];
// }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RigActiveCellGrid::cellIndexFromIJKUnguarded( size_t i, size_t j, size_t k ) const
{
auto index = RigGridBase::cellIndexFromIJKUnguarded( i, j, k );
return m_globalToActiveMap[index];
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigActiveCellGrid::ijkFromCellIndex( size_t cellIndex, size_t* i, size_t* j, size_t* k ) const
{
if ( cellIndex >= m_activeToGlobalMap.size() )
{
return false;
}
auto index = m_activeToGlobalMap[cellIndex];
return RigGridBase::ijkFromCellIndex( index, i, j, k );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigActiveCellGrid::ijkFromCellIndexUnguarded( size_t cellIndex, size_t* i, size_t* j, size_t* k ) const
{
auto index = m_activeToGlobalMap[cellIndex];
RigGridBase::ijkFromCellIndexUnguarded( index, i, j, k );
}
////--------------------------------------------------------------------------------------------------
/////
////--------------------------------------------------------------------------------------------------
// bool RigActiveCellGrid::ijkFromCellIndex( size_t cellIndex, size_t* i, size_t* j, size_t* k ) const
//{
// if ( cellIndex >= m_activeToGlobalMap.size() )
// {
// return false;
// }
// auto index = m_activeToGlobalMap[cellIndex];
// return RigGridBase::ijkFromCellIndex( index, i, j, k );
// }
//
////--------------------------------------------------------------------------------------------------
/////
////--------------------------------------------------------------------------------------------------
// void RigActiveCellGrid::ijkFromCellIndexUnguarded( size_t cellIndex, size_t* i, size_t* j, size_t* k ) const
//{
// auto index = m_activeToGlobalMap[cellIndex];
// RigGridBase::ijkFromCellIndexUnguarded( index, i, j, k );
// }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigCell& RigActiveCellGrid::cell( size_t gridLocalCellIndex )
{
return m_cells[gridLocalCellIndex];
const auto index = m_globalToActiveMap[gridLocalCellIndex];
return m_cells[index];
}
//--------------------------------------------------------------------------------------------------
@ -163,7 +164,24 @@ RigCell& RigActiveCellGrid::cell( size_t gridLocalCellIndex )
//--------------------------------------------------------------------------------------------------
const RigCell& RigActiveCellGrid::cell( size_t gridLocalCellIndex ) const
{
return m_cells[gridLocalCellIndex];
const auto index = m_globalToActiveMap[gridLocalCellIndex];
return m_cells[index];
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RigActiveCellGrid::globalToActualCellIndex( size_t globalCellIndex ) const
{
return m_globalToActiveMap[globalCellIndex];
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RigActiveCellGrid::actualToGlobalCellIndex( size_t actualCellIndex ) const
{
return m_activeToGlobalMap[actualCellIndex];
}
//--------------------------------------------------------------------------------------------------

14
ApplicationLibCode/ReservoirDataModel/RigActiveCellGrid.h
View File

@ -36,14 +36,18 @@ public:
const std::vector<int>& activeMatrixIndexes,
const std::vector<int>& activeFracIndexes );
size_t cellIndexFromIJK( size_t i, size_t j, size_t k ) const override;
size_t cellIndexFromIJKUnguarded( size_t i, size_t j, size_t k ) const override;
bool ijkFromCellIndex( size_t cellIndex, size_t* i, size_t* j, size_t* k ) const override;
void ijkFromCellIndexUnguarded( size_t cellIndex, size_t* i, size_t* j, size_t* k ) const override;
// size_t cellIndexFromIJK( size_t i, size_t j, size_t k ) const override;
// size_t cellIndexFromIJKUnguarded( size_t i, size_t j, size_t k ) const override;
// bool ijkFromCellIndex( size_t cellIndex, size_t* i, size_t* j, size_t* k ) const override;
// void ijkFromCellIndexUnguarded( size_t cellIndex, size_t* i, size_t* j, size_t* k ) const override;
RigCell& cell( size_t gridLocalCellIndex ) override;
const RigCell& cell( size_t gridLocalCellIndex ) const override;
size_t cellCount() const override;
size_t globalToActualCellIndex( size_t globalCellIndex ) const override;
size_t actualToGlobalCellIndex( size_t actualCellIndex ) const override;
size_t cellCount() const override;
private:
std::vector<size_t> m_globalToActiveMap;

2
ApplicationLibCode/ReservoirDataModel/RigActiveCellInfo.cpp
View File

@ -56,7 +56,7 @@ bool RigActiveCellInfo::isActive( size_t reservoirCellIndex ) const
return true;
}
CVF_TIGHT_ASSERT( reservoirCellIndex < m_cellIndexToResultIndex.size() );
if ( reservoirCellIndex >= m_cellIndexToResultIndex.size() ) return false;
return m_cellIndexToResultIndex[reservoirCellIndex] != cvf::UNDEFINED_SIZE_T;
}

16
ApplicationLibCode/ReservoirDataModel/RigGridBase.cpp
View File

@ -99,6 +99,22 @@ const RigCell& RigGridBase::cell( size_t gridLocalCellIndex ) const
return m_mainGrid->globalCellArray()[m_indexToStartOfCells + gridLocalCellIndex];
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RigGridBase::globalToActualCellIndex( size_t globalCellIndex ) const
{
return globalCellIndex;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RigGridBase::actualToGlobalCellIndex( size_t actualCellIndex ) const
{
return actualCellIndex;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

10
ApplicationLibCode/ReservoirDataModel/RigGridBase.h
View File

@ -37,6 +37,9 @@ class RigMainGrid;
class RigCell;
class RigActiveCellInfo;
// global cell index is index in full I,J,K grid
// actual cell index is the index into the m_cells array, will be differenc
class RigGridBase : public cvf::StructGridInterface
{
public:
@ -50,8 +53,11 @@ public:
size_t cellCountK() const override;
virtual size_t cellCount() const;
virtual RigCell& cell( size_t gridLocalCellIndex );
virtual const RigCell& cell( size_t gridLocalCellIndex ) const;
virtual RigCell& cell( size_t actualCellIndex );
virtual const RigCell& cell( size_t actualCellIndex ) const;
virtual size_t globalToActualCellIndex( size_t globalCellIndex ) const;
virtual size_t actualToGlobalCellIndex( size_t actualCellIndex ) const;
void characteristicCellSizes( double* iSize, double* jSize, double* kSize ) const override;

58
ApplicationLibCode/ReservoirDataModel/RigMainGrid.cpp
View File

@ -74,7 +74,7 @@ const std::vector<cvf::Vec3d>& RigMainGrid::nodes() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RigCell>& RigMainGrid::globalCellArray()
std::vector<RigCell>& RigMainGrid::reservoirCells()
{
return m_cells;
}
@ -82,25 +82,41 @@ std::vector<RigCell>& RigMainGrid::globalCellArray()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<RigCell>& RigMainGrid::globalCellArray() const
const std::vector<RigCell>& RigMainGrid::reservoirCells() const
{
return m_cells;
}
////--------------------------------------------------------------------------------------------------
/////
////--------------------------------------------------------------------------------------------------
// std::vector<RigCell>& RigMainGrid::globalCellArray()
//{
// return m_cells;
// }
//
////--------------------------------------------------------------------------------------------------
/////
////--------------------------------------------------------------------------------------------------
// const std::vector<RigCell>& RigMainGrid::globalCellArray() const
//{
// return m_cells;
// }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigGridBase* RigMainGrid::gridAndGridLocalIdxFromGlobalCellIdx( size_t globalCellIdx, size_t* gridLocalCellIdx )
{
CVF_ASSERT( globalCellIdx < m_cells.size() );
// CVF_ASSERT( globalCellIdx < m_cells.size() );
const RigCell& cell = m_cells[globalCellIdx];
RigGridBase* hostGrid = cell.hostGrid();
const RigCell& c = cell( globalCellIdx );
RigGridBase* hostGrid = c.hostGrid();
CVF_ASSERT( hostGrid );
if ( gridLocalCellIdx )
{
*gridLocalCellIdx = cell.gridLocalCellIndex();
*gridLocalCellIdx = c.gridLocalCellIndex();
}
return hostGrid;
@ -111,15 +127,15 @@ RigGridBase* RigMainGrid::gridAndGridLocalIdxFromGlobalCellIdx( size_t globalCel
//--------------------------------------------------------------------------------------------------
const RigGridBase* RigMainGrid::gridAndGridLocalIdxFromGlobalCellIdx( size_t globalCellIdx, size_t* gridLocalCellIdx ) const
{
CVF_ASSERT( globalCellIdx < m_cells.size() );
// CVF_ASSERT( globalCellIdx < m_cells.size() );
const RigCell& cell = m_cells[globalCellIdx];
const RigGridBase* hostGrid = cell.hostGrid();
const RigCell& c = cell( globalCellIdx );
const RigGridBase* hostGrid = c.hostGrid();
CVF_ASSERT( hostGrid );
if ( gridLocalCellIdx )
{
*gridLocalCellIdx = cell.gridLocalCellIndex();
*gridLocalCellIdx = c.gridLocalCellIndex();
}
return hostGrid;
@ -492,7 +508,7 @@ void RigMainGrid::calculateFaults( const RigActiveCellInfo* activeCellInfo )
return;
}
m_faultsPrCellAcc = new RigFaultsPrCellAccumulator( m_cells.size() );
m_faultsPrCellAcc = new RigFaultsPrCellAccumulator( RigGridBase::cellCount() );
// Spread fault idx'es on the cells from the faults
for ( size_t fIdx = 0; fIdx < m_faults.size(); ++fIdx )
@ -517,9 +533,10 @@ void RigMainGrid::calculateFaults( const RigActiveCellInfo* activeCellInfo )
std::vector<RigFault::FaultFace>& unNamedFaultFaces = unNamedFault->faultFaces();
std::vector<RigFault::FaultFace>& unNamedFaultFacesInactive = unNamedFaultWithInactive->faultFaces();
for ( int gcIdx = 0; gcIdx < static_cast<int>( m_cells.size() ); ++gcIdx )
for ( size_t i = 0; i < cellCount(); i++ )
{
addUnNamedFaultFaces( gcIdx,
const auto globIndex = actualToGlobalCellIndex( i );
addUnNamedFaultFaces( (int)globIndex,
activeCellInfo,
vxs,
unNamedFaultIdx,
@ -542,7 +559,7 @@ void RigMainGrid::addUnNamedFaultFaces( int gcIdx,
std::vector<RigFault::FaultFace>& unNamedFaultFacesInactive,
RigFaultsPrCellAccumulator* faultsPrCellAcc ) const
{
if ( m_cells[gcIdx].isInvalid() )
if ( cell( gcIdx ).isInvalid() )
{
return;
}
@ -586,19 +603,20 @@ void RigMainGrid::addUnNamedFaultFaces( int gcIdx,
}
neighborReservoirCellIdx = hostGrid->reservoirCellIndex( neighborGridCellIdx );
if ( m_cells[neighborReservoirCellIdx].isInvalid() )
if ( cell( neighborReservoirCellIdx ).isInvalid() )
{
continue;
}
bool isNeighborCellActive = activeCellInfo->isActive( neighborReservoirCellIdx );
auto activeNeighborCellIndex = hostGrid->globalToActualCellIndex( neighborGridCellIdx );
bool isNeighborCellActive = activeCellInfo->isActive( activeNeighborCellIndex );
double tolerance = 1e-6;
std::array<size_t, 4> faceIdxs;
m_cells[gcIdx].faceIndices( face, &faceIdxs );
cell( gcIdx ).faceIndices( face, &faceIdxs );
std::array<size_t, 4> nbFaceIdxs;
m_cells[neighborReservoirCellIdx].faceIndices( StructGridInterface::oppositeFace( face ), &nbFaceIdxs );
cell( neighborReservoirCellIdx ).faceIndices( StructGridInterface::oppositeFace( face ), &nbFaceIdxs );
bool sharedFaceVertices = true;
if ( sharedFaceVertices && vxs[faceIdxs[0]].pointDistance( vxs[nbFaceIdxs[0]] ) > tolerance ) sharedFaceVertices = false;
@ -664,7 +682,7 @@ void RigMainGrid::distributeNNCsToFaults()
if ( fIdx1 < 0 && fIdx2 < 0 )
{
cvf::String lgrString( "Same Grid" );
if ( m_cells[conn.c1GlobIdx()].hostGrid() != m_cells[conn.c2GlobIdx()].hostGrid() )
if ( cell( conn.c1GlobIdx() ).hostGrid() != cell( conn.c2GlobIdx() ).hostGrid() )
{
lgrString = "Different Grid";
}
@ -741,7 +759,7 @@ void RigMainGrid::computeFaceNormalsDirection( const std::vector<size_t>& reserv
for ( const auto& index : reservoirCellIndices )
{
const auto& cell = m_cells[index];
const auto& cell = this->cell( index );
if ( !cell.isInvalid() )
{
// Some cells can be very twisted and distorted. Use a volume criteria to find a reasonably regular cell.

6
ApplicationLibCode/ReservoirDataModel/RigMainGrid.h
View File

@ -46,8 +46,10 @@ public:
std::vector<cvf::Vec3d>& nodes();
const std::vector<cvf::Vec3d>& nodes() const;
std::vector<RigCell>& globalCellArray();
const std::vector<RigCell>& globalCellArray() const;
std::vector<RigCell>& reservoirCells();
const std::vector<RigCell>& reservoirCells() const;
// std::vector<RigCell>& globalCellArray();
// const std::vector<RigCell>& globalCellArray() const;
virtual RigGridBase* gridAndGridLocalIdxFromGlobalCellIdx( size_t globalCellIdx, size_t* gridLocalCellIdx );
virtual const RigGridBase* gridAndGridLocalIdxFromGlobalCellIdx( size_t globalCellIdx, size_t* gridLocalCellIdx ) const;