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

#1948 PLT plot. Prepare for saving PLT plot editor selections to project file

Browse Source
This commit is contained in:
Bjørn Erik Jensen
2017-10-26 10:35:23 +02:00
parent fcefa1e55b
commit cb78ad8c31
11 changed files with 453 additions and 300 deletions
Download Patch File Download Diff File Expand all files Collapse all files

194
ApplicationCode/ProjectDataModel/Flow/RimWellPltPlot.cpp
View File

@@ -149,7 +149,7 @@ void RimWellPltPlot::deleteViewWidget()
//--------------------------------------------------------------------------------------------------
//void RimWellPltPlot::applyCurveAppearance(RimWellLogCurve* newCurve)
//{
// const std::pair<RimWellRftAddress, QDateTime>& newCurveDef = curveDefFromCurve(newCurve);
// const std::pair<RifWellRftAddress, QDateTime>& newCurveDef = curveDefFromCurve(newCurve);
//
// std::vector<cvf::Color3f> colorTable;
// RiaColorTables::summaryCurveDefaultPaletteColors().color3fArray().toStdVector(&colorTable);
@@ -182,7 +182,7 @@ void RimWellPltPlot::deleteViewWidget()
// {
// if (curve == newCurve) continue;
//
// std::pair<RimWellRftAddress, QDateTime> cDef = curveDefFromCurve(curve);
// std::pair<RifWellRftAddress, QDateTime> cDef = curveDefFromCurve(curve);
// if (cDef.first == newCurveDef.first)
// {
// currentColor = curve->color();
@@ -253,15 +253,15 @@ void RimWellPltPlot::deleteViewWidget()
void RimWellPltPlot::updateSelectedTimeStepsFromSelectedSources()
{
std::vector<QDateTime> newTimeStepsSelections;
std::vector<RimWellRftAddress> selectedSourcesVector = selectedSources();
auto selectedSources = std::set<RimWellRftAddress>(selectedSourcesVector.begin(), selectedSourcesVector.end());
std::vector<RifWellRftAddress> selectedSourcesVector = selectedSources();
auto selectedSources = std::set<RifWellRftAddress>(selectedSourcesVector.begin(), selectedSourcesVector.end());
for (const QDateTime& timeStep : m_selectedTimeSteps())
{
if(m_timeStepsToAddresses.count(timeStep) > 0)
{
std::vector<RimWellRftAddress> intersectVector;
const std::set<RimWellRftAddress>& addresses = m_timeStepsToAddresses[timeStep];
std::vector<RifWellRftAddress> intersectVector;
const std::set<RifWellRftAddress>& addresses = m_timeStepsToAddresses[timeStep];
std::set_intersection(selectedSources.begin(), selectedSources.end(),
addresses.begin(), addresses.end(), std::inserter(intersectVector, intersectVector.end()));
if(intersectVector.size() > 0)
@@ -340,27 +340,27 @@ std::vector<RimEclipseCase*> RimWellPltPlot::eclipseCases() const
//{
// std::vector<std::tuple<RimEclipseResultCase*, bool, bool>> eclCaseTuples = eclipseCasesForWell(m_wellName);
//
// std::vector<RimWellRftAddress> sourcesToSelect;
// std::map<QDateTime, std::set<RimWellRftAddress>> rftTimeStepsMap;
// std::map<QDateTime, std::set<RimWellRftAddress>> observedTimeStepsMap;
// std::map<QDateTime, std::set<RimWellRftAddress>> gridTimeStepsMap;
// 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;
//
// for(RimEclipseResultCase* const rftCase : rftCasesFromEclipseCases(eclCaseTuples))
// {
// sourcesToSelect.push_back(RimWellRftAddress(RftSourceType::RFT, rftCase));
// sourcesToSelect.push_back(RifWellRftAddress(RftSourceType::RFT, rftCase));
// addTimeStepsToMap(rftTimeStepsMap, timeStepsFromRftCase(rftCase));
// }
//
// for (RimEclipseResultCase* const gridCase : gridCasesFromEclipseCases(eclCaseTuples))
// {
// sourcesToSelect.push_back(RimWellRftAddress(RftSourceType::GRID, gridCase));
// sourcesToSelect.push_back(RifWellRftAddress(RftSourceType::GRID, gridCase));
// addTimeStepsToMap(gridTimeStepsMap, timeStepsFromGridCase(gridCase));
// }
//
// std::vector<RimWellLogFile*> wellLogFiles = wellLogFilesContainingFlow(m_wellName);
// if(wellLogFiles.size() > 0)
// {
// sourcesToSelect.push_back(RimWellRftAddress(RftSourceType::OBSERVED));
// sourcesToSelect.push_back(RifWellRftAddress(RftSourceType::OBSERVED));
// for (RimWellLogFile* const wellLogFile : wellLogFiles)
// {
// addTimeStepsToMap(observedTimeStepsMap, timeStepsFromWellLogFile(wellLogFile));
@@ -370,11 +370,11 @@ std::vector<RimEclipseCase*> RimWellPltPlot::eclipseCases() const
// m_selectedSources = sourcesToSelect;
//
// std::set<QDateTime> timeStepsToSelect;
// for (const std::pair<QDateTime, std::set<RimWellRftAddress>>& dateTimePair : rftTimeStepsMap)
// for (const std::pair<QDateTime, std::set<RifWellRftAddress>>& dateTimePair : rftTimeStepsMap)
// {
// timeStepsToSelect.insert(dateTimePair.first);
// }
// for (const std::pair<QDateTime, std::set<RimWellRftAddress>>& dateTimePair : observedTimeStepsMap)
// for (const std::pair<QDateTime, std::set<RifWellRftAddress>>& dateTimePair : observedTimeStepsMap)
// {
// timeStepsToSelect.insert(dateTimePair.first);
// }
@@ -391,26 +391,26 @@ std::vector<RimEclipseCase*> RimWellPltPlot::eclipseCases() const
//--------------------------------------------------------------------------------------------------
void RimWellPltPlot::updateEditorsFromCurves()
{
// std::set<RimWellRftAddress> selectedSources;
// std::set<RifWellRftAddress> selectedSources;
// std::set<QDateTime> selectedTimeSteps;
// std::map<QDateTime, std::set<RimWellRftAddress>> selectedTimeStepsMap;
// std::map<QDateTime, std::set<RifWellRftAddress>> selectedTimeStepsMap;
//
// for (const std::pair<RimWellRftAddress, QDateTime>& curveDef : curveDefsFromCurves())
// for (const std::pair<RifWellRftAddress, QDateTime>& curveDef : curveDefsFromCurves())
// {
// if (curveDef.first.sourceType() == RftSourceType::OBSERVED)
// selectedSources.insert(RimWellRftAddress(RftSourceType::OBSERVED));
// selectedSources.insert(RifWellRftAddress(RftSourceType::OBSERVED));
// else
// selectedSources.insert(curveDef.first);
//
// auto newTimeStepMap = std::map<QDateTime, std::set<RimWellRftAddress>>
// auto newTimeStepMap = std::map<QDateTime, std::set<RifWellRftAddress>>
// {
// { curveDef.second, std::set<RimWellRftAddress> { curveDef.first} }
// { curveDef.second, std::set<RifWellRftAddress> { curveDef.first} }
// };
// addTimeStepsToMap(selectedTimeStepsMap, newTimeStepMap);
// selectedTimeSteps.insert(curveDef.second);
// }
//
// m_selectedSources = std::vector<RimWellRftAddress>(selectedSources.begin(), selectedSources.end());
// m_selectedSources = std::vector<RifWellRftAddress>(selectedSources.begin(), selectedSources.end());
// m_selectedTimeSteps = std::vector<QDateTime>(selectedTimeSteps.begin(), selectedTimeSteps.end());
// addTimeStepsToMap(m_timeStepsToAddresses, selectedTimeStepsMap);
}
@@ -441,7 +441,7 @@ void RimWellPltPlot::updateWidgetTitleWindowTitle()
void RimWellPltPlot::syncCurvesFromUiSelection()
{
RimWellLogTrack* plotTrack = m_wellLogPlot->trackByIndex(0);
const std::set<std::pair<RimWellRftAddress, QDateTime>>& curveDefs = selectedCurveDefs();
const std::set<std::pair<RifWellRftAddress, QDateTime>>& curveDefs = selectedCurveDefs();
updateCurvesInPlot(curveDefs);
}
@@ -598,9 +598,9 @@ RimWellPath* RimWellPltPlot::wellPathFromWellLogFile(const RimWellLogFile* wellL
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
//std::map<QDateTime, std::set<RimWellRftAddress>> RimWellPltPlot::timeStepsFromRftCase(RimEclipseResultCase* rftCase) const
//std::map<QDateTime, std::set<RifWellRftAddress>> RimWellPltPlot::timeStepsFromRftCase(RimEclipseResultCase* rftCase) const
//{
// std::map<QDateTime, std::set<RimWellRftAddress>> timeStepsMap;
// std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsMap;
// RifReaderEclipseRft* const reader = rftCase->rftReader();
// if (reader != nullptr)
// {
@@ -608,9 +608,9 @@ RimWellPath* RimWellPltPlot::wellPathFromWellLogFile(const RimWellLogFile* wellL
// {
// if (timeStepsMap.count(timeStep) == 0)
// {
// timeStepsMap.insert(std::make_pair(timeStep, std::set<RimWellRftAddress>()));
// timeStepsMap.insert(std::make_pair(timeStep, std::set<RifWellRftAddress>()));
// }
// timeStepsMap[timeStep].insert(RimWellRftAddress(RftSourceType::RFT, rftCase));
// timeStepsMap[timeStep].insert(RifWellRftAddress(RftSourceType::RFT, rftCase));
// }
// }
// return timeStepsMap;
@@ -619,23 +619,23 @@ RimWellPath* RimWellPltPlot::wellPathFromWellLogFile(const RimWellLogFile* wellL
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
//std::map<QDateTime, std::set<RimWellRftAddress>> RimWellPltPlot::timeStepsFromGridCase(RimEclipseCase* gridCase) const
//std::map<QDateTime, std::set<RifWellRftAddress>> RimWellPltPlot::timeStepsFromGridCase(RimEclipseCase* gridCase) const
//{
// const RigEclipseCaseData* const eclipseCaseData = gridCase->eclipseCaseData();
// size_t resultIndex = eclipseCaseData != nullptr ?
// eclipseCaseData->results(RiaDefines::MATRIX_MODEL)->findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, PRESSURE_DATA_NAME) :
// cvf::UNDEFINED_SIZE_T;
//
// std::map<QDateTime, std::set<RimWellRftAddress>> timeStepsMap;
// std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsMap;
// if (resultIndex != cvf::UNDEFINED_SIZE_T)
// {
// for (const QDateTime& timeStep : eclipseCaseData->results(RiaDefines::MATRIX_MODEL)->timeStepDates(resultIndex))
// {
// if (timeStepsMap.count(timeStep) == 0)
// {
// timeStepsMap.insert(std::make_pair(timeStep, std::set<RimWellRftAddress>()));
// timeStepsMap.insert(std::make_pair(timeStep, std::set<RifWellRftAddress>()));
// }
// timeStepsMap[timeStep].insert(RimWellRftAddress(RftSourceType::GRID, gridCase));
// timeStepsMap[timeStep].insert(RifWellRftAddress(RftSourceType::GRID, gridCase));
// }
// }
// return timeStepsMap;
@@ -644,17 +644,17 @@ RimWellPath* RimWellPltPlot::wellPathFromWellLogFile(const RimWellLogFile* wellL
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::map<QDateTime, std::set<RimWellRftAddress> > RimWellPltPlot::timeStepsFromWellLogFile(RimWellLogFile* wellLogFile) const
std::map<QDateTime, std::set<RifWellRftAddress> > RimWellPltPlot::timeStepsFromWellLogFile(RimWellLogFile* wellLogFile) const
{
std::map<QDateTime, std::set<RimWellRftAddress> > timeStepsMap;
std::map<QDateTime, std::set<RifWellRftAddress> > timeStepsMap;
QDateTime timeStep = RiaDateStringParser::parseDateString(wellLogFile->date());
if (timeStepsMap.count(timeStep) == 0)
{
timeStepsMap.insert(std::make_pair(timeStep, std::set<RimWellRftAddress>()));
timeStepsMap.insert(std::make_pair(timeStep, std::set<RifWellRftAddress>()));
}
timeStepsMap[timeStep].insert(RimWellRftAddress(RftSourceType::OBSERVED, wellLogFile));
timeStepsMap[timeStep].insert(RifWellRftAddress(RifWellRftAddress::OBSERVED, wellLogFile));
return timeStepsMap;
}
@@ -662,16 +662,16 @@ std::map<QDateTime, std::set<RimWellRftAddress> > RimWellPltPlot::timeStepsFromW
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::map<QDateTime, std::set<RimWellRftAddress>>
RimWellPltPlot::adjacentTimeSteps(const std::vector<std::pair<QDateTime, std::set<RimWellRftAddress>>>& allTimeSteps,
const std::pair<QDateTime, std::set<RimWellRftAddress>>& searchTimeStepPair)
std::map<QDateTime, std::set<RifWellRftAddress>>
RimWellPltPlot::adjacentTimeSteps(const std::vector<std::pair<QDateTime, std::set<RifWellRftAddress>>>& allTimeSteps,
const std::pair<QDateTime, std::set<RifWellRftAddress>>& searchTimeStepPair)
{
std::map<QDateTime, std::set<RimWellRftAddress>> timeStepsMap;
std::map<QDateTime, std::set<RifWellRftAddress>> timeStepsMap;
if (allTimeSteps.size() > 0)
{
auto itr = std::find_if(allTimeSteps.begin(), allTimeSteps.end(),
[searchTimeStepPair](const std::pair<QDateTime, std::set<RimWellRftAddress>>& dt)
[searchTimeStepPair](const std::pair<QDateTime, std::set<RifWellRftAddress>>& dt)
{
return dt.first > searchTimeStepPair.first;
});
@@ -693,9 +693,9 @@ RimWellPltPlot::adjacentTimeSteps(const std::vector<std::pair<QDateTime, std::se
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimWellPltPlot::mapContainsTimeStep(const std::map<QDateTime, std::set<RimWellRftAddress>>& map, const QDateTime& timeStep)
bool RimWellPltPlot::mapContainsTimeStep(const std::map<QDateTime, std::set<RifWellRftAddress>>& map, const QDateTime& timeStep)
{
return std::find_if(map.begin(), map.end(), [timeStep](const std::pair<QDateTime, std::set<RimWellRftAddress>>& pair)
return std::find_if(map.begin(), map.end(), [timeStep](const std::pair<QDateTime, std::set<RifWellRftAddress>>& pair)
{
return pair.first == timeStep;
}) != map.end();
@@ -704,22 +704,22 @@ bool RimWellPltPlot::mapContainsTimeStep(const std::map<QDateTime, std::set<RimW
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::set < std::pair<RimWellRftAddress, QDateTime>> RimWellPltPlot::selectedCurveDefs() const
std::set < std::pair<RifWellRftAddress, QDateTime>> RimWellPltPlot::selectedCurveDefs() const
{
std::set<std::pair<RimWellRftAddress, QDateTime>> curveDefs;
std::set<std::pair<RifWellRftAddress, QDateTime>> curveDefs;
//const std::vector<std::tuple<RimEclipseResultCase*,bool,bool>>& eclipseCases = eclipseCasesForWell(m_wellName);
//const std::vector<RimEclipseResultCase*> rftCases = rftCasesFromEclipseCases(eclipseCases);
//const std::vector<RimEclipseResultCase*> gridCases = gridCasesFromEclipseCases(eclipseCases);
for (const QDateTime& timeStep : m_selectedTimeSteps())
{
for (const RimWellRftAddress& addr : selectedSources())
for (const RifWellRftAddress& addr : selectedSources())
{
//if (addr.sourceType() == RftSourceType::RFT)
//{
// for (RimEclipseResultCase* const rftCase : rftCases)
// {
// const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsMap = timeStepsFromRftCase(rftCase);
// const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsMap = timeStepsFromRftCase(rftCase);
// if (mapContainsTimeStep(timeStepsMap , timeStep))
// {
// curveDefs.insert(std::make_pair(addr, timeStep));
@@ -730,7 +730,7 @@ std::set < std::pair<RimWellRftAddress, QDateTime>> RimWellPltPlot::selectedCurv
//{
// for (RimEclipseResultCase* const gridCase : gridCases)
// {
// const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsMap = timeStepsFromGridCase(gridCase);
// const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsMap = timeStepsFromGridCase(gridCase);
// if (mapContainsTimeStep(timeStepsMap, timeStep))
// {
// curveDefs.insert(std::make_pair(addr, timeStep));
@@ -738,14 +738,14 @@ std::set < std::pair<RimWellRftAddress, QDateTime>> RimWellPltPlot::selectedCurv
// }
//}
//else
if (addr.sourceType() == RftSourceType::OBSERVED)
if (addr.sourceType() == RifWellRftAddress::OBSERVED)
{
if (addr.wellLogFile() != nullptr)
{
const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsMap = timeStepsFromWellLogFile(addr.wellLogFile());
const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsMap = timeStepsFromWellLogFile(addr.wellLogFile());
if (mapContainsTimeStep(timeStepsMap, timeStep))
{
curveDefs.insert(std::make_pair(RimWellRftAddress(RftSourceType::OBSERVED, addr.wellLogFile()), timeStep));
curveDefs.insert(std::make_pair(RifWellRftAddress(RifWellRftAddress::OBSERVED, addr.wellLogFile()), timeStep));
}
}
}
@@ -757,9 +757,9 @@ std::set < std::pair<RimWellRftAddress, QDateTime>> RimWellPltPlot::selectedCurv
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::set<std::pair<RimWellRftAddress, QDateTime>> RimWellPltPlot::curveDefsFromCurves() const
std::set<std::pair<RifWellRftAddress, QDateTime>> RimWellPltPlot::curveDefsFromCurves() const
{
std::set<std::pair<RimWellRftAddress, QDateTime>> curveDefs;
std::set<std::pair<RifWellRftAddress, QDateTime>> curveDefs;
RimWellLogTrack* const plotTrack = m_wellLogPlot->trackByIndex(0);
for (RimWellLogCurve* const curve : plotTrack->curvesVector())
@@ -772,7 +772,7 @@ std::set<std::pair<RimWellRftAddress, QDateTime>> RimWellPltPlot::curveDefsFromC
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<RimWellRftAddress, QDateTime> RimWellPltPlot::curveDefFromCurve(const RimWellLogCurve* curve) const
std::pair<RifWellRftAddress, QDateTime> RimWellPltPlot::curveDefFromCurve(const RimWellLogCurve* curve) const
{
const RimWellLogRftCurve* rftCurve = dynamic_cast<const RimWellLogRftCurve*>(curve);
const RimWellLogExtractionCurve* gridCurve = dynamic_cast<const RimWellLogExtractionCurve*>(curve);
@@ -785,7 +785,7 @@ std::pair<RimWellRftAddress, QDateTime> RimWellPltPlot::curveDefFromCurve(const
// {
// const RifEclipseRftAddress rftAddress = rftCurve->rftAddress();
// const QDateTime timeStep = rftAddress.timeStep();
// return std::make_pair(RimWellRftAddress(RftSourceType::RFT, rftCase), timeStep);
// return std::make_pair(RifWellRftAddress(RftSourceType::RFT, rftCase), timeStep);
// }
//}
//else if (gridCurve != nullptr)
@@ -794,12 +794,12 @@ std::pair<RimWellRftAddress, QDateTime> RimWellPltPlot::curveDefFromCurve(const
// if (gridCase != nullptr)
// {
// size_t timeStepIndex = gridCurve->currentTimeStep();
// const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsMap = timeStepsFromGridCase(gridCase);
// auto timeStepsVector = std::vector<std::pair<QDateTime, std::set<RimWellRftAddress>>>(
// const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsMap = timeStepsFromGridCase(gridCase);
// auto timeStepsVector = std::vector<std::pair<QDateTime, std::set<RifWellRftAddress>>>(
// timeStepsMap.begin(), timeStepsMap.end());
// if (timeStepIndex < timeStepsMap.size())
// {
// return std::make_pair(RimWellRftAddress(RftSourceType::GRID, gridCase),
// return std::make_pair(RifWellRftAddress(RftSourceType::GRID, gridCase),
// timeStepsVector[timeStepIndex].first);
// }
// }
@@ -816,17 +816,17 @@ std::pair<RimWellRftAddress, QDateTime> RimWellPltPlot::curveDefFromCurve(const
if (date.isValid())
{
return std::make_pair(RimWellRftAddress(RftSourceType::OBSERVED, wellLogFile), date);
return std::make_pair(RifWellRftAddress(RifWellRftAddress::OBSERVED, wellLogFile), date);
}
}
}
return std::make_pair(RimWellRftAddress(), QDateTime());
return std::make_pair(RifWellRftAddress(), QDateTime());
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellPltPlot::updateCurvesInPlot(const std::set<std::pair<RimWellRftAddress, QDateTime>>& curveDefs)
void RimWellPltPlot::updateCurvesInPlot(const std::set<std::pair<RifWellRftAddress, QDateTime>>& curveDefs)
{
RimWellLogTrack* const plotTrack = m_wellLogPlot->trackByIndex(0);
@@ -840,7 +840,7 @@ void RimWellPltPlot::updateCurvesInPlot(const std::set<std::pair<RimWellRftAddre
}
// Add curves
for (const std::pair<RimWellRftAddress, QDateTime>& curveDefToAdd : curveDefs)
for (const std::pair<RifWellRftAddress, QDateTime>& curveDefToAdd : curveDefs)
{
//if (curveDefToAdd.first.sourceType() == RftSourceType::RFT)
//{
@@ -879,9 +879,9 @@ void RimWellPltPlot::updateCurvesInPlot(const std::set<std::pair<RimWellRftAddre
// curve->setEclipseResultDefinition(resultDef);
// // Time step
// const std::map<QDateTime, std::set<RimWellRftAddress>>& timeSteps = timeStepsFromGridCase(gridCase);
// const std::map<QDateTime, std::set<RifWellRftAddress>>& timeSteps = timeStepsFromGridCase(gridCase);
// auto currentTimeStepItr = std::find_if(timeSteps.begin(), timeSteps.end(),
// [curveDefToAdd](std::pair<QDateTime, std::set<RimWellRftAddress>> pair) {return pair.first == curveDefToAdd.second; });
// [curveDefToAdd](std::pair<QDateTime, std::set<RifWellRftAddress>> pair) {return pair.first == curveDefToAdd.second; });
// auto currentTimeStepIndex = std::distance(timeSteps.begin(), currentTimeStepItr);
// curve->setCurrentTimeStep(currentTimeStepIndex);
// curve->setZOrder(0);
@@ -891,7 +891,7 @@ void RimWellPltPlot::updateCurvesInPlot(const std::set<std::pair<RimWellRftAddre
// }
//}
//else
if (curveDefToAdd.first.sourceType() == RftSourceType::OBSERVED)
if (curveDefToAdd.first.sourceType() == RifWellRftAddress::OBSERVED)
{
RimWellLogFile* const wellLogFile = curveDefToAdd.first.wellLogFile();
RimWellPath* const wellPath = wellPathFromWellLogFile(wellLogFile);
@@ -947,21 +947,21 @@ void RimWellPltPlot::addStackedCurve(const QString& channelName,
//--------------------------------------------------------------------------------------------------
bool RimWellPltPlot::isOnlyGridSourcesSelected() const
{
const std::vector<RimWellRftAddress>& selSources = m_selectedSources();
return std::find_if(selSources.begin(), selSources.end(), [](const RimWellRftAddress& addr)
const std::vector<RifWellRftAddress>& selSources = m_selectedSources();
return std::find_if(selSources.begin(), selSources.end(), [](const RifWellRftAddress& addr)
{
return addr.sourceType() == RftSourceType::RFT || addr.sourceType() == RftSourceType::OBSERVED;
return addr.sourceType() == RifWellRftAddress::RFT || addr.sourceType() == RifWellRftAddress::OBSERVED;
}) == selSources.end();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimWellPltPlot::isAnySourceAddressSelected(const std::set<RimWellRftAddress>& addresses) const
bool RimWellPltPlot::isAnySourceAddressSelected(const std::set<RifWellRftAddress>& addresses) const
{
const std::vector<RimWellRftAddress>& selectedSourcesVector = m_selectedSources();
const auto selectedSources = std::set<RimWellRftAddress>(selectedSourcesVector.begin(), selectedSourcesVector.end());
std::vector<RimWellRftAddress> intersectVector;
const std::vector<RifWellRftAddress>& selectedSourcesVector = m_selectedSources();
const auto selectedSources = std::set<RifWellRftAddress>(selectedSourcesVector.begin(), selectedSourcesVector.end());
std::vector<RifWellRftAddress> intersectVector;
std::set_intersection(selectedSources.begin(), selectedSources.end(),
addresses.begin(), addresses.end(), std::inserter(intersectVector, intersectVector.end()));
@@ -971,16 +971,16 @@ bool RimWellPltPlot::isAnySourceAddressSelected(const std::set<RimWellRftAddress
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimWellRftAddress> RimWellPltPlot::selectedSources() const
std::vector<RifWellRftAddress> RimWellPltPlot::selectedSources() const
{
std::vector<RimWellRftAddress> sources;
for (const RimWellRftAddress& addr : m_selectedSources())
std::vector<RifWellRftAddress> sources;
for (const RifWellRftAddress& addr : m_selectedSources())
{
if (addr.sourceType() == RftSourceType::OBSERVED)
if (addr.sourceType() == RifWellRftAddress::OBSERVED)
{
for (RimWellLogFile* const wellLogFile : wellLogFilesContainingFlow(m_wellName))
{
sources.push_back(RimWellRftAddress(RftSourceType::OBSERVED, wellLogFile));
sources.push_back(RifWellRftAddress(RifWellRftAddress::OBSERVED, wellLogFile));
}
}
else
@@ -1107,11 +1107,11 @@ QList<caf::PdmOptionItemInfo> RimWellPltPlot::calculateValueOptions(const caf::P
//const std::vector<RimEclipseResultCase*> rftCases = rftCasesFromEclipseCases(eclipseCases);
//if (rftCases.size() > 0)
//{
// options.push_back(caf::PdmOptionItemInfo::createHeader(RimWellRftAddress::sourceTypeUiText(RftSourceType::RFT), true));
// options.push_back(caf::PdmOptionItemInfo::createHeader(RifWellRftAddress::sourceTypeUiText(RftSourceType::RFT), true));
//}
//for (const auto& rftCase : rftCases)
//{
// auto addr = RimWellRftAddress(RftSourceType::RFT, rftCase);
// auto addr = RifWellRftAddress(RftSourceType::RFT, rftCase);
// auto item = caf::PdmOptionItemInfo(rftCase->caseUserDescription(), QVariant::fromValue(addr));
// item.setLevel(1);
// options.push_back(item);
@@ -1120,11 +1120,11 @@ QList<caf::PdmOptionItemInfo> RimWellPltPlot::calculateValueOptions(const caf::P
//const std::vector<RimEclipseResultCase*> gridCases = gridCasesFromEclipseCases(eclipseCases);
//if (gridCases.size() > 0)
//{
// options.push_back(caf::PdmOptionItemInfo::createHeader(RimWellRftAddress::sourceTypeUiText(RftSourceType::GRID), true));
// options.push_back(caf::PdmOptionItemInfo::createHeader(RifWellRftAddress::sourceTypeUiText(RftSourceType::GRID), true));
//}
//for (const auto& gridCase : gridCases)
//{
// auto addr = RimWellRftAddress(RftSourceType::GRID, gridCase);
// auto addr = RifWellRftAddress(RftSourceType::GRID, gridCase);
// auto item = caf::PdmOptionItemInfo(gridCase->caseUserDescription(), QVariant::fromValue(addr));
// item.setLevel(1);
// options.push_back(item);
@@ -1132,9 +1132,9 @@ QList<caf::PdmOptionItemInfo> RimWellPltPlot::calculateValueOptions(const caf::P
if (wellLogFilesContainingFlow(m_wellName).size() > 0)
{
options.push_back(caf::PdmOptionItemInfo::createHeader(RimWellRftAddress::sourceTypeUiText(RftSourceType::OBSERVED), true));
options.push_back(caf::PdmOptionItemInfo::createHeader(RifWellRftAddress::sourceTypeUiText(RifWellRftAddress::OBSERVED), true));
auto addr = RimWellRftAddress(RftSourceType::OBSERVED);
auto addr = RifWellRftAddress(RifWellRftAddress::OBSERVED);
auto item = caf::PdmOptionItemInfo("Observed Data", QVariant::fromValue(addr));
item.setLevel(1);
options.push_back(item);
@@ -1290,18 +1290,18 @@ void RimWellPltPlot::defineEditorAttribute(const caf::PdmFieldHandle* field, QSt
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellPltPlot::addTimeStepToMap(std::map<QDateTime, std::set<RimWellRftAddress>>& destMap,
const std::pair<QDateTime, std::set<RimWellRftAddress>>& timeStepToAdd)
void RimWellPltPlot::addTimeStepToMap(std::map<QDateTime, std::set<RifWellRftAddress>>& destMap,
const std::pair<QDateTime, std::set<RifWellRftAddress>>& timeStepToAdd)
{
auto timeStepMapToAdd = std::map<QDateTime, std::set<RimWellRftAddress>> { timeStepToAdd };
auto timeStepMapToAdd = std::map<QDateTime, std::set<RifWellRftAddress>> { timeStepToAdd };
addTimeStepsToMap(destMap, timeStepMapToAdd);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellPltPlot::addTimeStepsToMap(std::map<QDateTime, std::set<RimWellRftAddress>>& destMap,
const std::map<QDateTime, std::set<RimWellRftAddress>>& timeStepsToAdd)
void RimWellPltPlot::addTimeStepsToMap(std::map<QDateTime, std::set<RifWellRftAddress>>& destMap,
const std::map<QDateTime, std::set<RifWellRftAddress>>& timeStepsToAdd)
{
for (const auto& timeStepPair : timeStepsToAdd)
{
@@ -1309,7 +1309,7 @@ void RimWellPltPlot::addTimeStepsToMap(std::map<QDateTime, std::set<RimWellRftAd
{
if (destMap.count(timeStepPair.first) == 0)
{
destMap.insert(std::make_pair(timeStepPair.first, std::set<RimWellRftAddress>()));
destMap.insert(std::make_pair(timeStepPair.first, std::set<RifWellRftAddress>()));
}
auto addresses = timeStepPair.second;
destMap[timeStepPair.first].insert(addresses.begin(), addresses.end());
@@ -1352,12 +1352,12 @@ void RimWellPltPlot::calculateValueOptionsForWells(QList<caf::PdmOptionItemInfo>
//--------------------------------------------------------------------------------------------------
void RimWellPltPlot::calculateValueOptionsForTimeSteps(const QString& wellName, QList<caf::PdmOptionItemInfo>& options)
{
std::map<QDateTime, std::set<RimWellRftAddress>> displayTimeStepsMap, obsAndRftTimeStepsMap, gridTimeStepsMap;
std::map<QDateTime, std::set<RifWellRftAddress>> displayTimeStepsMap, obsAndRftTimeStepsMap, gridTimeStepsMap;
//const std::vector<std::tuple<RimEclipseResultCase*, bool, bool>>& eclipseCases = eclipseCasesForWell(wellName);
//const std::vector<RimEclipseResultCase*> rftCases = rftCasesFromEclipseCases(eclipseCases);
//const std::vector<RimEclipseResultCase*> gridCases = gridCasesFromEclipseCases(eclipseCases);
for (const RimWellRftAddress& selection : selectedSources())
for (const RifWellRftAddress& selection : selectedSources())
{
//if (selection.sourceType() == RftSourceType::RFT)
//{
@@ -1374,7 +1374,7 @@ void RimWellPltPlot::calculateValueOptionsForTimeSteps(const QString& wellName,
// }
//}
//else
if (selection.sourceType() == RftSourceType::OBSERVED)
if (selection.sourceType() == RifWellRftAddress::OBSERVED)
{
if (selection.wellLogFile() != nullptr)
{
@@ -1389,11 +1389,11 @@ void RimWellPltPlot::calculateValueOptionsForTimeSteps(const QString& wellName,
}
else
{
const auto gridTimeStepsVector = std::vector<std::pair<QDateTime, std::set<RimWellRftAddress>>>(gridTimeStepsMap.begin(), gridTimeStepsMap.end());
const auto gridTimeStepsVector = std::vector<std::pair<QDateTime, std::set<RifWellRftAddress>>>(gridTimeStepsMap.begin(), gridTimeStepsMap.end());
for (const std::pair<QDateTime, std::set<RimWellRftAddress>>& timeStepPair : obsAndRftTimeStepsMap)
for (const std::pair<QDateTime, std::set<RifWellRftAddress>>& timeStepPair : obsAndRftTimeStepsMap)
{
const std::map<QDateTime, std::set<RimWellRftAddress>>& adjTimeSteps = adjacentTimeSteps(gridTimeStepsVector, timeStepPair);
const std::map<QDateTime, std::set<RifWellRftAddress>>& adjTimeSteps = adjacentTimeSteps(gridTimeStepsVector, timeStepPair);
addTimeStepsToMap(displayTimeStepsMap, adjTimeSteps);
}
@@ -1408,7 +1408,7 @@ void RimWellPltPlot::calculateValueOptionsForTimeSteps(const QString& wellName,
{
if (m_timeStepsToAddresses.count(timeStep) > 0)
{
const std::set<RimWellRftAddress> sourceAddresses = m_timeStepsToAddresses[timeStep];
const std::set<RifWellRftAddress> sourceAddresses = m_timeStepsToAddresses[timeStep];
if (isAnySourceAddressSelected(sourceAddresses))
{
addTimeStepToMap(displayTimeStepsMap, std::make_pair(timeStep, m_timeStepsToAddresses[timeStep]));
@@ -1421,13 +1421,13 @@ void RimWellPltPlot::calculateValueOptionsForTimeSteps(const QString& wellName,
// Create vector of all time steps
std::vector<QDateTime> allTimeSteps;
for (const std::pair<QDateTime, std::set<RimWellRftAddress>>& timeStepPair : m_timeStepsToAddresses)
for (const std::pair<QDateTime, std::set<RifWellRftAddress>>& timeStepPair : m_timeStepsToAddresses)
{
allTimeSteps.push_back(timeStepPair.first);
}
const QString dateFormatString = RimTools::createTimeFormatStringFromDates(allTimeSteps);
for (const std::pair<QDateTime, std::set<RimWellRftAddress>>& timeStepPair : displayTimeStepsMap)
for (const std::pair<QDateTime, std::set<RifWellRftAddress>>& timeStepPair : displayTimeStepsMap)
{
options.push_back(caf::PdmOptionItemInfo(timeStepPair.first.toString(dateFormatString), timeStepPair.first));
}