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

Import and plot of FMU RFT data works

Browse Source
This commit is contained in:
Gaute Lindkvist
2019-08-20 15:09:13 +02:00
parent f76c67dab3
commit 2c5ca4ce46
51 changed files with 862 additions and 237 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
ApplicationCode/ProjectDataModel/Flow/RimDataSourceForRftPlt.cpp
View File

@@ -1,23 +1,25 @@
/////////////////////////////////////////////////////////////////////////////////
//
// 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>
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#include "RimDataSourceForRftPlt.h"
#include "RimEclipseCase.h"
#include "RimObservedFmuRftData.h"
#include "RimSummaryCaseCollection.h"
#include "RimWellLogFile.h"
#include "cafAppEnum.h"
@@ -27,25 +29,25 @@
namespace caf
{
template<>
void caf::AppEnum<RifDataSourceForRftPlt::SourceType>::setUp()
{
addItem(RifDataSourceForRftPlt::SourceType::RFT, "RFT", "RFT Cases");
addItem(RifDataSourceForRftPlt::SourceType::GRID, "GRID", "Grid Cases");
addItem(RifDataSourceForRftPlt::SourceType::OBSERVED, "OBSERVED", "Observed Data");
addItem(RifDataSourceForRftPlt::SourceType::ENSEMBLE_RFT, "ENSEMBLE", "Ensembles with RFT Data");
setDefault(RifDataSourceForRftPlt::SourceType::NONE);
}
template<>
void caf::AppEnum<RifDataSourceForRftPlt::SourceType>::setUp()
{
addItem(RifDataSourceForRftPlt::SourceType::RFT, "RFT", "RFT Cases");
addItem(RifDataSourceForRftPlt::SourceType::GRID, "GRID", "Grid Cases");
addItem(RifDataSourceForRftPlt::SourceType::OBSERVED, "OBSERVED", "Observed Data");
addItem(RifDataSourceForRftPlt::SourceType::ENSEMBLE_RFT, "ENSEMBLE", "Ensembles with RFT Data");
addItem(RifDataSourceForRftPlt::SourceType::OBSERVED_FMU_RFT, "OBSERVED_FMU", "Observed FMU Data");
setDefault(RifDataSourceForRftPlt::SourceType::NONE);
}
} // namespace caf
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
CAF_PDM_SOURCE_INIT(RimDataSourceForRftPlt, "RftAddress");
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
RimDataSourceForRftPlt::RimDataSourceForRftPlt()
{
@@ -53,7 +55,7 @@ RimDataSourceForRftPlt::RimDataSourceForRftPlt()
}
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
RimDataSourceForRftPlt::RimDataSourceForRftPlt(const RifDataSourceForRftPlt& addr)
{
@@ -62,42 +64,62 @@ RimDataSourceForRftPlt::RimDataSourceForRftPlt(const RifDataSourceForRftPlt& add
}
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
void RimDataSourceForRftPlt::setAddress(const RifDataSourceForRftPlt& address)
{
m_sourceType = address.sourceType();
m_eclCase = address.eclCase();
m_wellLogFile = address.wellLogFile();
m_sourceType = address.sourceType();
m_eclCase = address.eclCase();
m_wellLogFile = address.wellLogFile();
m_ensemble = address.ensemble();
m_observedFmuRftData = address.observedFmuRftData();
}
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
RifDataSourceForRftPlt RimDataSourceForRftPlt::address() const
{
return m_eclCase() != nullptr ?
RifDataSourceForRftPlt(m_sourceType(), m_eclCase()) :
RifDataSourceForRftPlt(m_sourceType(), m_wellLogFile());
if (m_eclCase())
{
return RifDataSourceForRftPlt(m_sourceType(), m_eclCase);
}
else if (m_wellLogFile())
{
return RifDataSourceForRftPlt(m_sourceType(), m_wellLogFile);
}
else if (m_ensemble())
{
return RifDataSourceForRftPlt(m_sourceType(), m_ensemble);
}
else if (m_observedFmuRftData())
{
return RifDataSourceForRftPlt(m_sourceType(), m_observedFmuRftData);
}
return RifDataSourceForRftPlt(RifDataSourceForRftPlt::NONE);
}
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
void RimDataSourceForRftPlt::InitPdmObject()
{
CAF_PDM_InitFieldNoDefault(&m_sourceType, "SourceType", "Source Type", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_eclCase, "EclipseCase", "Eclipse Case", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_wellLogFile, "WellLogFile", "Well Log File", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_ensemble, "Ensemble", "Ensemble", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_observedFmuRftData, "ObservedFmuRftData", "Observed FMU Data", "", "", "");
}
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
RimDataSourceForRftPlt& RimDataSourceForRftPlt::operator=(const RimDataSourceForRftPlt& other)
{
m_sourceType = other.m_sourceType();
m_eclCase = other.m_eclCase();
m_wellLogFile = other.m_wellLogFile();
m_sourceType = other.m_sourceType();
m_eclCase = other.m_eclCase();
m_wellLogFile = other.m_wellLogFile();
m_ensemble = other.m_ensemble();
m_observedFmuRftData = other.m_observedFmuRftData();
return *this;
}

10
ApplicationCode/ProjectDataModel/Flow/RimDataSourceForRftPlt.h
View File

@@ -34,6 +34,8 @@
#include <QDate>
#include <QMetaType>
class RimObservedFmuRftData;
class RimSummaryCaseCollection;
class RimWellLogFile;
class RimEclipseCase;
@@ -58,7 +60,9 @@ public:
private:
void InitPdmObject();
caf::PdmField<caf::AppEnum<RifDataSourceForRftPlt::SourceType> > m_sourceType;
caf::PdmPtrField<RimEclipseCase*> m_eclCase;
caf::PdmPtrField<RimWellLogFile*> m_wellLogFile;
caf::PdmField<caf::AppEnum<RifDataSourceForRftPlt::SourceType>> m_sourceType;
caf::PdmPtrField<RimEclipseCase*> m_eclCase;
caf::PdmPtrField<RimWellLogFile*> m_wellLogFile;
caf::PdmPtrField<RimSummaryCaseCollection*> m_ensemble;
caf::PdmPtrField<RimObservedFmuRftData*> m_observedFmuRftData;
};

79
ApplicationCode/ProjectDataModel/Flow/RimWellPlotTools.cpp
View File

@@ -30,6 +30,8 @@
#include "RimEclipseCase.h"
#include "RimEclipseResultCase.h"
#include "RimObservedDataCollection.h"
#include "RimObservedFmuRftData.h"
#include "RimOilField.h"
#include "RimProject.h"
#include "RimSummaryCase.h"
@@ -450,6 +452,39 @@ std::vector<RimSummaryCaseCollection*> RimWellPlotTools::rftEnsembles()
return rftEnsembles;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimObservedFmuRftData*> RimWellPlotTools::observedFmuRftDataForWell(const QString& simWellName)
{
std::vector<RimObservedFmuRftData*> observedDataForWell;
std::vector<RimObservedFmuRftData*> allObservedData = observedFmuRftData();
for (RimObservedFmuRftData* observedData : allObservedData)
{
if (observedData->hasWell(simWellName))
{
observedDataForWell.push_back(observedData);
}
}
return observedDataForWell;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimObservedFmuRftData*> RimWellPlotTools::observedFmuRftData()
{
const RimProject* project = RiaApplication::instance()->project();
RimObservedDataCollection* observedDataCollection =
project->activeOilField() ? project->activeOilField()->observedDataCollection() : nullptr;
if (observedDataCollection)
{
return observedDataCollection->allObservedFmuRftData();
}
return {};
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -542,6 +577,7 @@ RiaRftPltCurveDefinition RimWellPlotTools::curveDefFromCurve(const RimWellLogCur
RimEclipseResultCase* rftCase = dynamic_cast<RimEclipseResultCase*>(rftCurve->eclipseResultCase());
RimSummaryCase* rftSummaryCase = rftCurve->summaryCase();
RimSummaryCaseCollection* rftEnsemble = rftCurve->ensemble();
RimObservedFmuRftData* rftFmuData = rftCurve->observedFmuRftData();
const RifEclipseRftAddress rftAddress = rftCurve->rftAddress();
const QString& wellName = rftAddress.wellName();
@@ -562,6 +598,11 @@ RiaRftPltCurveDefinition RimWellPlotTools::curveDefFromCurve(const RimWellLogCur
return RiaRftPltCurveDefinition(
RifDataSourceForRftPlt(RifDataSourceForRftPlt::ENSEMBLE_RFT, rftEnsemble), wellName, timeStep);
}
else if (rftFmuData != nullptr)
{
return RiaRftPltCurveDefinition(
RifDataSourceForRftPlt(RifDataSourceForRftPlt::OBSERVED_FMU_RFT, rftFmuData), wellName, timeStep);
}
}
else if (gridCurve != nullptr)
{
@@ -687,6 +728,21 @@ std::set<RiaRftPltCurveDefinition>
}
}
}
else if (addr.sourceType() == RifDataSourceForRftPlt::OBSERVED_FMU_RFT)
{
RimObservedFmuRftData* observedFmuRftData = addr.observedFmuRftData();
if (observedFmuRftData && observedFmuRftData->rftReader())
{
std::set<QDateTime> timeSteps = observedFmuRftData->rftReader()->availableTimeSteps(simWellName);
for (const QDateTime& time : timeSteps)
{
if (selectedTimeStepSet.count(time))
{
curveDefs.insert(RiaRftPltCurveDefinition(addr, simWellName, time));
}
}
}
}
else if (addr.sourceType() == RifDataSourceForRftPlt::ENSEMBLE_RFT)
{
if (addr.ensemble())
@@ -889,6 +945,7 @@ std::map<QDateTime, std::set<RifDataSourceForRftPlt>> RimWellPlotTools::calculat
hasGridData = true;
break;
case RifDataSourceForRftPlt::OBSERVED:
case RifDataSourceForRftPlt::OBSERVED_FMU_RFT:
hasObservedData = true;
break;
case RifDataSourceForRftPlt::SUMMARY_RFT:
@@ -914,6 +971,15 @@ std::map<QDateTime, std::set<RifDataSourceForRftPlt>> RimWellPlotTools::calculat
{
observedTimeStepsWithSources[source.wellLogFile()->date()].insert(source);
}
else if (source.sourceType() == RifDataSourceForRftPlt::OBSERVED_FMU_RFT && source.observedFmuRftData())
{
std::set<QDateTime> rftFmuTimes =
source.observedFmuRftData()->rftReader()->availableTimeSteps(wellPathNameOrSimWellName);
for (const QDateTime& date : rftFmuTimes)
{
observedTimeStepsWithSources[date].insert(source);
}
}
}
}
@@ -996,10 +1062,10 @@ std::map<QDateTime, std::set<RifDataSourceForRftPlt>> RimWellPlotTools::calculat
{
timeBaseline = &rftTimeStepsWithSources;
}
else if (hasSummaryRftData)
{
else if (hasSummaryRftData)
{
timeBaseline = &summaryRftTimeStepsWithSources;
}
}
else if (hasEnsembleData)
{
timeBaseline = &ensembleTimeStepsWithSources;
@@ -1019,7 +1085,7 @@ std::map<QDateTime, std::set<RifDataSourceForRftPlt>> RimWellPlotTools::calculat
for (const auto& dateSourceSetPair : gridTimestepsWithSources)
gridTimeSteps.insert(dateSourceSetPair.first);
std::set<QDateTime> summaryRftTimeSteps;
std::set<QDateTime> summaryRftTimeSteps;
for (const auto& dateSourceSetPair : summaryRftTimeStepsWithSources)
summaryRftTimeSteps.insert(dateSourceSetPair.first);
@@ -1056,14 +1122,14 @@ std::map<QDateTime, std::set<RifDataSourceForRftPlt>> RimWellPlotTools::calculat
timestepsToShowWithSources[time].insert(sourceSet.begin(), sourceSet.end());
}
auto gridTimeSourceSetIt = gridTimestepsWithSources.find(time);
auto gridTimeSourceSetIt = gridTimestepsWithSources.find(time);
if (gridTimeSourceSetIt != gridTimestepsWithSources.end())
{
std::set<RifDataSourceForRftPlt>& sourceSet = gridTimeSourceSetIt->second;
timestepsToShowWithSources[time].insert(sourceSet.begin(), sourceSet.end());
}
auto summaryRftTimeSourceSetIt = summaryRftTimeStepsWithSources.find(time);
auto summaryRftTimeSourceSetIt = summaryRftTimeStepsWithSources.find(time);
if (summaryRftTimeSourceSetIt != summaryRftTimeStepsWithSources.end())
{
std::set<RifDataSourceForRftPlt>& sourceSet = summaryRftTimeSourceSetIt->second;
@@ -1123,6 +1189,7 @@ void RimWellPlotTools::calculateValueOptionsForTimeSteps(
switch (source.sourceType())
{
case RifDataSourceForRftPlt::OBSERVED:
case RifDataSourceForRftPlt::OBSERVED_FMU_RFT:
hasObs = true;
break;
case RifDataSourceForRftPlt::RFT:

3
ApplicationCode/ProjectDataModel/Flow/RimWellPlotTools.h
View File

@@ -33,6 +33,7 @@
class RimEclipseCase;
class RimEclipseResultCase;
class RimObservedFmuRftData;
class RimSummaryCaseCollection;
class RimWellLogCurve;
class RimWellLogFileChannel;
@@ -85,6 +86,8 @@ public:
static std::vector<RimEclipseResultCase*> rftCasesForWell(const QString& simWellName);
static std::vector<RimSummaryCaseCollection*> rftEnsemblesForWell(const QString& simWellName);
static std::vector<RimSummaryCaseCollection*> rftEnsembles();
static std::vector<RimObservedFmuRftData*> observedFmuRftDataForWell(const QString& simWellName);
static std::vector<RimObservedFmuRftData*> observedFmuRftData();
static QString simWellName(const QString& wellPathNameOrSimWellName);
static std::map<QDateTime, std::set<RifDataSourceForRftPlt>>

173
ApplicationCode/ProjectDataModel/Flow/RimWellRftPlot.cpp
View File

@@ -19,8 +19,8 @@
#include "RimWellRftPlot.h"
#include "RiaApplication.h"
#include "RiaColorTools.h"
#include "RiaColorTables.h"
#include "RiaColorTools.h"
#include "RiaDateStringParser.h"
#include "RiaSimWellBranchTools.h"
@@ -35,6 +35,7 @@
#include "RimEclipseCaseCollection.h"
#include "RimEclipseResultCase.h"
#include "RimEclipseResultDefinition.h"
#include "RimObservedFmuRftData.h"
#include "RimOilField.h"
#include "RimProject.h"
#include "RimSummaryCaseCollection.h"
@@ -144,32 +145,33 @@ void RimWellRftPlot::applyCurveAppearance(RimWellLogCurve* newCurve)
RiuQwtPlotCurve::LineStyleEnum currentLineStyle = RiuQwtPlotCurve::STYLE_SOLID;
cvf::Color3f currentColor;
if (newCurveDef.address().sourceType() == RifDataSourceForRftPlt::SUMMARY_RFT)
{
cvf::Color3f currentColor;
if (newCurveDef.address().sourceType() == RifDataSourceForRftPlt::SUMMARY_RFT)
{
RifDataSourceForRftPlt sourceAddress(RifDataSourceForRftPlt::ENSEMBLE_RFT, newCurveDef.address().ensemble());
currentColor = m_dataSourceColors[sourceAddress];
if (m_showStatisticsCurves)
{
cvf::Color3f backgroundColor =
RiaColorTools::fromQColorTo3f(m_wellLogPlot->trackByIndex(0)->viewer()->canvasBackground().color());
currentColor = RiaColorTools::blendCvfColors(backgroundColor, currentColor, 2, 1);
}
}
else
{
if (m_showStatisticsCurves)
{
cvf::Color3f backgroundColor =
RiaColorTools::fromQColorTo3f(m_wellLogPlot->trackByIndex(0)->viewer()->canvasBackground().color());
currentColor = RiaColorTools::blendCvfColors(backgroundColor, currentColor, 2, 1);
}
}
else
{
currentColor = m_dataSourceColors[newCurveDef.address()];
}
}
RiuQwtSymbol::PointSymbolEnum currentSymbol = RiuQwtSymbol::SYMBOL_NONE;
if (newCurveDef.address().sourceType() != RifDataSourceForRftPlt::ENSEMBLE_RFT)
{
if (newCurveDef.address().sourceType() != RifDataSourceForRftPlt::ENSEMBLE_RFT)
{
currentSymbol = m_timeStepSymbols[newCurveDef.timeStep()];
}
}
bool isObservedData = newCurveDef.address().sourceType() == RifDataSourceForRftPlt::OBSERVED ||
newCurveDef.address().sourceType() == RifDataSourceForRftPlt::OBSERVED_FMU_RFT;
// Observed data
currentLineStyle = newCurveDef.address().sourceType() == RifDataSourceForRftPlt::OBSERVED ? RiuQwtPlotCurve::STYLE_NONE
: RiuQwtPlotCurve::STYLE_SOLID;
currentLineStyle = isObservedData ? RiuQwtPlotCurve::STYLE_NONE : RiuQwtPlotCurve::STYLE_SOLID;
newCurve->setColor(currentColor);
newCurve->setSymbolEdgeColor(currentColor);
@@ -253,6 +255,11 @@ void RimWellRftPlot::applyInitialSelections()
}
}
for (RimObservedFmuRftData* const observedFmuRftData : RimWellPlotTools::observedFmuRftData())
{
sourcesToSelect.push_back(RifDataSourceForRftPlt(RifDataSourceForRftPlt::OBSERVED_FMU_RFT, observedFmuRftData));
}
m_selectedSources = sourcesToSelect;
{
@@ -402,7 +409,7 @@ void RimWellRftPlot::updateCurvesInPlot(const std::set<RiaRftPltCurveDefinition>
// Delete curves
plotTrack->deleteAllCurves();
defineCurveColorsAndSymbols(allCurveDefs);
defineCurveColorsAndSymbols(allCurveDefs);
std::set<RimSummaryCaseCollection*> ensemblesWithSummaryCurves;
@@ -424,6 +431,18 @@ void RimWellRftPlot::updateCurvesInPlot(const std::set<RiaRftPltCurveDefinition>
applyCurveAppearance(curve);
}
else if (curveDefToAdd.address().sourceType() == RifDataSourceForRftPlt::OBSERVED_FMU_RFT)
{
auto curve = new RimWellLogRftCurve();
plotTrack->addCurve(curve);
auto observedFmuRftData = curveDefToAdd.address().observedFmuRftData();
curve->setObservedFmuRftData(observedFmuRftData);
RifEclipseRftAddress address(simWellName, curveDefToAdd.timeStep(), RifEclipseRftAddress::PRESSURE);
curve->setRftAddress(address);
curve->setZOrder(RiuQwtPlotCurve::Z_SINGLE_CURVE_OBSERVED);
applyCurveAppearance(curve);
}
else if (m_showEnsembleCurves && curveDefToAdd.address().sourceType() == RifDataSourceForRftPlt::SUMMARY_RFT)
{
auto curve = new RimWellLogRftCurve();
@@ -621,6 +640,26 @@ const char* RimWellRftPlot::plotNameFormatString()
return PLOT_NAME_QFORMAT_STRING;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellRftPlot::deleteCurvesAssosicatedWithObservedData(const RimObservedFmuRftData* observedFmuRftData)
{
for (auto track : m_wellLogPlot->tracks())
{
auto curves = track->curvesVector();
for (auto curve : curves)
{
RimWellLogRftCurve* rftCurve = dynamic_cast<RimWellLogRftCurve*>(curve);
if (rftCurve && rftCurve->observedFmuRftData() == observedFmuRftData)
{
track->takeOutCurve(rftCurve);
delete rftCurve;
}
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -692,6 +731,22 @@ QList<caf::PdmOptionItemInfo> RimWellRftPlot::calculateValueOptions(const caf::P
item.setLevel(1);
options.push_back(item);
}
const std::vector<RimObservedFmuRftData*> observedFmuRftCases = RimWellPlotTools::observedFmuRftDataForWell(simWellName);
if (!observedFmuRftCases.empty())
{
options.push_back(caf::PdmOptionItemInfo::createHeader(
RifDataSourceForRftPlt::sourceTypeUiText(RifDataSourceForRftPlt::OBSERVED_FMU_RFT), true));
for (const auto& observedFmuRftCase : observedFmuRftCases)
{
auto addr = RifDataSourceForRftPlt(RifDataSourceForRftPlt::OBSERVED_FMU_RFT, observedFmuRftCase);
auto item = caf::PdmOptionItemInfo(observedFmuRftCase->name(), QVariant::fromValue(addr));
item.setLevel(1);
options.push_back(item);
}
}
}
else if (fieldNeedingOptions == &m_selectedTimeSteps)
{
@@ -881,6 +936,19 @@ void RimWellRftPlot::calculateValueOptionsForWells(QList<caf::PdmOptionItemInfo>
}
}
// Observer FMU RFT wells
const std::vector<RimObservedFmuRftData*> allRftFmuData = RimWellPlotTools::observedFmuRftData();
if (!allRftFmuData.empty())
{
for (RimObservedFmuRftData* rftFmuData : allRftFmuData)
{
for (QString wellName : rftFmuData->wells())
{
wellNames.insert(std::make_pair(wellName, wellName));
}
}
}
for (const auto& wellName : wellNames)
{
options.push_back(caf::PdmOptionItemInfo(wellName.first, wellName.second));
@@ -1014,42 +1082,41 @@ void RimWellRftPlot::defineCurveColorsAndSymbols(const std::set<RiaRftPltCurveDe
{
m_dataSourceColors.clear();
m_timeStepSymbols.clear();
std::vector<cvf::Color3f> colorTable;
std::vector<cvf::Color3f> colorTable;
RiaColorTables::summaryCurveDefaultPaletteColors().color3fArray().toStdVector(&colorTable);
std::vector<RiuQwtSymbol::PointSymbolEnum> symbolTable = {RiuQwtSymbol::SYMBOL_ELLIPSE,
RiuQwtSymbol::SYMBOL_RECT,
RiuQwtSymbol::SYMBOL_DIAMOND,
RiuQwtSymbol::SYMBOL_CROSS,
RiuQwtSymbol::SYMBOL_XCROSS,
RiuQwtSymbol::SYMBOL_STAR1};
std::vector<RiuQwtSymbol::PointSymbolEnum> symbolTable = {RiuQwtSymbol::SYMBOL_ELLIPSE,
RiuQwtSymbol::SYMBOL_RECT,
RiuQwtSymbol::SYMBOL_DIAMOND,
RiuQwtSymbol::SYMBOL_CROSS,
RiuQwtSymbol::SYMBOL_XCROSS,
RiuQwtSymbol::SYMBOL_STAR1};
// Add new curves
for (const RiaRftPltCurveDefinition& curveDefToAdd : allCurveDefs)
{
auto colorTableIndex = m_dataSourceColors.size();
auto symbolTableIndex = m_timeStepSymbols.size();
// Add new curves
for (const RiaRftPltCurveDefinition& curveDefToAdd : allCurveDefs)
{
auto colorTableIndex = m_dataSourceColors.size();
auto symbolTableIndex = m_timeStepSymbols.size();
RifDataSourceForRftPlt address = curveDefToAdd.address();
if (address.sourceType() != RifDataSourceForRftPlt::SUMMARY_RFT)
{
if (!m_dataSourceColors.count(curveDefToAdd.address()))
{
colorTableIndex = colorTableIndex % colorTable.size();
m_dataSourceColors[curveDefToAdd.address()] = colorTable[colorTableIndex];
}
}
RifDataSourceForRftPlt address = curveDefToAdd.address();
if (address.sourceType() != RifDataSourceForRftPlt::ENSEMBLE_RFT)
{
if (!m_timeStepSymbols.count(curveDefToAdd.timeStep()))
{
symbolTableIndex = symbolTableIndex % symbolTable.size();
m_timeStepSymbols[curveDefToAdd.timeStep()] = symbolTable[symbolTableIndex];
}
}
if (address.sourceType() != RifDataSourceForRftPlt::SUMMARY_RFT)
{
if (!m_dataSourceColors.count(curveDefToAdd.address()))
{
colorTableIndex = colorTableIndex % colorTable.size();
m_dataSourceColors[curveDefToAdd.address()] = colorTable[colorTableIndex];
}
}
if (address.sourceType() != RifDataSourceForRftPlt::ENSEMBLE_RFT)
{
if (!m_timeStepSymbols.count(curveDefToAdd.timeStep()))
{
symbolTableIndex = symbolTableIndex % symbolTable.size();
m_timeStepSymbols[curveDefToAdd.timeStep()] = symbolTable[symbolTableIndex];
}
}
}
}

2
ApplicationCode/ProjectDataModel/Flow/RimWellRftPlot.h
View File

@@ -90,6 +90,8 @@ public:
static const char* plotNameFormatString();
void deleteCurvesAssosicatedWithObservedData(const RimObservedFmuRftData* observedFmuRftData);
protected:
// Overridden PDM methods
caf::PdmFieldHandle* userDescriptionField() override