Added handling of faults on higher level structures

ApplicationCode/ModelVisualization/RivFaultGeometryGenerator.cpp

@@ -335,6 +335,6 @@ void RivFaultGeometryGenerator::setShowOppositeFaultFaces(bool showOppositeFault
 //--------------------------------------------------------------------------------------------------
 void RivFaultGeometryGenerator::setLimitFaultsToFilter(bool limitFaultsToFilter)
 {
-    m_limitFaultsToFilters = limitFaultsToFilter;
+//    m_limitFaultsToFilters = limitFaultsToFilter;
 }
 

ApplicationCode/ModelVisualization/RivFaultPart.cpp

@@ -126,7 +126,7 @@ void RivFaultPartMgr::setLimitFaultToVisibleCells(bool limitFaultToVisibleCells)
     m_nativeFaultGenerator.setLimitFaultsToFilter(limitFaultToVisibleCells);
     m_oppositeFaultGenerator.setLimitFaultsToFilter(limitFaultToVisibleCells);
 
-    generatePartGeometry();
+//    generatePartGeometry();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/ModelVisualization/RivFaultPart.h

@@ -53,6 +53,7 @@ public:
     void updateCellResultColor(size_t timeStepIndex, RimResultSlot* cellResultSlot);
     void updateCellEdgeResultColor(size_t timeStepIndex, RimResultSlot* cellResultSlot, RimCellEdgeResultSlot* cellEdgeResultSlot);
 
+    // TODO: Remove all
     void setShowNativeFaces(bool showNativeFaces);
     void setShowOppositeFaces(bool showOppositeFaces);
     void setShowLabel(bool showLabel);

ApplicationCode/ModelVisualization/RivReservoirPartMgr.cpp

@@ -32,7 +32,6 @@
 void RivReservoirPartMgr::clearAndSetReservoir(const RigCaseData* eclipseCase, const RimFaultCollection* faultCollection)
 {
     m_allGrids.clear();
-    m_faults.clear();
 
     if (eclipseCase)
     {
@@ -44,7 +43,7 @@ void RivReservoirPartMgr::clearAndSetReservoir(const RigCaseData* eclipseCase, c
         }
 
         // Faults read from file are present only on main grid
-        m_faults.push_back(new RivReservoirFaultsPartMgr(eclipseCase->mainGrid(), 0, faultCollection));
+        m_faultsPartMgr = new RivReservoirFaultsPartMgr(eclipseCase->mainGrid(), 0, faultCollection);
     }
 }
 
@@ -58,9 +57,9 @@ void RivReservoirPartMgr::setTransform(cvf::Transform* scaleTransform)
         m_allGrids[i]->setTransform(scaleTransform);
     }
 
-    for (size_t i = 0; i < m_faults.size() ; ++i)
+    if (m_faultsPartMgr.notNull())
     {
-        m_faults[i]->setTransform(scaleTransform);
+        m_faultsPartMgr->setTransform(scaleTransform);
     }
 }
 
@@ -72,9 +71,10 @@ void RivReservoirPartMgr::setCellVisibility(size_t gridIndex, cvf::UByteArray* c
     CVF_ASSERT(gridIndex < m_allGrids.size());
     m_allGrids[gridIndex]->setCellVisibility(cellVisibilities);
 
-    if (gridIndex < m_faults.size())
+    if (gridIndex == 0)
     {
-        m_faults[gridIndex]->setCellVisibility(cellVisibilities);
+        CVF_ASSERT(m_faultsPartMgr.notNull());
+        m_faultsPartMgr->setCellVisibility(cellVisibilities);
     }
 }
 
@@ -96,11 +96,6 @@ void RivReservoirPartMgr::updateCellColor(cvf::Color4f color)
     {
         m_allGrids[i]->updateCellColor(color);
     }
-
-    for (size_t i = 0; i < m_faults.size() ; ++i)
-    {
-        m_faults[i]->updateCellColor(color);
-    }
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -112,12 +107,6 @@ void RivReservoirPartMgr::updateCellResultColor(size_t timeStepIndex, RimResultS
     {
         m_allGrids[i]->updateCellResultColor(timeStepIndex, cellResultSlot);
     }
-
-    for (size_t i = 0; i < m_faults.size() ; ++i)
-    {
-        m_faults[i]->updateCellResultColor(timeStepIndex, cellResultSlot);
-    }
-
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -129,33 +118,23 @@ void RivReservoirPartMgr::updateCellEdgeResultColor(size_t timeStepIndex, RimRes
     {
         m_allGrids[i]->updateCellEdgeResultColor(timeStepIndex, cellResultSlot, cellEdgeResultSlot);
     }
-
-    for (size_t i = 0; i < m_faults.size() ; ++i)
-    {
-        m_faults[i]->updateCellEdgeResultColor(timeStepIndex, cellResultSlot, cellEdgeResultSlot);
-    }
 }
 
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RivReservoirPartMgr::appendPartsToModel(cvf::ModelBasicList* model)
+void RivReservoirPartMgr::appendGridPartsToModel(cvf::ModelBasicList* model)
 {
     for (size_t i = 0; i < m_allGrids.size() ; ++i)
     {
         m_allGrids[i]->appendPartsToModel(model);
     }
-
-    for (size_t i = 0; i < m_faults.size() ; ++i)
-    {
-        m_faults[i]->appendPartsToModel(model);
-    }
 }
 
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RivReservoirPartMgr::appendPartsToModel(cvf::ModelBasicList* model, const std::vector<size_t>& gridIndices)
+void RivReservoirPartMgr::appendGridPartsToModel(cvf::ModelBasicList* model, const std::vector<size_t>& gridIndices)
 {
     for (size_t i = 0; i < gridIndices.size() ; ++i)
     {
@@ -163,10 +142,28 @@ void RivReservoirPartMgr::appendPartsToModel(cvf::ModelBasicList* model, const s
         {
             m_allGrids[gridIndices[i]]->appendPartsToModel(model);
         }
-
-        if (gridIndices[i] < m_faults.size())
-        {
-            m_faults[gridIndices[i]]->appendPartsToModel(model);
-        }
     }
 }
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RivReservoirPartMgr::updateFaultCellResultColor(size_t timeStepIndex, RimResultSlot* cellResultSlot)
+{
+    if (m_faultsPartMgr.notNull())
+    {
+        m_faultsPartMgr->updateCellResultColor(timeStepIndex, cellResultSlot);
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RivReservoirPartMgr::appendFaultPartsToModel(cvf::ModelBasicList* model)
+{
+    if (m_faultsPartMgr.notNull())
+    {
+        m_faultsPartMgr->appendPartsToModel(model);
+    }
+}
+

ApplicationCode/ModelVisualization/RivReservoirPartMgr.h

@@ -58,11 +58,14 @@ public:
     void   updateCellEdgeResultColor(size_t timeStepIndex, RimResultSlot* cellResultSlot, 
                                      RimCellEdgeResultSlot* cellEdgeResultSlot);
 
-    void   appendPartsToModel(cvf::ModelBasicList* model, const std::vector<size_t>& gridIdxes);
+    void   appendGridPartsToModel(cvf::ModelBasicList* model, const std::vector<size_t>& gridIdxes);
-    void   appendPartsToModel(cvf::ModelBasicList* model);
+    void   appendGridPartsToModel(cvf::ModelBasicList* model);
 
+    // Faults
+    void   updateFaultCellResultColor(size_t timeStepIndex, RimResultSlot* cellResultSlot);
+    void   appendFaultPartsToModel(cvf::ModelBasicList* model);
 private:
 
-    cvf::Collection<RivGridPartMgr> m_allGrids; // Main grid and all LGR's 
+    cvf::Collection<RivGridPartMgr>     m_allGrids; // Main grid and all LGR's 
-    cvf::Collection<RivReservoirFaultsPartMgr> m_faults;
+    cvf::ref<RivReservoirFaultsPartMgr> m_faultsPartMgr;
 };

ApplicationCode/ModelVisualization/RivReservoirViewPartMgr.cpp

@@ -205,7 +205,7 @@ void RivReservoirViewPartMgr::appendStaticGeometryPartsToModel(cvf::ModelBasicLi
     {
         createGeometry( geometryType);
     }
-    m_geometries[geometryType].appendPartsToModel(model, gridIndices);
+    m_geometries[geometryType].appendGridPartsToModel(model, gridIndices);
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -220,7 +220,7 @@ void RivReservoirViewPartMgr::appendDynamicGeometryPartsToModel(cvf::ModelBasicL
         {
             createPropertyFilteredNoneWellCellGeometry(frameIndex);
         }
-        m_propFilteredGeometryFrames[frameIndex]->appendPartsToModel(model, gridIndices);
+        m_propFilteredGeometryFrames[frameIndex]->appendGridPartsToModel(model, gridIndices);
     }
     else if (geometryType == PROPERTY_FILTERED_WELL_CELLS)
     {
@@ -228,7 +228,7 @@ void RivReservoirViewPartMgr::appendDynamicGeometryPartsToModel(cvf::ModelBasicL
         {
             createPropertyFilteredWellGeometry(frameIndex);
         }
-        m_propFilteredWellGeometryFrames[frameIndex]->appendPartsToModel(model, gridIndices);
+        m_propFilteredWellGeometryFrames[frameIndex]->appendGridPartsToModel(model, gridIndices);
     }
 }
 
@@ -818,3 +818,39 @@ RivReservoirPartMgr * RivReservoirViewPartMgr::reservoirPartManager(ReservoirGeo
         return &m_geometries[geometryType];
     }
 }
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RivReservoirViewPartMgr::updateFaultsCellResultColor(ReservoirGeometryCacheType geometryType, size_t timeStepIndex, RimResultSlot* cellResultSlot)
+{
+    RivReservoirPartMgr* pmgr = reservoirPartManager(geometryType, timeStepIndex);
+    pmgr->updateFaultCellResultColor(timeStepIndex, cellResultSlot);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RivReservoirViewPartMgr::appendFaultsStaticGeometryPartsToModel(cvf::ModelBasicList* model, ReservoirGeometryCacheType geometryType)
+{
+    if (m_geometriesNeedsRegen[geometryType])
+    {
+        createGeometry(geometryType);
+    }
+    m_geometries[geometryType].appendFaultPartsToModel(model);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RivReservoirViewPartMgr::appendFaultsDynamicGeometryPartsToModel(cvf::ModelBasicList* model, ReservoirGeometryCacheType geometryType, size_t frameIndex)
+{
+    if (geometryType == PROPERTY_FILTERED)
+    {
+        m_propFilteredGeometryFrames[frameIndex]->appendFaultPartsToModel(model);
+    }
+    else if (geometryType == PROPERTY_FILTERED_WELL_CELLS)
+    {
+        m_propFilteredWellGeometryFrames[frameIndex]->appendFaultPartsToModel(model);
+    }
+}

ApplicationCode/ModelVisualization/RivReservoirViewPartMgr.h

@@ -68,6 +68,11 @@ public:
     void                        updateCellEdgeResultColor(ReservoirGeometryCacheType geometryType, size_t timeStepIndex, 
                                                           RimResultSlot* cellResultSlot, RimCellEdgeResultSlot* cellEdgeResultSlot);
 
+    // Faults
+    void                        appendFaultsStaticGeometryPartsToModel(cvf::ModelBasicList* model, ReservoirGeometryCacheType geometryType);
+    void                        appendFaultsDynamicGeometryPartsToModel(cvf::ModelBasicList* model, ReservoirGeometryCacheType geometryType, size_t frameIndex);
+    void                        updateFaultsCellResultColor(ReservoirGeometryCacheType geometryType, size_t timeStepIndex, RimResultSlot* cellResultSlot);
+
 private:
     void                        createGeometry(ReservoirGeometryCacheType geometryType);
     void                        computeVisibility(cvf::UByteArray* cellVisibility, ReservoirGeometryCacheType geometryType, RigGridBase* grid, size_t gridIdx);

ApplicationCode/ProjectDataModel/RimReservoirView.cpp

@@ -607,7 +607,7 @@ void RimReservoirView::createDisplayModel()
                 geometryTypesToAdd.push_back(RivReservoirViewPartMgr::INACTIVE);
             }
         }
-      
+
         size_t frameIdx;
         for (frameIdx = 0; frameIdx < frameModels.size(); ++frameIdx)
         {
@@ -622,6 +622,35 @@ void RimReservoirView::createDisplayModel()
 
         m_visibleGridParts = geometryTypesToAdd;
     }
+
+    if (!this->propertyFilterCollection()->hasActiveFilters() ||
+        !faultCollection()->limitFaultsToFilter)
+    {
+        std::vector<RivReservoirViewPartMgr::ReservoirGeometryCacheType> faultGeometryTypesToAdd;
+        if (faultCollection()->limitFaultsToFilter)
+        {
+            faultGeometryTypesToAdd = m_visibleGridParts;
+        }
+        else
+        {
+            faultGeometryTypesToAdd.push_back(RivReservoirViewPartMgr::ALL_WELL_CELLS); // Should be all well cells
+            faultGeometryTypesToAdd.push_back(RivReservoirViewPartMgr::ACTIVE);
+
+            if (this->showInactiveCells())
+            {
+                faultGeometryTypesToAdd.push_back(RivReservoirViewPartMgr::INACTIVE);
+            }
+        }
+
+        size_t frameIdx;
+        for (frameIdx = 0; frameIdx < frameModels.size(); ++frameIdx)
+        {
+            for (size_t gtIdx = 0; gtIdx < faultGeometryTypesToAdd.size(); ++gtIdx)
+            {
+                m_reservoirGridPartManager->appendFaultsStaticGeometryPartsToModel(frameModels[frameIdx].p(), faultGeometryTypesToAdd[gtIdx]);
+            }
+        }
+    }
     
     // Compute triangle count, Debug only
 
@@ -683,6 +712,7 @@ void RimReservoirView::createDisplayModel()
 void RimReservoirView::updateCurrentTimeStep()
 {
     std::vector<RivReservoirViewPartMgr::ReservoirGeometryCacheType> geometriesToRecolor;
+    std::vector<RivReservoirViewPartMgr::ReservoirGeometryCacheType> faultGeometriesToRecolor;
 
     if (this->propertyFilterCollection()->hasActiveFilters())
     {
@@ -693,9 +723,17 @@ void RimReservoirView::updateCurrentTimeStep()
 
         geometriesToRecolor.push_back( RivReservoirViewPartMgr::PROPERTY_FILTERED);
         m_reservoirGridPartManager->appendDynamicGeometryPartsToModel(frameParts.p(), RivReservoirViewPartMgr::PROPERTY_FILTERED, m_currentTimeStep, gridIndices);
+        if (faultCollection()->limitFaultsToFilter)
+        {
+            m_reservoirGridPartManager->appendFaultsDynamicGeometryPartsToModel(frameParts.p(), RivReservoirViewPartMgr::PROPERTY_FILTERED, m_currentTimeStep);
+        }
 
         geometriesToRecolor.push_back( RivReservoirViewPartMgr::PROPERTY_FILTERED_WELL_CELLS);
         m_reservoirGridPartManager->appendDynamicGeometryPartsToModel(frameParts.p(), RivReservoirViewPartMgr::PROPERTY_FILTERED_WELL_CELLS, m_currentTimeStep, gridIndices);
+        if (faultCollection()->limitFaultsToFilter)
+        {
+            m_reservoirGridPartManager->appendFaultsDynamicGeometryPartsToModel(frameParts.p(), RivReservoirViewPartMgr::PROPERTY_FILTERED_WELL_CELLS, m_currentTimeStep);
+        }
 
         // Set the transparency on all the Wellcell parts before setting the result color
         float opacity = static_cast< float> (1 - cvf::Math::clamp(this->wellCollection()->wellCellTransparencyLevel(), 0.0, 1.0));
@@ -710,10 +748,20 @@ void RimReservoirView::updateCurrentTimeStep()
             if (this->rangeFilterCollection()->hasActiveFilters() ) // Wells not considered, because we do not have a INACTIVE_WELL_CELLS group yet.
             {
                 m_reservoirGridPartManager->appendStaticGeometryPartsToModel(frameParts.p(), RivReservoirViewPartMgr::RANGE_FILTERED_INACTIVE, gridIndices); 
+
+                if (faultCollection()->limitFaultsToFilter)
+                {
+                    m_reservoirGridPartManager->appendFaultsStaticGeometryPartsToModel(frameParts.p(), RivReservoirViewPartMgr::RANGE_FILTERED_INACTIVE); 
+                }
             }
             else
             {
-                m_reservoirGridPartManager->appendStaticGeometryPartsToModel(frameParts.p(), RivReservoirViewPartMgr::INACTIVE, gridIndices); 
+                m_reservoirGridPartManager->appendStaticGeometryPartsToModel(frameParts.p(), RivReservoirViewPartMgr::INACTIVE, gridIndices);
+
+                if (faultCollection()->limitFaultsToFilter)
+                {
+                    m_reservoirGridPartManager->appendFaultsStaticGeometryPartsToModel(frameParts.p(), RivReservoirViewPartMgr::INACTIVE);
+                }
             }
         }
 
@@ -752,7 +800,6 @@ void RimReservoirView::updateCurrentTimeStep()
         geometriesToRecolor.push_back(RivReservoirViewPartMgr::ACTIVE);
         geometriesToRecolor.push_back(RivReservoirViewPartMgr::ALL_WELL_CELLS);
     }
-    
 
     for (size_t i = 0; i < geometriesToRecolor.size(); ++i)
     {
@@ -770,6 +817,29 @@ void RimReservoirView::updateCurrentTimeStep()
         }
     }
 
+    if (faultCollection()->limitFaultsToFilter)
+    {
+        faultGeometriesToRecolor = geometriesToRecolor;
+    }
+    else
+    {
+        faultGeometriesToRecolor.push_back(RivReservoirViewPartMgr::ALL_WELL_CELLS); // Should be all well cells
+        faultGeometriesToRecolor.push_back(RivReservoirViewPartMgr::ACTIVE);
+    }
+
+    for (size_t i = 0; i < faultGeometriesToRecolor.size(); ++i)
+    {
+        if (this->animationMode() && this->cellResult()->hasResult())
+        {
+            m_reservoirGridPartManager->updateFaultsCellResultColor(faultGeometriesToRecolor[i], m_currentTimeStep, this->cellResult());
+        }
+        else
+        {
+            this->updateStaticCellColors(faultGeometriesToRecolor[i]);
+        }
+    }
+
+
     // Well pipes and well paths
     if (m_viewer)
     {