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

Fix source list in Summary Editor for ensemble plots

Browse Source
This commit is contained in:
Gaute Lindkvist 2020-09-15 12:53:46 +02:00
parent b4aaaa98e9
commit 71d032f4ad
15 changed files with 164 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
ApplicationCode/Application/RiaSummaryCurveDefinition.cpp
View File

@ -30,7 +30,7 @@
RiaSummaryCurveDefinition::RiaSummaryCurveDefinition()
: m_summaryCase( nullptr )
, m_ensemble( nullptr )
, m_isEnsembleCurve( false )
{
}
@ -38,22 +38,31 @@ RiaSummaryCurveDefinition::RiaSummaryCurveDefinition()
///
//--------------------------------------------------------------------------------------------------
RiaSummaryCurveDefinition::RiaSummaryCurveDefinition( RimSummaryCase* summaryCase,
const RifEclipseSummaryAddress& summaryAddress )
const RifEclipseSummaryAddress& summaryAddress,
bool isEnsembleCurve )
: m_summaryCase( summaryCase )
, m_ensemble( nullptr )
, m_summaryAddress( summaryAddress )
, m_treatAsSingleSummaryCurve( true )
, m_isEnsembleCurve( isEnsembleCurve )
{
CAF_ASSERT( summaryCase );
if ( summaryCase )
{
RimSummaryCaseCollection* ensemble = nullptr;
summaryCase->firstAncestorOfType( ensemble );
m_ensemble = ensemble;
}
}
RiaSummaryCurveDefinition::RiaSummaryCurveDefinition( RimSummaryCase* summaryCase,
const RifEclipseSummaryAddress& summaryAddress,
RimSummaryCaseCollection* ensemble,
bool treatAsSingleSummaryCurve )
: m_summaryCase( summaryCase )
, m_ensemble( ensemble )
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaSummaryCurveDefinition::RiaSummaryCurveDefinition( RimSummaryCaseCollection* ensemble,
const RifEclipseSummaryAddress& summaryAddress )
: m_summaryCase( nullptr )
, m_summaryAddress( summaryAddress )
, m_treatAsSingleSummaryCurve( treatAsSingleSummaryCurve )
, m_ensemble( ensemble )
, m_isEnsembleCurve( true )
{
}
@ -86,7 +95,7 @@ const RifEclipseSummaryAddress& RiaSummaryCurveDefinition::summaryAddress() cons
//--------------------------------------------------------------------------------------------------
bool RiaSummaryCurveDefinition::isEnsembleCurve() const
{
return m_ensemble != nullptr && !m_treatAsSingleSummaryCurve;
return m_isEnsembleCurve;
}
//--------------------------------------------------------------------------------------------------
@ -205,7 +214,12 @@ bool RiaSummaryCurveDefinition::operator<( const RiaSummaryCurveDefinition& othe
return m_summaryCase < other.summaryCase();
}
return ( m_summaryAddress < other.summaryAddress() );
if ( m_summaryAddress != other.summaryAddress() )
{
return ( m_summaryAddress < other.summaryAddress() );
}
return m_isEnsembleCurve < other.isEnsembleCurve();
}
//--------------------------------------------------------------------------------------------------

7
ApplicationCode/Application/RiaSummaryCurveDefinition.h
View File

@ -35,11 +35,10 @@ class RiaSummaryCurveDefinition
{
public:
RiaSummaryCurveDefinition();
explicit RiaSummaryCurveDefinition( RimSummaryCase* summaryCase, const RifEclipseSummaryAddress& summaryAddress );
explicit RiaSummaryCurveDefinition( RimSummaryCase* summaryCase,
const RifEclipseSummaryAddress& summaryAddress,
RimSummaryCaseCollection* ensemble,
bool treatAsSingleSummaryCurve );
bool isEnsembleCurve );
explicit RiaSummaryCurveDefinition( RimSummaryCaseCollection* ensemble, const RifEclipseSummaryAddress& summaryAddress );
RimSummaryCase* summaryCase() const;
const RifEclipseSummaryAddress& summaryAddress() const;
@ -60,7 +59,7 @@ private:
RimSummaryCase* m_summaryCase;
RifEclipseSummaryAddress m_summaryAddress;
RimSummaryCaseCollection* m_ensemble;
bool m_treatAsSingleSummaryCurve;
bool m_isEnsembleCurve;
};
class RiaSummaryCurveDefinitionAnalyser

17
ApplicationCode/Commands/SummaryPlotCommands/RicSummaryPlotEditorUi.cpp
View File

@ -354,11 +354,7 @@ void RicSummaryPlotEditorUi::syncPreviewCurvesFromUiSelection()
for ( const auto& curve : currentCurvesInPreviewPlot )
{
RimSummaryCase* sumCase = curve->summaryCaseY();
currentCurveDefs.insert( RiaSummaryCurveDefinition( sumCase,
curve->summaryAddressY(),
sumCase ? sumCase->ensemble() : nullptr,
sumCase && sumCase->ensemble() ) );
currentCurveDefs.insert( curve->curveDefinitionY() );
}
{
@ -372,11 +368,7 @@ void RicSummaryPlotEditorUi::syncPreviewCurvesFromUiSelection()
for ( const auto& curve : currentCurvesInPreviewPlot )
{
RimSummaryCase* sumCase = curve->summaryCaseY();
if ( sumCase && sumCase->ensemble() ) continue;
RiaSummaryCurveDefinition curveDef =
RiaSummaryCurveDefinition( sumCase, curve->summaryAddressY(), nullptr, false );
RiaSummaryCurveDefinition curveDef = curve->curveDefinitionY();
if ( deleteCurveDefs.count( curveDef ) > 0 ) curvesToDelete.insert( curve );
}
}
@ -597,7 +589,7 @@ void RicSummaryPlotEditorUi::populateCurveCreator( const RimSummaryPlot& sourceS
for ( const auto& curve : sourceSummaryPlot.summaryCurves() )
{
curveDefs.push_back( RiaSummaryCurveDefinition( curve->summaryCaseY(), curve->summaryAddressY(), nullptr, false ) );
curveDefs.push_back( curve->curveDefinitionY() );
// Copy curve object to the preview plot
copyCurveAndAddToPlot( curve, m_previewPlot.get(), true );
@ -613,8 +605,7 @@ void RicSummaryPlotEditorUi::populateCurveCreator( const RimSummaryPlot& sourceS
RimSummaryCaseCollection* ensemble = curveSet->summaryCaseCollection();
for ( const auto& curve : curveSet->curves() )
{
curveDefs.push_back(
RiaSummaryCurveDefinition( curve->summaryCaseY(), curve->summaryAddressY(), ensemble, true ) );
curveDefs.push_back( curve->curveDefinitionY() );
}
}

42
ApplicationCode/ProjectDataModel/AnalysisPlots/RimAnalysisPlot.cpp
View File

@ -454,7 +454,7 @@ void RimAnalysisPlot::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
dlg.enableMultiSelect( true );
dlg.enableIndividualEnsembleCaseSelection( true );
dlg.setCurveSelection( this->curveDefinitionsWithoutEnsembleReference() );
dlg.setCurveSelection( this->curveDefinitions() );
if ( dlg.exec() == QDialog::Accepted )
{
@ -899,7 +899,7 @@ void RimAnalysisPlot::updateAxes()
std::set<QString> timeHistoryQuantities;
RimSummaryPlotAxisFormatter calc( valAxisProperties, {}, curveDefinitionsWithoutEnsembleReference(), {}, {} );
RimSummaryPlotAxisFormatter calc( valAxisProperties, {}, curveDefinitions(), {}, {} );
calc.applyAxisPropertiesToPlot( m_plotWidget );
}
else
@ -1047,7 +1047,7 @@ std::vector<size_t> RimAnalysisPlot::findTimestepIndices( std::vector<time_t>
//--------------------------------------------------------------------------------------------------
std::vector<RiaSummaryCurveDefinition> RimAnalysisPlot::filteredCurveDefs()
{
std::vector<RiaSummaryCurveDefinition> dataDefinitions = curveDefinitionsWithEmbeddedEnsembleReference();
std::vector<RiaSummaryCurveDefinition> dataDefinitions = curveDefinitions();
// Split out the filter targets
@ -1667,54 +1667,24 @@ RiaSummaryCurveDefinitionAnalyser* RimAnalysisPlot::getOrCreateSelectedCurveDefA
m_analyserOfSelectedCurveDefs =
std::unique_ptr<RiaSummaryCurveDefinitionAnalyser>( new RiaSummaryCurveDefinitionAnalyser );
}
m_analyserOfSelectedCurveDefs->setCurveDefinitions( this->curveDefinitionsWithoutEnsembleReference() );
m_analyserOfSelectedCurveDefs->setCurveDefinitions( this->curveDefinitions() );
return m_analyserOfSelectedCurveDefs.get();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RiaSummaryCurveDefinition> RimAnalysisPlot::curveDefinitionsWithoutEnsembleReference() const
std::vector<RiaSummaryCurveDefinition> RimAnalysisPlot::curveDefinitions() const
{
std::vector<RiaSummaryCurveDefinition> curveDefs;
for ( auto dataEntry : m_analysisPlotDataSelection )
{
if ( dataEntry->isEnsembleCurve() )
{
curveDefs.push_back( dataEntry->curveDefinition() );
}
curveDefs.push_back( dataEntry->curveDefinition() );
}
return curveDefs;
}
//--------------------------------------------------------------------------------------------------
/// The curve definitions returned contain both the case AND the ensemble from which it has been spawned
//--------------------------------------------------------------------------------------------------
std::vector<RiaSummaryCurveDefinition> RimAnalysisPlot::curveDefinitionsWithEmbeddedEnsembleReference()
{
std::vector<RiaSummaryCurveDefinition> barDataDefinitions;
for ( const RimAnalysisPlotDataEntry* dataEntry : m_analysisPlotDataSelection )
{
RiaSummaryCurveDefinition orgBarDataEntry = dataEntry->curveDefinition();
if ( orgBarDataEntry.summaryCase() && orgBarDataEntry.summaryCase()->ensemble() )
{
barDataDefinitions.push_back( RiaSummaryCurveDefinition( orgBarDataEntry.summaryCase(),
orgBarDataEntry.summaryAddress(),
orgBarDataEntry.summaryCase()->ensemble(),
orgBarDataEntry.isEnsembleCurve() ) );
}
else
{
barDataDefinitions.push_back( orgBarDataEntry );
}
}
return barDataDefinitions;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

3
ApplicationCode/ProjectDataModel/AnalysisPlots/RimAnalysisPlot.h
View File

@ -158,8 +158,7 @@ private:
const QString& timestepString ) const;
RiaSummaryCurveDefinitionAnalyser* getOrCreateSelectedCurveDefAnalyser();
std::vector<RiaSummaryCurveDefinition> curveDefinitionsWithoutEnsembleReference() const;
std::vector<RiaSummaryCurveDefinition> curveDefinitionsWithEmbeddedEnsembleReference();
std::vector<RiaSummaryCurveDefinition> curveDefinitions() const;
std::vector<RiaSummaryCurveDefinition> filteredCurveDefs();
void applyFilter( const RimPlotDataFilterItem* filter,
std::set<RimSummaryCase*>* filteredSumCases,

4
ApplicationCode/ProjectDataModel/AnalysisPlots/RimAnalysisPlotCollection.cpp
View File

@ -147,7 +147,7 @@ void RimAnalysisPlotCollection::applyFirstEnsembleFieldAddressesToPlot( RimAnaly
{
for ( auto summaryCase : ensembles.front()->allSummaryCases() )
{
curveDefs.push_back( RiaSummaryCurveDefinition( summaryCase, address, ensembles.front(), false ) );
curveDefs.push_back( RiaSummaryCurveDefinition( summaryCase, address, false ) );
}
}
}
@ -173,7 +173,7 @@ void RimAnalysisPlotCollection::applyEnsembleFieldAndTimeStepToPlot( RimAnalysis
{
for ( auto summaryCase : ensemble->allSummaryCases() )
{
curveDefs.push_back( RiaSummaryCurveDefinition( summaryCase, address, ensemble, false ) );
curveDefs.push_back( RiaSummaryCurveDefinition( summaryCase, address, false ) );
}
}
}

10
ApplicationCode/ProjectDataModel/AnalysisPlots/RimAnalysisPlotDataEntry.cpp
View File

@ -77,11 +77,15 @@ void RimAnalysisPlotDataEntry::setFromCurveDefinition( const RiaSummaryCurveDefi
//--------------------------------------------------------------------------------------------------
RiaSummaryCurveDefinition RimAnalysisPlotDataEntry::curveDefinition() const
{
if ( m_ensemble )
if ( m_summaryCase() )
{
return RiaSummaryCurveDefinition( m_summaryCase(), m_summaryAddress->address(), m_ensemble(), m_isEnsembleCurve );
return RiaSummaryCurveDefinition( m_summaryCase(), m_summaryAddress->address(), m_isEnsembleCurve );
}
else
{
CAF_ASSERT( m_ensemble() );
return RiaSummaryCurveDefinition( m_ensemble(), m_summaryAddress->address() );
}
return RiaSummaryCurveDefinition( m_summaryCase(), m_summaryAddress->address() );
}
//--------------------------------------------------------------------------------------------------

13
ApplicationCode/ProjectDataModel/CorrelationPlots/RimCorrelationPlotCollection.cpp
View File

@ -228,7 +228,7 @@ void RimCorrelationPlotCollection::applyFirstEnsembleFieldAddressesToPlot( RimAb
auto it = std::find( quantityNames.begin(), quantityNames.end(), QString::fromStdString( address.uiText() ) );
if ( it != quantityNames.end() || quantityNames.empty() )
{
curveDefs.push_back( RiaSummaryCurveDefinition( nullptr, address, ensembles.front(), true ) );
curveDefs.push_back( RiaSummaryCurveDefinition( ensembles.front(), address ) );
}
}
plot->setCurveDefinitions( curveDefs );
@ -258,7 +258,7 @@ void RimCorrelationPlotCollection::applyEnsembleFieldAndTimeStepToPlot( RimAbstr
auto it = std::find( quantityNames.begin(), quantityNames.end(), QString::fromStdString( address.uiText() ) );
if ( it != quantityNames.end() || quantityNames.empty() )
{
curveDefs.push_back( RiaSummaryCurveDefinition( nullptr, address, ensemble, true ) );
curveDefs.push_back( RiaSummaryCurveDefinition( ensemble, address ) );
}
}
plot->setCurveDefinitions( curveDefs );
@ -287,14 +287,13 @@ void RimCorrelationPlotCollection::applyFirstEnsembleFieldAddressesToReport( Rim
QString::fromStdString( address.uiText() ) );
if ( it != matrixQuantityNames.end() || matrixQuantityNames.empty() )
{
curveDefsMatrix.push_back( RiaSummaryCurveDefinition( nullptr, address, ensembles.front(), true ) );
curveDefsMatrix.push_back( RiaSummaryCurveDefinition( ensembles.front(), address ) );
}
if ( tornadoAndCrossPlotQuantityName.isEmpty() ||
tornadoAndCrossPlotQuantityName == QString::fromStdString( address.uiText() ) )
{
curveDefsTornadoAndCrossPlot.push_back(
RiaSummaryCurveDefinition( nullptr, address, ensembles.front(), true ) );
curveDefsTornadoAndCrossPlot.push_back( RiaSummaryCurveDefinition( ensembles.front(), address ) );
}
}
@ -326,13 +325,13 @@ void RimCorrelationPlotCollection::applyEnsembleFieldAndTimeStepToReport( RimCor
QString::fromStdString( address.uiText() ) );
if ( it != matrixQuantityNames.end() || matrixQuantityNames.empty() )
{
curveDefsMatrix.push_back( RiaSummaryCurveDefinition( nullptr, address, ensemble, true ) );
curveDefsMatrix.push_back( RiaSummaryCurveDefinition( ensemble, address ) );
}
if ( tornadoAndCrossPlotQuantityName.isEmpty() ||
tornadoAndCrossPlotQuantityName == QString::fromStdString( address.uiText() ) )
{
curveDefsTornadoAndCrossPlot.push_back( RiaSummaryCurveDefinition( nullptr, address, ensemble, true ) );
curveDefsTornadoAndCrossPlot.push_back( RiaSummaryCurveDefinition( ensemble, address ) );
}
}
plot->matrixPlot()->setCurveDefinitions( curveDefsMatrix );

2
ApplicationCode/ProjectDataModel/RimSummaryCalculation.cpp
View File

@ -281,7 +281,7 @@ bool RimSummaryCalculation::calculate()
return false;
}
RiaSummaryCurveDefinition curveDef( v->summaryCase(), v->summaryAddress()->address() );
RiaSummaryCurveDefinition curveDef( v->summaryCase(), v->summaryAddress()->address(), false );
std::vector<double> curveValues;
RiaSummaryCurveDefinition::resultValues( curveDef, &curveValues );

60
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurve.cpp
View File

@ -70,7 +70,6 @@ RimSummaryCurve::RimSummaryCurve()
CAF_PDM_InitObject( "Summary Curve", ":/SummaryCurve16x16.png", "", "" );
// Y Values
CAF_PDM_InitFieldNoDefault( &m_yValuesSummaryCase, "SummaryCase", "Case", "", "", "" );
m_yValuesSummaryCase.uiCapability()->setUiTreeChildrenHidden( true );
m_yValuesSummaryCase.uiCapability()->setAutoAddingOptionFromValue( false );
@ -91,7 +90,6 @@ RimSummaryCurve::RimSummaryCurve()
m_yValuesSummaryAddress = new RimSummaryAddress;
// X Values
CAF_PDM_InitFieldNoDefault( &m_xValuesSummaryCase, "SummaryCaseX", "Case", "", "", "" );
m_xValuesSummaryCase.uiCapability()->setUiTreeChildrenHidden( true );
m_xValuesSummaryCase.uiCapability()->setAutoAddingOptionFromValue( false );
@ -113,6 +111,8 @@ RimSummaryCurve::RimSummaryCurve()
m_xValuesSummaryAddress = new RimSummaryAddress;
// Other members
CAF_PDM_InitFieldNoDefault( &m_isEnsembleCurve, "IsEnsembleCurve", "Ensemble Curve", "", "", "" );
m_isEnsembleCurve.v() = caf::Tristate::State::PartiallyTrue;
CAF_PDM_InitFieldNoDefault( &m_plotAxis, "PlotAxis", "Axis", "", "", "" );
@ -150,6 +150,14 @@ RimSummaryCurve::~RimSummaryCurve()
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaSummaryCurveDefinition RimSummaryCurve::curveDefinitionY() const
{
return RiaSummaryCurveDefinition( summaryCaseY(), summaryAddressY(), isEnsembleCurve() );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -160,6 +168,11 @@ void RimSummaryCurve::setSummaryCaseY( RimSummaryCase* sumCase )
m_qwtCurveErrorBars->setSamples( nullptr );
}
if ( m_isEnsembleCurve().isPartiallyTrue() )
{
setIsEnsembleCurve( sumCase->ensemble() );
}
m_yValuesSummaryCase = sumCase;
}
@ -275,6 +288,16 @@ std::vector<double> RimSummaryCurve::valuesY() const
return values;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurve::applyCurveDefinitionY( const RiaSummaryCurveDefinition& curveDefinition )
{
setSummaryCaseY( curveDefinition.summaryCase() );
setSummaryAddressY( curveDefinition.summaryAddress() );
setIsEnsembleCurve( curveDefinition.isEnsembleCurve() );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -392,6 +415,11 @@ void RimSummaryCurve::setOverrideCurveDataY( const std::vector<time_t>& dateTime
void RimSummaryCurve::setSummaryCaseX( RimSummaryCase* sumCase )
{
m_xValuesSummaryCase = sumCase;
if ( m_isEnsembleCurve().isPartiallyTrue() )
{
setIsEnsembleCurve( sumCase->ensemble() );
}
}
//--------------------------------------------------------------------------------------------------
@ -418,6 +446,22 @@ RiaDefines::PlotAxis RimSummaryCurve::axisY() const
return m_plotAxis();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimSummaryCurve::isEnsembleCurve() const
{
return m_isEnsembleCurve().isTrue();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurve::setIsEnsembleCurve( bool isEnsembleCurve )
{
m_isEnsembleCurve.v() = isEnsembleCurve ? caf::Tristate::State::True : caf::Tristate::State::False;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -664,6 +708,18 @@ void RimSummaryCurve::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrderi
setUiIcon( iconProvider );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurve::initAfterRead()
{
if ( m_isEnsembleCurve().isPartiallyTrue() )
{
m_isEnsembleCurve.v() = ( summaryCaseY() && summaryCaseY()->ensemble() ) ? caf::Tristate::State::True
: caf::Tristate::State::False;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

30
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurve.h
View File

@ -25,10 +25,12 @@
#include "cafPdmPtrField.h"
#include "RiaDefines.h"
#include "RiaSummaryCurveDefinition.h"
#include "RifEclipseSummaryAddressQMetaType.h"
#include "RimStackablePlotCurve.h"
#include "cafAppEnum.h"
#include "cafTristate.h"
class RifSummaryReaderInterface;
class RimSummaryCase;
@ -50,14 +52,17 @@ public:
~RimSummaryCurve() override;
// Y Axis functions
void setSummaryCaseY( RimSummaryCase* sumCase );
RimSummaryCase* summaryCaseY() const;
void setSummaryAddressYAndApplyInterpolation( const RifEclipseSummaryAddress& address );
void setSummaryAddressY( const RifEclipseSummaryAddress& address );
RiaSummaryCurveDefinition curveDefinitionY() const;
RimSummaryCase* summaryCaseY() const;
RifEclipseSummaryAddress summaryAddressY() const;
std::string unitNameY() const;
std::vector<double> valuesY() const;
void applyCurveDefinitionY( const RiaSummaryCurveDefinition& curveDefinition );
void setSummaryCaseY( RimSummaryCase* sumCase );
void setSummaryAddressYAndApplyInterpolation( const RifEclipseSummaryAddress& address );
void setSummaryAddressY( const RifEclipseSummaryAddress& address );
RifEclipseSummaryAddress summaryAddressY() const;
std::string unitNameY() const;
std::vector<double> valuesY() const;
RifEclipseSummaryAddress errorSummaryAddressY() const;
std::vector<double> errorValuesY() const;
void setLeftOrRightAxisY( RiaDefines::PlotAxis plotAxis );
@ -67,14 +72,18 @@ public:
void setOverrideCurveDataY( const std::vector<time_t>& xValues, const std::vector<double>& yValues );
// X Axis functions
void setSummaryCaseX( RimSummaryCase* sumCase );
RimSummaryCase* summaryCaseX() const;
RifEclipseSummaryAddress summaryAddressX() const;
void setSummaryAddressX( const RifEclipseSummaryAddress& address );
std::string unitNameX() const;
std::vector<double> valuesX() const;
void setSummaryCaseX( RimSummaryCase* sumCase );
void setSummaryAddressX( const RifEclipseSummaryAddress& address );
// Other
bool isEnsembleCurve() const;
void setIsEnsembleCurve( bool isEnsembleCurve );
void updateQwtPlotAxis();
void applyCurveAutoNameSettings( const RimSummaryCurveAutoName& autoNameSettings );
@ -97,6 +106,7 @@ protected:
void updateLegendsInPlot() override;
void defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName = "" ) override;
void initAfterRead();
private:
RifSummaryReaderInterface* valuesSummaryReaderX() const;
@ -129,6 +139,8 @@ private:
caf::PdmField<RifEclipseSummaryAddress> m_xValuesSummaryAddressUiField;
caf::PdmField<bool> m_xPushButtonSelectSummaryAddress;
caf::PdmField<caf::Tristate> m_isEnsembleCurve;
caf::PdmChildField<RimSummaryCurveAutoName*> m_curveNameConfig;
caf::PdmField<caf::AppEnum<RiaDefines::PlotAxis>> m_plotAxis;
caf::PdmField<bool> m_isTopZWithinCategory;

3
ApplicationCode/ProjectDataModel/Summary/RimSummaryPlot.cpp
View File

@ -535,7 +535,8 @@ std::set<RiaSummaryCurveDefinition> RimSummaryPlot::summaryAndEnsembleCurveDefin
for ( const auto& curve : this->summaryAndEnsembleCurves() )
{
allCurveDefs.insert( RiaSummaryCurveDefinition( curve->summaryCaseY(), curve->summaryAddressY() ) );
allCurveDefs.insert(
RiaSummaryCurveDefinition( curve->summaryCaseY(), curve->summaryAddressY(), curve->isEnsembleCurve() ) );
}
return allCurveDefs;
}

2
ApplicationCode/ProjectDataModel/Summary/RimSummaryPlotFilterTextCurveSetEditor.cpp
View File

@ -263,7 +263,7 @@ void RimSummaryPlotFilterTextCurveSetEditor::fieldChangedByUi( const caf::PdmFie
for ( const auto& filteredAddress : filteredAddressesFromSource )
{
curveDefinitions.insert( RiaSummaryCurveDefinition( sumCase, filteredAddress, ensemble, true ) );
curveDefinitions.insert( RiaSummaryCurveDefinition( sumCase, filteredAddress, ensemble != nullptr ) );
}
}

4
ApplicationCode/UserInterface/RiuSummaryVectorSelectionDialog.cpp
View File

@ -82,7 +82,7 @@ void RiuSummaryVectorSelectionDialog::setCaseAndAddress( RimSummaryCase*
if ( summaryCase )
{
std::vector<RiaSummaryCurveDefinition> curveDefs;
curveDefs.push_back( RiaSummaryCurveDefinition( summaryCase, address ) );
curveDefs.push_back( RiaSummaryCurveDefinition( summaryCase, address, false ) );
setCurveSelection( curveDefs );
}
}
@ -96,7 +96,7 @@ void RiuSummaryVectorSelectionDialog::setEnsembleAndAddress( RimSummaryCaseColle
if ( ensemble )
{
std::vector<RiaSummaryCurveDefinition> curveDefs;
curveDefs.push_back( RiaSummaryCurveDefinition( nullptr, address, ensemble, true ) );
curveDefs.push_back( RiaSummaryCurveDefinition( ensemble, address ) );
setCurveSelection( curveDefs );
}
}

35
ApplicationCode/UserInterface/RiuSummaryVectorSelectionUi.cpp
View File

@ -445,7 +445,7 @@ std::vector<RiaSummaryCurveDefinition> RiuSummaryVectorSelectionUi::allCurveDefi
if ( selectedAddressesFromUi.count( addressFromSource ) > 0 )
{
curveDefinitions.insert(
RiaSummaryCurveDefinition( caseFromSource, addressFromSource, ensemble, false ) );
RiaSummaryCurveDefinition( caseFromSource, addressFromSource, ensemble != nullptr ) );
}
}
}
@ -512,7 +512,7 @@ std::vector<RiaSummaryCurveDefinition> RiuSummaryVectorSelectionUi::selection()
{
if ( addressUnion.count( addr ) )
{
curveDefSelection.push_back( RiaSummaryCurveDefinition( nullptr, addr, ensemble, true ) );
curveDefSelection.push_back( RiaSummaryCurveDefinition( ensemble, addr ) );
}
}
}
@ -525,7 +525,7 @@ std::vector<RiaSummaryCurveDefinition> RiuSummaryVectorSelectionUi::selection()
{
if ( readerAddresses.count( addr ) )
{
curveDefSelection.push_back( RiaSummaryCurveDefinition( sourceCase, addr ) );
curveDefSelection.push_back( RiaSummaryCurveDefinition( sourceCase, addr, false ) );
}
}
}
@ -594,9 +594,14 @@ void RiuSummaryVectorSelectionUi::setDefaultSelection( const std::vector<Summary
{
RimSummaryCase* sumCase = dynamic_cast<RimSummaryCase*>( s );
RimSummaryCaseCollection* ensemble = dynamic_cast<RimSummaryCaseCollection*>( s );
RiaSummaryCurveDefinition curveDef( sumCase, defaultAddress, ensemble, true );
curveDefs.push_back( curveDef );
if ( ensemble )
{
curveDefs.push_back( RiaSummaryCurveDefinition( ensemble, defaultAddress ) );
}
else
{
curveDefs.push_back( RiaSummaryCurveDefinition( sumCase, defaultAddress, false ) );
}
}
setSelectedCurveDefinitions( curveDefs );
@ -640,14 +645,20 @@ void RiuSummaryVectorSelectionUi::setSelectedCurveDefinitions( const std::vector
}
// Select case if not already selected
SummarySource* summSource = curveDef.isEnsembleCurve() ? static_cast<SummarySource*>( curveDef.ensemble() )
: summaryCase;
if ( std::find( m_selectedSources.begin(), m_selectedSources.end(), summSource ) == m_selectedSources.end() )
if ( curveDef.isEnsembleCurve() )
{
if ( summaryCase != calculatedSummaryCase() )
if ( curveDef.ensemble() && !m_hideEnsembles )
{
m_selectedSources.push_back( summSource );
handleAddedSource( summSource );
m_selectedSources.push_back( curveDef.ensemble() );
handleAddedSource( curveDef.ensemble() );
}
}
else
{
if ( curveDef.summaryCase() && m_showIndividualEnsembleCases )
{
m_selectedSources.push_back( curveDef.summaryCase() );
handleAddedSource( curveDef.summaryCase() );
}
}