Improve property linking

* Allow linking of property filters across cases with same IJK size
* Recalculate when grid is replaced
Find dependencies between calculations and order them accordingly

ApplicationLibCode/Application/RiaApplication.cpp

@@ -710,7 +710,7 @@ bool RiaApplication::loadProject( const QString&      projectFileName,
 
     // Recalculate the results from grid property calculations.
     // Has to be done late since the results are filtered by view cell visibility
-    for ( auto gridCalculation : m_project->gridCalculationCollection()->calculations() )
+    for ( auto gridCalculation : m_project->gridCalculationCollection()->sortedGridCalculations() )
     {
         gridCalculation->calculate();
         gridCalculation->updateDependentObjects();

ApplicationLibCode/FileInterface/RifReaderOpmRft.cpp

@@ -778,7 +778,7 @@ void RifReaderOpmRft::identifyAnnulusBranches( RifRftSegment& segmentRef, const
             seglenstForBranch[branchId] = values;
         }
 
-        std::set<size_t> annulusBranchIds;
+        std::set<int> annulusBranchIds;
 
         for ( auto branchId : tubingIds )
         {
@@ -801,7 +801,7 @@ void RifReaderOpmRft::identifyAnnulusBranches( RifRftSegment& segmentRef, const
                 const double distanceTubingAnnulus = 0.1;
                 if ( std::fabs( ( std::fabs( diff ) - distanceTubingAnnulus ) ) < epsilon )
                 {
-                    size_t annulusBranchId = ( diff > 0 ) ? candidateBranchId : branchId;
+                    int annulusBranchId = ( diff > 0 ) ? candidateBranchId : branchId;
 
                     segmentRef.setBranchType( annulusBranchId, RiaDefines::RftBranchType::RFT_ANNULUS );
                     annulusBranchIds.insert( annulusBranchId );
@@ -818,9 +818,9 @@ void RifReaderOpmRft::reassignBranchIndices( RifRftSegment& segmentRef )
 {
     auto tubingBranchIds = segmentRef.tubingBranchIds();
 
-    size_t oneBasedBranchIndex = 1;
+    int oneBasedBranchIndex = 1;
 
-    std::map<size_t, size_t> newOneBasedBranchIndex;
+    std::map<int, int> newOneBasedBranchIndex;
     for ( auto branchId : tubingBranchIds )
     {
         auto previsousIndex                    = segmentRef.oneBasedBranchIndexForBranchId( branchId );

ApplicationLibCode/FileInterface/RifRftSegment.cpp

@@ -381,7 +381,7 @@ int RifRftSegment::segmentIndexFromSegmentNumber( int segmentNumber ) const
     {
         auto segment = m_topology[i];
 
-        if ( segment.segNo() == segmentNumber ) return i;
+        if ( segment.segNo() == segmentNumber ) return static_cast<int>( i );
     }
 
     return -1;

ApplicationLibCode/ProjectDataModel/RimGridCalculation.cpp

@@ -85,7 +85,7 @@ bool RimGridCalculation::calculate()
 {
     QString leftHandSideVariableName = RimGridCalculation::findLeftHandSide( m_expression );
 
-    RimEclipseCase* eclipseCase = destinationEclipseCase();
+    RimEclipseCase* eclipseCase = outputEclipseCase();
     if ( !eclipseCase )
     {
         RiaLogging::errorInMessageBox( nullptr,
@@ -183,7 +183,7 @@ bool RimGridCalculation::calculate()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimEclipseCase* RimGridCalculation::destinationEclipseCase() const
+RimEclipseCase* RimGridCalculation::outputEclipseCase() const
 {
     return m_destinationCase;
 }
@@ -345,6 +345,16 @@ void RimGridCalculation::onVariableUpdated( const SignalEmitter* emitter )
     }
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RigEclipseResultAddress RimGridCalculation::outputAddress() const
+{
+    QString                 leftHandSideVariableName = RimGridCalculation::findLeftHandSide( m_expression );
+    RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::GENERATED, leftHandSideVariableName );
+    return resAddr;
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -469,7 +479,7 @@ void RimGridCalculation::filterResults( RimGridView*
 //--------------------------------------------------------------------------------------------------
 void RimGridCalculation::updateDependentObjects()
 {
-    RimEclipseCase* eclipseCase = destinationEclipseCase();
+    RimEclipseCase* eclipseCase = outputEclipseCase();
     if ( eclipseCase )
     {
         RimReloadCaseTools::updateAll3dViews( eclipseCase );
@@ -487,7 +497,7 @@ void RimGridCalculation::removeDependentObjects()
 
     RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::GENERATED, leftHandSideVariableName );
 
-    RimEclipseCase* eclipseCase = destinationEclipseCase();
+    RimEclipseCase* eclipseCase = outputEclipseCase();
     if ( eclipseCase )
     {
         // Select "None" result if the result that is being removed were displayed in a view.

ApplicationLibCode/ProjectDataModel/RimGridCalculation.h

@@ -27,6 +27,7 @@
 
 class RimEclipseCase;
 class RimGridView;
+class RigEclipseResultAddress;
 
 //==================================================================================================
 ///
@@ -50,7 +51,10 @@ public:
     void updateDependentObjects() override;
     void removeDependentObjects() override;
 
-    RimEclipseCase* destinationEclipseCase() const;
+    RimEclipseCase*         outputEclipseCase() const;
+    RigEclipseResultAddress outputAddress() const;
+
+    std::vector<RimEclipseCase*> inputCases() const;
 
 protected:
     void onChildrenUpdated( caf::PdmChildArrayFieldHandle*      childArray,
@@ -59,8 +63,6 @@ protected:
     RimGridCalculationVariable* createVariable() override;
     std::pair<bool, QString>    validateVariables();
 
-    std::vector<RimEclipseCase*> inputCases() const;
-
     std::vector<double> getInputVectorForVariable( RimGridCalculationVariable*   v,
                                                    size_t                        tsId,
                                                    RiaDefines::PorosityModelType porosityModel ) const;

ApplicationLibCode/ProjectDataModel/RimGridCalculationCollection.cpp

@@ -18,6 +18,8 @@
 
 #include "RimGridCalculationCollection.h"
 
+#include "RiaLogging.h"
+#include "RigEclipseResultAddress.h"
 #include "RimGridCalculation.h"
 
 #include "cafPdmUiGroup.h"
@@ -40,6 +42,59 @@ RimGridCalculation* RimGridCalculationCollection::createCalculation() const
     return new RimGridCalculation;
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+std::vector<RimGridCalculation*> RimGridCalculationCollection::sortedGridCalculations() const
+{
+    std::vector<RimGridCalculation*> sortedCalculations;
+    for ( auto userCalculation : calculations() )
+    {
+        auto gridCalculation = dynamic_cast<RimGridCalculation*>( userCalculation );
+        if ( gridCalculation ) sortedCalculations.emplace_back( gridCalculation );
+    }
+
+    // Check if source calculation is depending on other. Will check one level dependency.
+    auto isSourceDependingOnOther = []( const RimGridCalculation* source, const RimGridCalculation* other ) -> bool {
+        auto outputCase = source->outputEclipseCase();
+        auto outputAdr  = source->outputAddress();
+
+        for ( auto v : other->allVariables() )
+        {
+            auto gridVariable = dynamic_cast<RimGridCalculationVariable*>( v );
+            if ( gridVariable->eclipseCase() == outputCase &&
+                 outputAdr.resultCatType() == gridVariable->resultCategoryType() &&
+                 outputAdr.resultName() == gridVariable->resultVariable() )
+            {
+                return true;
+            }
+        }
+
+        return false;
+    };
+
+    for ( auto source : sortedCalculations )
+    {
+        for ( auto other : sortedCalculations )
+        {
+            if ( source == other ) continue;
+
+            if ( isSourceDependingOnOther( source, other ) && isSourceDependingOnOther( other, source ) )
+            {
+                QString txt = "Detected circular dependency between " + source->description() + " and " +
+                              other->description();
+                RiaLogging::error( txt );
+
+                return sortedCalculations;
+            }
+        }
+    }
+
+    std::sort( sortedCalculations.begin(), sortedCalculations.end(), isSourceDependingOnOther );
+
+    return sortedCalculations;
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimGridCalculationCollection.h

@@ -34,7 +34,8 @@ public:
 
     void rebuildCaseMetaData() override;
 
-    RimGridCalculation* createCalculation() const override;
+    RimGridCalculation*              createCalculation() const override;
+    std::vector<RimGridCalculation*> sortedGridCalculations() const;
 
 private:
     void initAfterRead() override;

ApplicationLibCode/ProjectDataModel/RimReloadCaseTools.cpp

@@ -30,7 +30,10 @@
 #include "RimEclipseContourMapView.h"
 #include "RimEclipseContourMapViewCollection.h"
 #include "RimEclipseView.h"
+#include "RimGridCalculation.h"
+#include "RimGridCalculationCollection.h"
 #include "RimMainPlotCollection.h"
+#include "RimProject.h"
 #include "RimSummaryCaseMainCollection.h"
 
 //--------------------------------------------------------------------------------------------------
@@ -63,6 +66,20 @@ void RimReloadCaseTools::reloadAllEclipseData( RimEclipseCase* eclipseCase, bool
 
     eclipseCase->reloadEclipseGridFile();
 
+    std::vector<RimGridCalculation*> gridCalculations =
+        RimProject::current()->gridCalculationCollection()->sortedGridCalculations();
+
+    for ( auto gridCalculation : gridCalculations )
+    {
+        bool recalculate = false;
+        for ( auto inputCase : gridCalculation->inputCases() )
+        {
+            if ( inputCase == eclipseCase ) recalculate = true;
+        }
+
+        if ( recalculate ) gridCalculation->calculate();
+    }
+
     updateAll3dViews( eclipseCase );
 
     if ( reloadSummaryData )

ApplicationLibCode/ProjectDataModel/RimViewController.cpp

@@ -218,7 +218,7 @@ void RimViewController::fieldChangedByUi( const caf::PdmFieldHandle* changedFiel
     else if ( changedField == &m_managedView )
     {
         PdmObjectHandle* prevValue           = oldValue.value<caf::PdmPointer<PdmObjectHandle>>().rawPtr();
-        RimGridView*     previousManagedView = dynamic_cast<RimGridView*>( prevValue );
+        auto*            previousManagedView = dynamic_cast<RimGridView*>( prevValue );
         RimViewController::removeOverrides( previousManagedView );
 
         ownerViewLinker()->notifyManagedViewChange( previousManagedView, m_managedView() );
@@ -279,7 +279,7 @@ void RimViewController::updateOverrides()
         }
         else
         {
-            RimEclipseView* masterEclipseView = dynamic_cast<RimEclipseView*>( masterView );
+            auto* masterEclipseView = dynamic_cast<RimEclipseView*>( masterView );
             if ( masterEclipseView )
             {
                 if ( manEclView )
@@ -296,7 +296,7 @@ void RimViewController::updateOverrides()
                 }
             }
 
-            RimGeoMechView* masterGeoView = dynamic_cast<RimGeoMechView*>( masterView );
+            auto* masterGeoView = dynamic_cast<RimGeoMechView*>( masterView );
             if ( masterGeoView )
             {
                 if ( manGeoView )
@@ -354,8 +354,8 @@ void RimViewController::removeOverrides( RimGridView* view )
 {
     if ( view )
     {
-        RimEclipseView* manEclView = dynamic_cast<RimEclipseView*>( view );
+        auto* manEclView = dynamic_cast<RimEclipseView*>( view );
-        RimGeoMechView* manGeoView = dynamic_cast<RimGeoMechView*>( view );
+        auto* manGeoView = dynamic_cast<RimGeoMechView*>( view );
 
         if ( manEclView ) manEclView->setOverridePropertyFilterCollection( nullptr );
         if ( manGeoView ) manGeoView->setOverridePropertyFilterCollection( nullptr );
@@ -383,8 +383,8 @@ void RimViewController::updateOptionSensitivity()
         CVF_ASSERT( mainView );
     }
 
-    RimEclipseView* eclipseMasterView = dynamic_cast<RimEclipseView*>( mainView );
+    auto* eclipseMasterView = dynamic_cast<RimEclipseView*>( mainView );
-    RimGeoMechView* geoMasterView     = dynamic_cast<RimGeoMechView*>( mainView );
+    auto* geoMasterView     = dynamic_cast<RimGeoMechView*>( mainView );
 
     bool isMasterAndDependentViewDifferentType = false;
     if ( eclipseMasterView && !managedEclipseView() )
@@ -576,9 +576,9 @@ RimViewLinker* RimViewController::ownerViewLinker() const
 //--------------------------------------------------------------------------------------------------
 const RigCaseToCaseCellMapper* RimViewController::cellMapper()
 {
-    RimEclipseView* masterEclipseView = dynamic_cast<RimEclipseView*>( masterView() );
+    auto*           masterEclipseView = dynamic_cast<RimEclipseView*>( masterView() );
     RimEclipseView* dependEclipseView = managedEclipseView();
-    RimGeoMechView* masterGeomechView = dynamic_cast<RimGeoMechView*>( masterView() );
+    auto*           masterGeomechView = dynamic_cast<RimGeoMechView*>( masterView() );
     RimGeoMechView* dependGeomechView = managedGeoView();
 
     RigMainGrid* masterEclGrid = nullptr;
@@ -616,10 +616,8 @@ const RigCaseToCaseCellMapper* RimViewController::cellMapper()
         {
             return m_caseToCaseCellMapper.p();
         }
-        else
+
-        {
+        m_caseToCaseCellMapper = nullptr;
-            m_caseToCaseCellMapper = nullptr;
-        }
     }
 
     // Create the mapping if needed
@@ -660,8 +658,8 @@ RimGridView* RimViewController::masterView() const
 //--------------------------------------------------------------------------------------------------
 bool RimViewController::isMasterAndDepViewDifferentType() const
 {
-    RimEclipseView* eclipseMasterView = dynamic_cast<RimEclipseView*>( masterView() );
+    auto* eclipseMasterView = dynamic_cast<RimEclipseView*>( masterView() );
-    RimGeoMechView* geoMasterView     = dynamic_cast<RimGeoMechView*>( masterView() );
+    auto* geoMasterView     = dynamic_cast<RimGeoMechView*>( masterView() );
 
     bool isMasterAndDependentViewDifferentType = false;
     if ( eclipseMasterView && !managedEclipseView() )
@@ -737,10 +735,8 @@ bool RimViewController::isCameraLinked() const
     {
         return m_syncCamera;
     }
-    else
+
-    {
+    return false;
-        return false;
-    }
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -760,10 +756,8 @@ bool RimViewController::isTimeStepLinked() const
     {
         return m_syncTimeStep;
     }
-    else
+
-    {
+    return false;
-        return false;
-    }
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -775,10 +769,8 @@ bool RimViewController::isResultColorControlled() const
     {
         return m_syncCellResult;
     }
-    else
+
-    {
+    return false;
-        return false;
-    }
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -790,10 +782,8 @@ bool RimViewController::isLegendDefinitionsControlled() const
     {
         return m_syncLegendDefinitions;
     }
-    else
+
-    {
+    return false;
-        return false;
-    }
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -807,15 +797,11 @@ bool RimViewController::isVisibleCellsOveridden() const
         {
             return m_syncVisibleCells();
         }
-        else
+
-        {
-            return false;
-        }
-    }
-    else
-    {
         return false;
     }
+
+    return false;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -826,8 +812,8 @@ bool RimViewController::isCellFilterMappingApplicable() const
     if ( !isMasterAndDepViewDifferentType() ) return false;
 
     // Make sure the cases are in the same domain
-    RimEclipseView* eclipseView = dynamic_cast<RimEclipseView*>( masterView() );
+    auto* eclipseView = dynamic_cast<RimEclipseView*>( masterView() );
-    RimGeoMechView* geomView    = dynamic_cast<RimGeoMechView*>( masterView() );
+    auto* geomView    = dynamic_cast<RimGeoMechView*>( masterView() );
     if ( !geomView ) geomView = managedGeoView();
     if ( !eclipseView ) eclipseView = managedEclipseView();
 
@@ -890,10 +876,8 @@ bool RimViewController::isCellFiltersControlled() const
     {
         return m_syncCellFilters;
     }
-    else
+
-    {
+    return false;
-        return false;
-    }
 }
 //--------------------------------------------------------------------------------------------------
 ///
@@ -901,7 +885,7 @@ bool RimViewController::isCellFiltersControlled() const
 bool RimViewController::isPropertyFilterControlPossible() const
 {
     // The cases need to be the same
-    RimGeoMechView* geomView = dynamic_cast<RimGeoMechView*>( masterView() );
+    auto* geomView = dynamic_cast<RimGeoMechView*>( masterView() );
 
     if ( geomView )
     {
@@ -912,12 +896,11 @@ bool RimViewController::isPropertyFilterControlPossible() const
         }
     }
 
-    RimEclipseView* eclipseView = dynamic_cast<RimEclipseView*>( masterView() );
+    auto* eclipseView = dynamic_cast<RimEclipseView*>( masterView() );
-
     if ( eclipseView )
     {
         RimEclipseView* depEclipseView = managedEclipseView();
-        if ( depEclipseView && eclipseView->eclipseCase() == depEclipseView->eclipseCase() )
+        if ( depEclipseView && eclipseView->eclipseCase()->isGridSizeEqualTo( depEclipseView->eclipseCase() ) )
         {
             return true;
         }
@@ -937,10 +920,8 @@ bool RimViewController::isPropertyFilterOveridden() const
     {
         return m_syncPropertyFilters;
     }
-    else
+
-    {
+    return false;
-        return false;
-    }
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -963,7 +944,7 @@ void RimViewController::updateCellFilterOverrides( const RimCellFilter* changedF
         PdmXmlObjectHandle::readUnknownObjectFromXmlString( xmlFilterCollCopy,
                                                             caf::PdmDefaultObjectFactory::instance(),
                                                             true );
-    RimCellFilterCollection* overrideFilterColl = dynamic_cast<RimCellFilterCollection*>( objectCopy );
+    auto* overrideFilterColl = dynamic_cast<RimCellFilterCollection*>( objectCopy );
 
     std::vector<RimCellFilter*> srcFilters  = sourceFilterCollection->filters();
     std::vector<RimCellFilter*> dstFilters  = overrideFilterColl->filters();
@@ -973,8 +954,8 @@ void RimViewController::updateCellFilterOverrides( const RimCellFilter* changedF
     // Convert the cell filter to fit in the managed view if needed
     if ( isCellFilterMappingApplicable() )
     {
-        RimEclipseView* eclipseMasterView = dynamic_cast<RimEclipseView*>( masterView() );
+        auto* eclipseMasterView = dynamic_cast<RimEclipseView*>( masterView() );
-        RimGeoMechView* geoMasterView     = dynamic_cast<RimGeoMechView*>( masterView() );
+        auto* geoMasterView     = dynamic_cast<RimGeoMechView*>( masterView() );
 
         if ( eclipseMasterView && depGeomView )
         {
@@ -987,8 +968,8 @@ void RimViewController::updateCellFilterOverrides( const RimCellFilter* changedF
                 {
                     overrideFilterColl->connectToFilterUpdates( dstFilters[rfIdx] );
 
-                    RimCellRangeFilter* srcRFilter = dynamic_cast<RimCellRangeFilter*>( srcFilters[rfIdx] );
+                    auto* srcRFilter = dynamic_cast<RimCellRangeFilter*>( srcFilters[rfIdx] );
-                    RimCellRangeFilter* dstRFilter = dynamic_cast<RimCellRangeFilter*>( dstFilters[rfIdx] );
+                    auto* dstRFilter = dynamic_cast<RimCellRangeFilter*>( dstFilters[rfIdx] );
 
                     if ( ( srcRFilter != nullptr ) && ( dstRFilter != nullptr ) )
                     {
@@ -1044,11 +1025,11 @@ void RimViewController::updateCellFilterOverrides( const RimCellFilter* changedF
     }
     else
     {
-        for ( size_t rfIdx = 0; rfIdx < dstFilters.size(); ++rfIdx )
+        for ( auto& dstFilter : dstFilters )
         {
-            overrideFilterColl->connectToFilterUpdates( dstFilters[rfIdx] );
+            overrideFilterColl->connectToFilterUpdates( dstFilter );
 
-            RimPolygonFilter* polyDstFilter = dynamic_cast<RimPolygonFilter*>( dstFilters[rfIdx] );
+            RimPolygonFilter* polyDstFilter = dynamic_cast<RimPolygonFilter*>( dstFilter );
             if ( polyDstFilter != nullptr )
             {
                 RimCase* theCase = nullptr;
@@ -1127,8 +1108,6 @@ bool RimViewController::askUserToRestoreOriginalCellFilterCollection( const QStr
     {
         return false;
     }
-    else
+
-    {
+    return true;
-        return true;
-    }
 }

ApplicationLibCode/ReservoirDataModel/RigCaseCellResultsData.cpp

@@ -2906,7 +2906,7 @@ void RigCaseCellResultsData::computeCompletionTypeForTimeStep( size_t timeStep )
         for ( auto userCalculation : RimProject::current()->gridCalculationCollection()->calculations() )
         {
             auto gridCalculation = dynamic_cast<RimGridCalculation*>( userCalculation );
-            if ( gridCalculation && gridCalculation->destinationEclipseCase() != eclipseCase ) continue;
+            if ( gridCalculation && gridCalculation->outputEclipseCase() != eclipseCase ) continue;
 
             QString generatedPropertyName = userCalculation->findLeftHandSide( userCalculation->expression() );
             if ( generatedPropertyName == propertyName )