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 grid cell calculator

Browse Source 
* Use full name for grid case view
* FIx signed / unsigned issue
* Support drag/drop of file names into Main Window
* Add function to check if two grid cases are of equal size
* Result Info: Show cell result text for all linked views
* Improve how to specify cells to be included in calculation

- move view filter to calculation
- improve how to assign values to non-visible cells
- avoid computation between grids of different size

Closes #9482
This commit is contained in:
Magne Sjaastad
2022-11-17 15:51:01 +01:00
committed by GitHub
parent ffc3830110
commit e7c864c6d8
18 changed files with 392 additions and 180 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
ApplicationLibCode/ProjectDataModel/RimEclipseCase.cpp
View File

@@ -36,6 +36,7 @@
#include "RigActiveCellInfo.h"
#include "RigCaseCellResultsData.h"
#include "RigEclipseCaseData.h"
#include "RigGridManager.h"
#include "RigMainGrid.h"
#include "RigNNCData.h"
#include "RigSimWellData.h"
@@ -270,6 +271,19 @@ const RigMainGrid* RimEclipseCase::mainGrid() const
return nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimEclipseCase::isGridSizeEqualTo( const RimEclipseCase* otherCase ) const
{
if ( !mainGrid() || !otherCase || !otherCase->mainGrid() )
{
return false;
}
return RigGridManager::isMainGridDimensionsEqual( mainGrid(), otherCase->mainGrid() );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

1
ApplicationLibCode/ProjectDataModel/RimEclipseCase.h
View File

@@ -83,6 +83,7 @@ public:
cvf::Color3f defaultWellColor( const QString& wellName );
const RigMainGrid* mainGrid() const;
bool isGridSizeEqualTo( const RimEclipseCase* otherCase ) const;
RigCaseCellResultsData* results( RiaDefines::PorosityModelType porosityModel );
const RigCaseCellResultsData* results( RiaDefines::PorosityModelType porosityModel ) const;

246
ApplicationLibCode/ProjectDataModel/RimGridCalculation.cpp
View File

@@ -26,10 +26,13 @@
#include "RimEclipseCellColors.h"
#include "RimEclipseView.h"
#include "RimGridCalculationVariable.h"
#include "RimProject.h"
#include "RimReloadCaseTools.h"
#include "RimTools.h"
#include "RigCaseCellResultsData.h"
#include "RigEclipseResultAddress.h"
#include "RigGridManager.h"
#include "RigMainGrid.h"
#include "RigResultAccessor.h"
#include "RigResultAccessorFactory.h"
@@ -38,20 +41,41 @@
CAF_PDM_SOURCE_INIT( RimGridCalculation, "RimGridCalculation" );
namespace caf
{
template <>
void caf::AppEnum<RimGridCalculation::DefaultValueType>::setUp()
{
addItem( RimGridCalculation::DefaultValueType::POSITIVE_INFINITY, "POSITIVE_INFINITY", "Infinity" );
addItem( RimGridCalculation::DefaultValueType::FROM_PROPERTY, "FROM_PROPERTY", "Property Value" );
addItem( RimGridCalculation::DefaultValueType::USER_DEFINED, "USER_DEFINED", "User Defined Custom Value" );
setDefault( RimGridCalculation::DefaultValueType::POSITIVE_INFINITY );
}
}; // namespace caf
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimGridCalculation::RimGridCalculation()
{
CAF_PDM_InitObject( "RimGridCalculation", ":/octave.png", "Calculation", "" );
CAF_PDM_InitFieldNoDefault( &m_cellFilterView, "VisibleCellView", "Filter by 3d View Visibility" );
CAF_PDM_InitFieldNoDefault( &m_defaultValueType, "DefaultValueType", "Non-visible Cell Value" );
CAF_PDM_InitField( &m_defaultValue, "DefaultValue", 0.0, "Custom Value" );
CAF_PDM_InitFieldNoDefault( &m_destinationCase, "DestinationCase", "Destination Case" );
CAF_PDM_InitField( &m_defaultPropertyVariableIndex, "DefaultPropertyVariableName", 0, "Property Variable Name" );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimGridCalculationVariable* RimGridCalculation::createVariable() const
RimGridCalculationVariable* RimGridCalculation::createVariable()
{
return new RimGridCalculationVariable;
auto variable = new RimGridCalculationVariable;
variable->eclipseResultChanged.connect( this, &RimGridCalculation::onVariableUpdated );
return variable;
}
//--------------------------------------------------------------------------------------------------
@@ -61,7 +85,7 @@ bool RimGridCalculation::calculate()
{
QString leftHandSideVariableName = RimGridCalculation::findLeftHandSide( m_expression );
RimEclipseCase* eclipseCase = findEclipseCaseFromVariables();
RimEclipseCase* eclipseCase = destinationEclipseCase();
if ( !eclipseCase )
{
RiaLogging::errorInMessageBox( nullptr,
@@ -77,6 +101,17 @@ bool RimGridCalculation::calculate()
return false;
}
for ( auto variableCase : inputCases() )
{
if ( !eclipseCase->isGridSizeEqualTo( variableCase ) )
{
QString msg = "Detected IJK mismatch between input cases and destination case. All grid "
"cases must have identical IJK sizes.";
RiaLogging::errorInMessageBox( nullptr, "Grid Property Calculator", msg );
return false;
}
}
auto porosityModel = RiaDefines::PorosityModelType::MATRIX_MODEL;
RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::GENERATED, leftHandSideVariableName );
@@ -121,12 +156,9 @@ bool RimGridCalculation::calculate()
if ( evaluatedOk )
{
auto [cellFilterView, defaultValueConfig] = findFilterValuesFromVariables();
if ( cellFilterView )
if ( m_cellFilterView() )
{
auto [defaultValueType, defaultValue] = defaultValueConfig;
filterResults( cellFilterView, values, defaultValueType, defaultValue, resultValues );
filterResults( m_cellFilterView(), values, m_defaultValueType(), m_defaultValue(), resultValues );
}
scalarResultFrames->at( tsId ) = resultValues;
@@ -151,51 +183,166 @@ bool RimGridCalculation::calculate()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimEclipseCase* RimGridCalculation::findEclipseCaseFromVariables() const
RimEclipseCase* RimGridCalculation::destinationEclipseCase() const
{
for ( auto variable : m_variables )
{
RimGridCalculationVariable* v = dynamic_cast<RimGridCalculationVariable*>( variable.p() );
CAF_ASSERT( v != nullptr );
if ( v->eclipseCase() ) return v->eclipseCase();
}
return nullptr;
return m_destinationCase;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<RimGridView*, RimGridCalculationVariable::DefaultValueConfig>
RimGridCalculation::findFilterValuesFromVariables() const
std::vector<RimEclipseCase*> RimGridCalculation::inputCases() const
{
for ( auto variable : m_variables )
{
RimGridCalculationVariable* v = dynamic_cast<RimGridCalculationVariable*>( variable.p() );
CAF_ASSERT( v != nullptr );
std::vector<RimEclipseCase*> cases;
if ( v->cellFilterView() ) return std::make_pair( v->cellFilterView(), v->defaultValueConfiguration() );
for ( const auto& variable : m_variables )
{
auto* v = dynamic_cast<RimGridCalculationVariable*>( variable.p() );
if ( v->eclipseCase() ) cases.push_back( v->eclipseCase() );
}
return std::pair( nullptr, std::make_pair( RimGridCalculationVariable::DefaultValueType::POSITIVE_INFINITY, HUGE_VAL ) );
return cases;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
int RimGridCalculation::findFilterVariableIndex() const
RimGridCalculation::DefaultValueConfig RimGridCalculation::defaultValueConfiguration() const
{
for ( size_t i = 0; i < m_variables.size(); i++ )
{
auto variable = m_variables[i];
RimGridCalculationVariable* v = dynamic_cast<RimGridCalculationVariable*>( variable );
CAF_ASSERT( v != nullptr );
if ( m_defaultValueType() == RimGridCalculation::DefaultValueType::USER_DEFINED )
return std::make_pair( m_defaultValueType(), m_defaultValue() );
if ( v->cellFilterView() ) return static_cast<int>( i );
return std::make_pair( m_defaultValueType(), HUGE_VAL );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimGridCalculation::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
{
RimUserDefinedCalculation::defineUiOrdering( uiConfigName, uiOrdering );
uiOrdering.add( &m_destinationCase );
caf::PdmUiGroup* filterGroup = uiOrdering.addNewGroup( "Cell Filter" );
filterGroup->setCollapsedByDefault();
filterGroup->add( &m_cellFilterView );
if ( m_cellFilterView() != nullptr )
{
filterGroup->add( &m_defaultValueType );
if ( m_defaultValueType() == RimGridCalculation::DefaultValueType::FROM_PROPERTY )
filterGroup->add( &m_defaultPropertyVariableIndex );
else if ( m_defaultValueType() == RimGridCalculation::DefaultValueType::USER_DEFINED )
filterGroup->add( &m_defaultValue );
}
return -1;
uiOrdering.skipRemainingFields();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QList<caf::PdmOptionItemInfo> RimGridCalculation::calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions )
{
QList<caf::PdmOptionItemInfo> options;
if ( fieldNeedingOptions == &m_cellFilterView )
{
options.push_back( caf::PdmOptionItemInfo( "Disabled", nullptr ) );
std::vector<Rim3dView*> views;
RimProject::current()->allViews( views );
RimEclipseCase* firstEclipseCase = nullptr;
if ( !inputCases().empty() ) firstEclipseCase = inputCases().front();
if ( firstEclipseCase )
{
for ( auto* view : views )
{
auto eclipseView = dynamic_cast<RimEclipseView*>( view );
if ( !eclipseView ) continue;
if ( !firstEclipseCase->isGridSizeEqualTo( eclipseView->eclipseCase() ) ) continue;
options.push_back( caf::PdmOptionItemInfo( view->autoName(), view, false, view->uiIconProvider() ) );
}
}
}
else if ( fieldNeedingOptions == &m_destinationCase )
{
if ( inputCases().empty() )
{
RimTools::eclipseCaseOptionItems( &options );
}
else
{
RimEclipseCase* firstInputCase = inputCases()[0];
RimProject* proj = RimProject::current();
if ( proj )
{
std::vector<RimCase*> cases;
proj->allCases( cases );
for ( RimCase* c : cases )
{
auto* eclipseCase = dynamic_cast<RimEclipseCase*>( c );
if ( !eclipseCase ) continue;
if ( !firstInputCase->isGridSizeEqualTo( eclipseCase ) ) continue;
options.push_back( caf::PdmOptionItemInfo( c->caseUserDescription(), c, false, c->uiIconProvider() ) );
}
}
}
options.push_front( caf::PdmOptionItemInfo( "None", nullptr ) );
}
else if ( fieldNeedingOptions == &m_defaultPropertyVariableIndex )
{
for ( int i = 0; i < static_cast<int>( m_variables.size() ); i++ )
{
auto v = dynamic_cast<RimGridCalculationVariable*>( m_variables[i] );
QString optionText = v->name();
options.push_back( caf::PdmOptionItemInfo( optionText, i ) );
}
}
return options;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimGridCalculation::initAfterRead()
{
for ( auto& variable : m_variables )
{
auto gridVar = dynamic_cast<RimGridCalculationVariable*>( variable.p() );
if ( gridVar )
{
gridVar->eclipseResultChanged.connect( this, &RimGridCalculation::onVariableUpdated );
if ( m_destinationCase == nullptr ) m_destinationCase = gridVar->eclipseCase();
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimGridCalculation::onVariableUpdated( const SignalEmitter* emitter )
{
if ( m_destinationCase == nullptr )
{
auto variable = dynamic_cast<const RimGridCalculationVariable*>( emitter );
if ( variable && variable->eclipseCase() )
{
m_destinationCase = variable->eclipseCase();
}
}
}
//--------------------------------------------------------------------------------------------------
@@ -289,22 +436,31 @@ void RimGridCalculation::replaceFilteredValuesWithDefaultValue( double
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimGridCalculation::filterResults( RimGridView* cellFilterView,
const std::vector<std::vector<double>>& values,
RimGridCalculationVariable::DefaultValueType defaultValueType,
double defaultValue,
std::vector<double>& resultValues ) const
void RimGridCalculation::filterResults( RimGridView* cellFilterView,
const std::vector<std::vector<double>>& values,
RimGridCalculation::DefaultValueType defaultValueType,
double defaultValue,
std::vector<double>& resultValues ) const
{
auto visibility = cellFilterView->currentTotalCellVisibility();
if ( defaultValueType == RimGridCalculationVariable::DefaultValueType::FROM_PROPERTY )
if ( defaultValueType == RimGridCalculation::DefaultValueType::FROM_PROPERTY )
{
int filterVariableIndex = findFilterVariableIndex();
replaceFilteredValuesWithVector( values[filterVariableIndex], visibility, resultValues );
if ( m_defaultPropertyVariableIndex < static_cast<int>( values.size() ) )
replaceFilteredValuesWithVector( values[m_defaultPropertyVariableIndex], visibility, resultValues );
else
{
QString errorMessage =
"Invalid input data for default result property, no data assigned to non-visible cells.";
RiaLogging::errorInMessageBox( nullptr, "Grid Property Calculator", errorMessage );
}
}
else
{
replaceFilteredValuesWithDefaultValue( defaultValue, visibility, resultValues );
double valueToUse = defaultValue;
if ( defaultValueType == RimGridCalculation::DefaultValueType::POSITIVE_INFINITY ) valueToUse = HUGE_VAL;
replaceFilteredValuesWithDefaultValue( valueToUse, visibility, resultValues );
}
}
@@ -313,7 +469,7 @@ void RimGridCalculation::filterResults( RimGridView*
//--------------------------------------------------------------------------------------------------
void RimGridCalculation::updateDependentObjects()
{
RimEclipseCase* eclipseCase = findEclipseCaseFromVariables();
RimEclipseCase* eclipseCase = destinationEclipseCase();
if ( eclipseCase )
{
RimReloadCaseTools::updateAll3dViews( eclipseCase );
@@ -331,7 +487,7 @@ void RimGridCalculation::removeDependentObjects()
RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::GENERATED, leftHandSideVariableName );
RimEclipseCase* eclipseCase = findEclipseCaseFromVariables();
RimEclipseCase* eclipseCase = destinationEclipseCase();
if ( eclipseCase )
{
// Select "None" result if the result that is being removed were displayed in a view.

40
ApplicationLibCode/ProjectDataModel/RimGridCalculation.h
View File

@@ -22,6 +22,7 @@
#include "RimGridCalculationVariable.h"
#include "RimUserDefinedCalculation.h"
#include "cafSignal.h"
#include "cvfArray.h"
class RimEclipseCase;
@@ -36,6 +37,13 @@ class RimGridCalculation : public RimUserDefinedCalculation
CAF_PDM_HEADER_INIT;
public:
enum class DefaultValueType
{
POSITIVE_INFINITY,
FROM_PROPERTY,
USER_DEFINED
};
RimGridCalculation();
bool calculate() override;
@@ -46,20 +54,21 @@ protected:
void onChildrenUpdated( caf::PdmChildArrayFieldHandle* childArray,
std::vector<caf::PdmObjectHandle*>& updatedObjects ) override;
RimGridCalculationVariable* createVariable() const override;
RimGridCalculationVariable* createVariable() override;
std::pair<bool, QString> validateVariables();
RimEclipseCase* findEclipseCaseFromVariables() const;
RimEclipseCase* destinationEclipseCase() const;
std::vector<RimEclipseCase*> inputCases() const;
std::vector<double> getInputVectorForVariable( RimGridCalculationVariable* v,
size_t tsId,
RiaDefines::PorosityModelType porosityModel ) const;
void filterResults( RimGridView* cellFilterView,
const std::vector<std::vector<double>>& values,
RimGridCalculationVariable::DefaultValueType defaultValueType,
double defaultValue,
std::vector<double>& resultValues ) const;
void filterResults( RimGridView* cellFilterView,
const std::vector<std::vector<double>>& values,
RimGridCalculation::DefaultValueType defaultValueType,
double defaultValue,
std::vector<double>& resultValues ) const;
static void replaceFilteredValuesWithVector( const std::vector<double>& inputValues,
cvf::ref<cvf::UByteArray> visibility,
@@ -69,7 +78,20 @@ protected:
cvf::ref<cvf::UByteArray> visibility,
std::vector<double>& resultValues );
int findFilterVariableIndex() const;
using DefaultValueConfig = std::pair<RimGridCalculation::DefaultValueType, double>;
DefaultValueConfig defaultValueConfiguration() const;
std::pair<RimGridView*, RimGridCalculationVariable::DefaultValueConfig> findFilterValuesFromVariables() const;
void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;
QList<caf::PdmOptionItemInfo> calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions ) override;
void initAfterRead() override;
private:
void onVariableUpdated( const SignalEmitter* emitter );
private:
caf::PdmPtrField<RimGridView*> m_cellFilterView;
caf::PdmField<caf::AppEnum<DefaultValueType>> m_defaultValueType;
caf::PdmField<double> m_defaultValue;
caf::PdmPtrField<RimEclipseCase*> m_destinationCase;
caf::PdmField<int> m_defaultPropertyVariableIndex;
};

98
ApplicationLibCode/ProjectDataModel/RimGridCalculationVariable.cpp
View File

@@ -23,34 +23,23 @@
#include "RiaPorosityModel.h"
#include "RiaResultNames.h"
#include "RimGridCalculation.h"
#include "RiuDragDrop.h"
#include "RigCaseCellResultsData.h"
#include "RimEclipseCase.h"
#include "RimEclipseResultAddress.h"
#include "RimEclipseView.h"
#include "RimGridCalculation.h"
#include "RimTools.h"
CAF_PDM_SOURCE_INIT( RimGridCalculationVariable, "RimGridCalculationVariable" );
#include "RiuDragDrop.h"
namespace caf
{
template <>
void caf::AppEnum<RimGridCalculationVariable::DefaultValueType>::setUp()
{
addItem( RimGridCalculationVariable::DefaultValueType::POSITIVE_INFINITY, "POSITIVE_INFINITY", "Inf" );
addItem( RimGridCalculationVariable::DefaultValueType::FROM_PROPERTY, "FROM_PROPERTY", "Property Value" );
addItem( RimGridCalculationVariable::DefaultValueType::USER_DEFINED, "USER_DEFINED", "User Defined" );
setDefault( RimGridCalculationVariable::DefaultValueType::POSITIVE_INFINITY );
}
}; // namespace caf
CAF_PDM_SOURCE_INIT( RimGridCalculationVariable, "RimGridCalculationVariable" );
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimGridCalculationVariable::RimGridCalculationVariable()
: eclipseResultChanged( this )
{
CAF_PDM_InitObject( "RimGridCalculationVariable", ":/octave.png" );
@@ -58,9 +47,6 @@ RimGridCalculationVariable::RimGridCalculationVariable()
CAF_PDM_InitField( &m_resultVariable, "ResultVariable", RiaResultNames::undefinedResultName(), "Variable" );
CAF_PDM_InitFieldNoDefault( &m_eclipseCase, "EclipseGridCase", "Grid Case" );
CAF_PDM_InitField( &m_timeStep, "TimeStep", allTimeStepsValue(), "Time Step" );
CAF_PDM_InitFieldNoDefault( &m_cellFilterView, "VisibleCellView", "Filter by 3d View Visibility" );
CAF_PDM_InitFieldNoDefault( &m_defaultValueType, "DefaultValueType", "Default Value Type" );
CAF_PDM_InitField( &m_defaultValue, "DefaultValue", 0.0, "Default Value" );
}
//--------------------------------------------------------------------------------------------------
@@ -86,35 +72,11 @@ void RimGridCalculationVariable::defineUiOrdering( QString uiConfigName, caf::Pd
uiOrdering.add( &m_resultType );
uiOrdering.add( &m_resultVariable );
uiOrdering.add( &m_timeStep );
uiOrdering.add( &m_cellFilterView );
uiOrdering.add( &m_defaultValueType );
uiOrdering.add( &m_defaultValue );
uiOrdering.skipRemainingFields();
m_resultType.uiCapability()->setUiReadOnly( m_eclipseCase == nullptr );
m_timeStep.uiCapability()->setUiReadOnly( m_resultType == RiaDefines::ResultCatType::STATIC_NATIVE );
// Can have only one variable with cell filter at a time.
// Set read-only state based on the state of the sibling variables.
RimGridCalculation* calculation = nullptr;
firstAncestorOfType( calculation );
bool hasOtherVariableWithFilter = false;
for ( auto variable : calculation->allVariables() )
{
auto v = dynamic_cast<RimGridCalculationVariable*>( variable );
if ( variable != this && v->cellFilterView() )
{
hasOtherVariableWithFilter = true;
}
}
m_cellFilterView.uiCapability()->setUiReadOnly( m_eclipseCase == nullptr || hasOtherVariableWithFilter );
m_defaultValueType.uiCapability()->setUiReadOnly( m_cellFilterView == nullptr || hasOtherVariableWithFilter );
m_defaultValue.uiCapability()->setUiReadOnly(
m_cellFilterView == nullptr ||
defaultValueType() != RimGridCalculationVariable::DefaultValueType::USER_DEFINED || hasOtherVariableWithFilter );
}
//--------------------------------------------------------------------------------------------------
@@ -158,18 +120,6 @@ QList<caf::PdmOptionItemInfo>
RimTools::timeStepsForCase( m_eclipseCase(), &options );
}
else if ( fieldNeedingOptions == &m_cellFilterView )
{
if ( m_eclipseCase )
{
options.push_back( caf::PdmOptionItemInfo( "Disabled", nullptr ) );
for ( RimEclipseView* view : m_eclipseCase->reservoirViews.children() )
{
CVF_ASSERT( view && "Really always should have a valid view pointer in ReservoirViews" );
options.push_back( caf::PdmOptionItemInfo( view->name(), view, false, view->uiIconProvider() ) );
}
}
}
return options;
}
@@ -234,41 +184,6 @@ int RimGridCalculationVariable::allTimeStepsValue()
return -1;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimGridView* RimGridCalculationVariable::cellFilterView() const
{
return m_cellFilterView;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimGridCalculationVariable::defaultValue() const
{
return m_defaultValue;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimGridCalculationVariable::DefaultValueType RimGridCalculationVariable::defaultValueType() const
{
return m_defaultValueType();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimGridCalculationVariable::DefaultValueConfig RimGridCalculationVariable::defaultValueConfiguration() const
{
if ( m_defaultValueType() == RimGridCalculationVariable::DefaultValueType::USER_DEFINED )
return std::make_pair( m_defaultValueType(), m_defaultValue() );
return std::make_pair( m_defaultValueType(), HUGE_VAL );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -292,5 +207,8 @@ void RimGridCalculationVariable::setEclipseResultAddress( const RimEclipseResult
m_resultVariable = address.resultName();
m_resultType = address.resultType();
m_eclipseCase = address.eclipseCase();
eclipseResultChanged.send();
updateConnectedEditors();
}

20
ApplicationLibCode/ProjectDataModel/RimGridCalculationVariable.h
View File

@@ -25,10 +25,10 @@
#include "cafPdmField.h"
#include "cafPdmObject.h"
#include "cafPdmPtrField.h"
#include "cafSignal.h"
class RimEclipseCase;
class RimEclipseResultAddress;
class RimGridView;
class RigCaseCellResultsData;
//==================================================================================================
@@ -40,27 +40,16 @@ class RimGridCalculationVariable : public RimUserDefinedCalculationVariable
CAF_PDM_HEADER_INIT;
public:
enum class DefaultValueType
{
POSITIVE_INFINITY,
FROM_PROPERTY,
USER_DEFINED
};
RimGridCalculationVariable();
caf::Signal<> eclipseResultChanged;
QString displayString() const override;
RimEclipseCase* eclipseCase() const;
RiaDefines::ResultCatType resultCategoryType() const;
QString resultVariable() const;
int timeStep() const;
RimGridView* cellFilterView() const;
double defaultValue() const;
DefaultValueType defaultValueType() const;
using DefaultValueConfig = std::pair<RimGridCalculationVariable::DefaultValueType, double>;
DefaultValueConfig defaultValueConfiguration() const;
static int allTimeStepsValue();
@@ -81,7 +70,4 @@ private:
caf::PdmField<caf::AppEnum<RiaDefines::ResultCatType>> m_resultType;
caf::PdmField<QString> m_resultVariable;
caf::PdmField<int> m_timeStep;
caf::PdmPtrField<RimGridView*> m_cellFilterView;
caf::PdmField<caf::AppEnum<DefaultValueType>> m_defaultValueType;
caf::PdmField<double> m_defaultValue;
};

2
ApplicationLibCode/ProjectDataModel/RimSummaryCalculation.cpp
View File

@@ -54,7 +54,7 @@ RimSummaryCalculation::RimSummaryCalculation()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimSummaryCalculationVariable* RimSummaryCalculation::createVariable() const
RimSummaryCalculationVariable* RimSummaryCalculation::createVariable()
{
return new RimSummaryCalculationVariable;
}

2
ApplicationLibCode/ProjectDataModel/RimSummaryCalculation.h
View File

@@ -37,5 +37,5 @@ public:
void removeDependentObjects() override;
protected:
RimSummaryCalculationVariable* createVariable() const override;
RimSummaryCalculationVariable* createVariable() override;
};

10
ApplicationLibCode/ProjectDataModel/RimUserDefinedCalculation.cpp
View File

@@ -298,6 +298,16 @@ void RimUserDefinedCalculation::fieldChangedByUi( const caf::PdmFieldHandle* cha
PdmObject::fieldChangedByUi( changedField, oldValue, newValue );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimUserDefinedCalculation::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
{
uiOrdering.add( &m_description );
uiOrdering.add( &m_expression );
uiOrdering.add( &m_unit );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

3
ApplicationLibCode/ProjectDataModel/RimUserDefinedCalculation.h
View File

@@ -69,9 +69,10 @@ public:
void attachToWidget();
protected:
virtual RimUserDefinedCalculationVariable* createVariable() const = 0;
virtual RimUserDefinedCalculationVariable* createVariable() = 0;
void fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue ) override;
void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;
void defineEditorAttribute( const caf::PdmFieldHandle* field,
QString uiConfigName,