OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-09 23:16:00 -06:00
Code Issues Packages Projects Releases Wiki Activity

#2692 Ensemble curves. Add ensemble selection support to curve editor

Browse Source
This commit is contained in:
Bjørn Erik Jensen 2018-05-10 21:29:55 +02:00
parent 090435a2ea
commit 6270dd3bc9
16 changed files with 265 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
ApplicationCode/Application/RiaSummaryCurveDefinition.cpp
View File

@ -24,9 +24,12 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaSummaryCurveDefinition::RiaSummaryCurveDefinition(RimSummaryCase* summaryCase, const RifEclipseSummaryAddress& summaryAddress)
RiaSummaryCurveDefinition::RiaSummaryCurveDefinition(RimSummaryCase* summaryCase,
const RifEclipseSummaryAddress& summaryAddress,
RimSummaryCaseCollection* ensemble)
{
m_curveDefinition = std::make_pair(summaryCase, summaryAddress);
m_ensemble = ensemble;
}
//--------------------------------------------------------------------------------------------------
@ -37,6 +40,14 @@ RimSummaryCase* RiaSummaryCurveDefinition::summaryCase() const
return m_curveDefinition.first;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimSummaryCaseCollection* RiaSummaryCurveDefinition::ensemble() const
{
return m_ensemble;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -45,6 +56,14 @@ const RifEclipseSummaryAddress& RiaSummaryCurveDefinition::summaryAddress() cons
return m_curveDefinition.second;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RiaSummaryCurveDefinition::isEnsembleCurve() const
{
return m_ensemble != nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

10
ApplicationCode/Application/RiaSummaryCurveDefinition.h
View File

@ -26,6 +26,7 @@
#include <vector>
class RimSummaryCase;
class RimSummaryCaseCollection;
//==================================================================================================
///
@ -33,10 +34,14 @@ class RimSummaryCase;
class RiaSummaryCurveDefinition
{
public:
explicit RiaSummaryCurveDefinition(RimSummaryCase* summaryCase, const RifEclipseSummaryAddress& summaryAddress);
explicit RiaSummaryCurveDefinition(RimSummaryCase* summaryCase,
const RifEclipseSummaryAddress& summaryAddress,
RimSummaryCaseCollection* emsemble = nullptr);
RimSummaryCase* summaryCase() const;
const RifEclipseSummaryAddress& summaryAddress() const;
RimSummaryCaseCollection* ensemble() const;
bool isEnsembleCurve() const;
bool operator < (const RiaSummaryCurveDefinition& other) const;
@ -51,5 +56,6 @@ public:
private:
private:
std::pair<RimSummaryCase*, RifEclipseSummaryAddress> m_curveDefinition;
std::pair<RimSummaryCase*, RifEclipseSummaryAddress> m_curveDefinition;
RimSummaryCaseCollection* m_ensemble;
};

2
ApplicationCode/Commands/SummaryPlotCommands/RicNewSummaryEnsembleCurveSetFeature.cpp
View File

@ -70,7 +70,7 @@ void RicNewSummaryEnsembleCurveSetFeature::onActionTriggered(bool isChecked)
curveSet->setSummaryCaseCollection(project->summaryGroups().back());
}
plot->ensembleCurveSets()->addCurveSet(curveSet);
plot->ensembleCurveSetCollection()->addCurveSet(curveSet);
plot->updateConnectedEditors();
RiaApplication::instance()->getOrCreateAndShowMainPlotWindow()->selectAsCurrentItem(curveSet);

2
ApplicationCode/Commands/SummaryPlotCommands/RicPasteEnsembleCurveSetFeature.cpp
View File

@ -52,7 +52,7 @@ RimEnsembleCurveSet* RicPasteEnsembleCurveSetFeature::copyCurveSetAndAddToCollec
RimEnsembleCurveSet* newCurveSet = dynamic_cast<RimEnsembleCurveSet*>(sourceCurveSet->xmlCapability()->copyByXmlSerialization(caf::PdmDefaultObjectFactory::instance()));
CVF_ASSERT(newCurveSet);
if (!coll) coll = plot->ensembleCurveSets();
if (!coll) coll = plot->ensembleCurveSetCollection();
coll->addCurveSet(newCurveSet);

94
ApplicationCode/Commands/SummaryPlotCommands/RicSummaryCurveCreator.cpp
View File

@ -309,7 +309,7 @@ void RicSummaryCurveCreator::syncPreviewCurvesFromUiSelection()
std::vector<RiaSummaryCurveDefinition> allCurveDefinitionsVector = m_summaryCurveSelectionEditor->summaryAddressSelection()->selectedCurveDefinitions();
std::set<RiaSummaryCurveDefinition> allCurveDefinitions = std::set<RiaSummaryCurveDefinition>(allCurveDefinitionsVector.begin(), allCurveDefinitionsVector.end());
std::vector<RimSummaryCurve*> currentCurvesInPreviewPlot = m_previewPlot->summaryCurves();
std::vector<RimSummaryCurve*> currentCurvesInPreviewPlot = m_previewPlot->summaryAndEnsembleCurves();
if (allCurveDefinitions.size() != currentCurvesInPreviewPlot.size())
{
std::set<RiaSummaryCurveDefinition> currentCurveDefs;
@ -374,8 +374,33 @@ void RicSummaryCurveCreator::updatePreviewCurvesFromCurveDefinitions(const std::
curve->setSummaryCaseY(currentCase);
curve->setSummaryAddressY(curveDef.summaryAddress());
curve->applyCurveAutoNameSettings(*m_curveNameConfig());
m_previewPlot->addCurveNoUpdate(curve);
curveLookCalc.setupCurveLook(curve);
if (curveDef.isEnsembleCurve())
{
// Find curveSet
RimEnsembleCurveSet* curveSet = nullptr;
for (const auto& cs : m_previewPlot->ensembleCurveSetCollection()->curveSets())
{
if (cs->summaryCaseCollection() == curveDef.ensemble() && cs->summaryAddress() == curveDef.summaryAddress())
{
curveSet = cs;
break;
}
}
if (!curveSet)
{
curveSet = new RimEnsembleCurveSet();
curveSet->setSummaryCaseCollection(curveDef.ensemble());
curveSet->setSummaryAddress(curveDef.summaryAddress());
m_previewPlot->ensembleCurveSetCollection()->addCurveSet(curveSet);
}
curveSet->addCurve(curve);
}
else
{
m_previewPlot->addCurveNoUpdate(curve);
curveLookCalc.setupCurveLook(curve);
}
}
m_previewPlot->loadDataAndUpdate();
@ -489,24 +514,40 @@ void RicSummaryCurveCreator::populateCurveCreator(const RimSummaryPlot& sourceSu
std::vector<RiaSummaryCurveDefinition> curveDefs;
m_previewPlot->deleteAllSummaryCurves();
m_previewPlot->ensembleCurveSetCollection()->deleteAllCurveSets();
for (const auto& curve : sourceSummaryPlot.summaryCurves())
{
bool isObservedDataCase = isObservedData(curve->summaryCaseY());
curveDefs.push_back(RiaSummaryCurveDefinition(curve->summaryCaseY(), curve->summaryAddressY()));
// Copy curve object to the preview plot
copyCurveAndAddToPlot(curve, m_previewPlot.get(), true);
}
RimEnsembleCurveSetCollection* previewCurveSetColl = m_previewPlot->ensembleCurveSetCollection();
for (const auto& curveSet : sourceSummaryPlot.ensembleCurveSetCollection()->curveSets())
{
RimEnsembleCurveSet* newCurveSet = curveSet->clone();
previewCurveSetColl->addCurveSet(newCurveSet);
RimSummaryCaseCollection* ensemble = curveSet->summaryCaseCollection();
for (const auto& curve : curveSet->curves())
{
curveDefs.push_back(RiaSummaryCurveDefinition(curve->summaryCaseY(), curve->summaryAddressY(), ensemble));
// Copy curve object to the preview plot
copyEnsembleCurveAndAddToCurveSet(curve, newCurveSet, true);
}
}
// Set visibility for imported curves which were not checked in source plot
std::set <std::pair<RimSummaryCase*, RifEclipseSummaryAddress>> sourceCurveDefs;
for (const auto& curve : sourceSummaryPlot.summaryCurves())
for (const auto& curve : sourceSummaryPlot.summaryAndEnsembleCurves())
{
sourceCurveDefs.insert(std::make_pair(curve->summaryCaseY(), curve->summaryAddressY()));
}
for (const auto& curve : m_previewPlot->summaryCurves())
for (const auto& curve : m_previewPlot->summaryAndEnsembleCurves())
{
auto curveDef = std::make_pair(curve->summaryCaseY(), curve->summaryAddressY());
if (sourceCurveDefs.count(curveDef) == 0)
@ -531,6 +572,7 @@ void RicSummaryCurveCreator::updateTargetPlot()
if (m_targetPlot == nullptr) m_targetPlot = new RimSummaryPlot();
m_targetPlot->deleteAllSummaryCurves();
m_targetPlot->ensembleCurveSetCollection()->deleteAllCurveSets();
// Add edited curves to target plot
for (const auto& editedCurve : m_previewPlot->summaryCurves())
@ -542,22 +584,20 @@ void RicSummaryCurveCreator::updateTargetPlot()
copyCurveAndAddToPlot(editedCurve, m_targetPlot);
}
// DEBUG
//{
// m_targetPlot->ensembleCurveSets()->deleteAllCurveSets();
for (const auto& editedCurveSet : m_previewPlot->ensembleCurveSetCollection()->curveSets())
{
if (!editedCurveSet->isCurvesVisible())
{
continue;
}
// RimEnsembleCurveSet* curveSet = new RimEnsembleCurveSet();
// m_targetPlot->ensembleCurveSets()->addCurveSet(curveSet);
// for (const auto& editedCurve : m_previewPlot->summaryCurves())
// {
// if (!editedCurve->isCurveVisible())
// {
// continue;
// }
// copyEnsembleCurveAndAddToPlot(editedCurve, curveSet);
// }
//}
RimEnsembleCurveSet* newCurveSet = editedCurveSet->clone();
m_targetPlot->ensembleCurveSetCollection()->addCurveSet(newCurveSet);
for (const auto& editedCurve : newCurveSet->curves())
{
copyEnsembleCurveAndAddToCurveSet(editedCurve, editedCurveSet);
}
}
m_targetPlot->enableAutoPlotTitle(m_useAutoPlotTitleProxy());
@ -580,9 +620,6 @@ void RicSummaryCurveCreator::copyCurveAndAddToPlot(const RimSummaryCurve *curve,
plot->addCurveNoUpdate(curveCopy);
// Resolve references after object has been inserted into the project data model
curveCopy->resolveReferencesRecursively();
// The curve creator is not a descendant of the project, and need to be set manually
curveCopy->setSummaryCaseY(curve->summaryCaseY());
curveCopy->initAfterReadRecursively();
@ -592,7 +629,7 @@ void RicSummaryCurveCreator::copyCurveAndAddToPlot(const RimSummaryCurve *curve,
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicSummaryCurveCreator::copyEnsembleCurveAndAddToPlot(const RimSummaryCurve *curve, RimEnsembleCurveSet *curveSet, bool forceVisible)
void RicSummaryCurveCreator::copyEnsembleCurveAndAddToCurveSet(const RimSummaryCurve *curve, RimEnsembleCurveSet* curveSet, bool forceVisible)
{
RimSummaryCurve* curveCopy = dynamic_cast<RimSummaryCurve*>(curve->xmlCapability()->copyByXmlSerialization(caf::PdmDefaultObjectFactory::instance()));
CVF_ASSERT(curveCopy);
@ -604,9 +641,6 @@ void RicSummaryCurveCreator::copyEnsembleCurveAndAddToPlot(const RimSummaryCurve
curveSet->addCurve(curveCopy);
// Resolve references after object has been inserted into the project data model
curveCopy->resolveReferencesRecursively();
// The curve creator is not a descendant of the project, and need to be set manually
curveCopy->setSummaryCaseY(curve->summaryCaseY());
curveCopy->initAfterReadRecursively();
@ -703,7 +737,7 @@ std::set<RiaSummaryCurveDefinition> RicSummaryCurveCreator::allPreviewCurveDefs(
{
std::set<RiaSummaryCurveDefinition> allCurveDefs;
for (const auto& curve : m_previewPlot->summaryCurves())
for (const auto& curve : m_previewPlot->summaryAndEnsembleCurves())
{
allCurveDefs.insert(RiaSummaryCurveDefinition(curve->summaryCaseY(), curve->summaryAddressY()));
}

2
ApplicationCode/Commands/SummaryPlotCommands/RicSummaryCurveCreator.h
View File

@ -87,7 +87,7 @@ private:
void populateCurveCreator(const RimSummaryPlot& sourceSummaryPlot);
void updateTargetPlot();
static void copyCurveAndAddToPlot(const RimSummaryCurve *curve, RimSummaryPlot *plot, bool forceVisible = false);
static void copyEnsembleCurveAndAddToPlot(const RimSummaryCurve *curve, RimEnsembleCurveSet* curveSet, bool forceVisible = false);
static void copyEnsembleCurveAndAddToCurveSet(const RimSummaryCurve *curve, RimEnsembleCurveSet* curveSet, bool forceVisible = false);
void setDefaultCurveSelection(const std::vector<RimSummaryCase*>& defaultCases);
void resetAllFields();

2
ApplicationCode/ProjectDataModel/RimPlotCurve.cpp
View File

@ -596,7 +596,7 @@ void RimPlotCurve::updateLegendEntryVisibilityNoPlotUpdate()
{
bool showLegendInQwt = m_showLegend();
if (summaryPlot->ensembleCurveSets()->visibleCurveSets().empty() && summaryPlot->curveCount() == 1)
if (summaryPlot->ensembleCurveSetCollection()->visibleCurveSets().empty() && summaryPlot->curveCount() == 1)
{
// Disable display of legend if the summary plot has only one single curve
showLegendInQwt = false;

18
ApplicationCode/ProjectDataModel/Summary/RimEnsembleCurveSet.cpp
View File

@ -244,6 +244,14 @@ void RimEnsembleCurveSet::deleteCurve(RimSummaryCurve* curve)
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEnsembleCurveSet::setSummaryAddress(RifEclipseSummaryAddress address)
{
m_yValuesCurveVariable->setAddress(address);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -816,6 +824,16 @@ void RimEnsembleCurveSet::updateAllCurves()
updateCurveColors();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimEnsembleCurveSet* RimEnsembleCurveSet::clone() const
{
RimEnsembleCurveSet* copy = dynamic_cast<RimEnsembleCurveSet*>(this->xmlCapability()->copyByXmlSerialization(caf::PdmDefaultObjectFactory::instance()));
copy->m_yValuesSummaryGroup = m_yValuesSummaryGroup();
return copy;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

2
ApplicationCode/ProjectDataModel/Summary/RimEnsembleCurveSet.h
View File

@ -72,6 +72,7 @@ public:
void addCurve(RimSummaryCurve* curve);
void deleteCurve(RimSummaryCurve* curve);
void setSummaryAddress(RifEclipseSummaryAddress address);
RifEclipseSummaryAddress summaryAddress() const;
std::vector<RimSummaryCurve*> curves() const;
std::vector<RimSummaryCurve*> visibleCurves() const;
@ -89,6 +90,7 @@ public:
EnsembleParameterType currentEnsembleParameterType() const;
void updateAllCurves();
RimEnsembleCurveSet* clone() const;
private:
caf::PdmFieldHandle* userDescriptionField() override;

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

@ -23,6 +23,8 @@
#include "RimProject.h"
#include "RimSummaryCase.h"
#include "RifSummaryReaderInterface.h"
CAF_PDM_SOURCE_INIT(RimSummaryCaseCollection, "SummaryCaseSubCollection");
//--------------------------------------------------------------------------------------------------

2
ApplicationCode/ProjectDataModel/Summary/RimSummaryCaseCollection.h
View File

@ -18,6 +18,8 @@
#pragma once
#include "RifEclipseSummaryAddress.h"
#include "cafPdmChildArrayField.h"
#include "cafPdmField.h"
#include "cafPdmObject.h"

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

@ -466,6 +466,23 @@ QString RimSummaryPlot::asciiDataForPlotExport() const
return out;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimSummaryCurve*> RimSummaryPlot::summaryAndEnsembleCurves() const
{
std::vector<RimSummaryCurve*> curves = summaryCurves();
for (const auto& curveSet : ensembleCurveSetCollection()->curveSets())
{
for (const auto& curve : curveSet->curves())
{
curves.push_back(curve);
}
}
return curves;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -967,7 +984,32 @@ void RimSummaryPlot::deleteCurve(RimSummaryCurve* curve)
{
if (m_summaryCurveCollection)
{
m_summaryCurveCollection->deleteCurve(curve);
for (auto& c : m_summaryCurveCollection->curves())
{
if (c == curve)
{
m_summaryCurveCollection->deleteCurve(curve);
return;
}
}
}
if (m_ensembleCurveSetCollection)
{
for (auto& curveSet : m_ensembleCurveSetCollection->curveSets())
{
for (auto& c : curveSet->curves())
{
if (c == curve)
{
curveSet->deleteCurve(curve);
if (curveSet->curves().empty())
{
m_ensembleCurveSetCollection->deleteCurveSet(curveSet);
}
return;
}
}
}
}
}
}
@ -986,7 +1028,7 @@ void RimSummaryPlot::deleteCurvesAssosiatedWithCase(RimSummaryCase* summaryCase)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimEnsembleCurveSetCollection* RimSummaryPlot::ensembleCurveSets() const
RimEnsembleCurveSetCollection* RimSummaryPlot::ensembleCurveSetCollection() const
{
return m_ensembleCurveSetCollection;
}

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

@ -75,7 +75,7 @@ public:
void setCurveCollection(RimSummaryCurveCollection* curveCollection);
void deleteCurvesAssosiatedWithCase(RimSummaryCase* summaryCase);
RimEnsembleCurveSetCollection* ensembleCurveSets() const;
RimEnsembleCurveSetCollection* ensembleCurveSetCollection() const;
void addGridTimeHistoryCurve(RimGridTimeHistoryCurve* curve);
@ -108,6 +108,7 @@ public:
QString asciiDataForPlotExport() const;
std::vector<RimSummaryCurve*> summaryAndEnsembleCurves() const;
std::vector<RimSummaryCurve*> summaryCurves() const;
void deleteAllSummaryCurves();
RimSummaryCurveCollection* summaryCurveCollection() const;

125
ApplicationCode/UserInterface/RiuSummaryCurveDefSelection.cpp
View File

@ -39,6 +39,8 @@
#include "RiuSummaryVectorDescriptionMap.h"
#include "cafPdmUiTreeSelectionEditor.h"
//#include "cafPdmObject.h"
#include "cafPdmPointer.h"
#include <algorithm>
@ -147,8 +149,8 @@ RiuSummaryCurveDefSelection::RiuSummaryCurveDefSelection() : m_identifierFieldsM
} },
})
{
CAF_PDM_InitFieldNoDefault(&m_selectedCases, "SummaryCases", "Cases", "", "", "");
m_selectedCases.uiCapability()->setAutoAddingOptionFromValue(false);
CAF_PDM_InitFieldNoDefault(&m_selectedSources, "SummaryCases", "Cases", "", "", "");
m_selectedSources.uiCapability()->setAutoAddingOptionFromValue(false);
CAF_PDM_InitFieldNoDefault(&m_currentSummaryCategory, "CurrentSummaryCategory", "Current Summary Category", "", "", "");
@ -217,9 +219,9 @@ RiuSummaryCurveDefSelection::RiuSummaryCurveDefSelection() : m_identifierFieldsM
itemTypes.second.back()->pdmField()->uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::HIDDEN);
}
m_selectedCases.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::HIDDEN);
m_selectedCases.uiCapability()->setUiEditorTypeName(caf::PdmUiTreeSelectionEditor::uiEditorTypeName());
m_selectedCases.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::HIDDEN);
m_selectedSources.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::HIDDEN);
m_selectedSources.uiCapability()->setUiEditorTypeName(caf::PdmUiTreeSelectionEditor::uiEditorTypeName());
m_selectedSources.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::HIDDEN);
m_selectedSummaryCategories.uiCapability()->setUiEditorTypeName(caf::PdmUiTreeSelectionEditor::uiEditorTypeName());
m_selectedSummaryCategories.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::HIDDEN);
@ -247,34 +249,55 @@ RiuSummaryCurveDefSelection::~RiuSummaryCurveDefSelection()
//--------------------------------------------------------------------------------------------------
std::vector<RiaSummaryCurveDefinition> RiuSummaryCurveDefSelection::selectedCurveDefinitions() const
{
std::vector<RiaSummaryCurveDefinition> caseAndAddressVector;
std::vector<RiaSummaryCurveDefinition> curveDefVector;
{
std::set<RiaSummaryCurveDefinition> caseAndAddressPairs;
std::set<RifEclipseSummaryAddress> selectedAddressesFromUi = buildAddressListFromSelections();
for (RimSummaryCase* currCase : selectedSummaryCases())
for (SummarySource* currSource : selectedSummarySources())
{
if (currCase && currCase->summaryReader())
{
RifSummaryReaderInterface* reader = currCase->summaryReader();
std::vector<RimSummaryCase*> sourceCases;
RimSummaryCaseCollection* ensemble = dynamic_cast<RimSummaryCaseCollection*>(currSource);
const std::vector<RifEclipseSummaryAddress>& readerAddresses = reader->allResultAddresses();
for (const auto& readerAddress : readerAddresses)
// Build case list
if (ensemble)
{
auto sumCases = ensemble->allSummaryCases();
sourceCases.insert(sourceCases.end(), sumCases.begin(), sumCases.end());
}
else
{
RimSummaryCase* sourceCase = dynamic_cast<RimSummaryCase*>(currSource);
if (sourceCase)
{
if (selectedAddressesFromUi.count(readerAddress) > 0)
sourceCases.push_back(sourceCase);
}
}
for (const auto& currCase : sourceCases)
{
if (currCase && currCase->summaryReader())
{
RifSummaryReaderInterface* reader = currCase->summaryReader();
const std::vector<RifEclipseSummaryAddress>& readerAddresses = reader->allResultAddresses();
for (const auto& readerAddress : readerAddresses)
{
caseAndAddressPairs.insert(RiaSummaryCurveDefinition(currCase, readerAddress));
if (selectedAddressesFromUi.count(readerAddress) > 0)
{
caseAndAddressPairs.insert(RiaSummaryCurveDefinition(currCase, readerAddress, ensemble));
}
}
}
}
}
std::copy(caseAndAddressPairs.begin(), caseAndAddressPairs.end(), std::back_inserter(caseAndAddressVector));
std::copy(caseAndAddressPairs.begin(), caseAndAddressPairs.end(), std::back_inserter(curveDefVector));
}
return caseAndAddressVector;
return curveDefVector;
}
//--------------------------------------------------------------------------------------------------
@ -325,15 +348,15 @@ void RiuSummaryCurveDefSelection::setSelectedCurveDefinitions(const std::vector<
{
resetAllFields();
for (const auto& caseAddressPair : curveDefinitions)
for (const auto& curveDef : curveDefinitions)
{
RimSummaryCase* summaryCase = caseAddressPair.summaryCase();
RimSummaryCase* summaryCase = curveDef.summaryCase();
if (!summaryCase) continue;
RifEclipseSummaryAddress summaryAddress = caseAddressPair.summaryAddress();
RifEclipseSummaryAddress summaryAddress = curveDef.summaryAddress();
if (summaryAddress.category() == RifEclipseSummaryAddress::SUMMARY_INVALID)
{
// If we have an invalid address, set the default adress to Field
// If we have an invalid address, set the default address to Field
summaryAddress = RifEclipseSummaryAddress::fieldVarAddress(summaryAddress.quantityName());
}
@ -352,11 +375,13 @@ void RiuSummaryCurveDefSelection::setSelectedCurveDefinitions(const std::vector<
}
// Select case if not already selected
if (std::find(m_selectedCases.begin(), m_selectedCases.end(), summaryCase) == m_selectedCases.end())
if (std::find(m_selectedSources.begin(), m_selectedSources.end(),
curveDef.isEnsembleCurve() ? (SummarySource*)curveDef.ensemble() : summaryCase) == m_selectedSources.end())
{
if (summaryCase != calculatedSummaryCase())
{
m_selectedCases.push_back(summaryCase);
m_selectedSources.push_back(curveDef.isEnsembleCurve() ? (SummarySource*)curveDef.ensemble() : summaryCase);
}
}
@ -421,7 +446,7 @@ QList<caf::PdmOptionItemInfo> RiuSummaryCurveDefSelection::calculateValueOptions
{
QList<caf::PdmOptionItemInfo> options;
if (fieldNeedingOptions == &m_selectedCases)
if (fieldNeedingOptions == &m_selectedSources)
{
RimProject* proj = RiaApplication::instance()->project();
std::vector<RimSummaryCase*> topLevelCases;
@ -439,9 +464,28 @@ QList<caf::PdmOptionItemInfo> RiuSummaryCurveDefSelection::calculateValueOptions
options.push_back(caf::PdmOptionItemInfo(sumCase->caseName(), sumCase));
}
// Ensembles
bool ensembleHeaderCreated = false;
for (const auto& sumCaseColl : sumCaseMainColl->summaryCaseCollections())
{
if (!sumCaseColl->isEnsemble()) continue;
if (!ensembleHeaderCreated)
{
options.push_back(caf::PdmOptionItemInfo::createHeader("Ensembles", true));
ensembleHeaderCreated = true;
}
auto optionItem = caf::PdmOptionItemInfo(sumCaseColl->name(), sumCaseColl);
optionItem.setLevel(1);
options.push_back(optionItem);
}
// Grouped cases
for (const auto& sumCaseColl : sumCaseMainColl->summaryCaseCollections())
{
if (sumCaseColl->isEnsemble()) continue;
options.push_back(caf::PdmOptionItemInfo::createHeader(sumCaseColl->name(), true));
for (const auto& sumCase : sumCaseColl->allSummaryCases())
@ -575,7 +619,7 @@ QList<caf::PdmOptionItemInfo> RiuSummaryCurveDefSelection::calculateValueOptions
void RiuSummaryCurveDefSelection::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
caf::PdmUiGroup* sourcesGroup = uiOrdering.addNewGroupWithKeyword("Sources", RiuSummaryCurveDefinitionKeywords::sources());
sourcesGroup->add(&m_selectedCases);
sourcesGroup->add(&m_selectedSources);
caf::PdmUiGroup* itemTypesGroup = uiOrdering.addNewGroupWithKeyword("Summary Types", RiuSummaryCurveDefinitionKeywords::summaryTypes());
itemTypesGroup->add(&m_selectedSummaryCategories);
@ -729,9 +773,11 @@ void RiuSummaryCurveDefSelection::defineUiOrdering(QString uiConfigName, caf::Pd
std::set<RifEclipseSummaryAddress> RiuSummaryCurveDefSelection::findPossibleSummaryAddressesFromSelectedCases(const SummaryIdentifierAndField *identifierAndField)
{
std::vector<RimSummaryCase*> cases;
for (const auto& sumCase : m_selectedCases())
for (const auto& source : m_selectedSources())
{
if(isObservedData(sumCase)) continue;
RimSummaryCase* sumCase = dynamic_cast<RimSummaryCase*>(source.p());
if(!sumCase || isObservedData(sumCase)) continue;
cases.push_back(sumCase);
}
return findPossibleSummaryAddresses(cases, identifierAndField);
@ -743,9 +789,11 @@ std::set<RifEclipseSummaryAddress> RiuSummaryCurveDefSelection::findPossibleSumm
std::set<RifEclipseSummaryAddress> RiuSummaryCurveDefSelection::findPossibleSummaryAddressesFromSelectedObservedData(const SummaryIdentifierAndField *identifierAndField)
{
std::vector<RimSummaryCase*> obsData;
for (const auto& sumCase : m_selectedCases())
for (const auto& source : m_selectedSources())
{
if (isObservedData(sumCase))
RimSummaryCase* sumCase = dynamic_cast<RimSummaryCase*>(source.p());
if (sumCase && isObservedData(sumCase))
{
obsData.push_back(sumCase);
}
@ -964,7 +1012,7 @@ void RiuSummaryCurveDefSelection::defineEditorAttribute(const caf::PdmFieldHandl
//--------------------------------------------------------------------------------------------------
void RiuSummaryCurveDefSelection::resetAllFields()
{
m_selectedCases.clear();
m_selectedSources.clear();
m_selectedSummaryCategories = std::vector<caf::AppEnum<RifEclipseSummaryAddress::SummaryVarCategory>>();
// clear all state in fields
@ -980,27 +1028,30 @@ void RiuSummaryCurveDefSelection::resetAllFields()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RiuSummaryCurveDefSelection::isObservedData(RimSummaryCase *sumCase) const
bool RiuSummaryCurveDefSelection::isObservedData(const RimSummaryCase *sumCase) const
{
return dynamic_cast<RimObservedData*>(sumCase) != nullptr;
return dynamic_cast<const RimObservedData*>(sumCase) != nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimSummaryCase*> RiuSummaryCurveDefSelection::selectedSummaryCases() const
std::vector<SummarySource*> RiuSummaryCurveDefSelection::selectedSummarySources() const
{
std::vector<RimSummaryCase*> cases;
std::vector<SummarySource*> sources;
for (RimSummaryCase* currCase : m_selectedCases)
for (const auto& source : m_selectedSources)
{
cases.push_back(currCase);
RimSummaryCase* c = dynamic_cast<RimSummaryCase*>(source.p());
RimSummaryCaseCollection* cc = dynamic_cast<RimSummaryCaseCollection*>(source.p());
sources.push_back(source);
}
// Always add the summary case for calculated curves as this case is not displayed in UI
cases.push_back(RiuSummaryCurveDefSelection::calculatedSummaryCase());
sources.push_back(RiuSummaryCurveDefSelection::calculatedSummaryCase());
return cases;
return sources;
}
//--------------------------------------------------------------------------------------------------

11
ApplicationCode/UserInterface/RiuSummaryCurveDefSelection.h
View File

@ -33,11 +33,16 @@
#define OBSERVED_DATA_AVALUE_POSTFIX "_OBSDATA"
class RimSummaryCase;
class RimSummaryCaseCollection;
class RimSummaryCurveAutoName;
class RimSummaryPlot;
class RiaSummaryCurveDefinition;
class SummaryIdentifierAndField;
using SummarySource = caf::PdmObject;
//==================================================================================================
///
///
@ -86,13 +91,13 @@ private:
std::set<RifEclipseSummaryAddress>& addressSet) const;
void resetAllFields();
bool isObservedData(RimSummaryCase *sumCase) const;
bool isObservedData(const RimSummaryCase *sumCase) const;
std::vector<RimSummaryCase*> selectedSummaryCases() const;
std::vector<SummarySource*> selectedSummarySources() const;
static RimSummaryCase* calculatedSummaryCase();
private:
caf::PdmPtrArrayField<RimSummaryCase*> m_selectedCases;
caf::PdmPtrArrayField<SummarySource*> m_selectedSources;
caf::PdmField<std::vector<caf::AppEnum<RifEclipseSummaryAddress::SummaryVarCategory>>> m_selectedSummaryCategories;
caf::PdmField<caf::AppEnum<RifEclipseSummaryAddress::SummaryVarCategory>> m_currentSummaryCategory;

6
ApplicationCode/UserInterface/RiuSummaryQwtPlot.cpp
View File

@ -82,7 +82,7 @@ public:
for (auto const plot : project->mainPlotCollection->summaryPlotCollection()->summaryPlots())
{
RimSummaryPlot* sumPlot = plot->qwtPlot()->ownerPlotDefinition();
for (auto const curveSet : sumPlot->ensembleCurveSets()->curveSets())
for (auto const curveSet : sumPlot->ensembleCurveSetCollection()->curveSets())
{
for (auto const currSumCurve : curveSet->curves())
{
@ -219,9 +219,9 @@ void RiuSummaryQwtPlot::updateEnsembleLegendLayout()
int ypos = startMarginY;
int maxColumnWidth = 0;
if (!ownerPlotDefinition() || !ownerPlotDefinition()->ensembleCurveSets()) return;
if (!ownerPlotDefinition() || !ownerPlotDefinition()->ensembleCurveSetCollection()) return;
for (RimEnsembleCurveSet * curveSet : ownerPlotDefinition()->ensembleCurveSets()->curveSets())
for (RimEnsembleCurveSet * curveSet : ownerPlotDefinition()->ensembleCurveSetCollection()->curveSets())
{
auto pairIt = m_ensembleLegendWidgets.find(curveSet);
if (pairIt != m_ensembleLegendWidgets.end())