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

Privatize grid cell array

Browse Source
This commit is contained in:
jonjenssen
2024-10-23 20:43:08 +02:00
committed by jonjenssen
parent 69878f54d3
commit 88118ee4e1
49 changed files with 418 additions and 326 deletions
Download Patch File Download Diff File Expand all files Collapse all files

254
ApplicationLibCode/ReservoirDataModel/RigActiveCellGrid.cpp
View File

@@ -26,6 +26,10 @@
//--------------------------------------------------------------------------------------------------
RigActiveCellGrid::RigActiveCellGrid()
{
m_invalidCell.setInvalid( true );
for ( size_t i = 0; i < 8; i++ )
m_invalidCell.cornerIndices()[i] = 0;
m_invalidCell.setHostGrid( this );
}
//--------------------------------------------------------------------------------------------------
@@ -35,116 +39,129 @@ RigActiveCellGrid::~RigActiveCellGrid()
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigActiveCellGrid::transferActiveInformation( RigEclipseCaseData* eclipseCaseData,
size_t totalActiveCells,
size_t matrixActiveCells,
size_t fractureActiveCells,
const std::vector<int>& activeMatrixIndexes,
const std::vector<int>& activeFracIndexes )
{
const auto totalCells = activeMatrixIndexes.size();
////--------------------------------------------------------------------------------------------------
/////
////--------------------------------------------------------------------------------------------------
// size_t RigActiveCellGrid::transferActiveInformation( int gridIndex,
// RigEclipseCaseData* eclipseCaseData,
// size_t totalActiveCells,
// size_t matrixActiveCells,
// size_t fractureActiveCells,
// const std::vector<int>& activeMatrixIndexes,
// const std::vector<int>& activeFracIndexes,
// size_t inactiveCellIndex )
//{
// if ( gridIndex == 0 )
// {
// m_globalToNativeMap.clear();
// inactiveCellIndex = 0;
// }
//
// const auto totalCells = activeMatrixIndexes.size();
//
// const auto cellStartIndex = m_globalToNativeMap.size();
//
// m_globalToNativeMap.resize( cellStartIndex + totalCells );
// size_t activeCells = cellStartIndex;
// size_t anInactiveCellIdx = inactiveCellIndex;
//
// for ( size_t i = 0; i < totalCells; i++ )
// {
// const auto globalCellIndex = cellStartIndex + i;
// if ( ( activeMatrixIndexes[i] < 0 ) && ( activeFracIndexes[i] < 0 ) )
// {
// m_globalToNativeMap[globalCellIndex] = totalActiveCells;
// anInactiveCellIdx = globalCellIndex;
// continue;
// }
// m_nativeToGlobalMap.push_back( globalCellIndex );
// m_globalToNativeMap[i] = activeCells++;
// }
// m_nativeToGlobalMap.push_back( anInactiveCellIdx );
//
// RigActiveCellInfo* activeCellInfo = eclipseCaseData->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
// RigActiveCellInfo* fractureActiveCellInfo = eclipseCaseData->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL );
//
// activeCellInfo->setReservoirCellCount( activeCellInfo->reservoirCellCount() + totalActiveCells + 1 );
// fractureActiveCellInfo->setReservoirCellCount( fractureActiveCellInfo->reservoirCellCount() + totalActiveCells + 1 );
//
// activeCellInfo->setGridCount( gridIndex + 1 );
// fractureActiveCellInfo->setGridCount( gridIndex + 1 );
//
// activeCellInfo->setGridActiveCellCounts( gridIndex, matrixActiveCells );
// fractureActiveCellInfo->setGridActiveCellCounts( gridIndex, fractureActiveCells );
//
// // TODO - update indexes here
//
// #pragma omp parallel for
// for ( int opmCellIndex = 0; opmCellIndex < (int)totalCells; opmCellIndex++ )
// {
// auto activeCellIndex = m_globalToNativeMap[cellStartIndex + opmCellIndex];
//
// // active cell index
// int matrixActiveIndex = activeMatrixIndexes[opmCellIndex];
// if ( matrixActiveIndex != -1 )
// {
// activeCellInfo->setCellResultIndex( activeCellIndex, matrixActiveIndex );
// }
//
// int fractureActiveIndex = activeFracIndexes[opmCellIndex];
// if ( fractureActiveIndex != -1 )
// {
// fractureActiveCellInfo->setCellResultIndex( activeCellIndex, fractureActiveIndex );
// }
// }
//
// return anInactiveCellIdx;
// }
m_globalToActiveMap.resize( totalCells );
size_t activeCells = 0;
size_t anInactiveCellIdx = 0;
for ( size_t i = 0; i < totalCells; i++ )
{
if ( ( activeMatrixIndexes[i] < 0 ) && ( activeFracIndexes[i] < 0 ) )
{
m_globalToActiveMap[i] = totalActiveCells;
anInactiveCellIdx = i;
continue;
}
m_activeToGlobalMap.push_back( i );
m_globalToActiveMap[i] = activeCells++;
}
m_activeToGlobalMap.push_back( anInactiveCellIdx );
RigActiveCellInfo* activeCellInfo = eclipseCaseData->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
RigActiveCellInfo* fractureActiveCellInfo = eclipseCaseData->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL );
activeCellInfo->setReservoirCellCount( totalActiveCells + 1 );
fractureActiveCellInfo->setReservoirCellCount( totalActiveCells + 1 );
activeCellInfo->setGridCount( 1 );
fractureActiveCellInfo->setGridCount( 1 );
activeCellInfo->setGridActiveCellCounts( 0, matrixActiveCells );
fractureActiveCellInfo->setGridActiveCellCounts( 0, fractureActiveCells );
#pragma omp parallel for
for ( int opmCellIndex = 0; opmCellIndex < (int)totalCells; opmCellIndex++ )
{
auto activeCellIndex = m_globalToActiveMap[opmCellIndex];
// active cell index
int matrixActiveIndex = activeMatrixIndexes[opmCellIndex];
if ( matrixActiveIndex != -1 )
{
activeCellInfo->setCellResultIndex( activeCellIndex, matrixActiveIndex );
}
int fractureActiveIndex = activeFracIndexes[opmCellIndex];
if ( fractureActiveIndex != -1 )
{
fractureActiveCellInfo->setCellResultIndex( activeCellIndex, fractureActiveIndex );
}
}
activeCellInfo->computeDerivedData();
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::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 );
}
////--------------------------------------------------------------------------------------------------
/////
////--------------------------------------------------------------------------------------------------
// 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];
// }
//
////--------------------------------------------------------------------------------------------------
/////
////--------------------------------------------------------------------------------------------------
// 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];
if ( m_nativeCells.contains( gridLocalCellIndex ) ) return m_nativeCells[gridLocalCellIndex];
return m_invalidCell;
}
//--------------------------------------------------------------------------------------------------
@@ -152,13 +169,38 @@ RigCell& RigActiveCellGrid::cell( size_t gridLocalCellIndex )
//--------------------------------------------------------------------------------------------------
const RigCell& RigActiveCellGrid::cell( size_t gridLocalCellIndex ) const
{
return m_cells[gridLocalCellIndex];
if ( m_nativeCells.contains( gridLocalCellIndex ) ) return m_nativeCells.at( gridLocalCellIndex );
return m_invalidCell;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RigActiveCellGrid::cellCount() const
std::map<size_t, RigCell>& RigActiveCellGrid::nativeCells()
{
return m_cells.size();
return m_nativeCells;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::map<size_t, RigCell>& RigActiveCellGrid::nativeCells() const
{
return m_nativeCells;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RigActiveCellGrid::totalCellCount() const
{
return m_totalCellCount;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigActiveCellGrid::setTotalCellCount( size_t totalCellCount )
{
m_totalCellCount = totalCellCount;
}