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

Improve property linking

Browse Source 
* Allow linking of property filters across cases with same IJK size
* Recalculate when grid is replaced
Find dependencies between calculations and order them accordingly
This commit is contained in:
Magne Sjaastad 2022-11-22 10:22:17 +01:00 committed by GitHub
parent 10d5246644
commit a74b168e03
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 143 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ApplicationLibCode/Application/RiaApplication.cpp
View File

@ -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();

8
ApplicationLibCode/FileInterface/RifReaderOpmRft.cpp
View File

@ -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 );

2
ApplicationLibCode/FileInterface/RifRftSegment.cpp
View File

@ -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;

18
ApplicationLibCode/ProjectDataModel/RimGridCalculation.cpp
View File

@ -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.

8
ApplicationLibCode/ProjectDataModel/RimGridCalculation.h
View File

@ -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;

55
ApplicationLibCode/ProjectDataModel/RimGridCalculationCollection.cpp
View File

@ -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;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

3
ApplicationLibCode/ProjectDataModel/RimGridCalculationCollection.h
View File

@ -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;

17
ApplicationLibCode/ProjectDataModel/RimReloadCaseTools.cpp
View File

@ -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 )

107
ApplicationLibCode/ProjectDataModel/RimViewController.cpp
View File

@ -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 );
RimGeoMechView* manGeoView = dynamic_cast<RimGeoMechView*>( view );
auto* manEclView = dynamic_cast<RimEclipseView*>( 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 );
RimGeoMechView* geoMasterView = dynamic_cast<RimGeoMechView*>( mainView );
auto* eclipseMasterView = dynamic_cast<RimEclipseView*>( 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() );
RimGeoMechView* geoMasterView = dynamic_cast<RimGeoMechView*>( masterView() );
auto* eclipseMasterView = dynamic_cast<RimEclipseView*>( 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() );
RimGeoMechView* geomView = dynamic_cast<RimGeoMechView*>( masterView() );
auto* eclipseView = dynamic_cast<RimEclipseView*>( 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() );
RimGeoMechView* geoMasterView = dynamic_cast<RimGeoMechView*>( masterView() );
auto* eclipseMasterView = dynamic_cast<RimEclipseView*>( 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] );
RimCellRangeFilter* dstRFilter = dynamic_cast<RimCellRangeFilter*>( dstFilters[rfIdx] );
auto* srcRFilter = dynamic_cast<RimCellRangeFilter*>( srcFilters[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;
}

2
ApplicationLibCode/ReservoirDataModel/RigCaseCellResultsData.cpp
View File

@ -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 )