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

Summary Plot adjustments

Browse Source 
* #9435 Do not auto update curve appearance during source stepping
* Update toolbar after vector is dropped into empty plot
* Use summary vector text in RiaSummaryDefines
* Fix missing update of curve color when curve is highlighted
This commit is contained in:
Magne Sjaastad 2022-11-08 08:18:31 +01:00 committed by GitHub
parent 8dfaae512f
commit 95813f510e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
14 changed files with 386 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ApplicationLibCode/Application/CMakeLists_files.cmake
View File

@ -30,6 +30,7 @@ set(SOURCE_GROUP_HEADER_FILES
${CMAKE_CURRENT_LIST_DIR}/RiaDateTimeDefines.h
${CMAKE_CURRENT_LIST_DIR}/RiaPlotCollectionScheduler.h
${CMAKE_CURRENT_LIST_DIR}/RiaScheduler.h
${CMAKE_CURRENT_LIST_DIR}/RiaSummaryDefines.h
)
set(SOURCE_GROUP_SOURCE_FILES
@ -64,6 +65,7 @@ set(SOURCE_GROUP_SOURCE_FILES
${CMAKE_CURRENT_LIST_DIR}/RiaDateTimeDefines.cpp
${CMAKE_CURRENT_LIST_DIR}/RiaPlotCollectionScheduler.cpp
${CMAKE_CURRENT_LIST_DIR}/RiaScheduler.cpp
${CMAKE_CURRENT_LIST_DIR}/RiaSummaryDefines.cpp
)
list(APPEND CODE_HEADER_FILES ${SOURCE_GROUP_HEADER_FILES})

147
ApplicationLibCode/Application/RiaSummaryDefines.cpp Normal file
View File

@ -0,0 +1,147 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2022 Equinor ASA
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#include "RiaSummaryDefines.h"
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::summaryField()
{
return "Field";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::summaryAquifer()
{
return "Aquifer";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::summaryNetwork()
{
return "Network";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::summaryMisc()
{
return "Misc";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::summaryRegion()
{
return "Region";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::summaryRegion2Region()
{
return "Region-Region";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::summaryWell()
{
return "Well";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::summaryWellGroup()
{
return "Group";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::summaryWellSegment()
{
return "Well Segment";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::summaryCompletion()
{
return "Completion";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::summarySegment()
{
return "Segment";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::summaryBlock()
{
return "Block";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::summaryLgrCompletion()
{
return "LGR Completion";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::summaryLgrWell()
{
return "LGR Well";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::summaryLgrBlock()
{
return "LGR Block";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::summaryCalculated()
{
return "Calculated";
}

42
ApplicationLibCode/Application/RiaSummaryDefines.h Normal file
View File

@ -0,0 +1,42 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2022 Equinor ASA
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include <QString>
namespace RiaDefines
{
QString summaryField();
QString summaryAquifer();
QString summaryNetwork();
QString summaryMisc();
QString summaryRegion();
QString summaryRegion2Region();
QString summaryWell();
QString summaryWellGroup();
QString summaryWellSegment();
QString summaryCompletion();
QString summarySegment();
QString summaryBlock();
QString summaryLgrCompletion();
QString summaryLgrWell();
QString summaryLgrBlock();
QString summaryCalculated();
}; // namespace RiaDefines

6
ApplicationLibCode/ProjectDataModel/Summary/RimCalculatedSummaryCase.cpp
View File

@ -18,6 +18,8 @@
#include "RimCalculatedSummaryCase.h"
#include "RiaSummaryDefines.h"
#include "RimSummaryCalculation.h"
#include "RimSummaryCalculationCollection.h"
@ -31,7 +33,7 @@ RimCalculatedSummaryCase::RimCalculatedSummaryCase()
CAF_PDM_InitObject( "Calculated", ":/SummaryCase.svg" );
m_calculatedCurveReader = nullptr;
m_displayName = "Calculated";
m_displayName = RiaDefines::summaryCalculated();
}
//--------------------------------------------------------------------------------------------------
@ -46,7 +48,7 @@ RimCalculatedSummaryCase::~RimCalculatedSummaryCase()
//--------------------------------------------------------------------------------------------------
QString RimCalculatedSummaryCase::caseName() const
{
return "Calculated";
return RiaDefines::summaryCalculated();
}
//--------------------------------------------------------------------------------------------------

40
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryAddress.cpp
View File

@ -18,6 +18,8 @@
#include "RimSummaryAddress.h"
#include "RiaSummaryDefines.h"
#include "RimProject.h"
#include "RimSummaryCalculation.h"
#include "RimSummaryCalculationCollection.h"
@ -29,24 +31,26 @@ namespace caf
template <>
void caf::AppEnum<RifEclipseSummaryAddress::SummaryVarCategory>::setUp()
{
addItem( RifEclipseSummaryAddress::SUMMARY_FIELD, "SUMMARY_FIELD", "Field" );
addItem( RifEclipseSummaryAddress::SUMMARY_AQUIFER, "SUMMARY_AQUIFER", "Aquifer" );
addItem( RifEclipseSummaryAddress::SUMMARY_NETWORK, "SUMMARY_NETWORK", "Network" );
addItem( RifEclipseSummaryAddress::SUMMARY_MISC, "SUMMARY_MISC", "Misc" );
addItem( RifEclipseSummaryAddress::SUMMARY_REGION, "SUMMARY_REGION", "Region" );
addItem( RifEclipseSummaryAddress::SUMMARY_REGION_2_REGION, "SUMMARY_REGION_2_REGION", "Region-Region" );
addItem( RifEclipseSummaryAddress::SUMMARY_GROUP, "SUMMARY_WELL_GROUP", "Group" );
addItem( RifEclipseSummaryAddress::SUMMARY_WELL, "SUMMARY_WELL", "Well" );
addItem( RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION, "SUMMARY_WELL_COMPLETION", "Completion" );
addItem( RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION_LGR, "SUMMARY_WELL_COMPLETION_LGR", "Lgr-Completion" );
addItem( RifEclipseSummaryAddress::SUMMARY_WELL_LGR, "SUMMARY_WELL_LGR", "Lgr-Well" );
addItem( RifEclipseSummaryAddress::SUMMARY_WELL_SEGMENT, "SUMMARY_SEGMENT", "Segment" );
addItem( RifEclipseSummaryAddress::SUMMARY_BLOCK, "SUMMARY_BLOCK", "Block" );
addItem( RifEclipseSummaryAddress::SUMMARY_BLOCK_LGR, "SUMMARY_BLOCK_LGR", "Lgr-Block" );
addItem( RifEclipseSummaryAddress::SUMMARY_CALCULATED, "SUMMARY_CALCULATED", "Calculated" );
addItem( RifEclipseSummaryAddress::SUMMARY_IMPORTED, "SUMMARY_IMPORTED", "Imported" );
addItem( RifEclipseSummaryAddress::SUMMARY_ENSEMBLE_STATISTICS, "SUMMARY_ENSEMBLE_STATISTICS", "Ensemble Statistics" );
setDefault( RifEclipseSummaryAddress::SUMMARY_FIELD );
using RifAdr = RifEclipseSummaryAddress;
addItem( RifAdr::SUMMARY_FIELD, "SUMMARY_FIELD", RiaDefines::summaryField() );
addItem( RifAdr::SUMMARY_AQUIFER, "SUMMARY_AQUIFER", RiaDefines::summaryAquifer() );
addItem( RifAdr::SUMMARY_NETWORK, "SUMMARY_NETWORK", RiaDefines::summaryNetwork() );
addItem( RifAdr::SUMMARY_MISC, "SUMMARY_MISC", RiaDefines::summaryMisc() );
addItem( RifAdr::SUMMARY_REGION, "SUMMARY_REGION", RiaDefines::summaryRegion() );
addItem( RifAdr::SUMMARY_REGION_2_REGION, "SUMMARY_REGION_2_REGION", RiaDefines::summaryRegion2Region() );
addItem( RifAdr::SUMMARY_GROUP, "SUMMARY_WELL_GROUP", RiaDefines::summaryWellGroup() );
addItem( RifAdr::SUMMARY_WELL, "SUMMARY_WELL", RiaDefines::summaryWell() );
addItem( RifAdr::SUMMARY_WELL_COMPLETION, "SUMMARY_WELL_COMPLETION", RiaDefines::summaryCompletion() );
addItem( RifAdr::SUMMARY_WELL_COMPLETION_LGR, "SUMMARY_WELL_COMPLETION_LGR", RiaDefines::summaryLgrCompletion() );
addItem( RifAdr::SUMMARY_WELL_LGR, "SUMMARY_WELL_LGR", RiaDefines::summaryLgrWell() );
addItem( RifAdr::SUMMARY_WELL_SEGMENT, "SUMMARY_SEGMENT", RiaDefines::summarySegment() );
addItem( RifAdr::SUMMARY_BLOCK, "SUMMARY_BLOCK", RiaDefines::summaryBlock() );
addItem( RifAdr::SUMMARY_BLOCK_LGR, "SUMMARY_BLOCK_LGR", RiaDefines::summaryLgrBlock() );
addItem( RifAdr::SUMMARY_CALCULATED, "SUMMARY_CALCULATED", RiaDefines::summaryCalculated() );
addItem( RifAdr::SUMMARY_IMPORTED, "SUMMARY_IMPORTED", "Imported" );
addItem( RifAdr::SUMMARY_ENSEMBLE_STATISTICS, "SUMMARY_ENSEMBLE_STATISTICS", "Ensemble Statistics" );
setDefault( RifAdr::SUMMARY_FIELD );
}
} // namespace caf

95
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryAddressCollection.cpp
View File

@ -18,6 +18,8 @@
#include "RimSummaryAddressCollection.h"
#include "RiaSummaryDefines.h"
#include "RifEclipseSummaryAddress.h"
#include "RimSummaryAddress.h"
@ -27,26 +29,29 @@
template <>
void caf::AppEnum<RimSummaryAddressCollection::CollectionContentType>::setUp()
{
addItem( RimSummaryAddressCollection::CollectionContentType::NOT_DEFINED, "NOT_DEFINED", "Not Defined" );
addItem( RimSummaryAddressCollection::CollectionContentType::FIELD, "FIELD", "Field" );
addItem( RimSummaryAddressCollection::CollectionContentType::AQUIFER, "AQUIFER", "Aquifer" );
addItem( RimSummaryAddressCollection::CollectionContentType::NETWORK, "NETWORK", "Network" );
addItem( RimSummaryAddressCollection::CollectionContentType::MISC, "MISC", "Miscellaneous" );
addItem( RimSummaryAddressCollection::CollectionContentType::REGION, "REGION", "Region" );
addItem( RimSummaryAddressCollection::CollectionContentType::REGION_2_REGION, "REGION_2_REGION", "Region-Region" );
addItem( RimSummaryAddressCollection::CollectionContentType::GROUP, "GROUP", "Group" );
addItem( RimSummaryAddressCollection::CollectionContentType::WELL, "WELL", "Well" );
addItem( RimSummaryAddressCollection::CollectionContentType::WELL_COMPLETION, "WELL_COMPLETION", "Completion" );
addItem( RimSummaryAddressCollection::CollectionContentType::WELL_SEGMENT, "WELL_SEGMENT", "Segment" );
addItem( RimSummaryAddressCollection::CollectionContentType::BLOCK, "BLOCK", "Block" );
addItem( RimSummaryAddressCollection::CollectionContentType::WELL_LGR, "WELL_LGR", "Lgr-Well" );
addItem( RimSummaryAddressCollection::CollectionContentType::WELL_COMPLETION_LGR,
"WELL_COMPLETION_LGR",
"Lgr Completion" );
addItem( RimSummaryAddressCollection::CollectionContentType::BLOCK_LGR, "BLOCK_LGR", "Lgr-Block" );
addItem( RimSummaryAddressCollection::CollectionContentType::CALCULATED, "CALCULATED", "Calculated" );
addItem( RimSummaryAddressCollection::CollectionContentType::IMPORTED, "IMPORTED", "Imported" );
setDefault( RimSummaryAddressCollection::CollectionContentType::NOT_DEFINED );
using CollectionContentType = RimSummaryAddressCollection::CollectionContentType;
addItem( CollectionContentType::NOT_DEFINED, "NOT_DEFINED", "Not Defined" );
addItem( CollectionContentType::WELL, "WELL", RiaDefines::summaryWell() );
addItem( CollectionContentType::GROUP, "GROUP", RiaDefines::summaryWellGroup() );
addItem( CollectionContentType::REGION, "REGION", RiaDefines::summaryRegion() );
addItem( CollectionContentType::FIELD, "FIELD", RiaDefines::summaryField() );
addItem( CollectionContentType::MISC, "MISC", RiaDefines::summaryMisc() );
addItem( CollectionContentType::WELL_FOLDER, "WELL_FOLDER", RiaDefines::summaryWell() );
addItem( CollectionContentType::GROUP_FOLDER, "GROUP_FOLDER", RiaDefines::summaryWellGroup() );
addItem( CollectionContentType::REGION_FOLDER, "REGION_FOLDER", RiaDefines::summaryRegion() );
addItem( CollectionContentType::BLOCK, "BLOCK", RiaDefines::summaryBlock() );
addItem( CollectionContentType::SUMMARY_CASE, "SUMMARY_CASE", "Summary Case" );
addItem( CollectionContentType::AQUIFER, "AQUIFER", RiaDefines::summaryAquifer() );
addItem( CollectionContentType::NETWORK, "NETWORK", RiaDefines::summaryNetwork() );
addItem( CollectionContentType::REGION_2_REGION, "REGION_2_REGION", RiaDefines::summaryRegion2Region() );
addItem( CollectionContentType::WELL_COMPLETION, "WELL_COMPLETION", RiaDefines::summaryCompletion() );
addItem( CollectionContentType::WELL_LGR, "WELL_LGR", RiaDefines::summaryLgrWell() );
addItem( CollectionContentType::WELL_COMPLETION_LGR, "WELL_COMPLETION_LGR", RiaDefines::summaryLgrCompletion() );
addItem( CollectionContentType::WELL_SEGMENT, "WELL_SEGMENT", RiaDefines::summaryWellSegment() );
addItem( CollectionContentType::BLOCK_LGR, "BLOCK_LGR", RiaDefines::summaryLgrBlock() );
addItem( CollectionContentType::CALCULATED, "CALCULATED", RiaDefines::summaryCalculated() );
addItem( CollectionContentType::IMPORTED, "IMPORTED", "Imported" );
setDefault( CollectionContentType::NOT_DEFINED );
}
CAF_PDM_SOURCE_INIT( RimSummaryAddressCollection, "RimSummaryAddressCollection" );
@ -159,24 +164,24 @@ void RimSummaryAddressCollection::updateFolderStructure( const std::set<RifEclip
int caseId,
int ensembleId )
{
if ( addresses.size() == 0 ) return;
if ( addresses.empty() ) return;
auto* fields = getOrCreateSubfolder( "Field", CollectionContentType::FIELD );
auto* aquifer = getOrCreateSubfolder( "Aquifer", CollectionContentType::AQUIFER );
auto* network = getOrCreateSubfolder( "Network", CollectionContentType::NETWORK );
auto* misc = getOrCreateSubfolder( "Miscellaneous", CollectionContentType::MISC );
auto* regions = getOrCreateSubfolder( "Region", CollectionContentType::REGION_FOLDER );
auto* region2region = getOrCreateSubfolder( "Region-Region", CollectionContentType::REGION_2_REGION );
auto* groups = getOrCreateSubfolder( "Group", CollectionContentType::GROUP_FOLDER );
auto* wells = getOrCreateSubfolder( "Well", CollectionContentType::WELL_FOLDER );
auto* completion = getOrCreateSubfolder( "Completion", CollectionContentType::WELL_COMPLETION );
auto* segment = getOrCreateSubfolder( "Segment", CollectionContentType::WELL_SEGMENT );
auto* blocks = getOrCreateSubfolder( "Block", CollectionContentType::BLOCK );
auto* lgrwell = getOrCreateSubfolder( "Lgr-Well", CollectionContentType::WELL_LGR );
auto* lgrcompletion = getOrCreateSubfolder( "Lgr-Completion", CollectionContentType::WELL_COMPLETION_LGR );
auto* lgrblock = getOrCreateSubfolder( "Lgr-Block", CollectionContentType::BLOCK_LGR );
auto* calculated = getOrCreateSubfolder( "Calculated", CollectionContentType::CALCULATED );
auto* imported = getOrCreateSubfolder( "Imported", CollectionContentType::IMPORTED );
auto* fields = getOrCreateSubfolder( CollectionContentType::FIELD );
auto* aquifer = getOrCreateSubfolder( CollectionContentType::AQUIFER );
auto* network = getOrCreateSubfolder( CollectionContentType::NETWORK );
auto* misc = getOrCreateSubfolder( CollectionContentType::MISC );
auto* regions = getOrCreateSubfolder( CollectionContentType::REGION_FOLDER );
auto* region2region = getOrCreateSubfolder( CollectionContentType::REGION_2_REGION );
auto* groups = getOrCreateSubfolder( CollectionContentType::GROUP_FOLDER );
auto* wells = getOrCreateSubfolder( CollectionContentType::WELL_FOLDER );
auto* completion = getOrCreateSubfolder( CollectionContentType::WELL_COMPLETION );
auto* segment = getOrCreateSubfolder( CollectionContentType::WELL_SEGMENT );
auto* blocks = getOrCreateSubfolder( CollectionContentType::BLOCK );
auto* lgrwell = getOrCreateSubfolder( CollectionContentType::WELL_LGR );
auto* lgrcompletion = getOrCreateSubfolder( CollectionContentType::WELL_COMPLETION_LGR );
auto* lgrblock = getOrCreateSubfolder( CollectionContentType::BLOCK_LGR );
auto* calculated = getOrCreateSubfolder( CollectionContentType::CALCULATED );
auto* imported = getOrCreateSubfolder( CollectionContentType::IMPORTED );
for ( const auto& address : addresses )
{
@ -324,13 +329,23 @@ RimSummaryAddressCollection* RimSummaryAddressCollection::getOrCreateSubfolder(
}
}
RimSummaryAddressCollection* newFolder = new RimSummaryAddressCollection();
auto* newFolder = new RimSummaryAddressCollection();
newFolder->setName( folderName );
newFolder->setContentType( createFolderType );
m_subfolders.push_back( newFolder );
return newFolder;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimSummaryAddressCollection* RimSummaryAddressCollection::getOrCreateSubfolder( CollectionContentType createFolderType )
{
auto name = caf::AppEnum<CollectionContentType>::uiText( createFolderType );
return getOrCreateSubfolder( name, createFolderType );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -345,7 +360,7 @@ void RimSummaryAddressCollection::deleteChildren()
//--------------------------------------------------------------------------------------------------
bool RimSummaryAddressCollection::isEmpty() const
{
return ( ( m_adresses.size() == 0 ) && ( m_subfolders.size() == 0 ) );
return ( ( m_adresses.empty() ) && ( m_subfolders.empty() ) );
}
//--------------------------------------------------------------------------------------------------
@ -353,7 +368,7 @@ bool RimSummaryAddressCollection::isEmpty() const
//--------------------------------------------------------------------------------------------------
bool RimSummaryAddressCollection::canBeDragged() const
{
bool ok = m_subfolders.size() == 0;
bool ok = m_subfolders.empty();
ok = ok && ( m_contentType == CollectionContentType::WELL || m_contentType == CollectionContentType::GROUP ||
m_contentType == CollectionContentType::REGION );

2
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryAddressCollection.h
View File

@ -89,6 +89,8 @@ private:
getOrCreateSubfolder( const QString folderName,
CollectionContentType createFolderType = CollectionContentType::NOT_DEFINED );
RimSummaryAddressCollection* getOrCreateSubfolder( CollectionContentType createFolderType );
bool hasDataVector( const QString quantityName ) const;
bool hasDataVector( const std::string quantityName ) const;

12
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryDataSourceStepping.cpp
View File

@ -18,6 +18,8 @@
#include "RimSummaryDataSourceStepping.h"
#include "RiaSummaryDefines.h"
#include "cafAppEnum.h"
namespace caf
@ -26,13 +28,13 @@ template <>
void AppEnum<RimSummaryDataSourceStepping::SourceSteppingDimension>::setUp()
{
addItem( RimSummaryDataSourceStepping::SourceSteppingDimension::VECTOR, "VECTOR", "Vector" );
addItem( RimSummaryDataSourceStepping::SourceSteppingDimension::WELL, "WELL", "Well" );
addItem( RimSummaryDataSourceStepping::SourceSteppingDimension::WELL, "WELL", RiaDefines::summaryWell() );
addItem( RimSummaryDataSourceStepping::SourceSteppingDimension::SUMMARY_CASE, "SUMMARY_CASE", "Summary Case" );
addItem( RimSummaryDataSourceStepping::SourceSteppingDimension::ENSEMBLE, "ENSEMBLE", "Ensemble" );
addItem( RimSummaryDataSourceStepping::SourceSteppingDimension::GROUP, "GROUP", "Group" );
addItem( RimSummaryDataSourceStepping::SourceSteppingDimension::REGION, "REGION", "Region" );
addItem( RimSummaryDataSourceStepping::SourceSteppingDimension::BLOCK, "BLOCK", "Block" );
addItem( RimSummaryDataSourceStepping::SourceSteppingDimension::AQUIFER, "AQUIFER", "Aquifer" );
addItem( RimSummaryDataSourceStepping::SourceSteppingDimension::GROUP, "GROUP", RiaDefines::summaryWellGroup() );
addItem( RimSummaryDataSourceStepping::SourceSteppingDimension::REGION, "REGION", RiaDefines::summaryRegion() );
addItem( RimSummaryDataSourceStepping::SourceSteppingDimension::BLOCK, "BLOCK", RiaDefines::summaryBlock() );
addItem( RimSummaryDataSourceStepping::SourceSteppingDimension::AQUIFER, "AQUIFER", RiaDefines::summaryAquifer() );
setDefault( RimSummaryDataSourceStepping::SourceSteppingDimension::VECTOR );
}
} // namespace caf

105
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryPlotSourceStepping.cpp
View File

@ -93,6 +93,8 @@ RimSummaryPlotSourceStepping::RimSummaryPlotSourceStepping()
CAF_PDM_InitField( &m_indexLabel, "IndexLabel", QString( "Step By" ), "Step By" );
m_indexLabel.uiCapability()->setUiEditorTypeName( caf::PdmUiLabelEditor::uiEditorTypeName() );
m_indexLabel.xmlCapability()->disableIO();
CAF_PDM_InitField( &m_autoUpdateAppearance, "AutoUpdateAppearance", false, "Update Appearance" );
}
//--------------------------------------------------------------------------------------------------
@ -157,6 +159,8 @@ void RimSummaryPlotSourceStepping::defineUiOrdering( QString uiConfigName, caf::
uiOrdering.add( f );
}
uiOrdering.add( &m_autoUpdateAppearance );
uiOrdering.skipRemainingFields();
}
@ -166,18 +170,14 @@ void RimSummaryPlotSourceStepping::defineUiOrdering( QString uiConfigName, caf::
QList<caf::PdmOptionItemInfo>
RimSummaryPlotSourceStepping::calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions )
{
if ( ( fieldNeedingOptions == &m_placeholderForLabel ) || ( fieldNeedingOptions == &m_indexLabel ) ||
( fieldNeedingOptions == &m_autoUpdateAppearance ) ||
( fieldNeedingOptions == &m_includeEnsembleCasesForCaseStepping ) || ( fieldNeedingOptions == &m_stepDimension ) )
{
return {};
}
QList<caf::PdmOptionItemInfo> options;
if ( ( fieldNeedingOptions == &m_includeEnsembleCasesForCaseStepping ) || ( fieldNeedingOptions == &m_stepDimension ) )
{
return caf::PdmObject::calculateValueOptions( fieldNeedingOptions );
}
if ( ( fieldNeedingOptions == &m_placeholderForLabel ) || ( fieldNeedingOptions == &m_indexLabel ) )
{
return options;
}
if ( fieldNeedingOptions == &m_summaryCase )
{
auto summaryCases = RimSummaryPlotSourceStepping::summaryCasesForSourceStepping();
@ -376,7 +376,11 @@ void RimSummaryPlotSourceStepping::fieldChangedByUi( const caf::PdmFieldHandle*
if ( previousCase == curve->summaryCaseY() )
{
curve->setSummaryCaseY( m_summaryCase );
curve->setCurveAppearanceFromCaseType();
if ( m_autoUpdateAppearance )
{
curve->setCurveAppearanceFromCaseType();
}
}
}
@ -422,24 +426,7 @@ void RimSummaryPlotSourceStepping::fieldChangedByUi( const caf::PdmFieldHandle*
}
else if ( changedField == &m_vectorName )
{
for ( auto curve : curves )
{
if ( isYAxisStepping() )
{
auto adr = curve->summaryAddressY();
if ( RimDataSourceSteppingTools::updateQuantityIfMatching( oldValue, newValue, &adr ) )
curve->setSummaryAddressY( adr );
}
if ( isXAxisStepping() )
{
auto adr = curve->summaryAddressX();
if ( RimDataSourceSteppingTools::updateQuantityIfMatching( oldValue, newValue, &adr ) )
curve->setSummaryAddressX( adr );
}
curve->setDefaultCurveAppearance();
}
updateVectorNameInCurves( curves, oldValue, newValue );
if ( dataSourceSteppingObject() )
{
@ -450,6 +437,7 @@ void RimSummaryPlotSourceStepping::fieldChangedByUi( const caf::PdmFieldHandle*
curveSet->setSummaryAddress( adr );
}
}
m_vectorName.uiCapability()->updateConnectedEditors();
triggerLoadDataAndUpdate = true;
isAutoZoomAllowed = true;
@ -952,7 +940,7 @@ void RimSummaryPlotSourceStepping::defineEditorAttribute( const caf::PdmFieldHan
QString uiConfigName,
caf::PdmUiEditorAttribute* attribute )
{
caf::PdmUiComboBoxEditorAttribute* myAttr = dynamic_cast<caf::PdmUiComboBoxEditorAttribute*>( attribute );
auto* myAttr = dynamic_cast<caf::PdmUiComboBoxEditorAttribute*>( attribute );
if ( myAttr )
{
if ( field == &m_stepDimension )
@ -1283,6 +1271,61 @@ std::map<QString, QString> RimSummaryPlotSourceStepping::optionsForQuantity( Ria
return displayAndValueStrings;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryPlotSourceStepping::updateVectorNameInCurves( std::vector<RimSummaryCurve*>& curves,
const QVariant& oldValue,
const QVariant& newValue )
{
std::map<RimSummaryPlot*, std::vector<RimSummaryCurve*>> curvesInPlot;
for ( auto curve : curves )
{
if ( isYAxisStepping() )
{
auto adr = curve->summaryAddressY();
if ( RimDataSourceSteppingTools::updateQuantityIfMatching( oldValue, newValue, &adr ) )
curve->setSummaryAddressY( adr );
}
if ( isXAxisStepping() )
{
auto adr = curve->summaryAddressX();
if ( RimDataSourceSteppingTools::updateQuantityIfMatching( oldValue, newValue, &adr ) )
curve->setSummaryAddressX( adr );
}
if ( m_autoUpdateAppearance )
{
RimSummaryPlot* summaryPlot = nullptr;
curve->firstAncestorOfType( summaryPlot );
if ( summaryPlot )
{
if ( curvesInPlot.count( summaryPlot ) )
{
curvesInPlot[summaryPlot].push_back( curve );
}
else
{
curvesInPlot[summaryPlot] = { curve };
}
}
}
}
if ( m_autoUpdateAppearance )
{
// Apply the curve appearance for all curves in one go. If appearance of each curve was updated as part of the
// loop, the appearance of curves was based on a mix of old and new curves causing a mix of different curve
// styles
for ( const auto& [plot, curves] : curvesInPlot )
{
plot->applyDefaultCurveAppearances( curves );
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

3
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryPlotSourceStepping.h
View File

@ -106,6 +106,8 @@ private:
std::map<QString, QString> optionsForQuantity( std::set<RifEclipseSummaryAddress> addresses );
std::map<QString, QString> optionsForQuantity( RiaSummaryAddressAnalyzer* analyzser );
void updateVectorNameInCurves( std::vector<RimSummaryCurve*>& curves, const QVariant& oldValue, const QVariant& newValue );
private:
caf::PdmPointer<caf::PdmObject> m_objectForSourceStepping;
@ -129,6 +131,7 @@ private:
caf::PdmField<int> m_aquifer;
caf::PdmField<bool> m_includeEnsembleCasesForCaseStepping;
caf::PdmField<bool> m_autoUpdateAppearance;
RimSummaryDataSourceStepping::Axis m_sourceSteppingType;
std::vector<QString> m_cachedIdentifiers;

4
ApplicationLibCode/UserInterface/RiuPlotWidget.cpp
View File

@ -264,6 +264,10 @@ bool RiuPlotWidget::handleDragDropEvent( QEvent* event )
if ( RiuDragDrop::handleGenericDropEvent( event, objects ) )
{
if ( m_plotDefinition ) m_plotDefinition->handleDroppedObjects( objects );
RiuPlotMainWindow* mainPlotWindow = RiaGuiApplication::instance()->mainPlotWindow();
if ( mainPlotWindow ) mainPlotWindow->updateMultiPlotToolBar();
return true;
}

28
ApplicationLibCode/UserInterface/RiuQwtPlotWidget.cpp
View File

@ -22,10 +22,12 @@
#include "RiaColorTools.h"
#include "RiaDefines.h"
#include "RiaGuiApplication.h"
#include "RiaLogging.h"
#include "RiaPlotDefines.h"
#include "RiaPlotWindowRedrawScheduler.h"
#include "RimPlot.h"
#include "RimPlotCurve.h"
#include "RiuDraggableOverlayFrame.h"
#include "RiuGuiTheme.h"
@ -71,8 +73,6 @@
#include <algorithm>
#include <limits>
#include "RiaLogging.h"
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -1011,8 +1011,6 @@ void RiuQwtPlotWidget::highlightPlotItems( const std::set<const QwtPlotItem*>& c
symbol->setPen( blendedSymbolLineColor, symbol->pen().width(), symbol->pen().style() );
}
}
CurveProperties properties = { curveColor, symbolColor, symbolLineColor, penWidth };
m_originalCurveProperties.insert( std::make_pair( plotCurve, properties ) );
m_originalZValues.insert( std::make_pair( plotCurve, zValue ) );
continue;
@ -1040,23 +1038,18 @@ void RiuQwtPlotWidget::resetPlotItemHighlighting( bool doUpdateCurveOrder )
auto plotItemList = m_plot->itemList();
for ( QwtPlotItem* plotItem : plotItemList )
{
auto* plotCurve = dynamic_cast<QwtPlotCurve*>( plotItem );
if ( plotCurve && m_originalCurveProperties.count( plotCurve ) )
if ( auto* plotCurve = dynamic_cast<QwtPlotCurve*>( plotItem ) )
{
const QPen& existingPen = plotCurve->pen();
auto properties = m_originalCurveProperties[plotCurve];
double zValue = m_originalZValues[plotCurve];
auto* riuPlotCurve = dynamic_cast<RiuPlotCurve*>( plotItem );
plotCurve->setPen( properties.lineColor, properties.lineWidth, existingPen.style() );
plotCurve->setZ( zValue );
auto* symbol = const_cast<QwtSymbol*>( plotCurve->symbol() );
if ( symbol )
if ( auto rimPlotCurve =
dynamic_cast<RimPlotCurve*>( m_plotDefinition->findPdmObjectFromPlotCurve( riuPlotCurve ) ) )
{
symbol->setColor( properties.symbolColor );
symbol->setPen( properties.symbolLineColor, symbol->pen().width(), symbol->pen().style() );
rimPlotCurve->updateCurveAppearance();
double zValue = m_originalZValues[plotCurve];
riuPlotCurve->setZ( zValue );
continue;
}
continue;
}
auto* plotShapeItem = dynamic_cast<QwtPlotShapeItem*>( plotItem );
@ -1072,7 +1065,6 @@ void RiuQwtPlotWidget::resetPlotItemHighlighting( bool doUpdateCurveOrder )
plotShapeItem->setZ( plotShapeItem->z() - 100.0 );
}
}
m_originalCurveProperties.clear();
m_originalZValues.clear();
resetPlotAxisHighlighting();

5
ApplicationLibCode/UserInterface/RiuQwtPlotWidget.h
View File

@ -235,9 +235,8 @@ private:
int lineWidth;
};
std::map<QwtPlotCurve*, CurveProperties> m_originalCurveProperties;
std::map<QwtPlotCurve*, double> m_originalZValues;
std::map<RiuPlotAxis, QwtAxisId> m_axisMapping;
std::map<QwtPlotCurve*, double> m_originalZValues;
std::map<RiuPlotAxis, QwtAxisId> m_axisMapping;
QPointer<QwtPlot> m_plot;
};

23
ApplicationLibCode/UserInterface/RiuSummaryVectorSelectionUi.cpp
View File

@ -22,6 +22,7 @@
#include "RiaOptionItemFactory.h"
#include "RiaStdStringTools.h"
#include "RiaSummaryCurveDefinition.h"
#include "RiaSummaryDefines.h"
#include "RifEclipseSummaryAddress.h"
#include "RifReaderEclipseSummary.h"
@ -873,7 +874,7 @@ void RiuSummaryVectorSelectionUi::defineUiOrdering( QString uiConfigName, caf::P
else if ( sumCategory == RifEclipseSummaryAddress::SUMMARY_AQUIFER )
{
{
caf::PdmUiGroup* myGroup = uiOrdering.addNewGroup( "Aquifers" );
caf::PdmUiGroup* myGroup = uiOrdering.addNewGroup( RiaDefines::summaryAquifer() + "s" );
myGroup->add( m_identifierFieldsMap[RifEclipseSummaryAddress::SUMMARY_AQUIFER][0]->pdmField() );
}
@ -890,7 +891,7 @@ void RiuSummaryVectorSelectionUi::defineUiOrdering( QString uiConfigName, caf::P
else if ( sumCategory == RifEclipseSummaryAddress::SUMMARY_REGION )
{
{
caf::PdmUiGroup* myGroup = uiOrdering.addNewGroup( "Regions" );
caf::PdmUiGroup* myGroup = uiOrdering.addNewGroup( RiaDefines::summaryRegion() + "s" );
myGroup->add( m_identifierFieldsMap[RifEclipseSummaryAddress::SUMMARY_REGION][0]->pdmField() );
}
@ -908,7 +909,7 @@ void RiuSummaryVectorSelectionUi::defineUiOrdering( QString uiConfigName, caf::P
else if ( sumCategory == RifEclipseSummaryAddress::SUMMARY_GROUP )
{
{
caf::PdmUiGroup* myGroup = uiOrdering.addNewGroup( "Groups" );
caf::PdmUiGroup* myGroup = uiOrdering.addNewGroup( RiaDefines::summaryWellGroup() + "s" );
myGroup->add( m_identifierFieldsMap[RifEclipseSummaryAddress::SUMMARY_GROUP][0]->pdmField() );
}
@ -917,7 +918,7 @@ void RiuSummaryVectorSelectionUi::defineUiOrdering( QString uiConfigName, caf::P
else if ( sumCategory == RifEclipseSummaryAddress::SUMMARY_WELL )
{
{
caf::PdmUiGroup* myGroup = uiOrdering.addNewGroup( "Wells" );
caf::PdmUiGroup* myGroup = uiOrdering.addNewGroup( RiaDefines::summaryWell() + "s" );
myGroup->add( m_identifierFieldsMap[RifEclipseSummaryAddress::SUMMARY_WELL][0]->pdmField() );
}
@ -926,7 +927,7 @@ void RiuSummaryVectorSelectionUi::defineUiOrdering( QString uiConfigName, caf::P
else if ( sumCategory == RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION )
{
{
caf::PdmUiGroup* myGroup = uiOrdering.addNewGroup( "Completions" );
caf::PdmUiGroup* myGroup = uiOrdering.addNewGroup( RiaDefines::summaryCompletion() + "s" );
myGroup->add( m_identifierFieldsMap[RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION][0]->pdmField() );
myGroup->add( m_identifierFieldsMap[RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION][1]->pdmField() );
}
@ -936,7 +937,7 @@ void RiuSummaryVectorSelectionUi::defineUiOrdering( QString uiConfigName, caf::P
else if ( sumCategory == RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION_LGR )
{
{
caf::PdmUiGroup* myGroup = uiOrdering.addNewGroup( "LGR Completions" );
caf::PdmUiGroup* myGroup = uiOrdering.addNewGroup( RiaDefines::summaryLgrCompletion() + "s" );
myGroup->add( m_identifierFieldsMap[RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION_LGR][0]->pdmField() );
myGroup->add( m_identifierFieldsMap[RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION_LGR][1]->pdmField() );
myGroup->add( m_identifierFieldsMap[RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION_LGR][2]->pdmField() );
@ -947,7 +948,7 @@ void RiuSummaryVectorSelectionUi::defineUiOrdering( QString uiConfigName, caf::P
else if ( sumCategory == RifEclipseSummaryAddress::SUMMARY_WELL_LGR )
{
{
caf::PdmUiGroup* myGroup = uiOrdering.addNewGroup( "LGR Wells" );
caf::PdmUiGroup* myGroup = uiOrdering.addNewGroup( RiaDefines::summaryLgrWell() + "s" );
myGroup->add( m_identifierFieldsMap[RifEclipseSummaryAddress::SUMMARY_WELL_LGR][0]->pdmField() );
myGroup->add( m_identifierFieldsMap[RifEclipseSummaryAddress::SUMMARY_WELL_LGR][1]->pdmField() );
}
@ -957,7 +958,7 @@ void RiuSummaryVectorSelectionUi::defineUiOrdering( QString uiConfigName, caf::P
else if ( sumCategory == RifEclipseSummaryAddress::SUMMARY_WELL_SEGMENT )
{
{
caf::PdmUiGroup* myGroup = uiOrdering.addNewGroup( "Well Segments" );
caf::PdmUiGroup* myGroup = uiOrdering.addNewGroup( RiaDefines::summaryWellSegment() + "s" );
myGroup->add( m_identifierFieldsMap[RifEclipseSummaryAddress::SUMMARY_WELL_SEGMENT][0]->pdmField() );
myGroup->add( m_identifierFieldsMap[RifEclipseSummaryAddress::SUMMARY_WELL_SEGMENT][1]->pdmField() );
}
@ -967,7 +968,7 @@ void RiuSummaryVectorSelectionUi::defineUiOrdering( QString uiConfigName, caf::P
else if ( sumCategory == RifEclipseSummaryAddress::SUMMARY_BLOCK )
{
{
caf::PdmUiGroup* myGroup = uiOrdering.addNewGroup( "Blocks" );
caf::PdmUiGroup* myGroup = uiOrdering.addNewGroup( RiaDefines::summaryBlock() + "s" );
myGroup->add( m_identifierFieldsMap[RifEclipseSummaryAddress::SUMMARY_BLOCK][0]->pdmField() );
}
@ -976,7 +977,7 @@ void RiuSummaryVectorSelectionUi::defineUiOrdering( QString uiConfigName, caf::P
else if ( sumCategory == RifEclipseSummaryAddress::SUMMARY_BLOCK_LGR )
{
{
caf::PdmUiGroup* myGroup = uiOrdering.addNewGroup( "LGR Blocks" );
caf::PdmUiGroup* myGroup = uiOrdering.addNewGroup( RiaDefines::summaryLgrBlock() + "s" );
myGroup->add( m_identifierFieldsMap[RifEclipseSummaryAddress::SUMMARY_BLOCK_LGR][0]->pdmField() );
myGroup->add( m_identifierFieldsMap[RifEclipseSummaryAddress::SUMMARY_BLOCK_LGR][1]->pdmField() );
}
@ -1505,7 +1506,7 @@ void RiuSummaryVectorSelectionUi::appendOptionItemsForSubCategoriesAndVectors( Q
}
else if ( i == CALCULATED_CURVES )
{
headerText = QString( "Calculated" );
headerText = QString( RiaDefines::summaryCalculated() );
}
if ( !headerText.isEmpty() )