Faults: Improved forced visibility control of faults. Renaming.

ApplicationCode/ModelVisualization/RivReservoirFaultsPartMgr.cpp

@@ -45,7 +45,7 @@ RivReservoirFaultsPartMgr::RivReservoirFaultsPartMgr(const RigMainGrid* grid,  c
         }
     }
 
-    m_isFilterGenerated = false;
+    m_forceVisibility = false;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -101,9 +101,8 @@ void RivReservoirFaultsPartMgr::appendPartsToModel(cvf::ModelBasicList* model)
         CVF_ASSERT(rivFaultPart.notNull());
 
         // Parts that is overridden by the grid settings
-
+        bool forceDisplayOfFault = isShowingGrid;
-        bool forceDisplayOfFault = false;
+        if (m_forceVisibility)
-        if (isShowingGrid && m_isFilterGenerated)
         {
             forceDisplayOfFault = true;
         }
@@ -160,7 +159,7 @@ void RivReservoirFaultsPartMgr::applySingleColorEffect()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RivReservoirFaultsPartMgr::updateCellResultColor(size_t timeStepIndex, RimResultSlot* cellResultSlot)
+void RivReservoirFaultsPartMgr::updateColors(size_t timeStepIndex, RimResultSlot* cellResultSlot)
 {
     if (m_faultCollection->showResultsOnFaults())
     {
@@ -229,8 +228,8 @@ void RivReservoirFaultsPartMgr::appendLabelPartsToModel(cvf::ModelBasicList* mod
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RivReservoirFaultsPartMgr::setGeneratedByFilter(bool isFilterGenerated)
+void RivReservoirFaultsPartMgr::setFaultForceVisibility(bool forceVisibility)
 {
-    m_isFilterGenerated = isFilterGenerated;
+    m_forceVisibility = forceVisibility;
 }
 

ApplicationCode/ModelVisualization/RivReservoirFaultsPartMgr.h

@@ -44,10 +44,10 @@ public:
 
     void setTransform(cvf::Transform* scaleTransform);
     void setCellVisibility(cvf::UByteArray* cellVisibilities);
-    void setGeneratedByFilter(bool isFilterGenerated);
+    void setFaultForceVisibility(bool isFilterGenerated);
 
     void applySingleColorEffect();
-    void updateCellResultColor(size_t timeStepIndex, RimResultSlot* cellResultSlot);
+    void updateColors(size_t timeStepIndex, RimResultSlot* cellResultSlot);
     void updateCellEdgeResultColor(size_t timeStepIndex, RimResultSlot* cellResultSlot, 
         RimCellEdgeResultSlot* cellEdgeResultSlot);
 
@@ -60,5 +60,5 @@ private:
     cvf::ref<cvf::Transform>            m_scaleTransform;
     const RimFaultCollection*           m_faultCollection;
     cvf::Collection<RivFaultPartMgr>    m_faultParts;
-    bool                                m_isFilterGenerated;    // This fault geometry is created based on either range filter or property filter
+    bool                                m_forceVisibility;
 };

ApplicationCode/ModelVisualization/RivReservoirPartMgr.cpp

@@ -152,11 +152,11 @@ void RivReservoirPartMgr::appendGridPartsToModel(cvf::ModelBasicList* model, con
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RivReservoirPartMgr::updateFaultCellResultColor(size_t timeStepIndex, RimResultSlot* cellResultSlot)
+void RivReservoirPartMgr::updateFaultColors(size_t timeStepIndex, RimResultSlot* cellResultSlot)
 {
     if (m_faultsPartMgr.notNull())
     {
-        m_faultsPartMgr->updateCellResultColor(timeStepIndex, cellResultSlot);
+        m_faultsPartMgr->updateColors(timeStepIndex, cellResultSlot);
     }
 }
 
@@ -185,11 +185,11 @@ void RivReservoirPartMgr::appendFaultLabelPartsToModel(cvf::ModelBasicList* mode
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RivReservoirPartMgr::setGeneratedByFilter(bool isGeneratedByFilter)
+void RivReservoirPartMgr::setFaultForceVisibility(bool isGeneratedByFilter)
 {
     if (m_faultsPartMgr.notNull())
     {
-        m_faultsPartMgr->setGeneratedByFilter(isGeneratedByFilter);
+        m_faultsPartMgr->setFaultForceVisibility(isGeneratedByFilter);
     }
 }
 

ApplicationCode/ModelVisualization/RivReservoirPartMgr.h

@@ -48,7 +48,7 @@ public:
     void   clearAndSetReservoir(const RigCaseData* eclipseCase, const RimFaultCollection* faultCollection);
     void   setTransform(cvf::Transform* scaleTransform);
     void   setCellVisibility(size_t gridIndex, cvf::UByteArray* cellVisibilities );
-    void   setGeneratedByFilter(bool isGeneratedByFilter);
+    void   setFaultForceVisibility(bool isGeneratedByFilter);
 
     //size_t gridCount() { return m_allGrids.size(); }
     cvf::ref<cvf::UByteArray>  
@@ -63,7 +63,7 @@ public:
     void   appendGridPartsToModel(cvf::ModelBasicList* model);
 
     // Faults
-    void   updateFaultCellResultColor(size_t timeStepIndex, RimResultSlot* cellResultSlot);
+    void   updateFaultColors(size_t timeStepIndex, RimResultSlot* cellResultSlot);
     void   appendFaultPartsToModel(cvf::ModelBasicList* model);
     void   appendFaultLabelPartsToModel(cvf::ModelBasicList* model);
 private:

ApplicationCode/ModelVisualization/RivReservoirViewPartMgr.cpp

@@ -240,7 +240,6 @@ void RivReservoirViewPartMgr::createGeometry(ReservoirGeometryCacheType geometry
     RigCaseData* res = m_reservoirView->eclipseCase()->reservoirData();
     m_geometries[geometryType].clearAndSetReservoir(res, m_reservoirView->faultCollection());
     m_geometries[geometryType].setTransform(m_scaleTransform.p());
-    setGeneratedByFilterFromGeometryType(&m_geometries[geometryType], geometryType);
     
     std::vector<RigGridBase*> grids;
     res->allGrids(&grids);
@@ -397,7 +396,6 @@ void RivReservoirViewPartMgr::createPropertyFilteredNoneWellCellGeometry(size_t
 
     m_propFilteredGeometryFrames[frameIndex]->clearAndSetReservoir(res, m_reservoirView->faultCollection());
     m_propFilteredGeometryFrames[frameIndex]->setTransform(m_scaleTransform.p());
-    setGeneratedByFilterFromGeometryType(m_propFilteredGeometryFrames[frameIndex].p(), PROPERTY_FILTERED);
 
     std::vector<RigGridBase*> grids;
     res->allGrids(&grids);
@@ -475,7 +473,6 @@ void RivReservoirViewPartMgr::createPropertyFilteredWellGeometry(size_t frameInd
 
     m_propFilteredWellGeometryFrames[frameIndex]->clearAndSetReservoir(res, m_reservoirView->faultCollection());
     m_propFilteredWellGeometryFrames[frameIndex]->setTransform(m_scaleTransform.p());
-    setGeneratedByFilterFromGeometryType(m_propFilteredWellGeometryFrames[frameIndex].p(), PROPERTY_FILTERED_WELL_CELLS);
 
     std::vector<RigGridBase*> grids;
     res->allGrids(&grids);
@@ -826,10 +823,10 @@ RivReservoirPartMgr * RivReservoirViewPartMgr::reservoirPartManager(ReservoirGeo
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RivReservoirViewPartMgr::updateFaultsCellResultColor(ReservoirGeometryCacheType geometryType, size_t timeStepIndex, RimResultSlot* cellResultSlot)
+void RivReservoirViewPartMgr::updateFaultColors(ReservoirGeometryCacheType geometryType, size_t timeStepIndex, RimResultSlot* cellResultSlot)
 {
     RivReservoirPartMgr* pmgr = reservoirPartManager(geometryType, timeStepIndex);
-    pmgr->updateFaultCellResultColor(timeStepIndex, cellResultSlot);
+    pmgr->updateFaultColors(timeStepIndex, cellResultSlot);
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -907,22 +904,6 @@ void RivReservoirViewPartMgr::appendFaultLabelsDynamicGeometryPartsToModel(cvf::
     m_propFilteredGeometryFrames[frameIndex]->appendFaultLabelPartsToModel(model);
 }
 
-//--------------------------------------------------------------------------------------------------
-/// 
-//--------------------------------------------------------------------------------------------------
-void RivReservoirViewPartMgr::setGeneratedByFilterFromGeometryType(RivReservoirPartMgr* reservoirPartManager, ReservoirGeometryCacheType cacheType)
-{
-    CVF_ASSERT(reservoirPartManager);
-
-    if (cacheType == RANGE_FILTERED ||
-        cacheType == RANGE_FILTERED_INACTIVE ||
-        cacheType == RANGE_FILTERED_WELL_CELLS ||
-        cacheType == PROPERTY_FILTERED ||
-        cacheType == PROPERTY_FILTERED_WELL_CELLS)
-    {
-        reservoirPartManager->setGeneratedByFilter(true);
-    }
-}
 
 //--------------------------------------------------------------------------------------------------
 /// 
@@ -942,3 +923,11 @@ std::vector<RivReservoirViewPartMgr::ReservoirGeometryCacheType> RivReservoirVie
 
     return types;
 }
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RivReservoirViewPartMgr::setFaultForceVisibilityForGeometryType(ReservoirGeometryCacheType geometryType, bool forceVisibility)
+{
+    m_geometries[geometryType].setFaultForceVisibility(forceVisibility);
+}

ApplicationCode/ModelVisualization/RivReservoirViewPartMgr.h

@@ -71,7 +71,7 @@ public:
     // 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);
+    void                        updateFaultColors(ReservoirGeometryCacheType geometryType, size_t timeStepIndex, RimResultSlot* cellResultSlot);
 
     // Fault labels
     ReservoirGeometryCacheType  geometryTypeForFaultLabels(const std::vector<ReservoirGeometryCacheType>& geometryTypes) const;
@@ -80,6 +80,8 @@ public:
 
     static std::vector<ReservoirGeometryCacheType> defaultVisibleFaultTypes();
 
+    void                        setFaultForceVisibilityForGeometryType(ReservoirGeometryCacheType geometryType, bool forceVisibility);
+
 private:
     void                        createGeometry(ReservoirGeometryCacheType geometryType);
     void                        computeVisibility(cvf::UByteArray* cellVisibility, ReservoirGeometryCacheType geometryType, RigGridBase* grid, size_t gridIdx);
@@ -97,8 +99,6 @@ private:
 
     RivReservoirPartMgr *       reservoirPartManager(ReservoirGeometryCacheType geometryType, size_t timeStepIndex );
 
-    void                        setGeneratedByFilterFromGeometryType(RivReservoirPartMgr* reservoirPartManager, ReservoirGeometryCacheType cacheType);
-    
 
 private:
     caf::FixedArray<RivReservoirPartMgr, PROPERTY_FILTERED> m_geometries;

ApplicationCode/ProjectDataModel/RimReservoirView.cpp

@@ -631,45 +631,11 @@ void RimReservoirView::createDisplayModel()
 
     if (!this->propertyFilterCollection()->hasActiveFilters() || faultCollection()->showFaultsOutsideFilters)
     {
-        std::vector<RivReservoirViewPartMgr::ReservoirGeometryCacheType> faultGeometryTypesToAppend;
+        std::vector<RivReservoirViewPartMgr::ReservoirGeometryCacheType> faultGeometryTypesToAppend = visibleFaultParts();
-        if (!faultCollection()->showFaultsOutsideFilters)
-        {
-            if (this->rangeFilterCollection()->hasActiveFilters())
-            {
-                faultGeometryTypesToAppend.push_back(RivReservoirViewPartMgr::RANGE_FILTERED);
-                faultGeometryTypesToAppend.push_back(RivReservoirViewPartMgr::RANGE_FILTERED_WELL_CELLS);
-
-                if (this->showInactiveCells())
-                {
-                    faultGeometryTypesToAppend.push_back(RivReservoirViewPartMgr::RANGE_FILTERED_INACTIVE);
-                }
-            }
-            else
-            {
-                faultGeometryTypesToAppend = RivReservoirViewPartMgr::defaultVisibleFaultTypes();
-
-                if (this->showInactiveCells())
-                {
-                    faultGeometryTypesToAppend.push_back(RivReservoirViewPartMgr::INACTIVE);
-                }
-            }
-
-
-        }
-        else
-        {
-            faultGeometryTypesToAppend = RivReservoirViewPartMgr::defaultVisibleFaultTypes();
-
-            if (this->showInactiveCells())
-            {
-                faultGeometryTypesToAppend.push_back(RivReservoirViewPartMgr::INACTIVE);
-            }
-        }
 
         RivReservoirViewPartMgr::ReservoirGeometryCacheType faultLabelType = m_reservoirGridPartManager->geometryTypeForFaultLabels(faultGeometryTypesToAppend);
 
-        size_t frameIdx;
+        for (size_t frameIdx = 0; frameIdx < frameModels.size(); ++frameIdx)
-        for (frameIdx = 0; frameIdx < frameModels.size(); ++frameIdx)
         {
             for (size_t gtIdx = 0; gtIdx < faultGeometryTypesToAppend.size(); ++gtIdx)
             {
@@ -678,6 +644,8 @@ void RimReservoirView::createDisplayModel()
 
             m_reservoirGridPartManager->appendFaultLabelsStaticGeometryPartsToModel(frameModels[frameIdx].p(), faultLabelType);
         }
+
+        updateFaultForcedVisibility();
     }
     
     // Compute triangle count, Debug only
@@ -756,12 +724,7 @@ void RimReservoirView::updateCurrentTimeStep()
 
         if (faultCollection()->showFaultsOutsideFilters)
         {
-            std::vector<RivReservoirViewPartMgr::ReservoirGeometryCacheType> faultGeometryTypesToAppend = RivReservoirViewPartMgr::defaultVisibleFaultTypes();
+            std::vector<RivReservoirViewPartMgr::ReservoirGeometryCacheType> faultGeometryTypesToAppend = visibleFaultParts();
-
-            if (this->showInactiveCells())
-            {
-                faultGeometryTypesToAppend.push_back(RivReservoirViewPartMgr::INACTIVE);
-            }
 
             for (size_t i = 0; i < faultGeometryTypesToAppend.size(); i++)
             {
@@ -876,14 +839,7 @@ void RimReservoirView::updateCurrentTimeStep()
 
     for (size_t i = 0; i < faultGeometriesToRecolor.size(); ++i)
     {
-        if (this->animationMode() && this->cellResult()->hasResult())
+        m_reservoirGridPartManager->updateFaultColors(faultGeometriesToRecolor[i], m_currentTimeStep, this->cellResult());
-        {
-            m_reservoirGridPartManager->updateFaultsCellResultColor(faultGeometriesToRecolor[i], m_currentTimeStep, this->cellResult());
-        }
-        else
-        {
-            this->updateStaticCellColors(faultGeometriesToRecolor[i]);
-        }
     }
 
 
@@ -1932,3 +1888,90 @@ void RimReservoirView::appendNNCResultInfo(size_t nncIndex, QString* resultInfo)
     }
 }
 
+//--------------------------------------------------------------------------------------------------
+///     
+//--------------------------------------------------------------------------------------------------
+void RimReservoirView::updateFaultForcedVisibility()
+{
+    // Force visibility of faults based on application state
+    // As fault geometry is visible in grid visualization mode, fault geometry must be forced visible
+    // even if the fault item is disabled in project tree view
+
+    caf::FixedArray<bool, RivReservoirViewPartMgr::PROPERTY_FILTERED> forceOn;
+
+    for (size_t i = 0; i < RivReservoirViewPartMgr::PROPERTY_FILTERED; i++)
+    {
+        forceOn[i] = false;
+    }
+
+    std::vector<RivReservoirViewPartMgr::ReservoirGeometryCacheType> faultParts = visibleFaultParts();
+    for (size_t i = 0; i < faultParts.size(); i++)
+    {
+        forceOn[faultParts[i]];
+    }
+
+    for (size_t i = 0; i < RivReservoirViewPartMgr::PROPERTY_FILTERED; i++)
+    {
+        RivReservoirViewPartMgr::ReservoirGeometryCacheType cacheType = (RivReservoirViewPartMgr::ReservoirGeometryCacheType)i;
+
+        m_reservoirGridPartManager->setFaultForceVisibilityForGeometryType(cacheType, forceOn[i]);
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+std::vector<RivReservoirViewPartMgr::ReservoirGeometryCacheType> RimReservoirView::visibleFaultParts() const
+{
+    std::vector<RivReservoirViewPartMgr::ReservoirGeometryCacheType> faultParts;
+
+    if (this->faultCollection()->showFaultsOutsideFilters())
+    {
+        faultParts.push_back(RivReservoirViewPartMgr::ACTIVE);
+        faultParts.push_back(RivReservoirViewPartMgr::ALL_WELL_CELLS);
+        faultParts.push_back(RivReservoirViewPartMgr::RANGE_FILTERED);
+        faultParts.push_back(RivReservoirViewPartMgr::RANGE_FILTERED_WELL_CELLS);
+        faultParts.push_back(RivReservoirViewPartMgr::VISIBLE_WELL_CELLS_OUTSIDE_RANGE_FILTER);
+        faultParts.push_back(RivReservoirViewPartMgr::VISIBLE_WELL_FENCE_CELLS_OUTSIDE_RANGE_FILTER);
+
+        if (this->showInactiveCells())
+        {
+            faultParts.push_back(RivReservoirViewPartMgr::INACTIVE);
+            faultParts.push_back(RivReservoirViewPartMgr::RANGE_FILTERED_INACTIVE);
+        }
+    }
+    else if (this->rangeFilterCollection()->hasActiveFilters() && this->wellCollection()->hasVisibleWellCells())
+    {
+        faultParts.push_back(RivReservoirViewPartMgr::RANGE_FILTERED);
+        faultParts.push_back(RivReservoirViewPartMgr::RANGE_FILTERED_WELL_CELLS);
+        faultParts.push_back(RivReservoirViewPartMgr::VISIBLE_WELL_CELLS_OUTSIDE_RANGE_FILTER);
+        faultParts.push_back(RivReservoirViewPartMgr::VISIBLE_WELL_FENCE_CELLS_OUTSIDE_RANGE_FILTER);
+
+        if (this->showInactiveCells())
+        {
+            faultParts.push_back(RivReservoirViewPartMgr::RANGE_FILTERED_INACTIVE);
+        }
+    }
+    else if (!this->rangeFilterCollection()->hasActiveFilters() && this->wellCollection()->hasVisibleWellCells())
+    {
+        faultParts.push_back(RivReservoirViewPartMgr::VISIBLE_WELL_CELLS);
+        faultParts.push_back(RivReservoirViewPartMgr::VISIBLE_WELL_FENCE_CELLS);
+    }
+    else if (this->rangeFilterCollection()->hasActiveFilters() && !this->wellCollection()->hasVisibleWellCells())
+    {
+        faultParts.push_back(RivReservoirViewPartMgr::RANGE_FILTERED);
+        faultParts.push_back(RivReservoirViewPartMgr::RANGE_FILTERED_WELL_CELLS);
+
+        if (this->showInactiveCells())
+        {
+            faultParts.push_back(RivReservoirViewPartMgr::RANGE_FILTERED_INACTIVE);
+        }
+    }
+    else
+    {
+        faultParts.push_back(RivReservoirViewPartMgr::ACTIVE);
+        faultParts.push_back(RivReservoirViewPartMgr::ALL_WELL_CELLS);
+    }
+
+    return faultParts;
+}

ApplicationCode/ProjectDataModel/RimReservoirView.h

@@ -190,6 +190,10 @@ private:
     void                                    updateStaticCellColors(unsigned short geometryType);
     void                                    updateLegends();
 
+    std::vector<RivReservoirViewPartMgr::ReservoirGeometryCacheType> visibleFaultParts() const;
+    void                                    updateFaultForcedVisibility();
+
+
     cvf::ref<RivReservoirViewPartMgr>       m_reservoirGridPartManager;
     cvf::ref<RivReservoirPipesPartMgr>      m_pipesPartManager;