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

Browse Source
This commit is contained in:
jonjenssen 2024-09-17 00:33:04 +02:00
parent 99fa28f284
commit 68bc64598b
7 changed files with 85 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
ApplicationLibCode/FileInterface/RifReaderOpmCommonActive.cpp
View File

@ -236,10 +236,10 @@ void RifReaderOpmCommonActive::transferActiveGeometry( Opm::EclIO::EGrid& opmMa
yCenterCoordOpm = yCenter;
}
auto riReservoirIndex = activeGrid->cellIndexFromIJK( opmIJK[0], opmIJK[1], opmIJK[2] );
RigCell& cell = activeGrid->cell( riReservoirIndex );
auto nativeIndex = activeGrid->globalCellIndexToNative( riReservoirIndex );
cell.setGridLocalCellIndex( riReservoirIndex );
auto nativeIndex = activeGrid->cellIndexFromIJK( opmIJK[0], opmIJK[1], opmIJK[2] );
RigCell& cell = activeGrid->nativeCell( nativeIndex );
// auto globalIndex = activeGrid->nativeCellIndexToGlobal( nativeIndex );
cell.setGridLocalCellIndex( nativeIndex );
cell.setParentCellIndex( cvf::UNDEFINED_SIZE_T );
// corner coordinates

16
ApplicationLibCode/ModelVisualization/RivElementVectorResultPartMgr.cpp
View File

@ -167,11 +167,11 @@ void RivElementVectorResultPartMgr::appendDynamicGeometryPartsToModel( cvf::Mode
if ( !resultAddresses.empty() && !directions.empty() )
{
#pragma omp parallel for
for ( int gcIdx = 0; gcIdx < static_cast<int>( cells.size() ); ++gcIdx )
for ( int ncIdx = 0; ncIdx < static_cast<int>( cells.size() ); ++ncIdx )
{
if ( !cells[gcIdx].isInvalid() && activeCellInfo->isActive( gcIdx ) )
if ( !cells[ncIdx].isInvalid() && activeCellInfo->isActive( ncIdx ) )
{
size_t resultIdx = activeCellInfo->cellResultIndex( gcIdx );
size_t resultIdx = activeCellInfo->cellResultIndex( ncIdx );
if ( result->vectorView() == RimElementVectorResult::VectorView::PER_FACE )
{
for ( int dir = 0; dir < static_cast<int>( directions.size() ); dir++ )
@ -186,7 +186,7 @@ void RivElementVectorResultPartMgr::appendDynamicGeometryPartsToModel( cvf::Mode
{
cvf::Vec3d faceCenter;
cvf::Vec3d faceNormal;
getFaceCenterAndNormal( static_cast<size_t>( gcIdx ), directions[dir], faceCenter, faceNormal );
getFaceCenterAndNormal( static_cast<size_t>( ncIdx ), directions[dir], faceCenter, faceNormal );
faceNormal *= std::abs( resultValue );
bool centerArrow = false;
@ -200,7 +200,7 @@ void RivElementVectorResultPartMgr::appendDynamicGeometryPartsToModel( cvf::Mode
tensorVisualizations.push_back( ElementVectorResultVisualization( faceCenter,
faceNormal,
resultValue,
std::cbrt( cells[gcIdx].volume() / 3.0 ),
std::cbrt( cells[ncIdx].volume() / 3.0 ),
centerArrow ) );
}
}
@ -220,7 +220,7 @@ void RivElementVectorResultPartMgr::appendDynamicGeometryPartsToModel( cvf::Mode
cvf::Vec3d faceCenter;
cvf::Vec3d faceNormal;
cvf::Vec3d faceNormalScaled;
getFaceCenterAndNormal( gcIdx, directions[dir], faceCenter, faceNormal );
getFaceCenterAndNormal( ncIdx, directions[dir], faceCenter, faceNormal );
faceNormalScaled = faceNormal * resultValue;
aggregatedVector += faceNormalScaled;
aggregatedResult += faceNormal.getNormalized() * resultValue;
@ -235,10 +235,10 @@ void RivElementVectorResultPartMgr::appendDynamicGeometryPartsToModel( cvf::Mode
#pragma omp critical( critical_section_RivElementVectorResultPartMgr_add_2 )
tensorVisualizations.push_back(
ElementVectorResultVisualization( displayCordXf->transformToDisplayCoord( cells[gcIdx].center() ),
ElementVectorResultVisualization( displayCordXf->transformToDisplayCoord( cells[ncIdx].center() ),
aggregatedVector,
aggregatedResult.length(),
std::cbrt( cells[gcIdx].volume() / 3.0 ),
std::cbrt( cells[ncIdx].volume() / 3.0 ),
centerArrow ) );
}
}

2
ApplicationLibCode/ModelVisualization/RivReservoirViewPartMgr.cpp
View File

@ -604,7 +604,7 @@ void RivReservoirViewPartMgr::computeNativeVisibility( cvf::UByteArray*
#pragma omp parallel for
for ( int cellIndex = 0; cellIndex < static_cast<int>( grid->cellCount() ); cellIndex++ )
{
const RigCell& cell = grid->cell( cellIndex );
const RigCell& cell = grid->nativeCell( cellIndex );
size_t reservoirCellIndex = grid->reservoirCellIndex( cellIndex );
bool isCellActive = activeCellInfo->isActive( reservoirCellIndex );

76
ApplicationLibCode/ReservoirDataModel/RigActiveCellGrid.cpp
View File

@ -112,45 +112,45 @@ 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::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::cellIndexFromIJK( size_t i, size_t j, size_t k ) const
{
auto index = RigGridBase::cellIndexFromIJK( 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::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 );
}
//--------------------------------------------------------------------------------------------------
///

8
ApplicationLibCode/ReservoirDataModel/RigActiveCellGrid.h
View File

@ -36,10 +36,10 @@ 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;

28
ApplicationLibCode/ReservoirDataModel/RigGridBase.cpp
View File

@ -131,7 +131,7 @@ void RigGridBase::initSubCellsMainGridCellIndex()
size_t cellIdx;
for ( cellIdx = 0; cellIdx < grid->cellCount(); ++cellIdx )
{
RigCell& cell = grid->cell( cellIdx );
RigCell& cell = grid->nativeCell( cellIdx );
cell.setMainGridCellIndex( cellIdx );
}
}
@ -143,12 +143,12 @@ void RigGridBase::initSubCellsMainGridCellIndex()
RigLocalGrid* localGrid = static_cast<RigLocalGrid*>( grid );
RigGridBase* parentGrid = localGrid->parentGrid();
RigCell& cell = localGrid->cell( cellIdx );
RigCell& cell = localGrid->nativeCell( cellIdx );
size_t parentCellIndex = cell.parentCellIndex();
while ( !parentGrid->isMainGrid() )
{
const RigCell& parentCell = parentGrid->cell( parentCellIndex );
const RigCell& parentCell = parentGrid->nativeCell( parentCellIndex );
parentCellIndex = parentCell.parentCellIndex();
localGrid = static_cast<RigLocalGrid*>( parentGrid );
@ -167,7 +167,7 @@ void RigGridBase::initSubCellsMainGridCellIndex()
//--------------------------------------------------------------------------------------------------
void RigGridBase::cellCornerVertices( size_t cellIndex, cvf::Vec3d vertices[8] ) const
{
const std::array<size_t, 8>& indices = cell( cellIndex ).cornerIndices();
const std::array<size_t, 8>& indices = nativeCell( cellIndex ).cornerIndices();
vertices[0].set( m_mainGrid->nodes()[indices[0]] );
vertices[1].set( m_mainGrid->nodes()[indices[1]] );
@ -342,7 +342,7 @@ bool RigGridBase::isCellValid( size_t i, size_t j, size_t k ) const
}
size_t idx = cellIndexFromIJK( i, j, k );
const RigCell& c = cell( idx );
const RigCell& c = nativeCell( idx );
return !c.isInvalid();
}
@ -469,7 +469,7 @@ size_t RigGridBase::addCoarseningBox( size_t i1, size_t i2, size_t j1, size_t j2
{
size_t cellIdx = cellIndexFromIJK( i, j, k );
RigCell& c = cell( cellIdx );
RigCell& c = nativeCell( cellIdx );
CVF_ASSERT( c.coarseningBoxIndex() == cvf::UNDEFINED_SIZE_T );
c.setCoarseningBoxIndex( coarseningBoxIndex );
@ -572,8 +572,8 @@ bool RigGridCellFaceVisibilityFilter::isFaceVisible( size_t
{
CVF_TIGHT_ASSERT( m_grid );
size_t cellIndex = m_grid->cellIndexFromIJK( i, j, k );
if ( m_grid->cell( cellIndex ).subGrid() )
size_t nativeCellIndex = m_grid->cellIndexFromIJK( i, j, k );
if ( m_grid->nativeCell( nativeCellIndex ).subGrid() )
{
// Do not show any faces in the place where a LGR is present
return false;
@ -588,27 +588,27 @@ bool RigGridCellFaceVisibilityFilter::isFaceVisible( size_t
return true;
}
size_t neighborCellIndex = m_grid->cellIndexFromIJK( ni, nj, nk );
size_t nativeNeighborCellIndex = m_grid->cellIndexFromIJK( ni, nj, nk );
// Do show the faces in the boarder between this grid and a possible LGR. Some of the LGR cells
// might not be visible.
if ( m_grid->cell( neighborCellIndex ).subGrid() )
if ( m_grid->nativeCell( nativeNeighborCellIndex ).subGrid() )
{
return true;
}
// Do not show cell geometry if a fault is present to avoid z fighting between surfaces
// It will always be a better solution to avoid geometry creation instead of part priority and polygon offset
size_t nativeResvCellIndex = m_grid->reservoirCellIndex( cellIndex );
const RigFault* fault = m_grid->mainGrid()->findFaultFromCellIndexAndCellFace( nativeResvCellIndex, face );
const auto cellIndex = m_grid->nativeCellIndexToGlobal( nativeCellIndex );
size_t resvCellIndex = m_grid->reservoirCellIndex( cellIndex );
const RigFault* fault = m_grid->mainGrid()->findFaultFromCellIndexAndCellFace( resvCellIndex, face );
if ( fault )
{
return false;
}
auto nativeCellIndex = m_grid->globalCellIndexToNative( neighborCellIndex );
// If the neighbour cell is invisible, we need to draw the face
if ( ( cellVisibility != nullptr ) && !( *cellVisibility )[nativeCellIndex] )
if ( ( cellVisibility != nullptr ) && !( *cellVisibility )[nativeNeighborCellIndex] )
{
return true;
}

31
ApplicationLibCode/ReservoirDataModel/RigMainGrid.cpp
View File

@ -534,7 +534,7 @@ void RigMainGrid::calculateFaults( const RigActiveCellInfo* activeCellInfo )
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigMainGrid::addUnNamedFaultFaces( int gcIdx,
void RigMainGrid::addUnNamedFaultFaces( int globalCellIdx,
const RigActiveCellInfo* activeCellInfo,
const std::vector<cvf::Vec3d>& vxs,
int unNamedFaultIdx,
@ -543,13 +543,13 @@ void RigMainGrid::addUnNamedFaultFaces( int gcIdx,
std::vector<RigFault::FaultFace>& unNamedFaultFacesInactive,
RigFaultsPrCellAccumulator* faultsPrCellAcc ) const
{
if ( cell( gcIdx ).isInvalid() )
if ( cell( globalCellIdx ).isInvalid() )
{
return;
}
size_t neighborReservoirCellIdx;
size_t neighborGridCellIdx;
size_t nativeNeighborGridCellIdx;
size_t i = 0;
size_t j = 0;
size_t k = 0;
@ -567,38 +567,39 @@ void RigMainGrid::addUnNamedFaultFaces( int gcIdx,
// For faces that has no used defined Fault assigned:
if ( m_faultsPrCellAcc->faultIdx( gcIdx, face ) == RigFaultsPrCellAccumulator::NO_FAULT )
if ( m_faultsPrCellAcc->faultIdx( globalCellIdx, face ) == RigFaultsPrCellAccumulator::NO_FAULT )
{
// Find neighbor cell
if ( firstNO_FAULTFaceForCell ) // To avoid doing this for every face, and only when detecting a NO_FAULT
{
size_t gridLocalCellIndex;
hostGrid = gridAndGridLocalIdxFromGlobalCellIdx( gcIdx, &gridLocalCellIndex );
hostGrid = gridAndGridLocalIdxFromGlobalCellIdx( globalCellIdx, &gridLocalCellIndex );
const auto nativeCellIndex = globalCellIndexToNative( globalCellIdx );
isCellActive = activeCellInfo->isActive( nativeCellIndex );
hostGrid->ijkFromCellIndex( gridLocalCellIndex, &i, &j, &k );
isCellActive = activeCellInfo->isActive( gcIdx );
auto gridNativeCellIndex = hostGrid->globalCellIndexToNative( gridLocalCellIndex );
hostGrid->ijkFromCellIndex( gridNativeCellIndex, &i, &j, &k );
firstNO_FAULTFaceForCell = false;
}
if ( !hostGrid->cellIJKNeighbor( i, j, k, face, &neighborGridCellIdx ) )
if ( !hostGrid->cellIJKNeighbor( i, j, k, face, &nativeNeighborGridCellIdx ) )
{
continue;
}
neighborReservoirCellIdx = hostGrid->reservoirCellIndex( neighborGridCellIdx );
neighborReservoirCellIdx = hostGrid->reservoirCellIndex( nativeNeighborGridCellIdx );
if ( cell( neighborReservoirCellIdx ).isInvalid() )
{
continue;
}
auto activeNeighborCellIndex = hostGrid->globalCellIndexToNative( neighborGridCellIdx );
bool isNeighborCellActive = activeCellInfo->isActive( activeNeighborCellIndex );
bool isNeighborCellActive = activeCellInfo->isActive( nativeNeighborGridCellIdx );
double tolerance = 1e-6;
std::array<size_t, 4> faceIdxs;
cell( gcIdx ).faceIndices( face, &faceIdxs );
cell( globalCellIdx ).faceIndices( face, &faceIdxs );
std::array<size_t, 4> nbFaceIdxs;
cell( neighborReservoirCellIdx ).faceIndices( StructGridInterface::oppositeFace( face ), &nbFaceIdxs );
@ -617,14 +618,14 @@ void RigMainGrid::addUnNamedFaultFaces( int gcIdx,
int faultIdx = unNamedFaultIdx;
if ( !( isCellActive && isNeighborCellActive ) ) faultIdx = unNamedFaultWithInactiveIdx;
faultsPrCellAcc->setFaultIdx( gcIdx, face, faultIdx );
faultsPrCellAcc->setFaultIdx( globalCellIdx, face, faultIdx );
faultsPrCellAcc->setFaultIdx( neighborReservoirCellIdx, StructGridInterface::oppositeFace( face ), faultIdx );
// Add as fault face only if the grid index is less than the neighbors
if ( static_cast<size_t>( gcIdx ) < neighborReservoirCellIdx )
if ( static_cast<size_t>( globalCellIdx ) < neighborReservoirCellIdx )
{
RigFault::FaultFace ff( gcIdx, cvf::StructGridInterface::FaceType( faceIdx ), neighborReservoirCellIdx );
RigFault::FaultFace ff( globalCellIdx, cvf::StructGridInterface::FaceType( faceIdx ), neighborReservoirCellIdx );
if ( isCellActive && isNeighborCellActive )
{
unNamedFaultFaces.push_back( ff );