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

#1996 Rename RigSingleWellResultsData -> RigSimWellData

Browse Source
This commit is contained in:
Rebecca Cox 2017-10-13 13:44:53 +02:00
parent e3ac94a940
commit 44be1bfd6b
39 changed files with 203 additions and 217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ApplicationCode/Commands/CompletionCommands/RicExportFractureCompletionsImpl.cpp
View File

@ -41,7 +41,7 @@
#include "RigFractureTransmissibilityEquations.h" #include "RigFractureTransmissibilityEquations.h"
#include "RigWellPathStimplanIntersector.h" #include "RigWellPathStimplanIntersector.h"
#include "RigMainGrid.h" #include "RigMainGrid.h"
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
#include "RigSimulationWellCoordsAndMD.h" #include "RigSimulationWellCoordsAndMD.h"
#include "RigWellPath.h" #include "RigWellPath.h"

4
ApplicationCode/Commands/FlowCommands/RicPlotProductionRateFeature.cpp
View File

@ -24,7 +24,7 @@
#include "RifEclipseSummaryAddress.h" #include "RifEclipseSummaryAddress.h"
#include "RifReaderEclipseSummary.h" #include "RifReaderEclipseSummary.h"
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
#include "RimEclipseResultCase.h" #include "RimEclipseResultCase.h"
#include "RimGridSummaryCase.h" #include "RimGridSummaryCase.h"
@ -241,7 +241,7 @@ RimGridSummaryCase* RicPlotProductionRateFeature::gridSummaryCaseForWell(RimSimW
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RicPlotProductionRateFeature::isInjector(RimSimWellInView* well) bool RicPlotProductionRateFeature::isInjector(RimSimWellInView* well)
{ {
RigSingleWellResultsData* wRes = well->wellResults(); RigSimWellData* wRes = well->simWellData();
if (wRes) if (wRes)
{ {
RimView* rimView = nullptr; RimView* rimView = nullptr;

10
ApplicationCode/Commands/FlowCommands/RicShowContributingWellsFeatureImpl.cpp
View File

@ -23,7 +23,7 @@
#include "RicSelectOrCreateViewFeatureImpl.h" #include "RicSelectOrCreateViewFeatureImpl.h"
#include "RigFlowDiagResultAddress.h" #include "RigFlowDiagResultAddress.h"
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
#include "RimEclipseCellColors.h" #include "RimEclipseCellColors.h"
#include "RimEclipsePropertyFilter.h" #include "RimEclipsePropertyFilter.h"
@ -122,7 +122,7 @@ void RicShowContributingWellsFeatureImpl::modifyViewToShowContributingWells(RimE
viewToModify->cellResult()->loadDataAndUpdate(); viewToModify->cellResult()->loadDataAndUpdate();
viewToModify->cellResult()->updateConnectedEditors(); viewToModify->cellResult()->updateConnectedEditors();
std::vector<QString> tracerNames = findContributingTracerNames(flowDiagSolution, selectedWell->wellResults(), timeStep); std::vector<QString> tracerNames = findContributingTracerNames(flowDiagSolution, selectedWell->simWellData(), timeStep);
for (RimSimWellInView* w : viewToModify->wellCollection()->wells()) for (RimSimWellInView* w : viewToModify->wellCollection()->wells())
{ {
@ -170,16 +170,16 @@ void RicShowContributingWellsFeatureImpl::modifyViewToShowContributingWells(RimE
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::vector<QString> RicShowContributingWellsFeatureImpl::findContributingTracerNames( std::vector<QString> RicShowContributingWellsFeatureImpl::findContributingTracerNames(
const RimFlowDiagSolution* flowDiagSolution, const RimFlowDiagSolution* flowDiagSolution,
const RigSingleWellResultsData* wellResults, const RigSimWellData* simWellData,
int timeStep) int timeStep)
{ {
std::vector<QString> tracerCellFractionValues; std::vector<QString> tracerCellFractionValues;
if (flowDiagSolution && wellResults->hasWellResult(timeStep)) if (flowDiagSolution && simWellData->hasWellResult(timeStep))
{ {
RimFlowDiagSolution::TracerStatusType requestedTracerType = RimFlowDiagSolution::UNDEFINED; RimFlowDiagSolution::TracerStatusType requestedTracerType = RimFlowDiagSolution::UNDEFINED;
const RigWellResultFrame::WellProductionType prodType = wellResults->wellProductionType(timeStep); const RigWellResultFrame::WellProductionType prodType = simWellData->wellProductionType(timeStep);
if ( prodType == RigWellResultFrame::PRODUCER if ( prodType == RigWellResultFrame::PRODUCER
|| prodType == RigWellResultFrame::UNDEFINED_PRODUCTION_TYPE) || prodType == RigWellResultFrame::UNDEFINED_PRODUCTION_TYPE)
{ {

4
ApplicationCode/Commands/FlowCommands/RicShowContributingWellsFeatureImpl.h
View File

@ -22,7 +22,7 @@
#include <QString> #include <QString>
class RigSingleWellResultsData; class RigSimWellData;
class RimEclipseResultCase; class RimEclipseResultCase;
class RimEclipseView; class RimEclipseView;
class RimFlowDiagSolution; class RimFlowDiagSolution;
@ -41,7 +41,7 @@ private:
static std::vector<QString> findContributingTracerNames( static std::vector<QString> findContributingTracerNames(
const RimFlowDiagSolution* flowDiagSolution, const RimFlowDiagSolution* flowDiagSolution,
const RigSingleWellResultsData* wellResults, const RigSimWellData* wellResults,
int timeStep); int timeStep);
}; };

20
ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp
View File

@ -37,7 +37,7 @@
#include "RigCaseCellResultsData.h" #include "RigCaseCellResultsData.h"
#include "RigEclipseCaseData.h" #include "RigEclipseCaseData.h"
#include "RigMainGrid.h" #include "RigMainGrid.h"
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
#include "RigEclipseResultInfo.h" #include "RigEclipseResultInfo.h"
#include "cafProgressInfo.h" #include "cafProgressInfo.h"
@ -1308,7 +1308,7 @@ void RifReaderEclipseOutput::readWellCells(const ecl_grid_type* mainEclGrid, boo
std::vector<RigGridBase*> grids; std::vector<RigGridBase*> grids;
m_eclipseCase->allGrids(&grids); m_eclipseCase->allGrids(&grids);
cvf::Collection<RigSingleWellResultsData> wells; cvf::Collection<RigSimWellData> wells;
caf::ProgressInfo progress(well_info_get_num_wells(ert_well_info), ""); caf::ProgressInfo progress(well_info_get_num_wells(ert_well_info), "");
int wellIdx; int wellIdx;
@ -1317,20 +1317,20 @@ void RifReaderEclipseOutput::readWellCells(const ecl_grid_type* mainEclGrid, boo
const char* wellName = well_info_iget_well_name(ert_well_info, wellIdx); const char* wellName = well_info_iget_well_name(ert_well_info, wellIdx);
CVF_ASSERT(wellName); CVF_ASSERT(wellName);
cvf::ref<RigSingleWellResultsData> wellResults = new RigSingleWellResultsData; cvf::ref<RigSimWellData> simWellData = new RigSimWellData;
wellResults->m_wellName = wellName; simWellData->m_wellName = wellName;
well_ts_type* ert_well_time_series = well_info_get_ts(ert_well_info , wellName); well_ts_type* ert_well_time_series = well_info_get_ts(ert_well_info , wellName);
int timeStepCount = well_ts_get_size(ert_well_time_series); int timeStepCount = well_ts_get_size(ert_well_time_series);
wellResults->m_wellCellsTimeSteps.resize(timeStepCount); simWellData->m_wellCellsTimeSteps.resize(timeStepCount);
int timeIdx; int timeIdx;
for (timeIdx = 0; timeIdx < timeStepCount; timeIdx++) for (timeIdx = 0; timeIdx < timeStepCount; timeIdx++)
{ {
well_state_type* ert_well_state = well_ts_iget_state(ert_well_time_series, timeIdx); well_state_type* ert_well_state = well_ts_iget_state(ert_well_time_series, timeIdx);
RigWellResultFrame& wellResFrame = wellResults->m_wellCellsTimeSteps[timeIdx]; RigWellResultFrame& wellResFrame = simWellData->m_wellCellsTimeSteps[timeIdx];
// Build timestamp for well // Build timestamp for well
bool haveFoundTimeStamp = false; bool haveFoundTimeStamp = false;
@ -1386,7 +1386,7 @@ void RifReaderEclipseOutput::readWellCells(const ecl_grid_type* mainEclGrid, boo
if (importCompleteMswData && well_state_is_MSW(ert_well_state)) if (importCompleteMswData && well_state_is_MSW(ert_well_state))
{ {
wellResults->setMultiSegmentWell(true); simWellData->setMultiSegmentWell(true);
// how do we handle LGR-s ? // how do we handle LGR-s ?
// 1. Create separate visual branches for each Grid, with its own wellhead // 1. Create separate visual branches for each Grid, with its own wellhead
@ -1811,16 +1811,16 @@ void RifReaderEclipseOutput::readWellCells(const ecl_grid_type* mainEclGrid, boo
} }
} }
wellResults->computeMappingFromResultTimeIndicesToWellTimeIndices(filteredTimeSteps); simWellData->computeMappingFromResultTimeIndicesToWellTimeIndices(filteredTimeSteps);
wells.push_back(wellResults.p()); wells.push_back(simWellData.p());
progress.incrementProgress(); progress.incrementProgress();
} }
well_info_free(ert_well_info); well_info_free(ert_well_info);
m_eclipseCase->setWellResults(wells); m_eclipseCase->setSimWellData(wells);
} }

8
ApplicationCode/ModelVisualization/RivSimWellPipesPartMgr.cpp
View File

@ -209,15 +209,15 @@ void RivSimWellPipesPartMgr::updatePipeResultColor(size_t frameIndex)
{ {
if (m_rimWell == NULL) return; if (m_rimWell == NULL) return;
RigSingleWellResultsData* wRes = m_rimWell->wellResults(); RigSimWellData* simWellData = m_rimWell->simWellData();
if (wRes == NULL) return; if (simWellData == NULL) return;
if (!wRes->hasWellResult(frameIndex)) return; // Or reset colors or something if (!simWellData->hasWellResult(frameIndex)) return; // Or reset colors or something
const double closed = -0.1, producing = 1.5, water = 2.5, hcInjection = 3.5; // Closed set to -0.1 instead of 0.5 to workaround bug in the scalar mapper. const double closed = -0.1, producing = 1.5, water = 2.5, hcInjection = 3.5; // Closed set to -0.1 instead of 0.5 to workaround bug in the scalar mapper.
std::list<RivPipeBranchData>::iterator brIt; std::list<RivPipeBranchData>::iterator brIt;
const RigWellResultFrame& wResFrame = wRes->wellResultFrame(frameIndex); const RigWellResultFrame& wResFrame = simWellData->wellResultFrame(frameIndex);
std::vector<double> wellCellStates; std::vector<double> wellCellStates;

4
ApplicationCode/ModelVisualization/RivSimWellPipesPartMgr.h
View File

@ -18,13 +18,15 @@
#pragma once #pragma once
#include "RigSimWellData.h"
#include "cvfBase.h" #include "cvfBase.h"
#include "cvfObject.h" #include "cvfObject.h"
#include "cvfVector3.h" #include "cvfVector3.h"
#include "cafPdmPointer.h" #include "cafPdmPointer.h"
#include <list> #include <list>
#include "RigSingleWellResultsData.h"
namespace cvf namespace cvf
{ {

18
ApplicationCode/ModelVisualization/RivWellConnectionsPartMgr.cpp
View File

@ -23,7 +23,7 @@
#include "RimEclipseWellCollection.h" #include "RimEclipseWellCollection.h"
#include "RimSimWellInView.h" #include "RimSimWellInView.h"
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
#include "RigFlowDiagResults.h" #include "RigFlowDiagResults.h"
#include "RigEclipseCaseData.h" #include "RigEclipseCaseData.h"
#include "RigMainGrid.h" #include "RigMainGrid.h"
@ -63,11 +63,11 @@ void RivWellConnectionsPartMgr::appendDynamicGeometryPartsToModel(cvf::ModelBasi
if ( m_rimReservoirView.isNull() ) return; if ( m_rimReservoirView.isNull() ) return;
if ( !m_rimReservoirView->eclipseCase() ) return; if ( !m_rimReservoirView->eclipseCase() ) return;
if ( !m_rimWell->showWell() ) return; if ( !m_rimWell->showWell() ) return;
if ( !m_rimWell->wellResults()->hasWellResult(frameIndex) ) return; if ( !m_rimWell->simWellData()->hasWellResult(frameIndex) ) return;
if ( !m_rimWell->wellResults()->wellResultFrame(frameIndex).m_isOpen ) return; if ( !m_rimWell->simWellData()->wellResultFrame(frameIndex).m_isOpen ) return;
if ( m_rimWell->wellResults()->wellResultFrame(frameIndex).m_productionType == RigWellResultFrame::UNDEFINED_PRODUCTION_TYPE ) return; if ( m_rimWell->simWellData()->wellResultFrame(frameIndex).m_productionType == RigWellResultFrame::UNDEFINED_PRODUCTION_TYPE ) return;
bool isProducer = (m_rimWell->wellResults()->wellResultFrame(frameIndex).m_productionType == RigWellResultFrame::PRODUCER); bool isProducer = (m_rimWell->simWellData()->wellResultFrame(frameIndex).m_productionType == RigWellResultFrame::PRODUCER);
double pipeRadius = m_rimWell->pipeRadius(); double pipeRadius = m_rimWell->pipeRadius();
cvf::Vec3d wellHeadTop; cvf::Vec3d wellHeadTop;
@ -129,11 +129,11 @@ void RivWellConnectionsPartMgr::appendDynamicGeometryPartsToModel(cvf::ModelBasi
for ( RimSimWellInView * otherWell: wellColl->wells ) for ( RimSimWellInView * otherWell: wellColl->wells )
{ {
if ( otherWell == m_rimWell ) continue; if ( otherWell == m_rimWell ) continue;
if ( !otherWell->wellResults()->hasWellResult(frameIndex) ) continue; if ( !otherWell->simWellData()->hasWellResult(frameIndex) ) continue;
if ( !otherWell->wellResults()->wellResultFrame(frameIndex).m_isOpen ) continue; if ( !otherWell->simWellData()->wellResultFrame(frameIndex).m_isOpen ) continue;
if ( otherWell->wellResults()->wellResultFrame(frameIndex).m_productionType == RigWellResultFrame::UNDEFINED_PRODUCTION_TYPE ) continue; if ( otherWell->simWellData()->wellResultFrame(frameIndex).m_productionType == RigWellResultFrame::UNDEFINED_PRODUCTION_TYPE ) continue;
bool isOtherProducer = (otherWell->wellResults()->wellResultFrame(frameIndex).m_productionType == RigWellResultFrame::PRODUCER); bool isOtherProducer = (otherWell->simWellData()->wellResultFrame(frameIndex).m_productionType == RigWellResultFrame::PRODUCER);
{ {
std::string otherWellName = otherWell->name().toStdString(); std::string otherWellName = otherWell->name().toStdString();

6
ApplicationCode/ModelVisualization/RivWellHeadPartMgr.cpp
View File

@ -28,7 +28,7 @@
#include "RigCell.h" #include "RigCell.h"
#include "RigEclipseCaseData.h" #include "RigEclipseCaseData.h"
#include "RigMainGrid.h" #include "RigMainGrid.h"
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
#include "RimEclipseCase.h" #include "RimEclipseCase.h"
#include "RimEclipseView.h" #include "RimEclipseView.h"
@ -98,9 +98,9 @@ void RivWellHeadPartMgr::buildWellHeadParts(size_t frameIndex)
if (!well->wellResults()->hasWellResult(frameIndex)) return; if (!well->simWellData()->hasWellResult(frameIndex)) return;
const RigWellResultFrame& wellResultFrame = well->wellResults()->wellResultFrame(frameIndex); const RigWellResultFrame& wellResultFrame = well->simWellData()->wellResultFrame(frameIndex);
double pipeRadius = m_rimWell->pipeRadius(); double pipeRadius = m_rimWell->pipeRadius();

4
ApplicationCode/ModelVisualization/RivWellSpheresPartMgr.cpp
View File

@ -21,7 +21,7 @@
#include "RiaApplication.h" #include "RiaApplication.h"
#include "RigMainGrid.h" #include "RigMainGrid.h"
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
#include "RimEclipseCase.h" #include "RimEclipseCase.h"
#include "RimEclipseView.h" #include "RimEclipseView.h"
@ -76,7 +76,7 @@ void RivWellSpheresPartMgr::appendDynamicGeometryPartsToModel(cvf::ModelBasicLis
const RigMainGrid* mainGrid = m_rimReservoirView->mainGrid(); const RigMainGrid* mainGrid = m_rimReservoirView->mainGrid();
CVF_ASSERT(mainGrid); CVF_ASSERT(mainGrid);
RigSingleWellResultsData* rigWellResult = m_rimWell->wellResults(); RigSimWellData* rigWellResult = m_rimWell->simWellData();
if (!rigWellResult) return; if (!rigWellResult) return;
if (!rigWellResult->hasWellResult(frameIndex)) return; if (!rigWellResult->hasWellResult(frameIndex)) return;

2
ApplicationCode/ProjectDataModel/Completions/RimSimWellFracture.cpp
View File

@ -20,7 +20,7 @@
#include "RigCell.h" #include "RigCell.h"
#include "RigMainGrid.h" #include "RigMainGrid.h"
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
#include "RimEclipseView.h" #include "RimEclipseView.h"
#include "RimEllipseFractureTemplate.h" #include "RimEllipseFractureTemplate.h"

40
ApplicationCode/ProjectDataModel/Flow/RimFlowDiagSolution.cpp
View File

@ -26,7 +26,7 @@
#include "RigEclipseCaseData.h" #include "RigEclipseCaseData.h"
#include "RigFlowDiagResults.h" #include "RigFlowDiagResults.h"
#include "RigMainGrid.h" #include "RigMainGrid.h"
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
#include "RimEclipseResultCase.h" #include "RimEclipseResultCase.h"
#include "RimEclipseView.h" #include "RimEclipseView.h"
@ -128,12 +128,12 @@ std::vector<QString> RimFlowDiagSolution::tracerNames() const
if (eclCase) if (eclCase)
{ {
const cvf::Collection<RigSingleWellResultsData>& wellResults = eclCase->eclipseCaseData()->wellResults(); const cvf::Collection<RigSimWellData>& simWellData = eclCase->eclipseCaseData()->wellResults();
for (size_t wIdx = 0; wIdx < wellResults.size(); ++wIdx) for (size_t wIdx = 0; wIdx < simWellData.size(); ++wIdx)
{ {
tracerNameSet.push_back(wellResults[wIdx]->m_wellName); tracerNameSet.push_back(simWellData[wIdx]->m_wellName);
tracerNameSet.push_back(addCrossFlowEnding(wellResults[wIdx]->m_wellName)); tracerNameSet.push_back(addCrossFlowEnding(simWellData[wIdx]->m_wellName));
} }
} }
@ -168,20 +168,20 @@ std::map<std::string, std::vector<int> > RimFlowDiagSolution::allTracerActiveCel
if ( eclCase ) if ( eclCase )
{ {
const cvf::Collection<RigSingleWellResultsData>& wellResults = eclCase->eclipseCaseData()->wellResults(); const cvf::Collection<RigSimWellData>& simWellData = eclCase->eclipseCaseData()->wellResults();
RigMainGrid* mainGrid = eclCase->eclipseCaseData()->mainGrid(); RigMainGrid* mainGrid = eclCase->eclipseCaseData()->mainGrid();
RigActiveCellInfo* activeCellInfo = eclCase->eclipseCaseData()->activeCellInfo(RiaDefines::MATRIX_MODEL); //Todo: Must come from the results definition RigActiveCellInfo* activeCellInfo = eclCase->eclipseCaseData()->activeCellInfo(RiaDefines::MATRIX_MODEL); //Todo: Must come from the results definition
for ( size_t wIdx = 0; wIdx < wellResults.size(); ++wIdx ) for ( size_t wIdx = 0; wIdx < simWellData.size(); ++wIdx )
{ {
if (!wellResults[wIdx]->hasWellResult(timeStepIndex) ) continue; if (!simWellData[wIdx]->hasWellResult(timeStepIndex) ) continue;
const RigWellResultFrame& wellResFrame = wellResults[wIdx]->wellResultFrame(timeStepIndex); const RigWellResultFrame& wellResFrame = simWellData[wIdx]->wellResultFrame(timeStepIndex);
bool isInjectorWell = ( wellResFrame.m_productionType != RigWellResultFrame::PRODUCER bool isInjectorWell = ( wellResFrame.m_productionType != RigWellResultFrame::PRODUCER
&& wellResFrame.m_productionType != RigWellResultFrame::UNDEFINED_PRODUCTION_TYPE); && wellResFrame.m_productionType != RigWellResultFrame::UNDEFINED_PRODUCTION_TYPE);
std::string wellName = wellResults[wIdx]->m_wellName.toStdString(); std::string wellName = simWellData[wIdx]->m_wellName.toStdString();
std::string wellNameXf = addCrossFlowEnding(wellResults[wIdx]->m_wellName).toStdString(); std::string wellNameXf = addCrossFlowEnding(simWellData[wIdx]->m_wellName).toStdString();
std::vector<int>& tracerCells = tracersWithCells[wellName]; std::vector<int>& tracerCells = tracersWithCells[wellName];
std::vector<int>& tracerCellsCrossFlow = tracersWithCells[wellNameXf]; std::vector<int>& tracerCellsCrossFlow = tracersWithCells[wellNameXf];
@ -228,16 +228,16 @@ RimFlowDiagSolution::TracerStatusType RimFlowDiagSolution::tracerStatusOverall(c
TracerStatusType tracerStatus = UNDEFINED; TracerStatusType tracerStatus = UNDEFINED;
const cvf::Collection<RigSingleWellResultsData>& wellResults = eclCase->eclipseCaseData()->wellResults(); const cvf::Collection<RigSimWellData>& simWellData = eclCase->eclipseCaseData()->wellResults();
for ( size_t wIdx = 0; wIdx < wellResults.size(); ++wIdx ) for ( size_t wIdx = 0; wIdx < simWellData.size(); ++wIdx )
{ {
QString wellName = removeCrossFlowEnding(tracerName); QString wellName = removeCrossFlowEnding(tracerName);
if ( wellResults[wIdx]->m_wellName != wellName ) continue; if ( simWellData[wIdx]->m_wellName != wellName ) continue;
tracerStatus = CLOSED; tracerStatus = CLOSED;
for ( const RigWellResultFrame& wellResFrame : wellResults[wIdx]->m_wellCellsTimeSteps ) for ( const RigWellResultFrame& wellResFrame : simWellData[wIdx]->m_wellCellsTimeSteps )
{ {
if ( wellResFrame.m_productionType == RigWellResultFrame::GAS_INJECTOR if ( wellResFrame.m_productionType == RigWellResultFrame::GAS_INJECTOR
|| wellResFrame.m_productionType == RigWellResultFrame::OIL_INJECTOR || wellResFrame.m_productionType == RigWellResultFrame::OIL_INJECTOR
@ -274,16 +274,16 @@ RimFlowDiagSolution::TracerStatusType RimFlowDiagSolution::tracerStatusInTimeSte
RimEclipseResultCase* eclCase; RimEclipseResultCase* eclCase;
this->firstAncestorOrThisOfTypeAsserted(eclCase); this->firstAncestorOrThisOfTypeAsserted(eclCase);
const cvf::Collection<RigSingleWellResultsData>& wellResults = eclCase->eclipseCaseData()->wellResults(); const cvf::Collection<RigSimWellData>& simWellData = eclCase->eclipseCaseData()->wellResults();
for ( size_t wIdx = 0; wIdx < wellResults.size(); ++wIdx ) for ( size_t wIdx = 0; wIdx < simWellData.size(); ++wIdx )
{ {
QString wellName = removeCrossFlowEnding(tracerName); QString wellName = removeCrossFlowEnding(tracerName);
if ( wellResults[wIdx]->m_wellName != wellName ) continue; if ( simWellData[wIdx]->m_wellName != wellName ) continue;
if (!wellResults[wIdx]->hasWellResult(timeStepIndex)) return CLOSED; if (!simWellData[wIdx]->hasWellResult(timeStepIndex)) return CLOSED;
const RigWellResultFrame& wellResFrame = wellResults[wIdx]->wellResultFrame(timeStepIndex); const RigWellResultFrame& wellResFrame = simWellData[wIdx]->wellResultFrame(timeStepIndex);
if ( wellResFrame.m_productionType == RigWellResultFrame::GAS_INJECTOR if ( wellResFrame.m_productionType == RigWellResultFrame::GAS_INJECTOR
|| wellResFrame.m_productionType == RigWellResultFrame::OIL_INJECTOR || wellResFrame.m_productionType == RigWellResultFrame::OIL_INJECTOR

2
ApplicationCode/ProjectDataModel/Flow/RimTofAccumulatedPhaseFractionsPlot.cpp
View File

@ -24,7 +24,7 @@
#include "RimEclipseWellCollection.h" #include "RimEclipseWellCollection.h"
#include "RimWellAllocationPlot.h" #include "RimWellAllocationPlot.h"
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
#include "RigTofAccumulatedPhaseFractionsCalculator.h" #include "RigTofAccumulatedPhaseFractionsCalculator.h"
#include "RimWellLogPlot.h" #include "RimWellLogPlot.h"

2
ApplicationCode/ProjectDataModel/Flow/RimTotalWellAllocationPlot.cpp
View File

@ -23,7 +23,7 @@
#include "RimEclipseView.h" #include "RimEclipseView.h"
#include "RimEclipseWellCollection.h" #include "RimEclipseWellCollection.h"
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
#include "RimWellLogPlot.h" #include "RimWellLogPlot.h"
#include "RimWellLogTrack.h" #include "RimWellLogTrack.h"

36
ApplicationCode/ProjectDataModel/Flow/RimWellAllocationPlot.cpp
View File

@ -26,7 +26,7 @@
#include "RigFlowDiagResults.h" #include "RigFlowDiagResults.h"
#include "RigSimulationWellCenterLineCalculator.h" #include "RigSimulationWellCenterLineCalculator.h"
#include "RigSimulationWellCoordsAndMD.h" #include "RigSimulationWellCoordsAndMD.h"
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
#include "RimEclipseCase.h" #include "RimEclipseCase.h"
#include "RimEclipseCellColors.h" #include "RimEclipseCellColors.h"
@ -135,7 +135,7 @@ void RimWellAllocationPlot::setFromSimulationWell(RimSimWellInView* simWell)
simWell->firstAncestorOrThisOfType(eclCase); simWell->firstAncestorOrThisOfType(eclCase);
m_case = eclCase; m_case = eclCase;
m_wellName = simWell->wellResults()->m_wellName; m_wellName = simWell->simWellData()->m_wellName;
m_timeStep = eclView->currentTimeStep(); m_timeStep = eclView->currentTimeStep();
// Use the active flow diag solutions, or the first one as default // Use the active flow diag solutions, or the first one as default
@ -187,9 +187,9 @@ void RimWellAllocationPlot::updateFromWell()
if (!m_case) return; if (!m_case) return;
const RigSingleWellResultsData* wellResults = m_case->eclipseCaseData()->findWellResult(m_wellName); const RigSimWellData* simWellData = m_case->eclipseCaseData()->findSimWellData(m_wellName);
if (!wellResults) return; if (!simWellData) return;
// Set up the Accumulated Well Flow Calculator // Set up the Accumulated Well Flow Calculator
@ -197,14 +197,14 @@ void RimWellAllocationPlot::updateFromWell()
std::vector< std::vector <RigWellResultPoint> > pipeBranchesCellIds; std::vector< std::vector <RigWellResultPoint> > pipeBranchesCellIds;
RigSimulationWellCenterLineCalculator::calculateWellPipeCenterlineFromWellFrame(m_case->eclipseCaseData(), RigSimulationWellCenterLineCalculator::calculateWellPipeCenterlineFromWellFrame(m_case->eclipseCaseData(),
wellResults, simWellData,
m_timeStep, m_timeStep,
true, true,
true, true,
pipeBranchesCLCoords, pipeBranchesCLCoords,
pipeBranchesCellIds); pipeBranchesCellIds);
std::map<QString, const std::vector<double>* > tracerFractionCellValues = findRelevantTracerCellFractions(wellResults); std::map<QString, const std::vector<double>* > tracerFractionCellValues = findRelevantTracerCellFractions(simWellData);
std::unique_ptr< RigAccWellFlowCalculator > wfCalculator; std::unique_ptr< RigAccWellFlowCalculator > wfCalculator;
@ -213,8 +213,8 @@ void RimWellAllocationPlot::updateFromWell()
if ( tracerFractionCellValues.size() ) if ( tracerFractionCellValues.size() )
{ {
bool isProducer = ( wellResults->wellProductionType(m_timeStep) == RigWellResultFrame::PRODUCER bool isProducer = ( simWellData->wellProductionType(m_timeStep) == RigWellResultFrame::PRODUCER
|| wellResults->wellProductionType(m_timeStep) == RigWellResultFrame::UNDEFINED_PRODUCTION_TYPE ); || simWellData->wellProductionType(m_timeStep) == RigWellResultFrame::UNDEFINED_PRODUCTION_TYPE );
RigEclCellIndexCalculator cellIdxCalc(m_case->eclipseCaseData()->mainGrid(), m_case->eclipseCaseData()->activeCellInfo(RiaDefines::MATRIX_MODEL)); RigEclCellIndexCalculator cellIdxCalc(m_case->eclipseCaseData()->mainGrid(), m_case->eclipseCaseData()->activeCellInfo(RiaDefines::MATRIX_MODEL));
wfCalculator.reset(new RigAccWellFlowCalculator(pipeBranchesCLCoords, wfCalculator.reset(new RigAccWellFlowCalculator(pipeBranchesCLCoords,
pipeBranchesCellIds, pipeBranchesCellIds,
@ -327,15 +327,15 @@ void RimWellAllocationPlot::updateFromWell()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::map<QString, const std::vector<double> *> RimWellAllocationPlot::findRelevantTracerCellFractions(const RigSingleWellResultsData* wellResults) std::map<QString, const std::vector<double> *> RimWellAllocationPlot::findRelevantTracerCellFractions(const RigSimWellData* simWellData)
{ {
std::map<QString, const std::vector<double> *> tracerCellFractionValues; std::map<QString, const std::vector<double> *> tracerCellFractionValues;
if ( m_flowDiagSolution && wellResults->hasWellResult(m_timeStep) ) if ( m_flowDiagSolution && simWellData->hasWellResult(m_timeStep) )
{ {
RimFlowDiagSolution::TracerStatusType requestedTracerType = RimFlowDiagSolution::UNDEFINED; RimFlowDiagSolution::TracerStatusType requestedTracerType = RimFlowDiagSolution::UNDEFINED;
const RigWellResultFrame::WellProductionType prodType = wellResults->wellProductionType(m_timeStep); const RigWellResultFrame::WellProductionType prodType = simWellData->wellProductionType(m_timeStep);
if ( prodType == RigWellResultFrame::PRODUCER if ( prodType == RigWellResultFrame::PRODUCER
|| prodType == RigWellResultFrame::UNDEFINED_PRODUCTION_TYPE ) || prodType == RigWellResultFrame::UNDEFINED_PRODUCTION_TYPE )
{ {
@ -465,13 +465,13 @@ QString RimWellAllocationPlot::wellStatusTextForTimeStep(const QString& wellName
if (eclipseResultCase) if (eclipseResultCase)
{ {
const RigSingleWellResultsData* wellResults = eclipseResultCase->eclipseCaseData()->findWellResult(wellName); const RigSimWellData* simWellData = eclipseResultCase->eclipseCaseData()->findSimWellData(wellName);
if (wellResults) if (simWellData)
{ {
if (wellResults->hasWellResult(timeStep)) if (simWellData->hasWellResult(timeStep))
{ {
const RigWellResultFrame& wellResultFrame = wellResults->wellResultFrame(timeStep); const RigWellResultFrame& wellResultFrame = simWellData->wellResultFrame(timeStep);
RigWellResultFrame::WellProductionType prodType = wellResultFrame.m_productionType; RigWellResultFrame::WellProductionType prodType = wellResultFrame.m_productionType;
@ -718,11 +718,11 @@ std::set<QString> RimWellAllocationPlot::findSortedWellNames()
std::set<QString> sortedWellNames; std::set<QString> sortedWellNames;
if ( m_case && m_case->eclipseCaseData() ) if ( m_case && m_case->eclipseCaseData() )
{ {
const cvf::Collection<RigSingleWellResultsData>& wellRes = m_case->eclipseCaseData()->wellResults(); const cvf::Collection<RigSimWellData>& simWellData = m_case->eclipseCaseData()->wellResults();
for ( size_t wIdx = 0; wIdx < wellRes.size(); ++wIdx ) for ( size_t wIdx = 0; wIdx < simWellData.size(); ++wIdx )
{ {
sortedWellNames.insert(wellRes[wIdx]->m_wellName); sortedWellNames.insert(simWellData[wIdx]->m_wellName);
} }
} }

4
ApplicationCode/ProjectDataModel/Flow/RimWellAllocationPlot.h
View File

@ -27,7 +27,7 @@
#include <QPointer> #include <QPointer>
class RigSingleWellResultsData; class RigSimWellData;
class RimEclipseResultCase; class RimEclipseResultCase;
class RimFlowDiagSolution; class RimFlowDiagSolution;
class RimSimWellInView; class RimSimWellInView;
@ -100,7 +100,7 @@ protected:
private: private:
void updateFromWell(); void updateFromWell();
std::map<QString, const std::vector<double> *> findRelevantTracerCellFractions(const RigSingleWellResultsData* wellResults); std::map<QString, const std::vector<double> *> findRelevantTracerCellFractions(const RigSimWellData* simWellData);
void updateWellFlowPlotXAxisTitle(RimWellLogTrack* plotTrack); void updateWellFlowPlotXAxisTitle(RimWellLogTrack* plotTrack);

11
ApplicationCode/ProjectDataModel/Flow/RimWellRftAddress.h
View File

@ -29,18 +29,7 @@
#include <QDate> #include <QDate>
#include <QMetaType> #include <QMetaType>
class RigSingleWellResultsData;
class RimEclipseResultCase;
class RimFlowDiagSolution;
class RimTofAccumulatedPhaseFractionsPlot;
class RimTotalWellAllocationPlot;
class RimWellLogFile; class RimWellLogFile;
class RimWellLogFileChannel;
class RimWellLogPlot;
class RimWellLogTrack;
class RiuWellRftPlot;
//================================================================================================== //==================================================================================================
/// ///

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

@ -24,7 +24,7 @@
#include "RifReaderEclipseRft.h" #include "RifReaderEclipseRft.h"
#include "RigCaseCellResultsData.h" #include "RigCaseCellResultsData.h"
#include "RigEclipseCaseData.h" #include "RigEclipseCaseData.h"
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
#include "RigWellPath.h" #include "RigWellPath.h"
#include "RimEclipseCase.h" #include "RimEclipseCase.h"
#include "RimEclipseCaseCollection.h" #include "RimEclipseCaseCollection.h"

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

@ -33,17 +33,12 @@
#include <set> #include <set>
#include <map> #include <map>
class RigSingleWellResultsData;
class RigWellPath;
class RimEclipseCase; class RimEclipseCase;
class RimEclipseResultCase; class RimEclipseResultCase;
class RimFlowDiagSolution;
class RimTofAccumulatedPhaseFractionsPlot;
class RimTotalWellAllocationPlot;
class RimWellLogCurve; class RimWellLogCurve;
class RimWellLogFileChannel; class RimWellLogFileChannel;
class RimWellLogPlot; class RimWellLogPlot;
class RimWellLogTrack;
class RimWellPath; class RimWellPath;
class RiuWellRftPlot; class RiuWellRftPlot;

12
ApplicationCode/ProjectDataModel/RimEclipseCase.cpp
View File

@ -28,7 +28,7 @@
#include "RigCaseCellResultsData.h" #include "RigCaseCellResultsData.h"
#include "RigEclipseCaseData.h" #include "RigEclipseCaseData.h"
#include "RigMainGrid.h" #include "RigMainGrid.h"
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
#include "RimCaseCollection.h" #include "RimCaseCollection.h"
#include "RimCellEdgeColors.h" #include "RimCellEdgeColors.h"
@ -162,15 +162,15 @@ cvf::Color3f RimEclipseCase::defaultWellColor(const QString& wellName)
cvf::Color3ubArray wellColors = colorTable.color3ubArray(); cvf::Color3ubArray wellColors = colorTable.color3ubArray();
cvf::Color3ubArray interpolatedWellColors = wellColors; cvf::Color3ubArray interpolatedWellColors = wellColors;
const cvf::Collection<RigSingleWellResultsData>& wellResults = this->eclipseCaseData()->wellResults(); const cvf::Collection<RigSimWellData>& simWellData = this->eclipseCaseData()->wellResults();
if ( wellResults.size() > 1 ) if ( simWellData.size() > 1 )
{ {
interpolatedWellColors = caf::ColorTable::interpolateColorArray(wellColors, wellResults.size()); interpolatedWellColors = caf::ColorTable::interpolateColorArray(wellColors, simWellData.size());
} }
for ( size_t wIdx = 0; wIdx < wellResults.size(); ++wIdx ) for ( size_t wIdx = 0; wIdx < simWellData.size(); ++wIdx )
{ {
m_wellToColorMap[wellResults[wIdx]->m_wellName] = cvf::Color3f::BLACK; m_wellToColorMap[simWellData[wIdx]->m_wellName] = cvf::Color3f::BLACK;
} }
size_t wIdx = 0; size_t wIdx = 0;

12
ApplicationCode/ProjectDataModel/RimEclipseStatisticsCase.cpp
View File

@ -24,7 +24,7 @@
#include "RigCaseCellResultsData.h" #include "RigCaseCellResultsData.h"
#include "RigEclipseCaseData.h" #include "RigEclipseCaseData.h"
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
#include "RimCaseCollection.h" #include "RimCaseCollection.h"
#include "RimEclipseCellColors.h" #include "RimEclipseCellColors.h"
@ -511,13 +511,13 @@ void RimEclipseStatisticsCase::fieldChangedByUi(const caf::PdmFieldHandle* chang
// Propagate well info to statistics case // Propagate well info to statistics case
if (sourceResultCase->eclipseCaseData()) if (sourceResultCase->eclipseCaseData())
{ {
const cvf::Collection<RigSingleWellResultsData>& sourceCaseWellResults = sourceResultCase->eclipseCaseData()->wellResults(); const cvf::Collection<RigSimWellData>& sourceCaseSimWellData = sourceResultCase->eclipseCaseData()->wellResults();
setWellResultsAndUpdateViews(sourceCaseWellResults); setWellResultsAndUpdateViews(sourceCaseSimWellData);
} }
} }
else else
{ {
cvf::Collection<RigSingleWellResultsData> sourceCaseWellResults; cvf::Collection<RigSimWellData> sourceCaseWellResults;
setWellResultsAndUpdateViews(sourceCaseWellResults); setWellResultsAndUpdateViews(sourceCaseWellResults);
} }
} }
@ -526,9 +526,9 @@ void RimEclipseStatisticsCase::fieldChangedByUi(const caf::PdmFieldHandle* chang
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimEclipseStatisticsCase::setWellResultsAndUpdateViews(const cvf::Collection<RigSingleWellResultsData>& sourceCaseWellResults) void RimEclipseStatisticsCase::setWellResultsAndUpdateViews(const cvf::Collection<RigSimWellData>& sourceCaseSimWellData)
{ {
this->eclipseCaseData()->setWellResults(sourceCaseWellResults); this->eclipseCaseData()->setSimWellData(sourceCaseSimWellData);
caf::ProgressInfo progInfo(reservoirViews().size() + 1, "Updating Well Data for Views"); caf::ProgressInfo progInfo(reservoirViews().size() + 1, "Updating Well Data for Views");

4
ApplicationCode/ProjectDataModel/RimEclipseStatisticsCase.h
View File

@ -35,7 +35,7 @@ class RimIdenticalGridCaseGroup;
class RimEclipseResultDefinition; class RimEclipseResultDefinition;
class RimEclipseStatisticsCaseCollection; class RimEclipseStatisticsCaseCollection;
class RigMainGrid; class RigMainGrid;
class RigSingleWellResultsData; class RigSimWellData;
//================================================================================================== //==================================================================================================
@ -91,7 +91,7 @@ private:
void updatePercentileUiVisibility(); void updatePercentileUiVisibility();
void setWellResultsAndUpdateViews(const cvf::Collection<RigSingleWellResultsData>& sourceCaseWellResults); void setWellResultsAndUpdateViews(const cvf::Collection<RigSimWellData>& sourceCaseSimWellData);
// Pdm system overrides // Pdm system overrides
virtual void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) ; virtual void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) ;

24
ApplicationCode/ProjectDataModel/RimEclipseView.cpp
View File

@ -31,7 +31,7 @@
#include "RigMainGrid.h" #include "RigMainGrid.h"
#include "RigResultAccessor.h" #include "RigResultAccessor.h"
#include "RigResultAccessorFactory.h" #include "RigResultAccessorFactory.h"
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
#include "Rim3dOverlayInfoConfig.h" #include "Rim3dOverlayInfoConfig.h"
#include "RimCellEdgeColors.h" #include "RimCellEdgeColors.h"
@ -1192,7 +1192,7 @@ void RimEclipseView::syncronizeWellsWithResults()
{ {
if (!(m_eclipseCase && m_eclipseCase->eclipseCaseData()) ) return; if (!(m_eclipseCase && m_eclipseCase->eclipseCaseData()) ) return;
cvf::Collection<RigSingleWellResultsData> wellResults = m_eclipseCase->eclipseCaseData()->wellResults(); cvf::Collection<RigSimWellData> simWellData = m_eclipseCase->eclipseCaseData()->wellResults();
std::vector<caf::PdmPointer<RimSimWellInView> > newWells; std::vector<caf::PdmPointer<RimSimWellInView> > newWells;
@ -1201,27 +1201,27 @@ void RimEclipseView::syncronizeWellsWithResults()
for (size_t wIdx = 0; wIdx < this->wellCollection()->wells().size(); ++wIdx) for (size_t wIdx = 0; wIdx < this->wellCollection()->wells().size(); ++wIdx)
{ {
RimSimWellInView* well = this->wellCollection()->wells()[wIdx]; RimSimWellInView* well = this->wellCollection()->wells()[wIdx];
well->setWellResults(NULL, -1); well->setSimWellData(NULL, -1);
} }
bool isAnyWellCreated = false; bool isAnyWellCreated = false;
// Find corresponding well from well result, or create a new // Find corresponding well from well result, or create a new
for (size_t wIdx = 0; wIdx < wellResults.size(); ++wIdx) for (size_t wIdx = 0; wIdx < simWellData.size(); ++wIdx)
{ {
RimSimWellInView* well = this->wellCollection()->findWell(wellResults[wIdx]->m_wellName); RimSimWellInView* well = this->wellCollection()->findWell(simWellData[wIdx]->m_wellName);
if (!well) if (!well)
{ {
well = new RimSimWellInView; well = new RimSimWellInView;
well->name = wellResults[wIdx]->m_wellName; well->name = simWellData[wIdx]->m_wellName;
isAnyWellCreated = true; isAnyWellCreated = true;
} }
newWells.push_back(well); newWells.push_back(well);
well->setWellResults(wellResults[wIdx].p(), wIdx); well->setSimWellData(simWellData[wIdx].p(), wIdx);
} }
// Delete all wells that does not have a result // Delete all wells that does not have a result
@ -1229,8 +1229,8 @@ void RimEclipseView::syncronizeWellsWithResults()
for (size_t wIdx = 0; wIdx < this->wellCollection()->wells().size(); ++wIdx) for (size_t wIdx = 0; wIdx < this->wellCollection()->wells().size(); ++wIdx)
{ {
RimSimWellInView* well = this->wellCollection()->wells()[wIdx]; RimSimWellInView* well = this->wellCollection()->wells()[wIdx];
RigSingleWellResultsData* wellRes = well->wellResults(); RigSimWellData* simWellData = well->simWellData();
if (wellRes == NULL) if (simWellData == NULL)
{ {
delete well; delete well;
} }
@ -1292,10 +1292,10 @@ void RimEclipseView::calculateVisibleWellCellsIncFence(cvf::UByteArray* visibleC
RimSimWellInView* well = this->wellCollection()->wells()[wIdx]; RimSimWellInView* well = this->wellCollection()->wells()[wIdx];
if (well->isWellCellsVisible()) if (well->isWellCellsVisible())
{ {
RigSingleWellResultsData* wres = well->wellResults(); RigSimWellData* simWellData = well->simWellData();
if (!wres) continue; if (!simWellData) continue;
const std::vector< RigWellResultFrame >& wellResFrames = wres->m_wellCellsTimeSteps; const std::vector< RigWellResultFrame >& wellResFrames = simWellData->m_wellCellsTimeSteps;
for (size_t wfIdx = 0; wfIdx < wellResFrames.size(); ++wfIdx) for (size_t wfIdx = 0; wfIdx < wellResFrames.size(); ++wfIdx)
{ {
// Add the wellhead cell if it is active // Add the wellhead cell if it is active

12
ApplicationCode/ProjectDataModel/RimEclipseWellCollection.cpp
View File

@ -25,7 +25,7 @@
#include "RiaPreferences.h" #include "RiaPreferences.h"
#include "RigEclipseCaseData.h" #include "RigEclipseCaseData.h"
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
#include "RimEclipseCase.h" #include "RimEclipseCase.h"
#include "RimEclipseView.h" #include "RimEclipseView.h"
@ -287,11 +287,11 @@ bool RimEclipseWellCollection::hasVisibleWellCells()
for (size_t i = 0 ; !hasCells && i < this->wells().size(); ++i) for (size_t i = 0 ; !hasCells && i < this->wells().size(); ++i)
{ {
RimSimWellInView* well = this->wells()[i]; RimSimWellInView* well = this->wells()[i];
if ( well && well->wellResults() && ((well->showWell() && well->showWellCells())) ) if ( well && well->simWellData() && ((well->showWell() && well->showWellCells())) )
{ {
for (size_t tIdx = 0; !hasCells && tIdx < well->wellResults()->m_wellCellsTimeSteps.size(); ++tIdx ) for (size_t tIdx = 0; !hasCells && tIdx < well->simWellData()->m_wellCellsTimeSteps.size(); ++tIdx )
{ {
const RigWellResultFrame& wellResultFrame = well->wellResults()->m_wellCellsTimeSteps[tIdx]; const RigWellResultFrame& wellResultFrame = well->simWellData()->m_wellCellsTimeSteps[tIdx];
for (size_t wsIdx = 0; !hasCells && wsIdx < wellResultFrame.m_wellResultBranches.size(); ++wsIdx) for (size_t wsIdx = 0; !hasCells && wsIdx < wellResultFrame.m_wellResultBranches.size(); ++wsIdx)
{ {
if (wellResultFrame.m_wellResultBranches[wsIdx].m_branchResultPoints.size() > 0 ) hasCells = true; if (wellResultFrame.m_wellResultBranches[wsIdx].m_branchResultPoints.size() > 0 ) hasCells = true;
@ -488,9 +488,9 @@ void RimEclipseWellCollection::assignDefaultWellColors()
for (size_t wIdx = 0; wIdx < wells.size(); ++wIdx) for (size_t wIdx = 0; wIdx < wells.size(); ++wIdx)
{ {
RimSimWellInView* well = wells[wIdx]; RimSimWellInView* well = wells[wIdx];
if (well && well->wellResults() ) if (well && well->simWellData() )
{ {
well->wellPipeColor = ownerCase->defaultWellColor(well->wellResults()->m_wellName); well->wellPipeColor = ownerCase->defaultWellColor(well->simWellData()->m_wellName);
} }
} }

42
ApplicationCode/ProjectDataModel/RimSimWellInView.cpp
View File

@ -21,7 +21,7 @@
#include "RimSimWellInView.h" #include "RimSimWellInView.h"
#include "RigSimulationWellCenterLineCalculator.h" #include "RigSimulationWellCenterLineCalculator.h"
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
#include "RimCellRangeFilterCollection.h" #include "RimCellRangeFilterCollection.h"
#include "RimEclipseView.h" #include "RimEclipseView.h"
@ -192,9 +192,9 @@ void RimSimWellInView::wellHeadTopBottomPosition(size_t frameIndex, cvf::Vec3d*
RigEclipseCaseData* rigReservoir = m_rimReservoirView->eclipseCase()->eclipseCaseData(); RigEclipseCaseData* rigReservoir = m_rimReservoirView->eclipseCase()->eclipseCaseData();
if (!this->wellResults()->hasWellResult(frameIndex)) return; if (!this->simWellData()->hasWellResult(frameIndex)) return;
const RigWellResultFrame& wellResultFrame = this->wellResults()->wellResultFrame(frameIndex); const RigWellResultFrame& wellResultFrame = this->simWellData()->wellResultFrame(frameIndex);
const RigCell& whCell = rigReservoir->cellFromWellResultCell(wellResultFrame.m_wellHead); const RigCell& whCell = rigReservoir->cellFromWellResultCell(wellResultFrame.m_wellHead);
// Match this position with pipe start position in RivWellPipesPartMgr::calculateWellPipeCenterline() // Match this position with pipe start position in RivWellPipesPartMgr::calculateWellPipeCenterline()
@ -261,11 +261,11 @@ double RimSimWellInView::pipeRadius()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RimSimWellInView::intersectsDynamicWellCellsFilteredCells(size_t frameIndex) const bool RimSimWellInView::intersectsDynamicWellCellsFilteredCells(size_t frameIndex) const
{ {
if (this->wellResults() == nullptr) return false; if (this->simWellData() == nullptr) return false;
if (!wellResults()->hasWellResult(frameIndex)) return false; if (!simWellData()->hasWellResult(frameIndex)) return false;
const RigWellResultFrame& wrsf = this->wellResults()->wellResultFrame(frameIndex); const RigWellResultFrame& wrsf = this->simWellData()->wellResultFrame(frameIndex);
return intersectsWellCellsFilteredCells(wrsf, frameIndex); return intersectsWellCellsFilteredCells(wrsf, frameIndex);
} }
@ -341,10 +341,10 @@ bool RimSimWellInView::intersectsWellCellsFilteredCells(const RigWellResultFrame
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RimSimWellInView::intersectsStaticWellCellsFilteredCells() const bool RimSimWellInView::intersectsStaticWellCellsFilteredCells() const
{ {
if (this->wellResults() == nullptr) return false; if (this->simWellData() == nullptr) return false;
// NOTE: Read out static well cells, union of well cells across all time steps // NOTE: Read out static well cells, union of well cells across all time steps
const RigWellResultFrame& wrsf = this->wellResults()->staticWellCells(); const RigWellResultFrame& wrsf = this->simWellData()->staticWellCells();
// NOTE: Use first time step for visibility evaluation // NOTE: Use first time step for visibility evaluation
size_t frameIndex = 0; size_t frameIndex = 0;
@ -428,7 +428,7 @@ bool RimSimWellInView::isWellCellsVisible() const
this->firstAncestorOrThisOfType(reservoirView); this->firstAncestorOrThisOfType(reservoirView);
if (reservoirView == nullptr) return false; if (reservoirView == nullptr) return false;
if (this->wellResults() == nullptr) return false; if (this->simWellData() == nullptr) return false;
if (!reservoirView->wellCollection()->isActive()) if (!reservoirView->wellCollection()->isActive())
return false; return false;
@ -462,14 +462,14 @@ bool RimSimWellInView::isWellPipeVisible(size_t frameIndex) const
this->firstAncestorOrThisOfType(reservoirView); this->firstAncestorOrThisOfType(reservoirView);
if (reservoirView == nullptr) return false; if (reservoirView == nullptr) return false;
if (this->wellResults() == nullptr) return false; if (this->simWellData() == nullptr) return false;
if (frameIndex >= this->wellResults()->m_resultTimeStepIndexToWellTimeStepIndex.size()) if (frameIndex >= this->simWellData()->m_resultTimeStepIndexToWellTimeStepIndex.size())
{ {
return false; return false;
} }
size_t wellTimeStepIndex = this->wellResults()->m_resultTimeStepIndexToWellTimeStepIndex[frameIndex]; size_t wellTimeStepIndex = this->simWellData()->m_resultTimeStepIndexToWellTimeStepIndex[frameIndex];
if (wellTimeStepIndex == cvf::UNDEFINED_SIZE_T) if (wellTimeStepIndex == cvf::UNDEFINED_SIZE_T)
{ {
return false; return false;
@ -508,14 +508,14 @@ bool RimSimWellInView::isWellSpheresVisible(size_t frameIndex) const
this->firstAncestorOrThisOfType(reservoirView); this->firstAncestorOrThisOfType(reservoirView);
if (reservoirView == nullptr) return false; if (reservoirView == nullptr) return false;
if (this->wellResults() == nullptr) return false; if (this->simWellData() == nullptr) return false;
if (frameIndex >= this->wellResults()->m_resultTimeStepIndexToWellTimeStepIndex.size()) if (frameIndex >= this->simWellData()->m_resultTimeStepIndexToWellTimeStepIndex.size())
{ {
return false; return false;
} }
size_t wellTimeStepIndex = this->wellResults()->m_resultTimeStepIndexToWellTimeStepIndex[frameIndex]; size_t wellTimeStepIndex = this->simWellData()->m_resultTimeStepIndexToWellTimeStepIndex[frameIndex];
if (wellTimeStepIndex == cvf::UNDEFINED_SIZE_T) if (wellTimeStepIndex == cvf::UNDEFINED_SIZE_T)
{ {
return false; return false;
@ -562,26 +562,26 @@ bool RimSimWellInView::isUsingCellCenterForPipe() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimSimWellInView::setWellResults(RigSingleWellResultsData* wellResults, size_t resultWellIndex) void RimSimWellInView::setSimWellData(RigSimWellData* simWellData, size_t resultWellIndex)
{ {
m_wellResults = wellResults; m_simWellData = simWellData;
m_resultWellIndex = resultWellIndex; m_resultWellIndex = resultWellIndex;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RigSingleWellResultsData* RimSimWellInView::wellResults() RigSimWellData* RimSimWellInView::simWellData()
{ {
return m_wellResults.p(); return m_simWellData.p();
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
const RigSingleWellResultsData* RimSimWellInView::wellResults() const const RigSimWellData* RimSimWellInView::simWellData() const
{ {
return m_wellResults.p(); return m_simWellData.p();
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

10
ApplicationCode/ProjectDataModel/RimSimWellInView.h
View File

@ -32,7 +32,7 @@
#include "cvfObject.h" #include "cvfObject.h"
#include "cvfVector3.h" #include "cvfVector3.h"
class RigSingleWellResultsData; class RigSimWellData;
class RigWellResultFrame; class RigWellResultFrame;
struct RigWellResultPoint; struct RigWellResultPoint;
@ -53,9 +53,9 @@ public:
RimSimWellInView(); RimSimWellInView();
virtual ~RimSimWellInView(); virtual ~RimSimWellInView();
void setWellResults(RigSingleWellResultsData* wellResults, size_t resultWellIndex); void setSimWellData(RigSimWellData* simWellData, size_t resultWellIndex);
RigSingleWellResultsData* wellResults(); RigSimWellData* simWellData();
const RigSingleWellResultsData* wellResults() const; const RigSimWellData* simWellData() const;
size_t resultWellIndex() const; size_t resultWellIndex() const;
bool isWellCellsVisible() const; bool isWellCellsVisible() const;
@ -110,6 +110,6 @@ private:
bool intersectsWellCellsFilteredCells(const RigWellResultFrame &wrsf, size_t frameIndex) const; bool intersectsWellCellsFilteredCells(const RigWellResultFrame &wrsf, size_t frameIndex) const;
private: private:
cvf::ref<RigSingleWellResultsData> m_wellResults; cvf::ref<RigSimWellData> m_simWellData;
size_t m_resultWellIndex; size_t m_resultWellIndex;
}; };

14
ApplicationCode/ProjectDataModel/RimWellLogExtractionCurve.cpp
View File

@ -30,7 +30,7 @@
#include "RigResultAccessorFactory.h" #include "RigResultAccessorFactory.h"
#include "RigSimulationWellCenterLineCalculator.h" #include "RigSimulationWellCenterLineCalculator.h"
#include "RigSimulationWellCoordsAndMD.h" #include "RigSimulationWellCoordsAndMD.h"
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
#include "RigWellLogCurveData.h" #include "RigWellLogCurveData.h"
#include "RigWellPath.h" #include "RigWellPath.h"
@ -420,11 +420,11 @@ std::set<QString> RimWellLogExtractionCurve::findSortedWellNames()
if ( eclipseCase && eclipseCase->eclipseCaseData() ) if ( eclipseCase && eclipseCase->eclipseCaseData() )
{ {
const cvf::Collection<RigSingleWellResultsData>& wellRes = eclipseCase->eclipseCaseData()->wellResults(); const cvf::Collection<RigSimWellData>& simWellData = eclipseCase->eclipseCaseData()->wellResults();
for ( size_t wIdx = 0; wIdx < wellRes.size(); ++wIdx ) for ( size_t wIdx = 0; wIdx < simWellData.size(); ++wIdx )
{ {
sortedWellNames.insert(wellRes[wIdx]->m_wellName); sortedWellNames.insert(simWellData[wIdx]->m_wellName);
} }
} }
@ -448,15 +448,15 @@ void RimWellLogExtractionCurve::updateGeneratedSimulationWellpath()
} }
RigEclipseCaseData* eclCaseData = eclipseCase->eclipseCaseData(); RigEclipseCaseData* eclCaseData = eclipseCase->eclipseCaseData();
const RigSingleWellResultsData* wellResults = eclCaseData->findWellResult(m_simWellName()); const RigSimWellData* simWellData = eclCaseData->findSimWellData(m_simWellName());
if (!wellResults) return; if (!simWellData) return;
std::vector< std::vector <cvf::Vec3d> > pipeBranchesCLCoords; std::vector< std::vector <cvf::Vec3d> > pipeBranchesCLCoords;
std::vector< std::vector <RigWellResultPoint> > pipeBranchesCellIds; std::vector< std::vector <RigWellResultPoint> > pipeBranchesCellIds;
RigSimulationWellCenterLineCalculator::calculateWellPipeCenterlineFromWellFrame(eclCaseData, RigSimulationWellCenterLineCalculator::calculateWellPipeCenterlineFromWellFrame(eclCaseData,
wellResults, simWellData,
-1, -1,
true, true,
true, true,

4
ApplicationCode/ReservoirDataModel/CMakeLists_files.cmake
View File

@ -36,7 +36,7 @@ ${CEE_CURRENT_LIST_DIR}RigLocalGrid.h
${CEE_CURRENT_LIST_DIR}RigMainGrid.h ${CEE_CURRENT_LIST_DIR}RigMainGrid.h
${CEE_CURRENT_LIST_DIR}RigReservoirBuilderMock.h ${CEE_CURRENT_LIST_DIR}RigReservoirBuilderMock.h
${CEE_CURRENT_LIST_DIR}RigCaseCellResultsData.h ${CEE_CURRENT_LIST_DIR}RigCaseCellResultsData.h
${CEE_CURRENT_LIST_DIR}RigSingleWellResultsData.h ${CEE_CURRENT_LIST_DIR}RigSimWellData.h
${CEE_CURRENT_LIST_DIR}RigWellPath.h ${CEE_CURRENT_LIST_DIR}RigWellPath.h
${CEE_CURRENT_LIST_DIR}RigFault.h ${CEE_CURRENT_LIST_DIR}RigFault.h
${CEE_CURRENT_LIST_DIR}RigNNCData.h ${CEE_CURRENT_LIST_DIR}RigNNCData.h
@ -109,7 +109,7 @@ ${CEE_CURRENT_LIST_DIR}RigLocalGrid.cpp
${CEE_CURRENT_LIST_DIR}RigMainGrid.cpp ${CEE_CURRENT_LIST_DIR}RigMainGrid.cpp
${CEE_CURRENT_LIST_DIR}RigReservoirBuilderMock.cpp ${CEE_CURRENT_LIST_DIR}RigReservoirBuilderMock.cpp
${CEE_CURRENT_LIST_DIR}RigCaseCellResultsData.cpp ${CEE_CURRENT_LIST_DIR}RigCaseCellResultsData.cpp
${CEE_CURRENT_LIST_DIR}RigSingleWellResultsData.cpp ${CEE_CURRENT_LIST_DIR}RigSimWellData.cpp
${CEE_CURRENT_LIST_DIR}RigWellPath.cpp ${CEE_CURRENT_LIST_DIR}RigWellPath.cpp
${CEE_CURRENT_LIST_DIR}RigFault.cpp ${CEE_CURRENT_LIST_DIR}RigFault.cpp
${CEE_CURRENT_LIST_DIR}RigNNCData.cpp ${CEE_CURRENT_LIST_DIR}RigNNCData.cpp

2
ApplicationCode/ReservoirDataModel/RigAccWellFlowCalculator.cpp
View File

@ -18,7 +18,7 @@
#include "RigAccWellFlowCalculator.h" #include "RigAccWellFlowCalculator.h"
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
#include "RigMainGrid.h" #include "RigMainGrid.h"
#include "RigActiveCellInfo.h" #include "RigActiveCellInfo.h"
#include "RigFlowDiagResults.h" #include "RigFlowDiagResults.h"

24
ApplicationCode/ReservoirDataModel/RigEclipseCaseData.cpp
View File

@ -25,7 +25,7 @@
#include "RigFormationNames.h" #include "RigFormationNames.h"
#include "RigMainGrid.h" #include "RigMainGrid.h"
#include "RigResultAccessorFactory.h" #include "RigResultAccessorFactory.h"
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
#include <QDebug> #include <QDebug>
#include "RigSimulationWellCenterLineCalculator.h" #include "RigSimulationWellCenterLineCalculator.h"
@ -206,12 +206,12 @@ void RigEclipseCaseData::computeWellCellsPrGrid()
// Fill arrays with data // Fill arrays with data
size_t wIdx; size_t wIdx;
for (wIdx = 0; wIdx < m_wellResults.size(); ++wIdx) for (wIdx = 0; wIdx < m_simWellData.size(); ++wIdx)
{ {
size_t tIdx; size_t tIdx;
for (tIdx = 0; tIdx < m_wellResults[wIdx]->m_wellCellsTimeSteps.size(); ++tIdx) for (tIdx = 0; tIdx < m_simWellData[wIdx]->m_wellCellsTimeSteps.size(); ++tIdx)
{ {
RigWellResultFrame& wellCells = m_wellResults[wIdx]->m_wellCellsTimeSteps[tIdx]; RigWellResultFrame& wellCells = m_simWellData[wIdx]->m_wellCellsTimeSteps[tIdx];
// Well head // Well head
{ {
@ -257,9 +257,9 @@ void RigEclipseCaseData::computeWellCellsPrGrid()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RigEclipseCaseData::setWellResults(const cvf::Collection<RigSingleWellResultsData>& data) void RigEclipseCaseData::setSimWellData(const cvf::Collection<RigSimWellData>& data)
{ {
m_wellResults = data; m_simWellData = data;
m_wellCellsInGrid.clear(); m_wellCellsInGrid.clear();
m_gridCellToResultWellIndex.clear(); m_gridCellToResultWellIndex.clear();
@ -270,11 +270,11 @@ void RigEclipseCaseData::setWellResults(const cvf::Collection<RigSingleWellResul
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
const RigSingleWellResultsData* RigEclipseCaseData::findWellResult(QString wellName) const const RigSimWellData* RigEclipseCaseData::findSimWellData(QString wellName) const
{ {
for (size_t wIdx = 0; wIdx < m_wellResults.size(); ++wIdx) for (size_t wIdx = 0; wIdx < m_simWellData.size(); ++wIdx)
{ {
if (m_wellResults[wIdx]->m_wellName == wellName) return m_wellResults[wIdx].p(); if (m_simWellData[wIdx]->m_wellName == wellName) return m_simWellData[wIdx].p();
} }
return nullptr; return nullptr;
@ -473,15 +473,15 @@ std::vector<const RigWellPath*> RigEclipseCaseData::simulationWellBranches(const
return branches; return branches;
} }
const RigSingleWellResultsData* wellResults = findWellResult(simWellName); const RigSimWellData* simWellData = findSimWellData(simWellName);
if (!wellResults) return branches; if (!simWellData) return branches;
std::vector< std::vector <cvf::Vec3d> > pipeBranchesCLCoords; std::vector< std::vector <cvf::Vec3d> > pipeBranchesCLCoords;
std::vector< std::vector <RigWellResultPoint> > pipeBranchesCellIds; std::vector< std::vector <RigWellResultPoint> > pipeBranchesCellIds;
RigSimulationWellCenterLineCalculator::calculateWellPipeCenterlineFromWellFrame(this, RigSimulationWellCenterLineCalculator::calculateWellPipeCenterlineFromWellFrame(this,
wellResults, simWellData,
-1, -1,
true, true,
true, true,

10
ApplicationCode/ReservoirDataModel/RigEclipseCaseData.h
View File

@ -42,7 +42,7 @@ class RigMainGrid;
class RigGridBase; class RigGridBase;
class RigCaseCellResultsData; class RigCaseCellResultsData;
class RigActiveCellInfo; class RigActiveCellInfo;
class RigSingleWellResultsData; class RigSimWellData;
class RigCell; class RigCell;
class RigWellPath; class RigWellPath;
class RimEclipseCase; class RimEclipseCase;
@ -80,9 +80,9 @@ public:
void setActiveFormationNames(RigFormationNames* activeFormationNames); void setActiveFormationNames(RigFormationNames* activeFormationNames);
RigFormationNames* activeFormationNames(); RigFormationNames* activeFormationNames();
void setWellResults(const cvf::Collection<RigSingleWellResultsData>& data); void setSimWellData(const cvf::Collection<RigSimWellData>& data);
const cvf::Collection<RigSingleWellResultsData>& wellResults() const { return m_wellResults; } const cvf::Collection<RigSimWellData>& wellResults() const { return m_simWellData; }
const RigSingleWellResultsData* findWellResult(QString wellName) const; const RigSimWellData* findSimWellData(QString wellName) const;
const cvf::UByteArray* wellCellsInGrid(size_t gridIndex); const cvf::UByteArray* wellCellsInGrid(size_t gridIndex);
const cvf::UIntArray* gridCellToResultWellIndex(size_t gridIndex); const cvf::UIntArray* gridCellToResultWellIndex(size_t gridIndex);
@ -116,7 +116,7 @@ private:
cvf::ref<RigFormationNames> m_activeFormationNamesData; cvf::ref<RigFormationNames> m_activeFormationNamesData;
cvf::Collection<RigSingleWellResultsData> m_wellResults; //< A WellResults object for each well in the reservoir cvf::Collection<RigSimWellData> m_simWellData; //< A WellResults object for each well in the reservoir
cvf::Collection<cvf::UByteArray> m_wellCellsInGrid; //< A bool array pr grid with one bool pr cell telling whether the cell is a well cell or not cvf::Collection<cvf::UByteArray> m_wellCellsInGrid; //< A bool array pr grid with one bool pr cell telling whether the cell is a well cell or not
cvf::Collection<cvf::UIntArray> m_gridCellToResultWellIndex; //< Array pr grid with index to well pr cell telling which well a cell is in cvf::Collection<cvf::UIntArray> m_gridCellToResultWellIndex; //< Array pr grid with index to well pr cell telling which well a cell is in

8
ApplicationCode/ReservoirDataModel/RigReservoirBuilderMock.cpp
View File

@ -24,7 +24,7 @@
#include "RigEclipseCaseData.h" #include "RigEclipseCaseData.h"
#include "RigCell.h" #include "RigCell.h"
#include "RigMainGrid.h" #include "RigMainGrid.h"
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
/* rand example: guess the number */ /* rand example: guess the number */
#include <stdio.h> #include <stdio.h>
@ -372,12 +372,12 @@ void RigReservoirBuilderMock::addWellData(RigEclipseCaseData* eclipseCase, RigGr
cvf::Vec3st dim = grid->gridPointDimensions(); cvf::Vec3st dim = grid->gridPointDimensions();
cvf::Collection<RigSingleWellResultsData> wells; cvf::Collection<RigSimWellData> wells;
int wellIdx; int wellIdx;
for (wellIdx = 0; wellIdx < 1; wellIdx++) for (wellIdx = 0; wellIdx < 1; wellIdx++)
{ {
cvf::ref<RigSingleWellResultsData> wellCellsTimeHistory = new RigSingleWellResultsData; cvf::ref<RigSimWellData> wellCellsTimeHistory = new RigSimWellData;
wellCellsTimeHistory->m_wellName = QString("Well %1").arg(wellIdx); wellCellsTimeHistory->m_wellName = QString("Well %1").arg(wellIdx);
wellCellsTimeHistory->m_wellCellsTimeSteps.resize(m_timeStepCount); wellCellsTimeHistory->m_wellCellsTimeSteps.resize(m_timeStepCount);
@ -474,7 +474,7 @@ void RigReservoirBuilderMock::addWellData(RigEclipseCaseData* eclipseCase, RigGr
wells.push_back(wellCellsTimeHistory.p()); wells.push_back(wellCellsTimeHistory.p());
} }
eclipseCase->setWellResults(wells); eclipseCase->setSimWellData(wells);
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

21
ApplicationCode/ReservoirDataModel/RigSingleWellResultsData.cpp → ApplicationCode/ReservoirDataModel/RigSimWellData.cpp
View File

@ -16,7 +16,8 @@
// //
///////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
#include <map> #include <map>
#include <QDebug> #include <QDebug>
@ -24,7 +25,7 @@
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
const RigWellResultFrame& RigSingleWellResultsData::wellResultFrame(size_t resultTimeStepIndex) const const RigWellResultFrame& RigSimWellData::wellResultFrame(size_t resultTimeStepIndex) const
{ {
CVF_ASSERT(resultTimeStepIndex < m_resultTimeStepIndexToWellTimeStepIndex.size()); CVF_ASSERT(resultTimeStepIndex < m_resultTimeStepIndexToWellTimeStepIndex.size());
@ -37,7 +38,7 @@ const RigWellResultFrame& RigSingleWellResultsData::wellResultFrame(size_t resul
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RigSingleWellResultsData::computeMappingFromResultTimeIndicesToWellTimeIndices(const std::vector<QDateTime>& simulationTimeSteps) void RigSimWellData::computeMappingFromResultTimeIndicesToWellTimeIndices(const std::vector<QDateTime>& simulationTimeSteps)
{ {
m_resultTimeStepIndexToWellTimeStepIndex.clear(); m_resultTimeStepIndexToWellTimeStepIndex.clear();
if (m_wellCellsTimeSteps.size() == 0) return; if (m_wellCellsTimeSteps.size() == 0) return;
@ -84,7 +85,7 @@ void RigSingleWellResultsData::computeMappingFromResultTimeIndicesToWellTimeIndi
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RigSingleWellResultsData::hasWellResult(size_t resultTimeStepIndex) const bool RigSimWellData::hasWellResult(size_t resultTimeStepIndex) const
{ {
if (resultTimeStepIndex >= m_resultTimeStepIndexToWellTimeStepIndex.size()) if (resultTimeStepIndex >= m_resultTimeStepIndexToWellTimeStepIndex.size())
{ {
@ -108,7 +109,7 @@ bool operator== (const RigWellResultPoint& p1, const RigWellResultPoint& p2)
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RigSingleWellResultsData::computeStaticWellCellPath() const void RigSimWellData::computeStaticWellCellPath() const
{ {
if (m_wellCellsTimeSteps.size() == 0) return; if (m_wellCellsTimeSteps.size() == 0) return;
@ -249,7 +250,7 @@ void RigSingleWellResultsData::computeStaticWellCellPath() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RigSingleWellResultsData::setMultiSegmentWell(bool isMultiSegmentWell) void RigSimWellData::setMultiSegmentWell(bool isMultiSegmentWell)
{ {
m_isMultiSegmentWell = isMultiSegmentWell; m_isMultiSegmentWell = isMultiSegmentWell;
} }
@ -257,7 +258,7 @@ void RigSingleWellResultsData::setMultiSegmentWell(bool isMultiSegmentWell)
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RigSingleWellResultsData::isMultiSegmentWell() const bool RigSimWellData::isMultiSegmentWell() const
{ {
return m_isMultiSegmentWell; return m_isMultiSegmentWell;
} }
@ -266,7 +267,7 @@ bool RigSingleWellResultsData::isMultiSegmentWell() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RigWellResultFrame::WellProductionType RigSingleWellResultsData::wellProductionType(size_t resultTimeStepIndex) const RigWellResultFrame::WellProductionType RigSimWellData::wellProductionType(size_t resultTimeStepIndex) const
{ {
if (hasWellResult(resultTimeStepIndex)) if (hasWellResult(resultTimeStepIndex))
{ {
@ -282,7 +283,7 @@ RigWellResultFrame::WellProductionType RigSingleWellResultsData::wellProductionT
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
const RigWellResultFrame& RigSingleWellResultsData::staticWellCells() const const RigWellResultFrame& RigSimWellData::staticWellCells() const
{ {
// Make sure we have computed the static representation of the well // Make sure we have computed the static representation of the well
if (m_staticWellCells.m_wellResultBranches.size() == 0) if (m_staticWellCells.m_wellResultBranches.size() == 0)
@ -296,7 +297,7 @@ const RigWellResultFrame& RigSingleWellResultsData::staticWellCells() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RigSingleWellResultsData::isOpen(size_t resultTimeStepIndex) const bool RigSimWellData::isOpen(size_t resultTimeStepIndex) const
{ {
if (hasWellResult(resultTimeStepIndex)) if (hasWellResult(resultTimeStepIndex))
{ {

4
ApplicationCode/ReservoirDataModel/RigSingleWellResultsData.h → ApplicationCode/ReservoirDataModel/RigSimWellData.h
View File

@ -178,10 +178,10 @@ public:
//================================================================================================== //==================================================================================================
/// ///
//================================================================================================== //==================================================================================================
class RigSingleWellResultsData : public cvf::Object class RigSimWellData : public cvf::Object
{ {
public: public:
RigSingleWellResultsData() { m_isMultiSegmentWell = false; } RigSimWellData() { m_isMultiSegmentWell = false; }
void setMultiSegmentWell(bool isMultiSegmentWell); void setMultiSegmentWell(bool isMultiSegmentWell);
bool isMultiSegmentWell() const; bool isMultiSegmentWell() const;

6
ApplicationCode/ReservoirDataModel/RigSimulationWellCenterLineCalculator.cpp
View File

@ -52,7 +52,7 @@ void RigSimulationWellCenterLineCalculator::calculateWellPipeDynamicCenterline(c
{ {
CVF_ASSERT(rimWell); CVF_ASSERT(rimWell);
const RigSingleWellResultsData* wellResults = rimWell->wellResults(); const RigSimWellData* simWellData = rimWell->simWellData();
RimEclipseView* eclipseView; RimEclipseView* eclipseView;
rimWell->firstAncestorOrThisOfType(eclipseView); rimWell->firstAncestorOrThisOfType(eclipseView);
@ -65,7 +65,7 @@ void RigSimulationWellCenterLineCalculator::calculateWellPipeDynamicCenterline(c
bool useAllCellCenters = rimWell->isUsingCellCenterForPipe(); bool useAllCellCenters = rimWell->isUsingCellCenterForPipe();
calculateWellPipeCenterlineFromWellFrame(eclipseCaseData, calculateWellPipeCenterlineFromWellFrame(eclipseCaseData,
wellResults, simWellData,
static_cast<int>(timeStepIndex), static_cast<int>(timeStepIndex),
isAutoDetectBranches, isAutoDetectBranches,
useAllCellCenters, useAllCellCenters,
@ -79,7 +79,7 @@ void RigSimulationWellCenterLineCalculator::calculateWellPipeDynamicCenterline(c
/// and are describing the lines between the points, starting with the first line /// and are describing the lines between the points, starting with the first line
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RigSimulationWellCenterLineCalculator::calculateWellPipeCenterlineFromWellFrame(const RigEclipseCaseData* eclipseCaseData, void RigSimulationWellCenterLineCalculator::calculateWellPipeCenterlineFromWellFrame(const RigEclipseCaseData* eclipseCaseData,
const RigSingleWellResultsData* wellResults, const RigSimWellData* wellResults,
int timeStepIndex, int timeStepIndex,
bool isAutoDetectBranches, bool isAutoDetectBranches,
bool useAllCellCenters, bool useAllCellCenters,

4
ApplicationCode/ReservoirDataModel/RigSimulationWellCenterLineCalculator.h
View File

@ -18,7 +18,7 @@
///////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////
#pragma once #pragma once
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
#include "cvfVector3.h" #include "cvfVector3.h"
#include <vector> #include <vector>
@ -39,7 +39,7 @@ public:
static void calculateWellPipeCenterlineFromWellFrame(const RigEclipseCaseData* eclipseCaseData, static void calculateWellPipeCenterlineFromWellFrame(const RigEclipseCaseData* eclipseCaseData,
const RigSingleWellResultsData* wellResults, const RigSimWellData* simWellData,
int timeStepIndex, int timeStepIndex,
bool isAutoDetectBranches, bool isAutoDetectBranches,
bool useAllCellCenters, bool useAllCellCenters,

1
ApplicationCode/ReservoirDataModel/RigTofAccumulatedPhaseFractionsCalculator.cpp
View File

@ -27,7 +27,6 @@
#include "RigFlowDiagResults.h" #include "RigFlowDiagResults.h"
#include "RigResultAccessor.h" #include "RigResultAccessor.h"
#include "RigResultAccessorFactory.h" #include "RigResultAccessorFactory.h"
#include "RigSingleWellResultsData.h"
#include "RimEclipseResultCase.h" #include "RimEclipseResultCase.h"
#include "RimFlowDiagSolution.h" #include "RimFlowDiagSolution.h"

12
ApplicationCode/SocketInterface/RiaWellDataCommands.cpp
View File

@ -24,7 +24,7 @@
#include "RigGridBase.h" #include "RigGridBase.h"
#include "RigEclipseCaseData.h" #include "RigEclipseCaseData.h"
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
#include "RimEclipseCase.h" #include "RimEclipseCase.h"
@ -55,7 +55,7 @@ public:
std::vector<QString> wellNames; std::vector<QString> wellNames;
const cvf::Collection<RigSingleWellResultsData>& wells = rimCase->eclipseCaseData()->wellResults(); const cvf::Collection<RigSimWellData>& wells = rimCase->eclipseCaseData()->wellResults();
for (size_t wIdx = 0; wIdx < wells.size(); ++wIdx) for (size_t wIdx = 0; wIdx < wells.size(); ++wIdx)
{ {
@ -112,8 +112,8 @@ public:
std::vector<size_t> requestedTimesteps; std::vector<size_t> requestedTimesteps;
//First find the well result for the correct well //First find the well result for the correct well
const cvf::Collection<RigSingleWellResultsData>& allWellRes = rimCase->eclipseCaseData()->wellResults(); const cvf::Collection<RigSimWellData>& allWellRes = rimCase->eclipseCaseData()->wellResults();
cvf::ref<RigSingleWellResultsData> currentWellResult; cvf::ref<RigSimWellData> currentWellResult;
for (size_t tsIdx = 0; tsIdx < allWellRes.size(); ++tsIdx) for (size_t tsIdx = 0; tsIdx < allWellRes.size(); ++tsIdx)
{ {
if (allWellRes[tsIdx]->m_wellName == wellName) if (allWellRes[tsIdx]->m_wellName == wellName)
@ -247,8 +247,8 @@ public:
return true; return true;
} }
const cvf::Collection<RigSingleWellResultsData>& allWellRes = rimCase->eclipseCaseData()->wellResults(); const cvf::Collection<RigSimWellData>& allWellRes = rimCase->eclipseCaseData()->wellResults();
cvf::ref<RigSingleWellResultsData> currentWellResult; cvf::ref<RigSimWellData> currentWellResult;
for (size_t cIdx = 0; cIdx < allWellRes.size(); ++cIdx) for (size_t cIdx = 0; cIdx < allWellRes.size(); ++cIdx)
{ {
if (allWellRes[cIdx]->m_wellName == wellName) if (allWellRes[cIdx]->m_wellName == wellName)

8
ApplicationCode/UserInterface/RiuResultTextBuilder.cpp
View File

@ -25,7 +25,7 @@
#include "RigMainGrid.h" #include "RigMainGrid.h"
#include "RigResultAccessor.h" #include "RigResultAccessor.h"
#include "RigResultAccessorFactory.h" #include "RigResultAccessorFactory.h"
#include "RigSingleWellResultsData.h" #include "RigSimWellData.h"
#include "RimCellEdgeColors.h" #include "RimCellEdgeColors.h"
#include "RimEclipseCase.h" #include "RimEclipseCase.h"
@ -738,10 +738,10 @@ QString RiuResultTextBuilder::wellResultText()
if (m_reservoirView->eclipseCase() && if (m_reservoirView->eclipseCase() &&
m_reservoirView->eclipseCase()->eclipseCaseData() ) m_reservoirView->eclipseCase()->eclipseCaseData() )
{ {
cvf::Collection<RigSingleWellResultsData> wellResults = m_reservoirView->eclipseCase()->eclipseCaseData()->wellResults(); cvf::Collection<RigSimWellData> simWellData = m_reservoirView->eclipseCase()->eclipseCaseData()->wellResults();
for (size_t i = 0; i < wellResults.size(); i++) for (size_t i = 0; i < simWellData.size(); i++)
{ {
RigSingleWellResultsData* singleWellResultData = wellResults.at(i); RigSimWellData* singleWellResultData = simWellData.at(i);
if (!singleWellResultData->hasWellResult(m_timeStepIndex)) if (!singleWellResultData->hasWellResult(m_timeStepIndex))
{ {