RigActiveCellInfo: Use type-safe index types and add ActiveCellIndex

Refactor RigActiveCellInfo to use ReservoirCellIndex and ActiveCellIndex
instead of raw size_t. Add ActiveCellIndexTag/ActiveCellIndex to
RigTypeSafeIndex.h and add inline comments describing both index types.
Deprecate raw size_t overloads.

ApplicationLibCode/ReservoirDataModel/RigActiveCellInfo.cpp

@@ -33,7 +33,7 @@ RigActiveCellInfo::RigActiveCellInfo()
 //--------------------------------------------------------------------------------------------------
 void RigActiveCellInfo::setReservoirCellCount( size_t reservoirCellCount )
 {
-    m_cellIndexToResultIndex.resize( reservoirCellCount, cvf::UNDEFINED_SIZE_T );
+    m_reservoirCellToActiveCell.resize( reservoirCellCount, ActiveCellIndex( cvf::UNDEFINED_SIZE_T ) );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -41,7 +41,22 @@ void RigActiveCellInfo::setReservoirCellCount( size_t reservoirCellCount )
 //--------------------------------------------------------------------------------------------------
 size_t RigActiveCellInfo::reservoirCellCount() const
 {
-    return m_cellIndexToResultIndex.size();
+    return m_reservoirCellToActiveCell.size();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+bool RigActiveCellInfo::isActive( ReservoirCellIndex reservoirCellIndex ) const
+{
+    if ( m_reservoirCellToActiveCell.empty() )
+    {
+        return true;
+    }
+
+    CVF_TIGHT_ASSERT( reservoirCellIndex.value() < m_reservoirCellToActiveCell.size() );
+
+    return m_reservoirCellToActiveCell[reservoirCellIndex.value()].value() != cvf::UNDEFINED_SIZE_T;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -49,14 +64,17 @@ size_t RigActiveCellInfo::reservoirCellCount() const
 //--------------------------------------------------------------------------------------------------
 bool RigActiveCellInfo::isActive( size_t reservoirCellIndex ) const
 {
-    if ( m_cellIndexToResultIndex.empty() )
-    {
-        return true;
-    }
+    return isActive( ReservoirCellIndex( reservoirCellIndex ) );
+}
 
-    CVF_TIGHT_ASSERT( reservoirCellIndex < m_cellIndexToResultIndex.size() );
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+ActiveCellIndex RigActiveCellInfo::cellResultIndex( ReservoirCellIndex reservoirCellIndex ) const
+{
+    CVF_TIGHT_ASSERT( reservoirCellIndex.value() < m_reservoirCellToActiveCell.size() );
 
-    return m_cellIndexToResultIndex[reservoirCellIndex] != cvf::UNDEFINED_SIZE_T;
+    return m_reservoirCellToActiveCell[reservoirCellIndex.value()];
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -64,9 +82,17 @@ bool RigActiveCellInfo::isActive( size_t reservoirCellIndex ) const
 //--------------------------------------------------------------------------------------------------
 size_t RigActiveCellInfo::cellResultIndex( size_t reservoirCellIndex ) const
 {
-    CVF_TIGHT_ASSERT( reservoirCellIndex < m_cellIndexToResultIndex.size() );
+    return cellResultIndex( ReservoirCellIndex( reservoirCellIndex ) ).value();
+}
 
-    return m_cellIndexToResultIndex[reservoirCellIndex];
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RigActiveCellInfo::setCellResultIndex( ReservoirCellIndex reservoirCellIndex, ActiveCellIndex reservoirCellResultIndex )
+{
+    CVF_TIGHT_ASSERT( reservoirCellResultIndex < m_reservoirCellToActiveCell.size() );
+
+    m_reservoirCellToActiveCell[reservoirCellIndex.value()] = reservoirCellResultIndex;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -74,9 +100,7 @@ size_t RigActiveCellInfo::cellResultIndex( size_t reservoirCellIndex ) const
 //--------------------------------------------------------------------------------------------------
 void RigActiveCellInfo::setCellResultIndex( size_t reservoirCellIndex, size_t reservoirCellResultIndex )
 {
-    CVF_TIGHT_ASSERT( reservoirCellResultIndex < m_cellIndexToResultIndex.size() );
-
-    m_cellIndexToResultIndex[reservoirCellIndex] = reservoirCellResultIndex;
+    setCellResultIndex( ReservoirCellIndex( reservoirCellIndex ), ActiveCellIndex( reservoirCellResultIndex ) );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -84,7 +108,7 @@ void RigActiveCellInfo::setCellResultIndex( size_t reservoirCellIndex, size_t re
 //--------------------------------------------------------------------------------------------------
 std::vector<ReservoirCellIndex> RigActiveCellInfo::activeReservoirCellIndices() const
 {
-    return m_activeCellIndices;
+    return m_activeReservoirCells;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -117,11 +141,11 @@ void RigActiveCellInfo::computeDerivedData()
         m_reservoirActiveCellCount += m_perGridActiveCellInfo[i].activeCellCount();
     }
 
-    for ( size_t i = 0; i < m_cellIndexToResultIndex.size(); i++ )
+    for ( size_t i = 0; i < m_reservoirCellToActiveCell.size(); i++ )
     {
-        if ( m_cellIndexToResultIndex[i] != cvf::UNDEFINED_SIZE_T )
+        if ( m_reservoirCellToActiveCell[i].value() != cvf::UNDEFINED_SIZE_T )
         {
-            m_activeCellIndices.push_back( ReservoirCellIndex( i ) );
+            m_activeReservoirCells.push_back( ReservoirCellIndex( i ) );
         }
     }
 }
@@ -182,7 +206,7 @@ void RigActiveCellInfo::setGeometryBoundingBox( cvf::BoundingBox bb )
 void RigActiveCellInfo::clear()
 {
     m_perGridActiveCellInfo.clear();
-    m_cellIndexToResultIndex.clear();
+    m_reservoirCellToActiveCell.clear();
     m_reservoirActiveCellCount = 0;
     m_ijkBoundingBox           = RigBoundingBoxIjk<caf::VecIjk0>();
     m_activeCellsBoundingBox.reset();
@@ -205,7 +229,7 @@ void RigActiveCellInfo::addLgr( size_t cellCount )
 
     for ( size_t i = 0; i < cellCount; i++ )
     {
-        setCellResultIndex( currentReservoirCellCount + i, currentActiveCellCount + i );
+        setCellResultIndex( ReservoirCellIndex( currentReservoirCellCount + i ), ActiveCellIndex( currentActiveCellCount + i ) );
     }
 }
 

ApplicationLibCode/ReservoirDataModel/RigActiveCellInfo.h

@@ -38,11 +38,15 @@ public:
     size_t reservoirCellCount() const;
     size_t reservoirActiveCellCount() const;
 
-    bool                            isActive( size_t reservoirCellIndex ) const;
-    size_t                          cellResultIndex( size_t reservoirCellIndex ) const;
-    void                            setCellResultIndex( size_t reservoirCellIndex, size_t globalResultCellIndex );
+    bool                            isActive( ReservoirCellIndex reservoirCellIndex ) const;
+    ActiveCellIndex                 cellResultIndex( ReservoirCellIndex reservoirCellIndex ) const;
+    void                            setCellResultIndex( ReservoirCellIndex reservoirCellIndex, ActiveCellIndex globalResultCellIndex );
     std::vector<ReservoirCellIndex> activeReservoirCellIndices() const;
 
+    [[deprecated( "Use ReservoirCellIndex overload" )]] bool   isActive( size_t reservoirCellIndex ) const;
+    [[deprecated( "Use ReservoirCellIndex overload" )]] size_t cellResultIndex( size_t reservoirCellIndex ) const;
+    [[deprecated( "Use ReservoirCellIndex overload" )]] void setCellResultIndex( size_t reservoirCellIndex, size_t globalResultCellIndex );
+
     void   setGridCount( size_t gridCount );
     void   setGridActiveCellCounts( size_t gridIndex, size_t activeCellCount );
     size_t gridActiveCellCounts( size_t gridIndex ) const;
@@ -74,8 +78,8 @@ private:
 private:
     std::vector<GridActiveCellCounts> m_perGridActiveCellInfo;
 
-    std::vector<size_t>             m_cellIndexToResultIndex;
-    std::vector<ReservoirCellIndex> m_activeCellIndices;
+    std::vector<ActiveCellIndex>    m_reservoirCellToActiveCell;
+    std::vector<ReservoirCellIndex> m_activeReservoirCells;
 
     size_t m_reservoirActiveCellCount;
 

ApplicationLibCode/ReservoirDataModel/RigTypeSafeIndex.h

@@ -1,6 +1,6 @@
 /////////////////////////////////////////////////////////////////////////////////
 //
-//  Copyright (C) 2025 Equinor ASA
+//  Copyright (C) 2026  Equinor ASA
 //
 //  ResInsight is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -58,13 +58,6 @@ private:
     size_t m_value;
 };
 
-// Define specific types using tag structs
-struct ReservoirCellIndexTag
-{
-};
-
-using ReservoirCellIndex = TypeSafeIndex<ReservoirCellIndexTag>;
-
 // Hash support for using in std::unordered_map, etc.
 namespace std
 {
@@ -73,4 +66,19 @@ struct hash<TypeSafeIndex<Tag>>
 {
     size_t operator()( const TypeSafeIndex<Tag>& idx ) const noexcept { return hash<size_t>{}( idx.value() ); }
 };
+
 } // namespace std
+
+// Define specific types using tag structs
+
+struct ReservoirCellIndexTag
+{
+};
+// Global cell index in the full IJK reservoir grid
+using ReservoirCellIndex = TypeSafeIndex<ReservoirCellIndexTag>;
+
+struct ActiveCellIndexTag
+{
+};
+// Index into the subset of active cells. This is usually the index used to access results data.
+using ActiveCellIndex = TypeSafeIndex<ActiveCellIndexTag>;