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 // 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. // plot window. Otherwise the event processing ends up with the plot window on top.
QApplication::processEvents(); // QApplication::processEvents();
RiuMainWindow::instance()->activateWindow(); RiuMainWindow::instance()->activateWindow();
} }

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

@ -694,7 +694,7 @@ void RicWellPathExportMswCompletionsImpl::generateFishbonesMswExportInfo( const
for ( auto intersectionIndex : indices ) for ( auto intersectionIndex : indices )
{ {
auto intersection = filteredIntersections[intersectionIndex]; auto intersection = filteredIntersections[intersectionIndex];
if ( intersection.globCellIndex >= mainGrid->globalCellArray().size() ) continue; // if ( intersection.globCellIndex >= mainGrid->globalCellArray().size() ) continue;
size_t localGridCellIndex = 0u; size_t localGridCellIndex = 0u;
const RigGridBase* localGrid = 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 ) void RicCreateTemporaryLgrFeature::createLgr( const LgrInfo& lgrInfo, RigMainGrid* mainGrid )
{ {
int lgrId = lgrInfo.id; int lgrId = lgrInfo.id;
size_t totalCellCount = mainGrid->globalCellArray().size(); size_t totalCellCount = mainGrid->cellCount();
size_t lgrCellCount = lgrInfo.cellCount(); size_t lgrCellCount = lgrInfo.cellCount();
// Create local grid and set properties // 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 ) ); localGrid->setGridPointDimensions( cvf::Vec3st( lgrInfo.sizes.i() + 1, lgrInfo.sizes.j() + 1, lgrInfo.sizes.k() + 1 ) );
mainGrid->addLocalGrid( localGrid ); mainGrid->addLocalGrid( localGrid );
size_t cellStartIndex = mainGrid->globalCellArray().size(); size_t cellStartIndex = mainGrid->cellCount();
size_t nodeStartIndex = mainGrid->nodes().size(); size_t nodeStartIndex = mainGrid->nodes().size();
// Resize global cell and node arrays // Resize global cell and node arrays
{ {
RigCell defaultCell; RigCell defaultCell;
defaultCell.setHostGrid( localGrid ); 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 ) ); 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 mainI = lgrInfo.mainGridStartCell.i() + lgrI / lgrSizePerMainCell.i();
size_t mainCellIndex = mainGrid->cellIndexFromIJK( mainI, mainJ, mainK ); size_t mainCellIndex = mainGrid->cellIndexFromIJK( mainI, mainJ, mainK );
auto& mainGridCell = mainGrid->globalCellArray()[mainCellIndex]; auto& mainGridCell = mainGrid->reservoirCells()[mainCellIndex];
mainGridCell.setSubGrid( localGrid ); mainGridCell.setSubGrid( localGrid );
RigCell& cell = mainGrid->globalCellArray()[cellStartIndex + gridLocalCellIndex]; RigCell& cell = mainGrid->reservoirCells()[cellStartIndex + gridLocalCellIndex];
cell.setGridLocalCellIndex( gridLocalCellIndex ); cell.setGridLocalCellIndex( gridLocalCellIndex );
cell.setParentCellIndex( mainCellIndex ); 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 // Check if number of cells is matching
if ( eclipseCaseData->mainGrid()->globalCellArray().size() != reservoirCellCount ) if ( eclipseCaseData->mainGrid()->cellCount() != reservoirCellCount )
{ {
return false; return false;
} }

8
ApplicationLibCode/FileInterface/RifReaderEclipseOutput.cpp
View File

@ -161,12 +161,12 @@ bool RifReaderEclipseOutput::transferGridCellData( RigMainGrid* mainGrid
CVF_ASSERT( activeCellInfo && fractureActiveCellInfo ); CVF_ASSERT( activeCellInfo && fractureActiveCellInfo );
int cellCount = ecl_grid_get_global_size( localEclGrid ); 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(); size_t nodeStartIndex = mainGrid->nodes().size();
RigCell defaultCell; RigCell defaultCell;
defaultCell.setHostGrid( localGrid ); 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 ) ); mainGrid->nodes().resize( nodeStartIndex + cellCount * 8, cvf::Vec3d( 0, 0, 0 ) );
@ -175,7 +175,7 @@ bool RifReaderEclipseOutput::transferGridCellData( RigMainGrid* mainGrid
#pragma omp parallel for #pragma omp parallel for
for ( int gridLocalCellIndex = 0; gridLocalCellIndex < cellCount; ++gridLocalCellIndex ) for ( int gridLocalCellIndex = 0; gridLocalCellIndex < cellCount; ++gridLocalCellIndex )
{ {
RigCell& cell = mainGrid->globalCellArray()[cellStartIndex + gridLocalCellIndex]; RigCell& cell = mainGrid->reservoirCells()[cellStartIndex + gridLocalCellIndex];
cell.setGridLocalCellIndex( 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 // 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 ); mainGrid->nodes().reserve( 8 * totalCellCount );
caf::ProgressInfo progInfo( 3 + numLGRs, "" ); 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 ); activeCellInfo->setReservoirCellCount( totalCellCount );
fractureActiveCellInfo->setReservoirCellCount( totalCellCount ); fractureActiveCellInfo->setReservoirCellCount( totalCellCount );
mainGrid->globalCellArray().reserve( (size_t)totalCellCount ); mainGrid->reservoirCells().reserve( (size_t)totalCellCount );
mainGrid->nodes().reserve( (size_t)totalCellCount * 8 ); mainGrid->nodes().reserve( (size_t)totalCellCount * 8 );
activeCellInfo->setGridCount( 1 + numLGRs ); activeCellInfo->setGridCount( 1 + numLGRs );
@ -411,7 +411,7 @@ void RifReaderOpmCommon::transferGeometry( Opm::EclIO::EGrid& opmMainGrid,
RigEclipseCaseData* eclipseCaseData ) RigEclipseCaseData* eclipseCaseData )
{ {
int cellCount = opmGrid.totalNumberOfCells(); int cellCount = opmGrid.totalNumberOfCells();
size_t cellStartIndex = mainGrid->globalCellArray().size(); size_t cellStartIndex = mainGrid->reservoirCells().size();
size_t nodeStartIndex = mainGrid->nodes().size(); size_t nodeStartIndex = mainGrid->nodes().size();
const bool invalidateLongPyramidCells = invalidateLongThinCells(); const bool invalidateLongPyramidCells = invalidateLongThinCells();
@ -419,7 +419,7 @@ void RifReaderOpmCommon::transferGeometry( Opm::EclIO::EGrid& opmMainGrid,
RigCell defaultCell; RigCell defaultCell;
defaultCell.setHostGrid( localGrid ); 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 ) ); 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] ); 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 ); cell.setGridLocalCellIndex( riReservoirIndex );
// parent cell index // 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 // TODO - loop over all grids
activeGrid->transferActiveInformation( eclipseCaseData, activeGrid->transferActiveInformation( 0,
eclipseCaseData,
opmGrid.totalActiveCells(), opmGrid.totalActiveCells(),
opmGrid.activeCells(), opmGrid.activeCells(),
opmGrid.activeFracCells(), opmGrid.activeFracCells(),
@ -194,8 +195,8 @@ void RifReaderOpmCommonActive::transferActiveGeometry( Opm::EclIO::EGrid& opmMa
for ( size_t i = 0; i < 8; i++ ) for ( size_t i = 0; i < 8; i++ )
defaultCell.cornerIndices()[i] = 0; defaultCell.cornerIndices()[i] = 0;
activeGrid->globalCellArray().resize( cellCount + 1, defaultCell ); activeGrid->reservoirCells().resize( cellCount + 1, defaultCell );
activeGrid->globalCellArray()[cellCount].setInvalid( true ); activeGrid->reservoirCells()[cellCount].setInvalid( true );
activeGrid->nodes().resize( ( cellCount + 1 ) * 8, cvf::Vec3d( 0, 0, 0 ) ); 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] ); 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.setGridLocalCellIndex( riReservoirIndex );
cell.setParentCellIndex( cvf::UNDEFINED_SIZE_T ); cell.setParentCellIndex( cvf::UNDEFINED_SIZE_T );
@ -246,8 +248,8 @@ void RifReaderOpmCommonActive::transferActiveGeometry( Opm::EclIO::EGrid& opmMa
std::array<double, 8> opmZ{}; std::array<double, 8> opmZ{};
opmMainGrid.getCellCorners( opmCellIndex, opmX, opmY, 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 // Each cell has 8 nodes, use active cell index and multiply to find first node index for cell
auto riNodeStartIndex = riReservoirIndex * 8; auto riNodeStartIndex = actualIndex * 8;
for ( size_t opmNodeIndex = 0; opmNodeIndex < 8; opmNodeIndex++ ) for ( size_t opmNodeIndex = 0; opmNodeIndex < 8; opmNodeIndex++ )
{ {
@ -267,4 +269,6 @@ void RifReaderOpmCommonActive::transferActiveGeometry( Opm::EclIO::EGrid& opmMa
cell.setInvalid( cell.isLongPyramidCell() ); 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 ); fractureActiveCellInfo->setReservoirCellCount( totalCellCount );
// Reserve room for the cells and nodes and fill them with data // 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 ); mainGrid->nodes().reserve( 8 * totalCellCount );
int progTicks = 100; int progTicks = 100;
caf::ProgressInfo progInfo( progTicks, "" ); caf::ProgressInfo progInfo( progTicks, "" );
int cellCount = static_cast<int>( totalCellCount ); int cellCount = static_cast<int>( totalCellCount );
size_t cellStartIndex = mainGrid->globalCellArray().size(); size_t cellStartIndex = mainGrid->reservoirCells().size();
size_t nodeStartIndex = mainGrid->nodes().size(); size_t nodeStartIndex = mainGrid->nodes().size();
RigCell defaultCell; RigCell defaultCell;
defaultCell.setHostGrid( mainGrid ); 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 ) ); 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 #pragma omp for
for ( int gridLocalCellIndex = 0; gridLocalCellIndex < cellCount; ++gridLocalCellIndex ) for ( int gridLocalCellIndex = 0; gridLocalCellIndex < cellCount; ++gridLocalCellIndex )
{ {
RigCell& cell = mainGrid->globalCellArray()[cellStartIndex + gridLocalCellIndex]; RigCell& cell = mainGrid->reservoirCells()[cellStartIndex + gridLocalCellIndex];
cell.setGridLocalCellIndex( 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 ) ) if ( m_intervalTool.isNumberIncluded( k ) )
{ {
const RigCell& cell = m_mainGrid->globalCellArray()[cellIndex]; const RigCell& cell = m_mainGrid->cell( cellIndex );
if ( m_showInactiveCells ) if ( m_showInactiveCells )
return !cell.isInvalid() && ( cell.subGrid() == nullptr ); return !cell.isInvalid() && ( cell.subGrid() == nullptr );
else else
@ -88,7 +88,7 @@ void RivEclipseIntersectionGrid::cellCornerVertices( size_t cellIndex, cvf::Vec3
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RivEclipseIntersectionGrid::cellCornerIndices( size_t cellIndex, size_t cornerIndices[8] ) const 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++ ) 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 ); 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, auto getFaceCenterAndNormal = [arrowScaling, displayCordXf, grid]( size_t globalCellIdx,
cvf::StructGridInterface::FaceType faceType, cvf::StructGridInterface::FaceType faceType,
cvf::Vec3d& faceCenter, cvf::Vec3d& faceCenter,
cvf::Vec3d& faceNormal ) cvf::Vec3d& faceNormal )
{ {
faceCenter = displayCordXf->transformToDisplayCoord( cells[globalCellIdx].faceCenter( faceType ) ); faceCenter = displayCordXf->transformToDisplayCoord( grid->cell( globalCellIdx ).faceCenter( faceType ) );
cvf::Vec3d cellCenter = displayCordXf->transformToDisplayCoord( cells[globalCellIdx].center() ); cvf::Vec3d cellCenter = displayCordXf->transformToDisplayCoord( grid->cell( globalCellIdx ).center() );
faceNormal = ( faceCenter - cellCenter ).getNormalized() * arrowScaling; faceNormal = ( faceCenter - cellCenter ).getNormalized() * arrowScaling;
}; };
const std::vector<RigCell>& cells = eclipseCase->mainGrid()->reservoirCells();
if ( !resultAddresses.empty() && !directions.empty() ) if ( !resultAddresses.empty() && !directions.empty() )
{ {
#pragma omp parallel for #pragma omp parallel for

16
ApplicationLibCode/ModelVisualization/RivNNCGeometryGenerator.cpp
View File

@ -77,12 +77,8 @@ void RivNNCGeometryGenerator::computeArrays()
const cvf::Vec3f offset( m_offset ); const cvf::Vec3f offset( m_offset );
long long numConnections = static_cast<long long>( m_nncIndexes.empty() ? m_nncData->allConnections().size() : m_nncIndexes.size() ); 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(); bool isVisibilityCalcActive = m_cellVisibility.notNull() && m_grid.notNull();
std::vector<RigCell>* allCells = nullptr; const auto mainGrid = m_grid->mainGrid();
if ( isVisibilityCalcActive )
{
allCells = &( m_grid->mainGrid()->globalCellArray() );
}
#pragma omp parallel for ordered #pragma omp parallel for ordered
for ( long long nIdx = 0; nIdx < numConnections; ++nIdx ) for ( long long nIdx = 0; nIdx < numConnections; ++nIdx )
@ -104,15 +100,15 @@ void RivNNCGeometryGenerator::computeArrays()
bool cell1Visible = false; bool cell1Visible = false;
bool cell2Visible = 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]; 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]; 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 ); 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(); auto mainGridCellIndex = cell.mainGridCellIndex();
size_t i, j, k; 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() ) else if ( eclipseView->mainGrid() )
{ {
QString totCellCount = QString totCellCount = localeWithSpaceAsGroupSeparator.toString( static_cast<int>( eclipseView->mainGrid()->cellCount() ) );
localeWithSpaceAsGroupSeparator.toString( static_cast<int>( eclipseView->mainGrid()->globalCellArray().size() ) );
size_t mxActCellCount = size_t mxActCellCount =
eclipseView->eclipseCase()->eclipseCaseData()->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL )->reservoirActiveCellCount(); 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 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 mainGridCellIdx = cell.mainGridCellIndex();
size_t i, j, k; size_t i, j, k;
m_mainGrid->ijkFromCellIndex( mainGridCellIdx, &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; 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(); size_t localCellIdx = cell.gridLocalCellIndex();
RigGridBase* localGrid = cell.hostGrid(); RigGridBase* localGrid = cell.hostGrid();
@ -461,7 +461,7 @@ double RimEclipseContourMapProjection::calculateRayLengthInCell( size_t
{ {
std::array<cvf::Vec3d, 8> hexCorners; std::array<cvf::Vec3d, 8> hexCorners;
RigCell cell = m_mainGrid->globalCellArray()[globalCellIdx]; RigCell cell = m_mainGrid->cell( globalCellIdx );
size_t localCellIdx = cell.gridLocalCellIndex(); size_t localCellIdx = cell.gridLocalCellIndex();
RigGridBase* localGrid = cell.hostGrid(); RigGridBase* localGrid = cell.hostGrid();

2
ApplicationLibCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.cpp
View File

@ -401,7 +401,7 @@ RimEclipseStatisticsCaseEvaluator::RimEclipseStatisticsCaseEvaluator( const std:
{ {
if ( !sourceCases.empty() ) if ( !sourceCases.empty() )
{ {
m_reservoirCellCount = sourceCases[0]->eclipseCaseData()->mainGrid()->globalCellArray().size(); m_reservoirCellCount = sourceCases[0]->eclipseCaseData()->mainGrid()->cellCount();
} }
CVF_ASSERT( m_destinationCase ); 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 ) void RimEclipseView::calculateCurrentTotalCellVisibility( cvf::UByteArray* totalVisibility, int timeStep )
{ {
size_t cellCount = mainGrid()->globalCellArray().size(); size_t cellCount = mainGrid()->cellCount();
totalVisibility->resize( cellCount ); totalVisibility->resize( cellCount );
totalVisibility->setAll( false ); 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 ) void RimEclipseView::calculateCellVisibility( cvf::UByteArray* visibility, std::vector<RivCellSetEnum> geomTypes, int timeStep )
{ {
if ( !mainGrid() ) return; if ( !mainGrid() ) return;
size_t cellCount = mainGrid()->cellCount();
size_t cellCount = mainGrid()->globalCellArray().size();
visibility->resize( cellCount ); visibility->resize( cellCount );
visibility->setAll( false ); visibility->setAll( false );

4
ApplicationLibCode/ProjectDataModel/RimIdenticalGridCaseGroup.cpp
View File

@ -267,8 +267,8 @@ void RimIdenticalGridCaseGroup::computeUnionOfActiveCells()
return; return;
} }
m_unionOfMatrixActiveCells->setReservoirCellCount( m_mainGrid->globalCellArray().size() ); m_unionOfMatrixActiveCells->setReservoirCellCount( m_mainGrid->cellCount() );
m_unionOfFractureActiveCells->setReservoirCellCount( m_mainGrid->globalCellArray().size() ); m_unionOfFractureActiveCells->setReservoirCellCount( m_mainGrid->cellCount() );
m_unionOfMatrixActiveCells->setGridCount( m_mainGrid->gridCount() ); m_unionOfMatrixActiveCells->setGridCount( m_mainGrid->gridCount() );
m_unionOfFractureActiveCells->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(); RifOpmCommonEclipseSummary::resetEnhancedSummaryFileCount();
RiaThreadSafeLogger threadSafeLogger; 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. // 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 ); bool canUseMultipleTreads = ( prefs->summaryDataReader() != RiaPreferencesSummary::SummaryReaderMode::HDF5_OPM_COMMON );
@ -554,7 +554,7 @@ std::vector<RimSummaryCase*>
for ( const RifSummaryCaseFileResultInfo& fileInfo : summaryHeaderFileInfos ) for ( const RifSummaryCaseFileResultInfo& fileInfo : summaryHeaderFileInfos )
{ {
QCoreApplication::processEvents( QEventLoop::ExcludeUserInputEvents ); // QCoreApplication::processEvents( QEventLoop::ExcludeUserInputEvents );
auto existingSummaryCase = findTopLevelSummaryCaseFromFileName( fileInfo.summaryFileName() ); auto existingSummaryCase = findTopLevelSummaryCaseFromFileName( fileInfo.summaryFileName() );
if ( !existingSummaryCase ) if ( !existingSummaryCase )
@ -597,7 +597,7 @@ std::vector<RimSummaryCase*>
if ( progress != nullptr ) progress->incrementProgress(); if ( progress != nullptr ) progress->incrementProgress();
} }
QCoreApplication::processEvents( QEventLoop::ExcludeUserInputEvents ); // QCoreApplication::processEvents( QEventLoop::ExcludeUserInputEvents );
} }
RimSummaryCaseMainCollection::loadSummaryCaseData( sumCases ); 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. // Use main grid cell to evaluate if a cell is active or not.
// All cells in temporary grids are active // All cells in temporary grids are active
const RigCell& cell = mainGrid->globalCellArray()[reservoirCellIndex]; const RigCell& cell = mainGrid->cell( reservoirCellIndex );
size_t mainGridReservoirIndex = cell.mainGridCellIndex(); size_t mainGridReservoirIndex = cell.mainGridCellIndex();
if ( !activeCellInfo->isActive( mainGridReservoirIndex ) ) if ( !activeCellInfo->isActive( mainGridReservoirIndex ) )
@ -358,7 +358,7 @@ std::vector<size_t>
std::vector<size_t> cellIndicesToLeafCells; std::vector<size_t> cellIndicesToLeafCells;
for ( const size_t& index : cellIndices ) for ( const size_t& index : cellIndices )
{ {
const RigCell& cell = mainGrid->globalCellArray()[index]; const RigCell& cell = mainGrid->cell( index );
if ( !cell.subGrid() ) if ( !cell.subGrid() )
{ {
cellIndicesToLeafCells.push_back( index ); 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() ); cellVolumeResults.resize( cellResultCount, std::numeric_limits<double>::infinity() );
#pragma omp parallel for #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++ ) nativeResvCellIndex++ )
{ {
size_t resultIndex = m_resultsData->activeCellInfo()->cellResultIndex( nativeResvCellIndex ); size_t resultIndex = m_resultsData->activeCellInfo()->cellResultIndex( nativeResvCellIndex );
if ( resultIndex != cvf::UNDEFINED_SIZE_T ) 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() ) if ( !cell.subGrid() )
{ {
cellVolumeResults[resultIndex] = cell.volume(); cellVolumeResults[resultIndex] = cell.volume();

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

@ -79,8 +79,9 @@ void RigFaultDistanceResultCalculator::calculate( const RigEclipseResultAddress&
if ( !shouldCompute ) return; if ( !shouldCompute ) return;
const std::vector<RigCell>& globalCellArray = m_resultsData->m_ownerMainGrid->globalCellArray(); 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(); 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(); fractureActiveCellInfo->computeDerivedData();
} }
//-------------------------------------------------------------------------------------------------- ////--------------------------------------------------------------------------------------------------
/// /////
//-------------------------------------------------------------------------------------------------- ////--------------------------------------------------------------------------------------------------
size_t RigActiveCellGrid::cellIndexFromIJK( size_t i, size_t j, size_t k ) const // size_t RigActiveCellGrid::cellIndexFromIJK( size_t i, size_t j, size_t k ) const
{ //{
auto index = RigGridBase::cellIndexFromIJK( i, j, k ); // auto index = RigGridBase::cellIndexFromIJK( i, j, k );
return m_globalToActiveMap[index]; // 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 // bool RigActiveCellGrid::ijkFromCellIndex( size_t cellIndex, size_t* i, size_t* j, size_t* k ) const
{ //{
auto index = RigGridBase::cellIndexFromIJKUnguarded( i, j, k ); // if ( cellIndex >= m_activeToGlobalMap.size() )
return m_globalToActiveMap[index]; // {
} // return false;
// }
//-------------------------------------------------------------------------------------------------- // auto index = m_activeToGlobalMap[cellIndex];
/// // return RigGridBase::ijkFromCellIndex( 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; // void RigActiveCellGrid::ijkFromCellIndexUnguarded( size_t cellIndex, size_t* i, size_t* j, size_t* k ) const
} //{
auto index = m_activeToGlobalMap[cellIndex]; // auto index = m_activeToGlobalMap[cellIndex];
return RigGridBase::ijkFromCellIndex( index, i, j, k ); // RigGridBase::ijkFromCellIndexUnguarded( 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 ) 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 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>& activeMatrixIndexes,
const std::vector<int>& activeFracIndexes ); const std::vector<int>& activeFracIndexes );
size_t cellIndexFromIJK( 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; // 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; // 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; // void ijkFromCellIndexUnguarded( size_t cellIndex, size_t* i, size_t* j, size_t* k ) const override;
RigCell& cell( size_t gridLocalCellIndex ) override; RigCell& cell( size_t gridLocalCellIndex ) override;
const RigCell& cell( size_t gridLocalCellIndex ) const 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: private:
std::vector<size_t> m_globalToActiveMap; 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; return true;
} }
CVF_TIGHT_ASSERT( reservoirCellIndex < m_cellIndexToResultIndex.size() ); if ( reservoirCellIndex >= m_cellIndexToResultIndex.size() ) return false;
return m_cellIndexToResultIndex[reservoirCellIndex] != cvf::UNDEFINED_SIZE_T; 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]; 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 RigCell;
class RigActiveCellInfo; 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 class RigGridBase : public cvf::StructGridInterface
{ {
public: public:
@ -50,8 +53,11 @@ public:
size_t cellCountK() const override; size_t cellCountK() const override;
virtual size_t cellCount() const; virtual size_t cellCount() const;
virtual RigCell& cell( size_t gridLocalCellIndex ); virtual RigCell& cell( size_t actualCellIndex );
virtual const RigCell& cell( size_t gridLocalCellIndex ) const; 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; 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; 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; 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 ) 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]; const RigCell& c = cell( globalCellIdx );
RigGridBase* hostGrid = cell.hostGrid(); RigGridBase* hostGrid = c.hostGrid();
CVF_ASSERT( hostGrid ); CVF_ASSERT( hostGrid );
if ( gridLocalCellIdx ) if ( gridLocalCellIdx )
{ {
*gridLocalCellIdx = cell.gridLocalCellIndex(); *gridLocalCellIdx = c.gridLocalCellIndex();
} }
return hostGrid; return hostGrid;
@ -111,15 +127,15 @@ RigGridBase* RigMainGrid::gridAndGridLocalIdxFromGlobalCellIdx( size_t globalCel
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
const RigGridBase* RigMainGrid::gridAndGridLocalIdxFromGlobalCellIdx( size_t globalCellIdx, size_t* gridLocalCellIdx ) const 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 RigCell& c = cell( globalCellIdx );
const RigGridBase* hostGrid = cell.hostGrid(); const RigGridBase* hostGrid = c.hostGrid();
CVF_ASSERT( hostGrid ); CVF_ASSERT( hostGrid );
if ( gridLocalCellIdx ) if ( gridLocalCellIdx )
{ {
*gridLocalCellIdx = cell.gridLocalCellIndex(); *gridLocalCellIdx = c.gridLocalCellIndex();
} }
return hostGrid; return hostGrid;
@ -492,7 +508,7 @@ void RigMainGrid::calculateFaults( const RigActiveCellInfo* activeCellInfo )
return; return;
} }
m_faultsPrCellAcc = new RigFaultsPrCellAccumulator( m_cells.size() ); m_faultsPrCellAcc = new RigFaultsPrCellAccumulator( RigGridBase::cellCount() );
// Spread fault idx'es on the cells from the faults // Spread fault idx'es on the cells from the faults
for ( size_t fIdx = 0; fIdx < m_faults.size(); ++fIdx ) 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>& unNamedFaultFaces = unNamedFault->faultFaces();
std::vector<RigFault::FaultFace>& unNamedFaultFacesInactive = unNamedFaultWithInactive->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, activeCellInfo,
vxs, vxs,
unNamedFaultIdx, unNamedFaultIdx,
@ -542,7 +559,7 @@ void RigMainGrid::addUnNamedFaultFaces( int gcIdx,
std::vector<RigFault::FaultFace>& unNamedFaultFacesInactive, std::vector<RigFault::FaultFace>& unNamedFaultFacesInactive,
RigFaultsPrCellAccumulator* faultsPrCellAcc ) const RigFaultsPrCellAccumulator* faultsPrCellAcc ) const
{ {
if ( m_cells[gcIdx].isInvalid() ) if ( cell( gcIdx ).isInvalid() )
{ {
return; return;
} }
@ -586,19 +603,20 @@ void RigMainGrid::addUnNamedFaultFaces( int gcIdx,
} }
neighborReservoirCellIdx = hostGrid->reservoirCellIndex( neighborGridCellIdx ); neighborReservoirCellIdx = hostGrid->reservoirCellIndex( neighborGridCellIdx );
if ( m_cells[neighborReservoirCellIdx].isInvalid() ) if ( cell( neighborReservoirCellIdx ).isInvalid() )
{ {
continue; continue;
} }
bool isNeighborCellActive = activeCellInfo->isActive( neighborReservoirCellIdx ); auto activeNeighborCellIndex = hostGrid->globalToActualCellIndex( neighborGridCellIdx );
bool isNeighborCellActive = activeCellInfo->isActive( activeNeighborCellIndex );
double tolerance = 1e-6; double tolerance = 1e-6;
std::array<size_t, 4> faceIdxs; std::array<size_t, 4> faceIdxs;
m_cells[gcIdx].faceIndices( face, &faceIdxs ); cell( gcIdx ).faceIndices( face, &faceIdxs );
std::array<size_t, 4> nbFaceIdxs; std::array<size_t, 4> nbFaceIdxs;
m_cells[neighborReservoirCellIdx].faceIndices( StructGridInterface::oppositeFace( face ), &nbFaceIdxs ); cell( neighborReservoirCellIdx ).faceIndices( StructGridInterface::oppositeFace( face ), &nbFaceIdxs );
bool sharedFaceVertices = true; bool sharedFaceVertices = true;
if ( sharedFaceVertices && vxs[faceIdxs[0]].pointDistance( vxs[nbFaceIdxs[0]] ) > tolerance ) sharedFaceVertices = false; if ( sharedFaceVertices && vxs[faceIdxs[0]].pointDistance( vxs[nbFaceIdxs[0]] ) > tolerance ) sharedFaceVertices = false;
@ -664,7 +682,7 @@ void RigMainGrid::distributeNNCsToFaults()
if ( fIdx1 < 0 && fIdx2 < 0 ) if ( fIdx1 < 0 && fIdx2 < 0 )
{ {
cvf::String lgrString( "Same Grid" ); 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"; lgrString = "Different Grid";
} }
@ -741,7 +759,7 @@ void RigMainGrid::computeFaceNormalsDirection( const std::vector<size_t>& reserv
for ( const auto& index : reservoirCellIndices ) for ( const auto& index : reservoirCellIndices )
{ {
const auto& cell = m_cells[index]; const auto& cell = this->cell( index );
if ( !cell.isInvalid() ) if ( !cell.isInvalid() )
{ {
// Some cells can be very twisted and distorted. Use a volume criteria to find a reasonably regular cell. // 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(); std::vector<cvf::Vec3d>& nodes();
const std::vector<cvf::Vec3d>& nodes() const; const std::vector<cvf::Vec3d>& nodes() const;
std::vector<RigCell>& globalCellArray(); std::vector<RigCell>& reservoirCells();
const std::vector<RigCell>& globalCellArray() const; 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 RigGridBase* gridAndGridLocalIdxFromGlobalCellIdx( size_t globalCellIdx, size_t* gridLocalCellIdx );
virtual const RigGridBase* gridAndGridLocalIdxFromGlobalCellIdx( size_t globalCellIdx, size_t* gridLocalCellIdx ) const; virtual const RigGridBase* gridAndGridLocalIdxFromGlobalCellIdx( size_t globalCellIdx, size_t* gridLocalCellIdx ) const;