mirror of
https://github.com/OPM/ResInsight.git
synced 2025-02-25 18:55:39 -06:00
1125 lines
39 KiB
C++
1125 lines
39 KiB
C++
/////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (C) 2017- Statoil 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 "RimSummaryPlotSourceStepping.h"
|
|
|
|
#include "RiaGuiApplication.h"
|
|
#include "RiaSummaryCurveAnalyzer.h"
|
|
#include "RiaSummaryCurveDefinition.h"
|
|
|
|
#include "RifSummaryReaderInterface.h"
|
|
|
|
#include "RimDataSourceSteppingTools.h"
|
|
#include "RimEnsembleCurveSet.h"
|
|
#include "RimEnsembleCurveSetCollection.h"
|
|
#include "RimProject.h"
|
|
#include "RimSummaryCase.h"
|
|
#include "RimSummaryCaseMainCollection.h"
|
|
#include "RimSummaryCrossPlot.h"
|
|
#include "RimSummaryCurve.h"
|
|
#include "RimSummaryCurveCollection.h"
|
|
#include "RimSummaryPlot.h"
|
|
|
|
#include "RiuPlotMainWindow.h"
|
|
|
|
#include "RiaStdStringTools.h"
|
|
#include "cafPdmUiComboBoxEditor.h"
|
|
#include "cafPdmUiItem.h"
|
|
#include "cafPdmUiListEditor.h"
|
|
|
|
CAF_PDM_SOURCE_INIT(RimSummaryPlotSourceStepping, "RimSummaryCurveCollectionModifier");
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimSummaryPlotSourceStepping::RimSummaryPlotSourceStepping()
|
|
: m_sourceSteppingType(Y_AXIS)
|
|
{
|
|
// clang-format off
|
|
CAF_PDM_InitObject("Summary Curves Modifier", "", "", "");
|
|
|
|
CAF_PDM_InitFieldNoDefault(&m_summaryCase, "CurveCase", "Case", "", "", "");
|
|
|
|
CAF_PDM_InitField(&m_includeEnsembleCasesForCaseStepping,
|
|
"IncludeEnsembleCasesForCaseStepping",
|
|
false,
|
|
"Allow Stepping on Ensemble cases",
|
|
"",
|
|
"",
|
|
"");
|
|
|
|
CAF_PDM_InitFieldNoDefault(&m_wellName, "WellName", "Well Name", "", "", "");
|
|
CAF_PDM_InitFieldNoDefault(&m_wellGroupName, "GroupName", "Group Name", "", "", "");
|
|
CAF_PDM_InitFieldNoDefault(&m_region, "Region", "Region", "", "", "");
|
|
CAF_PDM_InitFieldNoDefault(&m_quantity, "Quantities", "Quantity", "", "", "");
|
|
|
|
CAF_PDM_InitFieldNoDefault(&m_cellBlock, "CellBlock", "Block", "", "", "");
|
|
CAF_PDM_InitFieldNoDefault(&m_segment, "Segment", "Segment", "", "", "");
|
|
CAF_PDM_InitFieldNoDefault(&m_completion, "Completion", "Completion", "", "", "");
|
|
|
|
CAF_PDM_InitFieldNoDefault(&m_ensemble, "Ensemble", "Ensemble", "", "", "");
|
|
|
|
CAF_PDM_InitFieldNoDefault(&m_placeholderForLabel, "Placeholder", "", "", "", "");
|
|
m_placeholderForLabel = "No common identifiers detected";
|
|
m_placeholderForLabel.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::TOP);
|
|
m_placeholderForLabel.uiCapability()->setUiReadOnly(true);
|
|
|
|
// clang-format on
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimSummaryPlotSourceStepping::setSourceSteppingType(SourceSteppingType sourceSteppingType)
|
|
{
|
|
m_sourceSteppingType = sourceSteppingType;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimSummaryPlotSourceStepping::applyNextCase()
|
|
{
|
|
modifyCurrentIndex(&m_summaryCase, 1);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimSummaryPlotSourceStepping::applyPrevCase()
|
|
{
|
|
modifyCurrentIndex(&m_summaryCase, -1);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimSummaryPlotSourceStepping::applyNextQuantity()
|
|
{
|
|
if (!m_quantity.uiCapability()->isUiHidden())
|
|
{
|
|
modifyCurrentIndex(&m_quantity, 1);
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimSummaryPlotSourceStepping::applyPrevQuantity()
|
|
{
|
|
if (!m_quantity.uiCapability()->isUiHidden())
|
|
{
|
|
modifyCurrentIndex(&m_quantity, -1);
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimSummaryPlotSourceStepping::applyNextOtherIdentifier()
|
|
{
|
|
caf::PdmValueField* valueField = fieldToModify();
|
|
if (!valueField) return;
|
|
|
|
modifyCurrentIndex(valueField, 1);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimSummaryPlotSourceStepping::applyPrevOtherIdentifier()
|
|
{
|
|
caf::PdmValueField* valueField = fieldToModify();
|
|
if (!valueField) return;
|
|
|
|
modifyCurrentIndex(valueField, -1);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<caf::PdmFieldHandle*> RimSummaryPlotSourceStepping::fieldsToShowInToolbar()
|
|
{
|
|
return computeVisibleFieldsAndSetFieldVisibility();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimSummaryPlotSourceStepping::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
|
|
{
|
|
auto visible = computeVisibleFieldsAndSetFieldVisibility();
|
|
if (visible.size() == 0)
|
|
{
|
|
m_placeholderForLabel.uiCapability()->setUiHidden(false);
|
|
}
|
|
else
|
|
{
|
|
m_placeholderForLabel.uiCapability()->setUiHidden(true);
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QList<caf::PdmOptionItemInfo> RimSummaryPlotSourceStepping::calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions,
|
|
bool* useOptionsOnly)
|
|
{
|
|
QList<caf::PdmOptionItemInfo> options;
|
|
|
|
if (fieldNeedingOptions == &m_includeEnsembleCasesForCaseStepping)
|
|
{
|
|
return caf::PdmObject::calculateValueOptions(fieldNeedingOptions, useOptionsOnly);
|
|
}
|
|
else if (fieldNeedingOptions == &m_placeholderForLabel)
|
|
{
|
|
options;
|
|
}
|
|
else if (fieldNeedingOptions == &m_summaryCase)
|
|
{
|
|
auto summaryCases = RimSummaryPlotSourceStepping::summaryCasesForSourceStepping();
|
|
for (auto sumCase : summaryCases)
|
|
{
|
|
options.append(caf::PdmOptionItemInfo(sumCase->caseName(), sumCase));
|
|
}
|
|
|
|
return options;
|
|
}
|
|
else if (fieldNeedingOptions == &m_ensemble)
|
|
{
|
|
RimProject* proj = RiaApplication::instance()->project();
|
|
for (auto ensemble : proj->summaryGroups())
|
|
{
|
|
if (ensemble->isEnsemble())
|
|
{
|
|
options.append(caf::PdmOptionItemInfo(ensemble->name(), ensemble));
|
|
}
|
|
}
|
|
|
|
return options;
|
|
}
|
|
|
|
std::vector<RifSummaryReaderInterface*> readers = summaryReadersForCurves();
|
|
if (!readers.empty())
|
|
{
|
|
if (fieldNeedingOptions == &m_quantity)
|
|
{
|
|
RifEclipseSummaryAddress::SummaryVarCategory category = RifEclipseSummaryAddress::SUMMARY_FIELD;
|
|
|
|
auto addresses = addressesCurveCollection();
|
|
if (!addresses.empty())
|
|
{
|
|
category = addresses.begin()->category();
|
|
}
|
|
|
|
std::map<QString, QString> displayAndValueStrings;
|
|
|
|
{
|
|
RiaSummaryCurveAnalyzer quantityAnalyzer;
|
|
|
|
for (auto reader : readers)
|
|
{
|
|
if (reader != nullptr)
|
|
{
|
|
auto subset = RiaSummaryCurveAnalyzer::addressesForCategory(reader->allResultAddresses(), category);
|
|
quantityAnalyzer.appendAdresses(subset);
|
|
}
|
|
}
|
|
|
|
RiaSummaryCurveAnalyzer analyzerForCurves;
|
|
analyzerForCurves.appendAdresses(addressesCurveCollection());
|
|
|
|
if (analyzerForCurves.quantityNamesWithHistory().empty())
|
|
{
|
|
auto quantities = quantityAnalyzer.quantities();
|
|
for (const auto& s : quantities)
|
|
{
|
|
QString valueString = QString::fromStdString(s);
|
|
|
|
displayAndValueStrings[valueString] = valueString;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
auto quantitiesWithHistory = quantityAnalyzer.quantityNamesWithHistory();
|
|
for (const auto& s : quantitiesWithHistory)
|
|
{
|
|
QString valueString = QString::fromStdString(s);
|
|
QString displayString = valueString + " (H)";
|
|
|
|
displayAndValueStrings[displayString] = valueString;
|
|
}
|
|
|
|
auto quantitiesNoHistory = quantityAnalyzer.quantityNamesNoHistory();
|
|
for (const auto& s : quantitiesNoHistory)
|
|
{
|
|
QString valueString = QString::fromStdString(s);
|
|
|
|
displayAndValueStrings[valueString] = valueString;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const auto& displayAndValue : displayAndValueStrings)
|
|
{
|
|
options.append(caf::PdmOptionItemInfo(displayAndValue.first, displayAndValue.second));
|
|
}
|
|
|
|
if (options.isEmpty())
|
|
{
|
|
options.push_back(caf::PdmOptionItemInfo("None", "None"));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
RifEclipseSummaryAddress::SummaryVarCategory category = RifEclipseSummaryAddress::SUMMARY_INVALID;
|
|
std::string secondaryIdentifier;
|
|
|
|
if (fieldNeedingOptions == &m_wellName)
|
|
{
|
|
category = RifEclipseSummaryAddress::SUMMARY_WELL;
|
|
}
|
|
else if (fieldNeedingOptions == &m_region)
|
|
{
|
|
category = RifEclipseSummaryAddress::SUMMARY_REGION;
|
|
}
|
|
else if (fieldNeedingOptions == &m_wellGroupName)
|
|
{
|
|
category = RifEclipseSummaryAddress::SUMMARY_WELL_GROUP;
|
|
}
|
|
else if (fieldNeedingOptions == &m_cellBlock)
|
|
{
|
|
category = RifEclipseSummaryAddress::SUMMARY_BLOCK;
|
|
}
|
|
else if (fieldNeedingOptions == &m_segment)
|
|
{
|
|
secondaryIdentifier = m_wellName().toStdString();
|
|
category = RifEclipseSummaryAddress::SUMMARY_WELL_SEGMENT;
|
|
}
|
|
else if (fieldNeedingOptions == &m_completion)
|
|
{
|
|
secondaryIdentifier = m_wellName().toStdString();
|
|
category = RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION;
|
|
}
|
|
|
|
std::vector<QString> identifierTexts;
|
|
|
|
if (category != RifEclipseSummaryAddress::SUMMARY_INVALID)
|
|
{
|
|
for (auto reader : readers)
|
|
{
|
|
auto analyzer = analyzerForReader(reader);
|
|
|
|
if (analyzer)
|
|
{
|
|
identifierTexts = analyzer->identifierTexts(category, secondaryIdentifier);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!identifierTexts.empty())
|
|
{
|
|
for (const auto& text : identifierTexts)
|
|
{
|
|
options.append(caf::PdmOptionItemInfo(text, text));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
options.push_back(caf::PdmOptionItemInfo("None", "None"));
|
|
}
|
|
}
|
|
}
|
|
|
|
return options;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimSummaryPlotSourceStepping::fieldChangedByUi(const caf::PdmFieldHandle* changedField,
|
|
const QVariant& oldValue,
|
|
const QVariant& newValue)
|
|
{
|
|
std::vector<RimSummaryCurve*> curves;
|
|
|
|
RimSummaryCurveCollection* curveCollection = nullptr;
|
|
this->firstAncestorOrThisOfType(curveCollection);
|
|
if (curveCollection)
|
|
{
|
|
curves = curveCollection->curves();
|
|
}
|
|
|
|
RimEnsembleCurveSetCollection* ensembleCurveColl = nullptr;
|
|
this->firstAncestorOrThisOfType(ensembleCurveColl);
|
|
|
|
if (changedField == &m_includeEnsembleCasesForCaseStepping)
|
|
{
|
|
if (curveCollection)
|
|
{
|
|
curveCollection->updateConnectedEditors();
|
|
}
|
|
|
|
if (ensembleCurveColl)
|
|
{
|
|
ensembleCurveColl->updateConnectedEditors();
|
|
}
|
|
|
|
RiuPlotMainWindow* mainPlotWindow = RiaGuiApplication::instance()->getOrCreateMainPlotWindow();
|
|
bool forceUpdateOfFieldsInToolbar = true;
|
|
mainPlotWindow->updateSummaryPlotToolBar(forceUpdateOfFieldsInToolbar);
|
|
|
|
return;
|
|
}
|
|
|
|
bool triggerLoadDataAndUpdate = false;
|
|
|
|
if (changedField == &m_summaryCase)
|
|
{
|
|
if (m_summaryCase())
|
|
{
|
|
caf::PdmPointer<caf::PdmObjectHandle> variantHandle = oldValue.value<caf::PdmPointer<caf::PdmObjectHandle>>();
|
|
RimSummaryCase* previousCase = dynamic_cast<RimSummaryCase*>(variantHandle.p());
|
|
|
|
for (auto curve : curves)
|
|
{
|
|
if (isYAxisStepping())
|
|
{
|
|
if (previousCase == curve->summaryCaseY())
|
|
{
|
|
curve->setSummaryCaseY(m_summaryCase);
|
|
curve->setCurveAppearanceFromCaseType();
|
|
}
|
|
}
|
|
|
|
if (isXAxisStepping())
|
|
{
|
|
if (previousCase == curve->summaryCaseX())
|
|
{
|
|
curve->setSummaryCaseX(m_summaryCase);
|
|
}
|
|
}
|
|
}
|
|
|
|
triggerLoadDataAndUpdate = true;
|
|
}
|
|
|
|
m_wellName.uiCapability()->updateConnectedEditors();
|
|
m_wellGroupName.uiCapability()->updateConnectedEditors();
|
|
m_region.uiCapability()->updateConnectedEditors();
|
|
m_quantity.uiCapability()->updateConnectedEditors();
|
|
}
|
|
else if (changedField == &m_ensemble)
|
|
{
|
|
if (m_ensemble() && ensembleCurveColl)
|
|
{
|
|
caf::PdmPointer<caf::PdmObjectHandle> variantHandle = oldValue.value<caf::PdmPointer<caf::PdmObjectHandle>>();
|
|
RimSummaryCaseCollection* previousCollection = dynamic_cast<RimSummaryCaseCollection*>(variantHandle.p());
|
|
|
|
for (auto curveSet : ensembleCurveColl->curveSets())
|
|
{
|
|
if (curveSet->summaryCaseCollection() == previousCollection)
|
|
{
|
|
curveSet->setSummaryCaseCollection(m_ensemble);
|
|
}
|
|
}
|
|
|
|
triggerLoadDataAndUpdate = true;
|
|
}
|
|
|
|
m_wellName.uiCapability()->updateConnectedEditors();
|
|
m_wellGroupName.uiCapability()->updateConnectedEditors();
|
|
m_region.uiCapability()->updateConnectedEditors();
|
|
m_quantity.uiCapability()->updateConnectedEditors();
|
|
}
|
|
else if (changedField == &m_quantity)
|
|
{
|
|
for (auto curve : curves)
|
|
{
|
|
if (isYAxisStepping())
|
|
{
|
|
auto adr = curve->summaryAddressY();
|
|
updateHistoryAndSummaryQuantityIfMatching(oldValue, newValue, &adr);
|
|
curve->setSummaryAddressY(adr);
|
|
}
|
|
|
|
if (isXAxisStepping())
|
|
{
|
|
auto adr = curve->summaryAddressX();
|
|
updateHistoryAndSummaryQuantityIfMatching(oldValue, newValue, &adr);
|
|
curve->setSummaryAddressX(adr);
|
|
}
|
|
}
|
|
|
|
if (ensembleCurveColl)
|
|
{
|
|
for (auto curveSet : ensembleCurveColl->curveSets())
|
|
{
|
|
auto adr = curveSet->summaryAddress();
|
|
updateHistoryAndSummaryQuantityIfMatching(oldValue, newValue, &adr);
|
|
curveSet->setSummaryAddress(adr);
|
|
}
|
|
}
|
|
|
|
triggerLoadDataAndUpdate = true;
|
|
}
|
|
|
|
{
|
|
RifEclipseSummaryAddress::SummaryVarCategory summaryCategoryToModify = RifEclipseSummaryAddress::SUMMARY_INVALID;
|
|
if (changedField == &m_wellName)
|
|
{
|
|
summaryCategoryToModify = RifEclipseSummaryAddress::SUMMARY_WELL;
|
|
}
|
|
else if (changedField == &m_region)
|
|
{
|
|
summaryCategoryToModify = RifEclipseSummaryAddress::SUMMARY_REGION;
|
|
}
|
|
else if (changedField == &m_wellGroupName)
|
|
{
|
|
summaryCategoryToModify = RifEclipseSummaryAddress::SUMMARY_WELL_GROUP;
|
|
}
|
|
else if (changedField == &m_cellBlock)
|
|
{
|
|
summaryCategoryToModify = RifEclipseSummaryAddress::SUMMARY_BLOCK;
|
|
}
|
|
else if (changedField == &m_segment)
|
|
{
|
|
summaryCategoryToModify = RifEclipseSummaryAddress::SUMMARY_WELL_SEGMENT;
|
|
}
|
|
else if (changedField == &m_completion)
|
|
{
|
|
summaryCategoryToModify = RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION;
|
|
}
|
|
|
|
if (summaryCategoryToModify != RifEclipseSummaryAddress::SUMMARY_INVALID)
|
|
{
|
|
for (auto curve : curves)
|
|
{
|
|
if (isYAxisStepping())
|
|
{
|
|
RifEclipseSummaryAddress adr = curve->summaryAddressY();
|
|
updateAddressIfMatching(oldValue, newValue, summaryCategoryToModify, &adr);
|
|
curve->setSummaryAddressY(adr);
|
|
}
|
|
|
|
if (isXAxisStepping())
|
|
{
|
|
RifEclipseSummaryAddress adr = curve->summaryAddressX();
|
|
updateAddressIfMatching(oldValue, newValue, summaryCategoryToModify, &adr);
|
|
curve->setSummaryAddressX(adr);
|
|
}
|
|
}
|
|
|
|
if (ensembleCurveColl)
|
|
{
|
|
for (auto curveSet : ensembleCurveColl->curveSets())
|
|
{
|
|
auto adr = curveSet->summaryAddress();
|
|
updateAddressIfMatching(oldValue, newValue, summaryCategoryToModify, &adr);
|
|
curveSet->setSummaryAddress(adr);
|
|
}
|
|
}
|
|
|
|
triggerLoadDataAndUpdate = true;
|
|
}
|
|
}
|
|
|
|
if (triggerLoadDataAndUpdate)
|
|
{
|
|
RimSummaryPlot* summaryPlot = nullptr;
|
|
this->firstAncestorOrThisOfTypeAsserted(summaryPlot);
|
|
|
|
summaryPlot->updatePlotTitle();
|
|
summaryPlot->loadDataAndUpdate();
|
|
|
|
if (ensembleCurveColl)
|
|
{
|
|
ensembleCurveColl->updateConnectedEditors();
|
|
}
|
|
|
|
RimSummaryCrossPlot* summaryCrossPlot = dynamic_cast<RimSummaryCrossPlot*>(summaryPlot);
|
|
if (summaryCrossPlot)
|
|
{
|
|
// Trigger update of curve collection (and summary toolbar in main window), as the visibility of combo boxes might
|
|
// have been changed due to the updates in this function
|
|
if (curveCollection)
|
|
{
|
|
curveCollection->updateConnectedEditors();
|
|
}
|
|
|
|
RiuPlotMainWindow* mainPlotWindow = RiaGuiApplication::instance()->mainPlotWindow();
|
|
mainPlotWindow->updateSummaryPlotToolBar();
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<RifSummaryReaderInterface*> RimSummaryPlotSourceStepping::summaryReadersForCurves() const
|
|
{
|
|
std::vector<RifSummaryReaderInterface*> readers;
|
|
RimSummaryCurveCollection* curveCollection = nullptr;
|
|
this->firstAncestorOrThisOfType(curveCollection);
|
|
|
|
if (curveCollection)
|
|
{
|
|
for (auto curve : curveCollection->curves())
|
|
{
|
|
if (isYAxisStepping() && curve->summaryCaseY())
|
|
{
|
|
readers.push_back(curve->summaryCaseY()->summaryReader());
|
|
}
|
|
|
|
if (isXAxisStepping() && curve->summaryCaseX())
|
|
{
|
|
readers.push_back(curve->summaryCaseX()->summaryReader());
|
|
}
|
|
}
|
|
}
|
|
|
|
RimEnsembleCurveSetCollection* ensembleCollection = nullptr;
|
|
this->firstAncestorOrThisOfType(ensembleCollection);
|
|
if (ensembleCollection)
|
|
{
|
|
auto curveSets = ensembleCollection->curveSets();
|
|
for (const RimEnsembleCurveSet* curveSet : curveSets)
|
|
{
|
|
for (auto curve : curveSet->curves())
|
|
{
|
|
if (isYAxisStepping() && curve->summaryCaseY())
|
|
{
|
|
readers.push_back(curve->summaryCaseY()->summaryReader());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return readers;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
caf::PdmValueField* RimSummaryPlotSourceStepping::fieldToModify()
|
|
{
|
|
RiaSummaryCurveAnalyzer analyzer;
|
|
analyzer.appendAdresses(addressesCurveCollection());
|
|
|
|
if (analyzer.wellNames().size() == 1)
|
|
{
|
|
return &m_wellName;
|
|
}
|
|
|
|
if (analyzer.wellGroupNames().size() == 1)
|
|
{
|
|
return &m_wellGroupName;
|
|
}
|
|
|
|
if (analyzer.regionNumbers().size() == 1)
|
|
{
|
|
return &m_region;
|
|
}
|
|
|
|
if (analyzer.blocks().size() == 1)
|
|
{
|
|
return &m_cellBlock;
|
|
}
|
|
|
|
if (analyzer.wellNames().size() == 1)
|
|
{
|
|
auto wellName = *(analyzer.wellNames().begin());
|
|
|
|
if (analyzer.wellSegmentNumbers(wellName).size() == 1)
|
|
{
|
|
return &m_segment;
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::set<RifEclipseSummaryAddress> RimSummaryPlotSourceStepping::addressesCurveCollection() const
|
|
{
|
|
std::set<RifEclipseSummaryAddress> addresses;
|
|
|
|
RimSummaryCurveCollection* curveCollection = nullptr;
|
|
this->firstAncestorOrThisOfType(curveCollection);
|
|
|
|
if (curveCollection)
|
|
{
|
|
auto curves = curveCollection->curvesForSourceStepping(m_sourceSteppingType);
|
|
for (auto c : curves)
|
|
{
|
|
if (isYAxisStepping())
|
|
{
|
|
addresses.insert(c->summaryAddressY());
|
|
}
|
|
|
|
if (isXAxisStepping())
|
|
{
|
|
addresses.insert(c->summaryAddressX());
|
|
}
|
|
}
|
|
}
|
|
|
|
RimEnsembleCurveSetCollection* ensembleCollection = nullptr;
|
|
this->firstAncestorOrThisOfType(ensembleCollection);
|
|
if (ensembleCollection)
|
|
{
|
|
auto curveSets = ensembleCollection->curveSetsForSourceStepping();
|
|
for (const RimEnsembleCurveSet* curveSet : curveSets)
|
|
{
|
|
addresses.insert(curveSet->summaryAddress());
|
|
}
|
|
}
|
|
|
|
return addresses;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::set<RimSummaryCase*> RimSummaryPlotSourceStepping::summaryCasesCurveCollection() const
|
|
{
|
|
std::set<RimSummaryCase*> sumCases;
|
|
|
|
RimSummaryCurveCollection* curveCollection = nullptr;
|
|
this->firstAncestorOrThisOfType(curveCollection);
|
|
|
|
if (!curveCollection) return sumCases;
|
|
|
|
auto curves = curveCollection->curvesForSourceStepping(m_sourceSteppingType);
|
|
for (auto c : curves)
|
|
{
|
|
if (isYAxisStepping())
|
|
{
|
|
sumCases.insert(c->summaryCaseY());
|
|
}
|
|
|
|
if (isXAxisStepping())
|
|
{
|
|
sumCases.insert(c->summaryCaseX());
|
|
}
|
|
}
|
|
|
|
return sumCases;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<caf::PdmFieldHandle*> RimSummaryPlotSourceStepping::computeVisibleFieldsAndSetFieldVisibility()
|
|
{
|
|
// Required to set all stepping controls hidden, as they show up in the property editor when selecting a plot
|
|
m_summaryCase.uiCapability()->setUiHidden(true);
|
|
m_includeEnsembleCasesForCaseStepping.uiCapability()->setUiHidden(true);
|
|
m_wellName.uiCapability()->setUiHidden(true);
|
|
m_wellGroupName.uiCapability()->setUiHidden(true);
|
|
m_region.uiCapability()->setUiHidden(true);
|
|
m_quantity.uiCapability()->setUiHidden(true);
|
|
m_ensemble.uiCapability()->setUiHidden(true);
|
|
m_cellBlock.uiCapability()->setUiHidden(true);
|
|
m_segment.uiCapability()->setUiHidden(true);
|
|
m_completion.uiCapability()->setUiHidden(true);
|
|
|
|
std::vector<caf::PdmFieldHandle*> fields;
|
|
|
|
auto sumCases = summaryCasesCurveCollection();
|
|
if (sumCases.size() == 1)
|
|
{
|
|
RimProject* proj = RiaApplication::instance()->project();
|
|
if (proj->allSummaryCases().size() > 1)
|
|
{
|
|
m_summaryCase = *(sumCases.begin());
|
|
|
|
m_summaryCase.uiCapability()->setUiHidden(false);
|
|
|
|
fields.push_back(&m_summaryCase);
|
|
|
|
m_includeEnsembleCasesForCaseStepping.uiCapability()->setUiHidden(false);
|
|
}
|
|
}
|
|
|
|
auto ensembleColl = ensembleCollection();
|
|
if (ensembleColl.size() == 1)
|
|
{
|
|
RimProject* proj = RiaApplication::instance()->project();
|
|
|
|
if (proj->summaryGroups().size() > 1)
|
|
{
|
|
m_ensemble = *(ensembleColl.begin());
|
|
|
|
m_ensemble.uiCapability()->setUiHidden(false);
|
|
|
|
fields.push_back(&m_ensemble);
|
|
}
|
|
}
|
|
|
|
std::vector<caf::PdmFieldHandle*> fieldsCommonForAllCurves;
|
|
|
|
{
|
|
RiaSummaryCurveAnalyzer analyzer;
|
|
analyzer.appendAdresses(addressesCurveCollection());
|
|
|
|
RifEclipseSummaryAddress::SummaryVarCategory category = RifEclipseSummaryAddress::SUMMARY_INVALID;
|
|
|
|
if (!analyzer.categories().empty())
|
|
{
|
|
if (analyzer.categories().size() == 1)
|
|
{
|
|
category = *(analyzer.categories().begin());
|
|
}
|
|
else
|
|
{
|
|
bool allCategoriesAreDependingOnWellName = true;
|
|
for (auto c : analyzer.categories())
|
|
{
|
|
if (!RifEclipseSummaryAddress::isDependentOnWellName(c))
|
|
{
|
|
allCategoriesAreDependingOnWellName = false;
|
|
}
|
|
}
|
|
|
|
if (allCategoriesAreDependingOnWellName)
|
|
{
|
|
category = RifEclipseSummaryAddress::SUMMARY_WELL;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (category != RifEclipseSummaryAddress::SUMMARY_INVALID)
|
|
{
|
|
if (analyzer.wellNames().size() == 1)
|
|
{
|
|
QString txt = QString::fromStdString(*(analyzer.wellNames().begin()));
|
|
m_wellName = txt;
|
|
m_wellName.uiCapability()->setUiHidden(false);
|
|
|
|
fieldsCommonForAllCurves.push_back(&m_wellName);
|
|
}
|
|
|
|
if (analyzer.wellGroupNames().size() == 1)
|
|
{
|
|
QString txt = QString::fromStdString(*(analyzer.wellGroupNames().begin()));
|
|
m_wellGroupName = txt;
|
|
m_wellGroupName.uiCapability()->setUiHidden(false);
|
|
|
|
fieldsCommonForAllCurves.push_back(&m_wellGroupName);
|
|
}
|
|
|
|
if (analyzer.regionNumbers().size() == 1)
|
|
{
|
|
m_region = *(analyzer.regionNumbers().begin());
|
|
m_region.uiCapability()->setUiHidden(false);
|
|
|
|
fieldsCommonForAllCurves.push_back(&m_region);
|
|
}
|
|
|
|
if (analyzer.wellSegmentNumbers(m_wellName().toStdString()).size() == 1)
|
|
{
|
|
QString txt = QString::number(*(analyzer.wellSegmentNumbers(m_wellName().toStdString()).begin()));
|
|
m_segment = txt;
|
|
m_segment.uiCapability()->setUiHidden(false);
|
|
|
|
fieldsCommonForAllCurves.push_back(&m_segment);
|
|
}
|
|
|
|
if (analyzer.blocks().size() == 1)
|
|
{
|
|
QString txt = QString::fromStdString(*(analyzer.blocks().begin()));
|
|
m_cellBlock = txt;
|
|
m_cellBlock.uiCapability()->setUiHidden(false);
|
|
|
|
fieldsCommonForAllCurves.push_back(&m_cellBlock);
|
|
}
|
|
|
|
if (analyzer.wellCompletions(m_wellName().toStdString()).size() == 1)
|
|
{
|
|
QString txt = QString::fromStdString(*(analyzer.wellCompletions(m_wellName().toStdString()).begin()));
|
|
m_completion = txt;
|
|
m_completion.uiCapability()->setUiHidden(false);
|
|
|
|
fieldsCommonForAllCurves.push_back(&m_completion);
|
|
}
|
|
|
|
if (!analyzer.quantityNameForTitle().empty())
|
|
{
|
|
QString txt = QString::fromStdString(analyzer.quantityNameForTitle());
|
|
m_quantity = txt;
|
|
m_quantity.uiCapability()->setUiHidden(false);
|
|
|
|
fieldsCommonForAllCurves.push_back(&m_quantity);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const auto& f : fieldsCommonForAllCurves)
|
|
{
|
|
fields.push_back(f);
|
|
}
|
|
|
|
return fields;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::set<RimSummaryCaseCollection*> RimSummaryPlotSourceStepping::ensembleCollection() const
|
|
{
|
|
std::set<RimSummaryCaseCollection*> sumCases;
|
|
|
|
RimEnsembleCurveSetCollection* curveCollection = nullptr;
|
|
this->firstAncestorOrThisOfType(curveCollection);
|
|
|
|
if (!curveCollection) return sumCases;
|
|
|
|
auto curves = curveCollection->curveSets();
|
|
for (auto c : curves)
|
|
{
|
|
sumCases.insert(c->summaryCaseCollection());
|
|
}
|
|
|
|
return sumCases;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RimSummaryPlotSourceStepping::isXAxisStepping() const
|
|
{
|
|
if (m_sourceSteppingType == UNION_X_Y_AXIS) return true;
|
|
|
|
if (m_sourceSteppingType == X_AXIS) return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RimSummaryPlotSourceStepping::isYAxisStepping() const
|
|
{
|
|
if (m_sourceSteppingType == UNION_X_Y_AXIS) return true;
|
|
|
|
if (m_sourceSteppingType == Y_AXIS) return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RiaSummaryCurveAnalyzer* RimSummaryPlotSourceStepping::analyzerForReader(RifSummaryReaderInterface* reader)
|
|
{
|
|
if (!reader) return nullptr;
|
|
|
|
if (m_curveAnalyzerForReader.first != reader)
|
|
{
|
|
RiaSummaryCurveAnalyzer analyzer;
|
|
m_curveAnalyzerForReader = std::make_pair(reader, analyzer);
|
|
}
|
|
|
|
m_curveAnalyzerForReader.second.appendAdresses(reader->allResultAddresses());
|
|
|
|
return &m_curveAnalyzerForReader.second;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimSummaryPlotSourceStepping::modifyCurrentIndex(caf::PdmValueField* valueField, int indexOffset)
|
|
{
|
|
bool useOptionsOnly;
|
|
QList<caf::PdmOptionItemInfo> options = calculateValueOptions(valueField, &useOptionsOnly);
|
|
RimDataSourceSteppingTools::modifyCurrentIndex(valueField, options, indexOffset);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RimSummaryPlotSourceStepping::updateAddressIfMatching(const QVariant& oldValue,
|
|
const QVariant& newValue,
|
|
RifEclipseSummaryAddress::SummaryVarCategory category,
|
|
RifEclipseSummaryAddress* adr)
|
|
{
|
|
if (!adr) return false;
|
|
|
|
if (category == RifEclipseSummaryAddress::SUMMARY_REGION)
|
|
{
|
|
int oldInt = oldValue.toInt();
|
|
int newInt = newValue.toInt();
|
|
|
|
if (adr->regionNumber() == oldInt)
|
|
{
|
|
adr->setRegion(newInt);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
else if (category == RifEclipseSummaryAddress::SUMMARY_WELL_GROUP)
|
|
{
|
|
std::string oldString = oldValue.toString().toStdString();
|
|
std::string newString = newValue.toString().toStdString();
|
|
|
|
if (adr->wellGroupName() == oldString)
|
|
{
|
|
adr->setWellGroupName(newString);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
else if (category == RifEclipseSummaryAddress::SUMMARY_WELL)
|
|
{
|
|
std::string oldString = oldValue.toString().toStdString();
|
|
std::string newString = newValue.toString().toStdString();
|
|
|
|
if (adr->wellName() == oldString)
|
|
{
|
|
adr->setWellName(newString);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
else if (category == RifEclipseSummaryAddress::SUMMARY_BLOCK || category == RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION)
|
|
{
|
|
std::string oldString = oldValue.toString().toStdString();
|
|
std::string newString = newValue.toString().toStdString();
|
|
if (adr->blockAsString() == oldString)
|
|
{
|
|
adr->setCellIjk(newString);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
else if (category == RifEclipseSummaryAddress::SUMMARY_WELL_SEGMENT)
|
|
{
|
|
int oldInt = oldValue.toInt();
|
|
int newInt = newValue.toInt();
|
|
if (adr->wellSegmentNumber() == oldInt)
|
|
{
|
|
adr->setWellSegmentNumber(newInt);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RimSummaryPlotSourceStepping::updateHistoryAndSummaryQuantityIfMatching(const QVariant& oldValue,
|
|
const QVariant& newValue,
|
|
RifEclipseSummaryAddress* adr)
|
|
{
|
|
if (!adr) return false;
|
|
|
|
std::string oldString = oldValue.toString().toStdString();
|
|
std::string newString = newValue.toString().toStdString();
|
|
|
|
if (adr->quantityName() == oldString)
|
|
{
|
|
adr->setQuantityName(newString);
|
|
|
|
return true;
|
|
}
|
|
|
|
std::string correspondingOldString = RiaSummaryCurveAnalyzer::correspondingHistorySummaryCurveName(oldString);
|
|
std::string correspondingNewString = RiaSummaryCurveAnalyzer::correspondingHistorySummaryCurveName(newString);
|
|
|
|
if (adr->quantityName() == correspondingOldString)
|
|
{
|
|
adr->setQuantityName(correspondingNewString);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<RimSummaryCase*> RimSummaryPlotSourceStepping::summaryCasesForSourceStepping()
|
|
{
|
|
std::vector<RimSummaryCase*> cases;
|
|
|
|
RimProject* proj = RiaApplication::instance()->project();
|
|
for (auto sumCase : proj->allSummaryCases())
|
|
{
|
|
if (sumCase->isObservedData()) continue;
|
|
|
|
RimSummaryCaseCollection* sumCaseColl = nullptr;
|
|
sumCase->firstAncestorOrThisOfType(sumCaseColl);
|
|
|
|
if (sumCaseColl && sumCaseColl->isEnsemble())
|
|
{
|
|
if (m_includeEnsembleCasesForCaseStepping())
|
|
{
|
|
cases.push_back(sumCase);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cases.push_back(sumCase);
|
|
}
|
|
}
|
|
|
|
return cases;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimSummaryPlotSourceStepping::defineEditorAttribute(const caf::PdmFieldHandle* field,
|
|
QString uiConfigName,
|
|
caf::PdmUiEditorAttribute* attribute)
|
|
{
|
|
caf::PdmUiComboBoxEditorAttribute* myAttr = dynamic_cast<caf::PdmUiComboBoxEditorAttribute*>(attribute);
|
|
if (myAttr)
|
|
{
|
|
myAttr->showPreviousAndNextButtons = true;
|
|
|
|
QString modifierText;
|
|
|
|
if (field == &m_summaryCase)
|
|
{
|
|
modifierText = ("(Shift+");
|
|
}
|
|
else if (field == &m_wellName || field == &m_wellGroupName || field == &m_region)
|
|
{
|
|
modifierText = ("(Ctrl+");
|
|
}
|
|
else if (field == &m_quantity)
|
|
{
|
|
modifierText = ("(");
|
|
}
|
|
|
|
if (!modifierText.isEmpty())
|
|
{
|
|
myAttr->nextButtonText = "Next " + modifierText + "PgDown)";
|
|
myAttr->prevButtonText = "Previous " + modifierText + "PgUp)";
|
|
}
|
|
}
|
|
}
|