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

#2100 RFT plot. Add RftPltCurveDefinition. Use that in RFT plot

Browse Source
This commit is contained in:
Bjørn Erik Jensen
2017-11-09 08:21:36 +01:00
parent a46c5af1f8
commit 89e5c04aef
7 changed files with 238 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
ApplicationCode/Application/CMakeLists_files.cmake
View File

@@ -10,6 +10,7 @@ ${CEE_CURRENT_LIST_DIR}RiaDefines.h
${CEE_CURRENT_LIST_DIR}RiaPreferences.h
${CEE_CURRENT_LIST_DIR}RiaPorosityModel.h
${CEE_CURRENT_LIST_DIR}RiaSummaryCurveDefinition.h
${CEE_CURRENT_LIST_DIR}RiaRftPltCurveDefinition.h
)
set (SOURCE_GROUP_SOURCE_FILES
@@ -19,6 +20,7 @@ ${CEE_CURRENT_LIST_DIR}RiaMain.cpp
${CEE_CURRENT_LIST_DIR}RiaPreferences.cpp
${CEE_CURRENT_LIST_DIR}RiaPorosityModel.cpp
${CEE_CURRENT_LIST_DIR}RiaSummaryCurveDefinition.cpp
${CEE_CURRENT_LIST_DIR}RiaRftPltCurveDefinition.cpp
)
list(APPEND CODE_HEADER_FILES

52
ApplicationCode/Application/RiaRftPltCurveDefinition.cpp Normal file
View File

@@ -0,0 +1,52 @@
/////////////////////////////////////////////////////////////////////////////////
//
// 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 "RiaRftPltCurveDefinition.h"
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaRftPltCurveDefinition::RiaRftPltCurveDefinition(RifWellRftAddress address, const QDateTime timeStep)
{
m_curveDefinition = std::make_pair(address, timeStep);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifWellRftAddress RiaRftPltCurveDefinition::address() const
{
return m_curveDefinition.first;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QDateTime RiaRftPltCurveDefinition::timeStep() const
{
return m_curveDefinition.second;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RiaRftPltCurveDefinition::operator<(const RiaRftPltCurveDefinition& other) const
{
return m_curveDefinition < other.m_curveDefinition;
}

45
ApplicationCode/Application/RiaRftPltCurveDefinition.h Normal file
View File

@@ -0,0 +1,45 @@
/////////////////////////////////////////////////////////////////////////////////
//
// 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.
//
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "RifWellRftAddress.h"
#include <QString>
#include <utility>
#include <vector>
class RimSummaryCase;
//==================================================================================================
///
//==================================================================================================
class RiaRftPltCurveDefinition
{
public:
explicit RiaRftPltCurveDefinition(RifWellRftAddress address, const QDateTime timeStep);
RifWellRftAddress address() const;
QDateTime timeStep() const;
bool operator < (const RiaRftPltCurveDefinition& other) const;
private:
std::pair<RifWellRftAddress, QDateTime> m_curveDefinition;
};

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

@@ -159,7 +159,7 @@ std::vector<RimWellLogFile*> RimWellPlotTools::wellLogFilesContainingPressure(co
for (RimWellLogFile* const file : files)
{
size_t timeStepCount = timeStepsFromWellLogFile(file).size();
size_t timeStepCount = timeStepsMapFromWellLogFile(file).size();
if (timeStepCount == 0) continue;
if (QString::compare(file->wellName(), wellName) != 0) continue;
@@ -258,7 +258,52 @@ std::vector<RimEclipseResultCase*> RimWellPlotTools::rftCasesForWell(const QStri
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::map<QDateTime, std::set<RifWellRftAddress>> RimWellPlotTools::timeStepsFromRftCase(RimEclipseResultCase* rftCase, const QString& wellName)
std::set<QDateTime> RimWellPlotTools::timeStepsFromRftCase(RimEclipseResultCase* rftCase, const QString& wellName)
{
std::set<QDateTime> timeSteps;
RifReaderEclipseRft* const reader = rftCase->rftReader();
if (reader != nullptr)
{
for (const QDateTime& timeStep : reader->availableTimeSteps(wellName, RifEclipseRftAddress::PRESSURE))
{
timeSteps.insert(timeStep);
}
}
return timeSteps;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::set<QDateTime> RimWellPlotTools::timeStepsFromGridCase(RimEclipseCase* gridCase)
{
const RigEclipseCaseData* const eclipseCaseData = gridCase->eclipseCaseData();
std::pair<size_t, QString> resultDataInfo = pressureResultDataInfo(eclipseCaseData);
std::set<QDateTime> timeSteps;
if (resultDataInfo.first != cvf::UNDEFINED_SIZE_T)
{
for (const QDateTime& timeStep : eclipseCaseData->results(RiaDefines::MATRIX_MODEL)->timeStepDates(resultDataInfo.first))
{
timeSteps.insert(timeStep);
}
}
return timeSteps;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QDateTime RimWellPlotTools::timeStepFromWellLogFile(RimWellLogFile* wellLogFile)
{
QDateTime timeStep = wellLogFile->date();
return timeStep;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::map<QDateTime, std::set<RifWellRftAddress>> RimWellPlotTools::timeStepsMapFromRftCase(RimEclipseResultCase* rftCase, const QString& wellName)
{
std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsMap;
RifReaderEclipseRft* const reader = rftCase->rftReader();
@@ -279,7 +324,7 @@ std::map<QDateTime, std::set<RifWellRftAddress>> RimWellPlotTools::timeStepsFrom
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::map<QDateTime, std::set<RifWellRftAddress>> RimWellPlotTools::timeStepsFromGridCase(RimEclipseCase* gridCase)
std::map<QDateTime, std::set<RifWellRftAddress>> RimWellPlotTools::timeStepsMapFromGridCase(RimEclipseCase* gridCase)
{
const RigEclipseCaseData* const eclipseCaseData = gridCase->eclipseCaseData();
std::pair<size_t, QString> resultDataInfo = pressureResultDataInfo(eclipseCaseData);
@@ -302,7 +347,7 @@ std::map<QDateTime, std::set<RifWellRftAddress>> RimWellPlotTools::timeStepsFrom
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::map<QDateTime, std::set<RifWellRftAddress> > RimWellPlotTools::timeStepsFromWellLogFile(RimWellLogFile* wellLogFile)
std::map<QDateTime, std::set<RifWellRftAddress> > RimWellPlotTools::timeStepsMapFromWellLogFile(RimWellLogFile* wellLogFile)
{
std::map<QDateTime, std::set<RifWellRftAddress> > timeStepsMap;
@@ -362,7 +407,7 @@ bool RimWellPlotTools::mapContainsTimeStep(const std::map<QDateTime, std::set<Ri
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<RifWellRftAddress, QDateTime> RimWellPlotTools::curveDefFromCurve(const RimWellLogCurve* curve)
RiaRftPltCurveDefinition RimWellPlotTools::curveDefFromCurve(const RimWellLogCurve* curve)
{
const RimWellLogRftCurve* rftCurve = dynamic_cast<const RimWellLogRftCurve*>(curve);
const RimWellLogExtractionCurve* gridCurve = dynamic_cast<const RimWellLogExtractionCurve*>(curve);
@@ -375,7 +420,7 @@ std::pair<RifWellRftAddress, QDateTime> RimWellPlotTools::curveDefFromCurve(cons
{
const RifEclipseRftAddress rftAddress = rftCurve->rftAddress();
const QDateTime timeStep = rftAddress.timeStep();
return std::make_pair(RifWellRftAddress(RifWellRftAddress::RFT, rftCase), timeStep);
return RiaRftPltCurveDefinition(RifWellRftAddress(RifWellRftAddress::RFT, rftCase), timeStep);
}
}
else if (gridCurve != nullptr)
@@ -384,12 +429,12 @@ std::pair<RifWellRftAddress, QDateTime> RimWellPlotTools::curveDefFromCurve(cons
if (gridCase != nullptr)
{
size_t timeStepIndex = gridCurve->currentTimeStep();
const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsMap = timeStepsFromGridCase(gridCase);
const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsMap = timeStepsMapFromGridCase(gridCase);
auto timeStepsVector = std::vector<std::pair<QDateTime, std::set<RifWellRftAddress>>>(
timeStepsMap.begin(), timeStepsMap.end());
if (timeStepIndex < timeStepsMap.size())
{
return std::make_pair(RifWellRftAddress(RifWellRftAddress::GRID, gridCase),
return RiaRftPltCurveDefinition(RifWellRftAddress(RifWellRftAddress::GRID, gridCase),
timeStepsVector[timeStepIndex].first);
}
}
@@ -405,9 +450,9 @@ std::pair<RifWellRftAddress, QDateTime> RimWellPlotTools::curveDefFromCurve(cons
if (date.isValid())
{
return std::make_pair(RifWellRftAddress(RifWellRftAddress::OBSERVED, wellLogFile), date);
return RiaRftPltCurveDefinition(RifWellRftAddress(RifWellRftAddress::OBSERVED, wellLogFile), date);
}
}
}
return std::make_pair(RifWellRftAddress(), QDateTime());
return RiaRftPltCurveDefinition(RifWellRftAddress(), QDateTime());
}

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

@@ -20,6 +20,7 @@
#include "RifWellRftAddressQMetaType.h"
#include "RiaRftPltCurveDefinition.h"
#include <QMetaType>
@@ -63,12 +64,30 @@ public:
static std::vector<RimEclipseResultCase*> gridCasesForWell(const QString& wellName);
static std::vector<RimEclipseResultCase*> rftCasesForWell(const QString& wellName);
static std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsFromRftCase(RimEclipseResultCase* gridCase, const QString& wellName);
static std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsFromGridCase(RimEclipseCase* gridCase);
static std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsFromWellLogFile(RimWellLogFile* wellLogFile);
static std::set<QDateTime> timeStepsFromRftCase(RimEclipseResultCase* rftCase, const QString& wellName);
static std::set<QDateTime> timeStepsFromGridCase(RimEclipseCase* gridCase);
static QDateTime timeStepFromWellLogFile(RimWellLogFile* wellLogFile);
static std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsMapFromRftCase(RimEclipseResultCase* rftCase, const QString& wellName);
static std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsMapFromGridCase(RimEclipseCase* gridCase);
static std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsMapFromWellLogFile(RimWellLogFile* wellLogFile);
static std::map<QDateTime, std::set<RifWellRftAddress>> adjacentTimeSteps(const std::vector<std::pair<QDateTime, std::set<RifWellRftAddress>>>& allTimeSteps,
const std::pair<QDateTime, std::set<RifWellRftAddress>>& searchTimeStepPair);
static bool mapContainsTimeStep(const std::map<QDateTime, std::set<RifWellRftAddress>>& map, const QDateTime& timeStep);
static std::pair<RifWellRftAddress, QDateTime> curveDefFromCurve(const RimWellLogCurve* curve);
static RiaRftPltCurveDefinition curveDefFromCurve(const RimWellLogCurve* curve);
template<typename T>
static void appendSet(std::set<T>& destSet, const std::set<T>& setToAppend);
};
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
template<typename T>
void RimWellPlotTools::appendSet(std::set<T>& destSet, const std::set<T>& setToAppend)
{
destSet.insert(setToAppend.begin(), setToAppend.end());
}

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

@@ -127,7 +127,7 @@ void RimWellRftPlot::deleteViewWidget()
//--------------------------------------------------------------------------------------------------
void RimWellRftPlot::applyCurveAppearance(RimWellLogCurve* newCurve)
{
const std::pair<RifWellRftAddress, QDateTime>& newCurveDef = RimWellPlotTools::curveDefFromCurve(newCurve);
const RiaRftPltCurveDefinition& newCurveDef = RimWellPlotTools::curveDefFromCurve(newCurve);
std::vector<cvf::Color3f> colorTable;
RiaColorTables::summaryCurveDefaultPaletteColors().color3fArray().toStdVector(&colorTable);
@@ -160,13 +160,13 @@ void RimWellRftPlot::applyCurveAppearance(RimWellLogCurve* newCurve)
{
if (curve == newCurve) continue;
std::pair<RifWellRftAddress, QDateTime> cDef = RimWellPlotTools::curveDefFromCurve(curve);
if (cDef.first == newCurveDef.first)
RiaRftPltCurveDefinition cDef = RimWellPlotTools::curveDefFromCurve(curve);
if (cDef.address() == newCurveDef.address())
{
currentColor = curve->color();
isCurrentColorSet = true;
}
if (cDef.second == newCurveDef.second)
if (cDef.timeStep() == newCurveDef.timeStep())
{
currentSymbol = curve->symbol();
isCurrentSymbolSet = true;
@@ -217,7 +217,7 @@ void RimWellRftPlot::applyCurveAppearance(RimWellLogCurve* newCurve)
}
// Observed data
currentLineStyle = newCurveDef.first.sourceType() == RifWellRftAddress::OBSERVED
currentLineStyle = newCurveDef.address().sourceType() == RifWellRftAddress::OBSERVED
? RimPlotCurve::STYLE_NONE : RimPlotCurve::STYLE_SOLID;
newCurve->setColor(currentColor);
@@ -302,20 +302,20 @@ void RimWellRftPlot::updateFormationsOnPlot() const
void RimWellRftPlot::applyInitialSelections()
{
std::vector<RifWellRftAddress> sourcesToSelect;
std::map<QDateTime, std::set<RifWellRftAddress>> rftTimeStepsMap;
std::map<QDateTime, std::set<RifWellRftAddress>> observedTimeStepsMap;
std::map<QDateTime, std::set<RifWellRftAddress>> gridTimeStepsMap;
std::set<QDateTime> rftTimeSteps;
std::set<QDateTime> observedTimeSteps;
std::set<QDateTime> gridTimeSteps;
for(RimEclipseResultCase* const rftCase : RimWellPlotTools::rftCasesForWell(m_wellName))
{
sourcesToSelect.push_back(RifWellRftAddress(RifWellRftAddress::RFT, rftCase));
RimWellPlotTools::addTimeStepsToMap(rftTimeStepsMap, RimWellPlotTools::timeStepsFromRftCase(rftCase, m_wellName));
RimWellPlotTools::appendSet(rftTimeSteps, RimWellPlotTools::timeStepsFromRftCase(rftCase, m_wellName));
}
for (RimEclipseResultCase* const gridCase : RimWellPlotTools::gridCasesForWell(m_wellName))
{
sourcesToSelect.push_back(RifWellRftAddress(RifWellRftAddress::GRID, gridCase));
RimWellPlotTools::addTimeStepsToMap(gridTimeStepsMap, RimWellPlotTools::timeStepsFromGridCase(gridCase));
RimWellPlotTools::appendSet(gridTimeSteps, RimWellPlotTools::timeStepsFromGridCase(gridCase));
}
std::vector<RimWellLogFile*> wellLogFiles = RimWellPlotTools::wellLogFilesContainingPressure(m_wellName);
@@ -324,23 +324,23 @@ void RimWellRftPlot::applyInitialSelections()
sourcesToSelect.push_back(RifWellRftAddress(RifWellRftAddress::OBSERVED));
for (RimWellLogFile* const wellLogFile : wellLogFiles)
{
RimWellPlotTools::addTimeStepsToMap(observedTimeStepsMap, RimWellPlotTools::timeStepsFromWellLogFile(wellLogFile));
observedTimeSteps.insert(RimWellPlotTools::timeStepFromWellLogFile(wellLogFile));
}
}
m_selectedSources = sourcesToSelect;
std::set<QDateTime> timeStepsToSelect;
for (const std::pair<QDateTime, std::set<RifWellRftAddress>>& dateTimePair : rftTimeStepsMap)
for (const QDateTime& timeStep : rftTimeSteps)
{
timeStepsToSelect.insert(dateTimePair.first);
timeStepsToSelect.insert(timeStep);
}
for (const std::pair<QDateTime, std::set<RifWellRftAddress>>& dateTimePair : observedTimeStepsMap)
for (const QDateTime& timeStep : observedTimeSteps)
{
timeStepsToSelect.insert(dateTimePair.first);
timeStepsToSelect.insert(timeStep);
}
if (gridTimeStepsMap.size() > 0)
timeStepsToSelect.insert((*gridTimeStepsMap.begin()).first);
if (gridTimeSteps.size() > 0)
timeStepsToSelect.insert(*gridTimeSteps.begin());
m_selectedTimeSteps = std::vector<QDateTime>(timeStepsToSelect.begin(), timeStepsToSelect.end());
@@ -356,19 +356,19 @@ void RimWellRftPlot::updateEditorsFromCurves()
std::set<QDateTime> selectedTimeSteps;
std::map<QDateTime, std::set<RifWellRftAddress>> selectedTimeStepsMap;
for (const std::pair<RifWellRftAddress, QDateTime>& curveDef : curveDefsFromCurves())
for (const RiaRftPltCurveDefinition& curveDef : curveDefsFromCurves())
{
if (curveDef.first.sourceType() == RifWellRftAddress::OBSERVED)
if (curveDef.address().sourceType() == RifWellRftAddress::OBSERVED)
selectedSources.insert(RifWellRftAddress(RifWellRftAddress::OBSERVED));
else
selectedSources.insert(curveDef.first);
selectedSources.insert(curveDef.address());
auto newTimeStepMap = std::map<QDateTime, std::set<RifWellRftAddress>>
{
{ curveDef.second, std::set<RifWellRftAddress> { curveDef.first} }
{ curveDef.timeStep(), std::set<RifWellRftAddress> { curveDef.address()} }
};
RimWellPlotTools::addTimeStepsToMap(selectedTimeStepsMap, newTimeStepMap);
selectedTimeSteps.insert(curveDef.second);
selectedTimeSteps.insert(curveDef.timeStep());
}
m_selectedSources = std::vector<RifWellRftAddress>(selectedSources.begin(), selectedSources.end());
@@ -402,22 +402,22 @@ void RimWellRftPlot::updateWidgetTitleWindowTitle()
void RimWellRftPlot::syncCurvesFromUiSelection()
{
RimWellLogTrack* plotTrack = m_wellLogPlot->trackByIndex(0);
const std::set<std::pair<RifWellRftAddress, QDateTime>>& allCurveDefs = selectedCurveDefs();
const std::set<std::pair<RifWellRftAddress, QDateTime>>& curveDefsInPlot = curveDefsFromCurves();
const std::set<RiaRftPltCurveDefinition>& allCurveDefs = selectedCurveDefs();
const std::set<RiaRftPltCurveDefinition>& curveDefsInPlot = curveDefsFromCurves();
std::set<RimWellLogCurve*> curvesToDelete;
std::set<std::pair<RifWellRftAddress, QDateTime>> newCurveDefs;
std::set<RiaRftPltCurveDefinition> newCurveDefs;
if (allCurveDefs.size() < curveDefsInPlot.size())
{
// Determine which curves to delete from plot
std::set<std::pair<RifWellRftAddress, QDateTime>> deleteCurveDefs;
std::set<RiaRftPltCurveDefinition> deleteCurveDefs;
std::set_difference(curveDefsInPlot.begin(), curveDefsInPlot.end(),
allCurveDefs.begin(), allCurveDefs.end(),
std::inserter(deleteCurveDefs, deleteCurveDefs.end()));
for (RimWellLogCurve* const curve : plotTrack->curvesVector())
{
std::pair<RifWellRftAddress, QDateTime> curveDef = RimWellPlotTools::curveDefFromCurve(curve);
RiaRftPltCurveDefinition curveDef = RimWellPlotTools::curveDefFromCurve(curve);
if (deleteCurveDefs.count(curveDef) > 0)
curvesToDelete.insert(curve);
}
@@ -435,9 +435,9 @@ void RimWellRftPlot::syncCurvesFromUiSelection()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::set < std::pair<RifWellRftAddress, QDateTime>> RimWellRftPlot::selectedCurveDefs() const
std::set < RiaRftPltCurveDefinition> RimWellRftPlot::selectedCurveDefs() const
{
std::set<std::pair<RifWellRftAddress, QDateTime>> curveDefs;
std::set<RiaRftPltCurveDefinition> curveDefs;
const std::vector<RimEclipseResultCase*> rftCases = RimWellPlotTools::rftCasesForWell(m_wellName);
const std::vector<RimEclipseResultCase*> gridCases = RimWellPlotTools::gridCasesForWell(m_wellName);
@@ -449,10 +449,10 @@ std::set < std::pair<RifWellRftAddress, QDateTime>> RimWellRftPlot::selectedCurv
{
for (RimEclipseResultCase* const rftCase : rftCases)
{
const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsMap = RimWellPlotTools::timeStepsFromRftCase(rftCase, m_wellName);
if (RimWellPlotTools::mapContainsTimeStep(timeStepsMap , timeStep))
const std::set<QDateTime>& timeSteps = RimWellPlotTools::timeStepsFromRftCase(rftCase, m_wellName);
if (timeSteps.count(timeStep) > 0)
{
curveDefs.insert(std::make_pair(addr, timeStep));
curveDefs.insert(RiaRftPltCurveDefinition(addr, timeStep));
}
}
}
@@ -460,10 +460,10 @@ std::set < std::pair<RifWellRftAddress, QDateTime>> RimWellRftPlot::selectedCurv
{
for (RimEclipseResultCase* const gridCase : gridCases)
{
const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsMap = RimWellPlotTools::timeStepsFromGridCase(gridCase);
if (RimWellPlotTools::mapContainsTimeStep(timeStepsMap, timeStep))
const std::set<QDateTime>& timeSteps = RimWellPlotTools::timeStepsFromGridCase(gridCase);
if (timeSteps.count(timeStep) > 0)
{
curveDefs.insert(std::make_pair(addr, timeStep));
curveDefs.insert(RiaRftPltCurveDefinition(addr, timeStep));
}
}
}
@@ -471,10 +471,10 @@ std::set < std::pair<RifWellRftAddress, QDateTime>> RimWellRftPlot::selectedCurv
{
if (addr.wellLogFile() != nullptr)
{
const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsMap = RimWellPlotTools::timeStepsFromWellLogFile(addr.wellLogFile());
if (RimWellPlotTools::mapContainsTimeStep(timeStepsMap, timeStep))
const QDateTime wlfTimeStep = RimWellPlotTools::timeStepFromWellLogFile(addr.wellLogFile());
if (wlfTimeStep == timeStep)
{
curveDefs.insert(std::make_pair(RifWellRftAddress(RifWellRftAddress::OBSERVED, addr.wellLogFile()), timeStep));
curveDefs.insert(RiaRftPltCurveDefinition(RifWellRftAddress(RifWellRftAddress::OBSERVED, addr.wellLogFile()), timeStep));
}
}
}
@@ -486,9 +486,9 @@ std::set < std::pair<RifWellRftAddress, QDateTime>> RimWellRftPlot::selectedCurv
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::set<std::pair<RifWellRftAddress, QDateTime>> RimWellRftPlot::curveDefsFromCurves() const
std::set<RiaRftPltCurveDefinition> RimWellRftPlot::curveDefsFromCurves() const
{
std::set<std::pair<RifWellRftAddress, QDateTime>> curveDefs;
std::set<RiaRftPltCurveDefinition> curveDefs;
RimWellLogTrack* const plotTrack = m_wellLogPlot->trackByIndex(0);
for (RimWellLogCurve* const curve : plotTrack->curvesVector())
@@ -501,8 +501,8 @@ std::set<std::pair<RifWellRftAddress, QDateTime>> RimWellRftPlot::curveDefsFromC
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellRftPlot::updateCurvesInPlot(const std::set<std::pair<RifWellRftAddress, QDateTime>>& allCurveDefs,
const std::set<std::pair<RifWellRftAddress, QDateTime>>& curveDefsToAdd,
void RimWellRftPlot::updateCurvesInPlot(const std::set<RiaRftPltCurveDefinition>& allCurveDefs,
const std::set<RiaRftPltCurveDefinition>& curveDefsToAdd,
const std::set<RimWellLogCurve*>& curvesToDelete)
{
RimWellLogTrack* const plotTrack = m_wellLogPlot->trackByIndex(0);
@@ -514,24 +514,24 @@ void RimWellRftPlot::updateCurvesInPlot(const std::set<std::pair<RifWellRftAddre
}
// Add new curves
for (const std::pair<RifWellRftAddress, QDateTime>& curveDefToAdd : curveDefsToAdd)
for (const RiaRftPltCurveDefinition& curveDefToAdd : curveDefsToAdd)
{
if (curveDefToAdd.first.sourceType() == RifWellRftAddress::RFT)
if (curveDefToAdd.address().sourceType() == RifWellRftAddress::RFT)
{
auto curve = new RimWellLogRftCurve();
plotTrack->addCurve(curve);
auto rftCase = curveDefToAdd.first.eclCase();
auto rftCase = curveDefToAdd.address().eclCase();
curve->setEclipseResultCase(dynamic_cast<RimEclipseResultCase*>(rftCase));
RifEclipseRftAddress address(m_wellName, curveDefToAdd.second, RifEclipseRftAddress::PRESSURE);
RifEclipseRftAddress address(m_wellName, curveDefToAdd.timeStep(), RifEclipseRftAddress::PRESSURE);
curve->setRftAddress(address);
curve->setZOrder(1);
applyCurveAppearance(curve);
curve->loadDataAndUpdate(true);
}
else if (curveDefToAdd.first.sourceType() == RifWellRftAddress::GRID)
else if (curveDefToAdd.address().sourceType() == RifWellRftAddress::GRID)
{
auto curve = new RimWellLogExtractionCurve();
plotTrack->addCurve(curve);
@@ -541,7 +541,7 @@ void RimWellRftPlot::updateCurvesInPlot(const std::set<std::pair<RifWellRftAddre
curve->setFromSimulationWellName(m_wellName, m_branchIndex);
// Fetch cases and time steps
auto gridCase = curveDefToAdd.first.eclCase();
auto gridCase = curveDefToAdd.address().eclCase();
if (gridCase != nullptr)
{
std::pair<size_t, QString> resultDataInfo = RimWellPlotTools::pressureResultDataInfo(gridCase->eclipseCaseData());
@@ -555,9 +555,9 @@ void RimWellRftPlot::updateCurvesInPlot(const std::set<std::pair<RifWellRftAddre
curve->setEclipseResultDefinition(resultDef);
// Time step
const std::map<QDateTime, std::set<RifWellRftAddress>>& timeSteps = RimWellPlotTools::timeStepsFromGridCase(gridCase);
const std::map<QDateTime, std::set<RifWellRftAddress>>& timeSteps = RimWellPlotTools::timeStepsMapFromGridCase(gridCase);
auto currentTimeStepItr = std::find_if(timeSteps.begin(), timeSteps.end(),
[curveDefToAdd](std::pair<QDateTime, std::set<RifWellRftAddress>> pair) {return pair.first == curveDefToAdd.second; });
[curveDefToAdd](std::pair<QDateTime, std::set<RifWellRftAddress>> pair) {return pair.first == curveDefToAdd.timeStep(); });
auto currentTimeStepIndex = std::distance(timeSteps.begin(), currentTimeStepItr);
curve->setCurrentTimeStep(currentTimeStepIndex);
curve->setZOrder(0);
@@ -566,9 +566,9 @@ void RimWellRftPlot::updateCurvesInPlot(const std::set<std::pair<RifWellRftAddre
curve->loadDataAndUpdate(false);
}
}
else if (curveDefToAdd.first.sourceType() == RifWellRftAddress::OBSERVED)
else if (curveDefToAdd.address().sourceType() == RifWellRftAddress::OBSERVED)
{
RimWellLogFile* const wellLogFile = curveDefToAdd.first.wellLogFile();
RimWellLogFile* const wellLogFile = curveDefToAdd.address().wellLogFile();
RimWellPath* const wellPath = RimWellPlotTools::wellPathFromWellLogFile(wellLogFile);
if(wellLogFile!= nullptr)
{
@@ -928,21 +928,21 @@ void RimWellRftPlot::calculateValueOptionsForTimeSteps(QList<caf::PdmOptionItemI
{
for (RimEclipseResultCase* const rftCase : rftCases)
{
RimWellPlotTools::addTimeStepsToMap(obsAndRftTimeStepsMap, RimWellPlotTools::timeStepsFromRftCase(rftCase, m_wellName));
RimWellPlotTools::addTimeStepsToMap(obsAndRftTimeStepsMap, RimWellPlotTools::timeStepsMapFromRftCase(rftCase, m_wellName));
}
}
else if (selection.sourceType() == RifWellRftAddress::GRID)
{
for (RimEclipseResultCase* const gridCase : gridCases)
{
RimWellPlotTools::addTimeStepsToMap(gridTimeStepsMap, RimWellPlotTools::timeStepsFromGridCase(gridCase));
RimWellPlotTools::addTimeStepsToMap(gridTimeStepsMap, RimWellPlotTools::timeStepsMapFromGridCase(gridCase));
}
}
else if (selection.sourceType() == RifWellRftAddress::OBSERVED)
{
if (selection.wellLogFile() != nullptr)
{
RimWellPlotTools::addTimeStepsToMap(obsAndRftTimeStepsMap, RimWellPlotTools::timeStepsFromWellLogFile(selection.wellLogFile()));
RimWellPlotTools::addTimeStepsToMap(obsAndRftTimeStepsMap, RimWellPlotTools::timeStepsMapFromWellLogFile(selection.wellLogFile()));
}
}
}

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

@@ -21,6 +21,8 @@
#include "RimViewWindow.h"
#include "RiaRftPltCurveDefinition.h"
#include "RimCase.h"
#include "RimPlotCurve.h"
@@ -109,11 +111,11 @@ private:
void syncCurvesFromUiSelection();
std::set<std::pair<RifWellRftAddress, QDateTime>> selectedCurveDefs() const;
std::set<std::pair<RifWellRftAddress, QDateTime>> curveDefsFromCurves() const;
std::set<RiaRftPltCurveDefinition> selectedCurveDefs() const;
std::set<RiaRftPltCurveDefinition> curveDefsFromCurves() const;
void updateCurvesInPlot(const std::set<std::pair<RifWellRftAddress, QDateTime>>& allCurveDefs,
const std::set<std::pair<RifWellRftAddress, QDateTime>>& curveDefsToAdd,
void updateCurvesInPlot(const std::set<RiaRftPltCurveDefinition>& allCurveDefs,
const std::set<RiaRftPltCurveDefinition>& curveDefsToAdd,
const std::set<RimWellLogCurve*>& curvesToDelete);
bool isOnlyGridSourcesSelected() const;
bool isAnySourceAddressSelected(const std::set<RifWellRftAddress>& addresses) const;