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 RimEclipseWell -> RimSimWellInView

Browse Source
This commit is contained in:
Rebecca Cox 2017-10-13 09:29:42 +02:00
parent 3e986a63a1
commit d748803159
72 changed files with 329 additions and 328 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
ApplicationCode/CommandFileInterface/RicfExportSimWellCompletions.cpp
View File

@ -23,16 +23,16 @@
#include "RiaApplication.h"
#include "RiaLogging.h"
#include "RimProject.h"
#include "RimOilField.h"
#include "RimEclipseCaseCollection.h"
#include "RimEclipseCase.h"
#include "RimEclipseWell.h"
#include "RimEclipseCaseCollection.h"
#include "RimEclipseView.h"
#include "RimEclipseWellCollection.h"
#include "RimEclipseWell.h"
#include "RimWellPathCollection.h"
#include "RimOilField.h"
#include "RimProject.h"
#include "RimSimWellInView.h"
#include "RimSimWellInView.h"
#include "RimWellPath.h"
#include "RimWellPathCollection.h"
#include "CompletionCommands/RicWellPathExportCompletionDataFeature.h"
@ -100,7 +100,7 @@ void RicfExportSimWellCompletions::execute()
return;
}
std::vector<RimEclipseWell*> simWells;
std::vector<RimSimWellInView*> simWells;
if (m_wellPathNames().empty())
{
std::copy(view->wellCollection->wells.begin(),
@ -111,7 +111,7 @@ void RicfExportSimWellCompletions::execute()
{
for (const QString& wellPathName : m_wellPathNames())
{
RimEclipseWell* simWell = view->wellCollection->findWell(wellPathName);
RimSimWellInView* simWell = view->wellCollection->findWell(wellPathName);
if (simWell)
{
simWells.push_back(simWell);

2
ApplicationCode/CommandFileInterface/RicfExportWellPathCompletions.cpp
View File

@ -112,7 +112,7 @@ void RicfExportWellPathCompletions::execute()
}
}
std::vector<RimEclipseWell*> simWells;
std::vector<RimSimWellInView*> simWells;
RicWellPathExportCompletionDataFeature::exportCompletions(wellPaths, simWells, exportSettings);
}

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

@ -23,14 +23,14 @@
#include "RicExportCompletionDataSettingsUi.h"
#include "RimEclipseCase.h"
#include "RimFracture.h"
#include "RimWellPath.h"
#include "RimFractureTemplate.h"
#include "RimEclipseView.h"
#include "RimEclipseWell.h"
#include "RimSimWellFractureCollection.h"
#include "RimStimPlanFractureTemplate.h"
#include "RimFracture.h"
#include "RimFractureTemplate.h"
#include "RimSimWellFracture.h"
#include "RimSimWellFractureCollection.h"
#include "RimSimWellInView.h"
#include "RimStimPlanFractureTemplate.h"
#include "RimWellPath.h"
#include "RimWellPathCompletions.h"
#include "RigEclipseCaseData.h"
@ -70,7 +70,7 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdat
///
//--------------------------------------------------------------------------------------------------
std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdatValuesForSimWell(RimEclipseCase* eclipseCase,
const RimEclipseWell* well,
const RimSimWellInView* well,
QTextStream* outputStreamForIntermediateResultsText)
{
std::vector<RigCompletionData> completionData;

4
ApplicationCode/Commands/CompletionCommands/RicExportFractureCompletionsImpl.h
View File

@ -29,8 +29,8 @@ class RicExportCompletionDataSettingsUi;
class QTextStream;
class RigWellPath;
class RimEclipseCase;
class RimEclipseWell;
class RimFracture;
class RimSimWellInView;
//--------------------------------------------------------------------------------------------------
///
@ -43,7 +43,7 @@ public:
QTextStream* outputStreamForIntermediateResultsText);
static std::vector<RigCompletionData> generateCompdatValuesForSimWell(RimEclipseCase* eclipseCase,
const RimEclipseWell* well,
const RimSimWellInView* well,
QTextStream* outputStreamForIntermediateResultsText);
private:

18
ApplicationCode/Commands/CompletionCommands/RicWellPathExportCompletionDataFeature.cpp
View File

@ -38,6 +38,7 @@
#include "RigWellPath.h"
#include "RigWellPathIntersectionTools.h"
#include "RimEclipseWellCollection.h"
#include "RimFishboneWellPath.h"
#include "RimFishboneWellPathCollection.h"
#include "RimFishbonesCollection.h"
@ -45,8 +46,7 @@
#include "RimPerforationCollection.h"
#include "RimPerforationInterval.h"
#include "RimProject.h"
#include "RimEclipseWell.h"
#include "RimEclipseWellCollection.h"
#include "RimSimWellInView.h"
#include "RimWellPath.h"
#include "RimWellPathCollection.h"
#include "RimWellPathCompletions.h"
@ -71,7 +71,7 @@ CAF_CMD_SOURCE_INIT(RicWellPathExportCompletionDataFeature, "RicWellPathExportCo
bool RicWellPathExportCompletionDataFeature::isCommandEnabled()
{
std::vector<RimWellPath*> wellPaths = selectedWellPaths();
std::vector<RimEclipseWell*> simWells = selectedSimWells();
std::vector<RimSimWellInView*> simWells = selectedSimWells();
if (wellPaths.empty() && simWells.empty())
{
@ -104,7 +104,7 @@ bool RicWellPathExportCompletionDataFeature::isCommandEnabled()
void RicWellPathExportCompletionDataFeature::onActionTriggered(bool isChecked)
{
std::vector<RimWellPath*> wellPaths = selectedWellPaths();
std::vector<RimEclipseWell*> simWells = selectedSimWells();
std::vector<RimSimWellInView*> simWells = selectedSimWells();
CVF_ASSERT(wellPaths.size() > 0 || simWells.size() > 0);
@ -199,9 +199,9 @@ bool RicWellPathExportCompletionDataFeature::noWellPathsSelectedDirectly()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimEclipseWell*> RicWellPathExportCompletionDataFeature::selectedSimWells()
std::vector<RimSimWellInView*> RicWellPathExportCompletionDataFeature::selectedSimWells()
{
std::vector<RimEclipseWell*> simWells;
std::vector<RimSimWellInView*> simWells;
caf::SelectionManager::instance()->objectsByType(&simWells);
std::vector<RimEclipseWellCollection*> simWellCollections;
@ -215,7 +215,7 @@ std::vector<RimEclipseWell*> RicWellPathExportCompletionDataFeature::selectedSim
}
}
std::set<RimEclipseWell*> uniqueSimWells(simWells.begin(), simWells.end());
std::set<RimSimWellInView*> uniqueSimWells(simWells.begin(), simWells.end());
simWells.assign(uniqueSimWells.begin(), uniqueSimWells.end());
return simWells;
@ -225,7 +225,7 @@ std::vector<RimEclipseWell*> RicWellPathExportCompletionDataFeature::selectedSim
///
//--------------------------------------------------------------------------------------------------
void RicWellPathExportCompletionDataFeature::exportCompletions(const std::vector<RimWellPath*>& wellPaths,
const std::vector<RimEclipseWell*>& simWells,
const std::vector<RimSimWellInView*>& simWells,
const RicExportCompletionDataSettingsUi& exportSettings)
{
@ -262,7 +262,7 @@ void RicWellPathExportCompletionDataFeature::exportCompletions(const std::vector
break;
}
}
for (const RimEclipseWell* simWell : simWells)
for (const RimSimWellInView* simWell : simWells)
{
RimEclipseCase* eclipseCase;
simWell->firstAncestorOrThisOfType(eclipseCase);

12
ApplicationCode/Commands/CompletionCommands/RicWellPathExportCompletionDataFeature.h
View File

@ -31,13 +31,13 @@
#include "cvfBoundingBox.h"
class RimWellPath;
class RimEclipseCase;
class RimEclipseWell;
class RigCell;
class RigEclipseCaseData;
class RigMainGrid;
class RigCell;
class RimEclipseCase;
class RimFishbonesMultipleSubs;
class RimSimWellInView;
class RimWellPath;
//==================================================================================================
///
@ -129,7 +129,7 @@ protected:
virtual void setupActionLook(QAction* actionToSetup) override;
std::vector<RimWellPath*> selectedWellPaths();
std::vector<RimEclipseWell*> selectedSimWells();
std::vector<RimSimWellInView*> selectedSimWells();
bool noWellPathsSelectedDirectly();
@ -156,7 +156,7 @@ public:
double wellRadius,
size_t cellIndex,
CellDirection direction);
static void exportCompletions(const std::vector<RimWellPath*>& wellPaths, const std::vector<RimEclipseWell*>& simWells, const RicExportCompletionDataSettingsUi& exportSettings);
static void exportCompletions(const std::vector<RimWellPath*>& wellPaths, const std::vector<RimSimWellInView*>& simWells, const RicExportCompletionDataSettingsUi& exportSettings);
private:
static RigCompletionData combineEclipseCellCompletions(const std::vector<RigCompletionData>& completions,

10
ApplicationCode/Commands/CrossSectionCommands/RicNewSimWellIntersectionFeature.cpp
View File

@ -19,10 +19,10 @@
#include "RicNewSimWellIntersectionFeature.h"
#include "RimEclipseView.h"
#include "RimIntersection.h"
#include "RimIntersectionCollection.h"
#include "RimEclipseView.h"
#include "RimEclipseWell.h"
#include "RimSimWellInView.h"
#include "cafCmdExecCommandManager.h"
#include "cafSelectionManager.h"
@ -46,11 +46,11 @@ bool RicNewSimWellIntersectionFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
void RicNewSimWellIntersectionFeature::onActionTriggered(bool isChecked)
{
std::vector<RimEclipseWell*> collection;
std::vector<RimSimWellInView*> collection;
caf::SelectionManager::instance()->objectsByType(&collection);
CVF_ASSERT(collection.size() == 1);
RimEclipseWell* eclWell = collection[0];
RimSimWellInView* eclWell = collection[0];
RimEclipseView* eclView = NULL;
eclWell->firstAncestorOrThisOfType(eclView);
@ -72,7 +72,7 @@ void RicNewSimWellIntersectionFeature::setupActionLook(QAction* actionToSetup)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RicNewSimWellIntersectionCmd::RicNewSimWellIntersectionCmd(RimIntersectionCollection* intersectionCollection, RimEclipseWell* simWell)
RicNewSimWellIntersectionCmd::RicNewSimWellIntersectionCmd(RimIntersectionCollection* intersectionCollection, RimSimWellInView* simWell)
: CmdExecuteCommand(NULL),
m_intersectionCollection(intersectionCollection),
m_simWell(simWell)

6
ApplicationCode/Commands/CrossSectionCommands/RicNewSimWellIntersectionFeature.h
View File

@ -24,7 +24,7 @@
#include "cafPdmPointer.h"
class RimIntersectionCollection;
class RimEclipseWell;
class RimSimWellInView;
//==================================================================================================
@ -33,7 +33,7 @@ class RimEclipseWell;
class RicNewSimWellIntersectionCmd : public caf::CmdExecuteCommand
{
public:
RicNewSimWellIntersectionCmd(RimIntersectionCollection* intersectionCollection, RimEclipseWell* simWell);
RicNewSimWellIntersectionCmd(RimIntersectionCollection* intersectionCollection, RimSimWellInView* simWell);
virtual ~RicNewSimWellIntersectionCmd();
virtual QString name();
@ -42,7 +42,7 @@ public:
private:
caf::PdmPointer<RimIntersectionCollection> m_intersectionCollection;
caf::PdmPointer<RimEclipseWell> m_simWell;
caf::PdmPointer<RimSimWellInView> m_simWell;
};

12
ApplicationCode/Commands/EclipseCommands/EclipseWell/RicEclipseWellFeatureImpl.cpp
View File

@ -18,8 +18,8 @@
#include "RicEclipseWellFeatureImpl.h"
#include "RimEclipseWell.h"
#include "RimEclipseWellCollection.h"
#include "RimSimWellInView.h"
#include "cafSelectionManager.h"
@ -30,7 +30,7 @@
//--------------------------------------------------------------------------------------------------
bool RicEclipseWellFeatureImpl::isAnyWellSelected()
{
std::vector<RimEclipseWell*> selection = selectedWells();
std::vector<RimSimWellInView*> selection = selectedWells();
if (selection.size() > 0)
{
return true;
@ -42,9 +42,9 @@ bool RicEclipseWellFeatureImpl::isAnyWellSelected()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimEclipseWell*> RicEclipseWellFeatureImpl::selectedWells()
std::vector<RimSimWellInView*> RicEclipseWellFeatureImpl::selectedWells()
{
std::vector<RimEclipseWell*> selection;
std::vector<RimSimWellInView*> selection;
caf::SelectionManager::instance()->objectsByType(&selection);
return selection;
@ -55,10 +55,10 @@ std::vector<RimEclipseWell*> RicEclipseWellFeatureImpl::selectedWells()
//--------------------------------------------------------------------------------------------------
RimEclipseWellCollection* RicEclipseWellFeatureImpl::wellCollectionFromSelection()
{
std::vector<RimEclipseWell*> selection = selectedWells();
std::vector<RimSimWellInView*> selection = selectedWells();
if (selection.size() > 0)
{
RimEclipseWell* firstWell = selection[0];
RimSimWellInView* firstWell = selection[0];
RimEclipseWellCollection* wellCollection = nullptr;
firstWell->firstAncestorOrThisOfType(wellCollection);

8
ApplicationCode/Commands/EclipseCommands/EclipseWell/RicEclipseWellFeatureImpl.h
View File

@ -20,8 +20,8 @@
#include <vector>
class RimEclipseWell;
class RimEclipseWellCollection;
class RimSimWellInView;
//==================================================================================================
///
@ -29,7 +29,7 @@ class RimEclipseWellCollection;
class RicEclipseWellFeatureImpl
{
public:
static bool isAnyWellSelected();
static std::vector<RimEclipseWell*> selectedWells();
static RimEclipseWellCollection* wellCollectionFromSelection();
static bool isAnyWellSelected();
static std::vector<RimSimWellInView*> selectedWells();
static RimEclipseWellCollection* wellCollectionFromSelection();
};

50
ApplicationCode/Commands/EclipseCommands/EclipseWell/RicEclipseWellShowFeatures.cpp
View File

@ -20,8 +20,8 @@
#include "RicEclipseWellFeatureImpl.h"
#include "RimEclipseWell.h"
#include "RimEclipseWellCollection.h"
#include "RimSimWellInView.h"
#include <QAction>
@ -34,8 +34,8 @@ CAF_CMD_SOURCE_INIT(RicEclipseWellShowLabelFeature, "RicEclipseWellShowLabelFeat
//--------------------------------------------------------------------------------------------------
void RicEclipseWellShowLabelFeature::onActionTriggered(bool isChecked)
{
std::vector<RimEclipseWell*> selection = RicEclipseWellFeatureImpl::selectedWells();
for (RimEclipseWell* w : selection)
std::vector<RimSimWellInView*> selection = RicEclipseWellFeatureImpl::selectedWells();
for (RimSimWellInView* w : selection)
{
w->showWellLabel.setValueWithFieldChanged(isChecked);
}
@ -64,10 +64,10 @@ bool RicEclipseWellShowLabelFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
bool RicEclipseWellShowLabelFeature::isCommandChecked()
{
std::vector<RimEclipseWell*> selection = RicEclipseWellFeatureImpl::selectedWells();
std::vector<RimSimWellInView*> selection = RicEclipseWellFeatureImpl::selectedWells();
if (selection.size() > 0)
{
RimEclipseWell* well = selection[0];
RimSimWellInView* well = selection[0];
return well->showWellLabel();
}
@ -89,8 +89,8 @@ CAF_CMD_SOURCE_INIT(RicEclipseWellShowHeadFeature, "RicEclipseWellShowHeadFeatur
//--------------------------------------------------------------------------------------------------
void RicEclipseWellShowHeadFeature::onActionTriggered(bool isChecked)
{
std::vector<RimEclipseWell*> selection = RicEclipseWellFeatureImpl::selectedWells();
for (RimEclipseWell* w : selection)
std::vector<RimSimWellInView*> selection = RicEclipseWellFeatureImpl::selectedWells();
for (RimSimWellInView* w : selection)
{
w->showWellHead.setValueWithFieldChanged(isChecked);
}
@ -119,10 +119,10 @@ bool RicEclipseWellShowHeadFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
bool RicEclipseWellShowHeadFeature::isCommandChecked()
{
std::vector<RimEclipseWell*> selection = RicEclipseWellFeatureImpl::selectedWells();
std::vector<RimSimWellInView*> selection = RicEclipseWellFeatureImpl::selectedWells();
if (selection.size() > 0)
{
RimEclipseWell* well = selection[0];
RimSimWellInView* well = selection[0];
return well->showWellHead();
}
@ -145,8 +145,8 @@ CAF_CMD_SOURCE_INIT(RicEclipseWellShowPipeFeature, "RicEclipseWellShowPipeFeatur
//--------------------------------------------------------------------------------------------------
void RicEclipseWellShowPipeFeature::onActionTriggered(bool isChecked)
{
std::vector<RimEclipseWell*> selection = RicEclipseWellFeatureImpl::selectedWells();
for (RimEclipseWell* w : selection)
std::vector<RimSimWellInView*> selection = RicEclipseWellFeatureImpl::selectedWells();
for (RimSimWellInView* w : selection)
{
w->showWellPipe.setValueWithFieldChanged(isChecked);
}
@ -175,10 +175,10 @@ bool RicEclipseWellShowPipeFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
bool RicEclipseWellShowPipeFeature::isCommandChecked()
{
std::vector<RimEclipseWell*> selection = RicEclipseWellFeatureImpl::selectedWells();
std::vector<RimSimWellInView*> selection = RicEclipseWellFeatureImpl::selectedWells();
if (selection.size() > 0)
{
RimEclipseWell* well = selection[0];
RimSimWellInView* well = selection[0];
return well->showWellPipe();
}
@ -201,8 +201,8 @@ CAF_CMD_SOURCE_INIT(RicEclipseWellShowSpheresFeature, "RicEclipseWellShowSpheres
//--------------------------------------------------------------------------------------------------
void RicEclipseWellShowSpheresFeature::onActionTriggered(bool isChecked)
{
std::vector<RimEclipseWell*> selection = RicEclipseWellFeatureImpl::selectedWells();
for (RimEclipseWell* w : selection)
std::vector<RimSimWellInView*> selection = RicEclipseWellFeatureImpl::selectedWells();
for (RimSimWellInView* w : selection)
{
w->showWellSpheres.setValueWithFieldChanged(isChecked);
}
@ -231,10 +231,10 @@ bool RicEclipseWellShowSpheresFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
bool RicEclipseWellShowSpheresFeature::isCommandChecked()
{
std::vector<RimEclipseWell*> selection = RicEclipseWellFeatureImpl::selectedWells();
std::vector<RimSimWellInView*> selection = RicEclipseWellFeatureImpl::selectedWells();
if (selection.size() > 0)
{
RimEclipseWell* well = selection[0];
RimSimWellInView* well = selection[0];
return well->showWellSpheres();
}
@ -256,8 +256,8 @@ CAF_CMD_SOURCE_INIT(RicEclipseWellShowWellCellsFeature, "RicEclipseWellShowWellC
//--------------------------------------------------------------------------------------------------
void RicEclipseWellShowWellCellsFeature::onActionTriggered(bool isChecked)
{
std::vector<RimEclipseWell*> selection = RicEclipseWellFeatureImpl::selectedWells();
for (RimEclipseWell* w : selection)
std::vector<RimSimWellInView*> selection = RicEclipseWellFeatureImpl::selectedWells();
for (RimSimWellInView* w : selection)
{
w->showWellCells.setValueWithFieldChanged(isChecked);
}
@ -286,10 +286,10 @@ bool RicEclipseWellShowWellCellsFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
bool RicEclipseWellShowWellCellsFeature::isCommandChecked()
{
std::vector<RimEclipseWell*> selection = RicEclipseWellFeatureImpl::selectedWells();
std::vector<RimSimWellInView*> selection = RicEclipseWellFeatureImpl::selectedWells();
if (selection.size() > 0)
{
RimEclipseWell* well = selection[0];
RimSimWellInView* well = selection[0];
return well->showWellCells();
}
@ -310,8 +310,8 @@ CAF_CMD_SOURCE_INIT(RicEclipseWellShowWellCellFenceFeature, "RicEclipseWellShowW
//--------------------------------------------------------------------------------------------------
void RicEclipseWellShowWellCellFenceFeature::onActionTriggered(bool isChecked)
{
std::vector<RimEclipseWell*> selection = RicEclipseWellFeatureImpl::selectedWells();
for (RimEclipseWell* w : selection)
std::vector<RimSimWellInView*> selection = RicEclipseWellFeatureImpl::selectedWells();
for (RimSimWellInView* w : selection)
{
w->showWellCellFence.setValueWithFieldChanged(isChecked);
}
@ -340,10 +340,10 @@ bool RicEclipseWellShowWellCellFenceFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
bool RicEclipseWellShowWellCellFenceFeature::isCommandChecked()
{
std::vector<RimEclipseWell*> selection = RicEclipseWellFeatureImpl::selectedWells();
std::vector<RimSimWellInView*> selection = RicEclipseWellFeatureImpl::selectedWells();
if (selection.size() > 0)
{
RimEclipseWell* well = selection[0];
RimSimWellInView* well = selection[0];
return well->showWellCellFence();
}

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

@ -27,11 +27,11 @@
#include "RigSingleWellResultsData.h"
#include "RimEclipseResultCase.h"
#include "RimEclipseWell.h"
#include "RimGridSummaryCase.h"
#include "RimMainPlotCollection.h"
#include "RimOilField.h"
#include "RimProject.h"
#include "RimSimWellInView.h"
#include "RimSummaryCaseMainCollection.h"
#include "RimSummaryCurve.h"
#include "RimSummaryCurveAppearanceCalculator.h"
@ -53,10 +53,10 @@ CAF_CMD_SOURCE_INIT(RicPlotProductionRateFeature, "RicPlotProductionRateFeature"
//--------------------------------------------------------------------------------------------------
bool RicPlotProductionRateFeature::isCommandEnabled()
{
std::vector<RimEclipseWell*> collection;
std::vector<RimSimWellInView*> collection;
caf::SelectionManager::instance()->objectsByType(&collection);
for (RimEclipseWell* well : collection)
for (RimSimWellInView* well : collection)
{
RimGridSummaryCase* gridSummaryCase = RicPlotProductionRateFeature::gridSummaryCaseForWell(well);
if (gridSummaryCase)
@ -85,12 +85,12 @@ void RicPlotProductionRateFeature::onActionTriggered(bool isChecked)
RimSummaryPlotCollection* summaryPlotColl = mainPlotColl->summaryPlotCollection();
CAF_ASSERT(summaryPlotColl);
std::vector<RimEclipseWell*> collection;
std::vector<RimSimWellInView*> collection;
caf::SelectionManager::instance()->objectsByType(&collection);
RimSummaryPlot* summaryPlotToSelect = nullptr;
for (RimEclipseWell* well : collection)
for (RimSimWellInView* well : collection)
{
RimGridSummaryCase* gridSummaryCase = RicPlotProductionRateFeature::gridSummaryCaseForWell(well);
if (!gridSummaryCase) continue;
@ -214,7 +214,7 @@ void RicPlotProductionRateFeature::setupActionLook(QAction* actionToSetup)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimGridSummaryCase* RicPlotProductionRateFeature::gridSummaryCaseForWell(RimEclipseWell* well)
RimGridSummaryCase* RicPlotProductionRateFeature::gridSummaryCaseForWell(RimSimWellInView* well)
{
RimProject* project = RiaApplication::instance()->project();
if (!project) return nullptr;
@ -239,7 +239,7 @@ RimGridSummaryCase* RicPlotProductionRateFeature::gridSummaryCaseForWell(RimEcli
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RicPlotProductionRateFeature::isInjector(RimEclipseWell* well)
bool RicPlotProductionRateFeature::isInjector(RimSimWellInView* well)
{
RigSingleWellResultsData* wRes = well->wellResults();
if (wRes)
@ -268,7 +268,7 @@ bool RicPlotProductionRateFeature::isInjector(RimEclipseWell* well)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimSummaryCurve* RicPlotProductionRateFeature::addSummaryCurve( RimSummaryPlot* plot, const RimEclipseWell* well,
RimSummaryCurve* RicPlotProductionRateFeature::addSummaryCurve( RimSummaryPlot* plot, const RimSimWellInView* well,
RimGridSummaryCase* gridSummaryCase, const QString& vectorName,
RiaDefines::PlotAxis plotAxis, const cvf::Color3f& color)
{

10
ApplicationCode/Commands/FlowCommands/RicPlotProductionRateFeature.h
View File

@ -24,9 +24,9 @@
#include "RiaDefines.h"
class RimGridSummaryCase;
class RimEclipseWell;
class RimSummaryPlot;
class RimSimWellInView;
class RimSummaryCurve;
class RimSummaryPlot;
//==================================================================================================
///
@ -42,9 +42,9 @@ protected:
virtual void setupActionLook( QAction* actionToSetup ) override;
private:
static RimGridSummaryCase* gridSummaryCaseForWell(RimEclipseWell* well);
static bool isInjector(RimEclipseWell* well);
static RimSummaryCurve* addSummaryCurve(RimSummaryPlot* plot, const RimEclipseWell* well,
static RimGridSummaryCase* gridSummaryCaseForWell(RimSimWellInView* well);
static bool isInjector(RimSimWellInView* well);
static RimSummaryCurve* addSummaryCurve(RimSummaryPlot* plot, const RimSimWellInView* well,
RimGridSummaryCase* gridSummaryCase, const QString& vectorName,
RiaDefines::PlotAxis plotAxis, const cvf::Color3f& color);
};

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

@ -23,7 +23,7 @@
#include "RimEclipseCellColors.h"
#include "RimEclipseResultCase.h"
#include "RimEclipseView.h"
#include "RimEclipseWell.h"
#include "RimSimWellInView.h"
#include "RimViewManipulator.h"
#include "RiuMainWindow.h"
@ -40,11 +40,11 @@ CAF_CMD_SOURCE_INIT(RicShowContributingWellsFeature, "RicShowContributingWellsFe
//--------------------------------------------------------------------------------------------------
bool RicShowContributingWellsFeature::isCommandEnabled()
{
std::vector<RimEclipseWell*> collection;
std::vector<RimSimWellInView*> collection;
caf::SelectionManager::instance()->objectsByType(&collection);
if (collection.size() == 1)
{
RimEclipseWell* well = collection[0];
RimSimWellInView* well = collection[0];
RimEclipseView* eclipseView = nullptr;
well->firstAncestorOrThisOfType(eclipseView);
@ -77,12 +77,12 @@ bool RicShowContributingWellsFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
void RicShowContributingWellsFeature::onActionTriggered(bool isChecked)
{
std::vector<RimEclipseWell*> collection;
std::vector<RimSimWellInView*> collection;
caf::SelectionManager::instance()->objectsByType(&collection);
CAF_ASSERT(collection.size() == 1);
RimEclipseWell* well = collection[0];
RimSimWellInView* well = collection[0];
RimEclipseView* eclipseView = nullptr;
well->firstAncestorOrThisOfTypeAsserted(eclipseView);

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

@ -30,11 +30,11 @@
#include "RimEclipsePropertyFilterCollection.h"
#include "RimEclipseResultCase.h"
#include "RimEclipseView.h"
#include "RimEclipseWell.h"
#include "RimEclipseWellCollection.h"
#include "RimFaultCollection.h"
#include "RimFlowDiagSolution.h"
#include "RimProject.h"
#include "RimSimWellInView.h"
#include "RimViewManipulator.h"
#include "RiuMainWindow.h"
@ -69,9 +69,9 @@ void RicShowContributingWellsFeatureImpl::modifyViewToShowContributingWells(RimE
{
CVF_ASSERT(viewToModify);
RimEclipseWell* selectedWell = nullptr;
RimSimWellInView* selectedWell = nullptr;
for (RimEclipseWell* w : viewToModify->wellCollection()->wells())
for (RimSimWellInView* w : viewToModify->wellCollection()->wells())
{
if (w->name() == wellName)
{
@ -124,7 +124,7 @@ void RicShowContributingWellsFeatureImpl::modifyViewToShowContributingWells(RimE
std::vector<QString> tracerNames = findContributingTracerNames(flowDiagSolution, selectedWell->wellResults(), timeStep);
for (RimEclipseWell* w : viewToModify->wellCollection()->wells())
for (RimSimWellInView* w : viewToModify->wellCollection()->wells())
{
if (std::find(tracerNames.begin(), tracerNames.end(), w->name()) != tracerNames.end()
|| selectedWell->name() == w->name())

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

@ -25,8 +25,8 @@
class RigSingleWellResultsData;
class RimEclipseResultCase;
class RimEclipseView;
class RimEclipseWell;
class RimFlowDiagSolution;
class RimSimWellInView;
//==================================================================================================
///

2
ApplicationCode/Commands/FlowCommands/RicShowFlowCharacteristicsPlotFeature.h
View File

@ -20,7 +20,7 @@
#include "cafCmdFeature.h"
class RimEclipseWell;
class RimSimWellInView;
//==================================================================================================

8
ApplicationCode/Commands/FlowCommands/RicShowWellAllocationPlotFeature.cpp
View File

@ -21,10 +21,10 @@
#include "RiaApplication.h"
#include "RimEclipseResultCase.h"
#include "RimEclipseWell.h"
#include "RimFlowPlotCollection.h"
#include "RimMainPlotCollection.h"
#include "RimProject.h"
#include "RimSimWellInView.h"
#include "RimView.h"
#include "RimWellAllocationPlot.h"
@ -41,7 +41,7 @@ CAF_CMD_SOURCE_INIT(RicShowWellAllocationPlotFeature, "RicShowWellAllocationPlot
//--------------------------------------------------------------------------------------------------
bool RicShowWellAllocationPlotFeature::isCommandEnabled()
{
std::vector<RimEclipseWell*> collection;
std::vector<RimSimWellInView*> collection;
caf::SelectionManager::instance()->objectsByType(&collection);
if (collection.size() > 0)
@ -57,12 +57,12 @@ bool RicShowWellAllocationPlotFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
void RicShowWellAllocationPlotFeature::onActionTriggered(bool isChecked)
{
std::vector<RimEclipseWell*> collection;
std::vector<RimSimWellInView*> collection;
caf::SelectionManager::instance()->objectsByType(&collection);
if (collection.size() > 0)
{
RimEclipseWell* eclWell = collection[0];
RimSimWellInView* eclWell = collection[0];
if (RiaApplication::instance()->project())
{

2
ApplicationCode/Commands/FlowCommands/RicShowWellAllocationPlotFeature.h
View File

@ -20,7 +20,7 @@
#include "cafCmdFeature.h"
class RimEclipseWell;
class RimSimWellInView;
//==================================================================================================

4
ApplicationCode/Commands/RicDeleteItemExec.cpp
View File

@ -24,11 +24,11 @@
#include "RimCase.h"
#include "RimCellRangeFilterCollection.h"
#include "RimEclipsePropertyFilterCollection.h"
#include "RimEclipseWell.h"
#include "RimFormationNamesCollection.h"
#include "RimGeoMechPropertyFilterCollection.h"
#include "RimIntersectionCollection.h"
#include "RimProject.h"
#include "RimSimWellInView.h"
#include "RimView.h"
#include "RimViewLinkerCollection.h"
#include "RimWellLogPlot.h"
@ -126,7 +126,7 @@ void RicDeleteItemExec::redo()
}
// SimWell Fractures
RimEclipseWell* eclipseWell;
RimSimWellInView* eclipseWell;
parentObj->firstAncestorOrThisOfType(eclipseWell);
if (view && eclipseWell)
{

6
ApplicationCode/Commands/RicNewSimWellFractureAtPosFeature.cpp
View File

@ -23,13 +23,13 @@
#include "RimCase.h"
#include "RimEclipseResultCase.h"
#include "RimEclipseWell.h"
#include "RimEllipseFractureTemplate.h"
#include "RimFractureTemplateCollection.h"
#include "RimOilField.h"
#include "RimProject.h"
#include "RimSimWellFracture.h"
#include "RimSimWellFractureCollection.h"
#include "RimSimWellInView.h"
#include "RimView.h"
#include "RiuMainWindow.h"
@ -58,7 +58,7 @@ void RicNewSimWellFractureAtPosFeature::onActionTriggered(bool isChecked)
RiuSimWellSelectionItem* simWellItem = static_cast<RiuSimWellSelectionItem*>(selItem);
if (!simWellItem) return;
RimEclipseWell* simWell = simWellItem->m_simWell;
RimSimWellInView* simWell = simWellItem->m_simWell;
if (!simWell) return;
RimSimWellFractureCollection* fractureCollection = simWell->simwellFractureCollection();
@ -126,7 +126,7 @@ bool RicNewSimWellFractureAtPosFeature::isCommandEnabled()
caf::PdmObjectHandle* objHandle = dynamic_cast<caf::PdmObjectHandle*>(pdmUiItem);
if (!objHandle) return false;
RimEclipseWell* eclipseWell = nullptr;
RimSimWellInView* eclipseWell = nullptr;
objHandle->firstAncestorOrThisOfType(eclipseWell);
if (eclipseWell)

8
ApplicationCode/Commands/RicNewSimWellFractureFeature.cpp
View File

@ -24,16 +24,16 @@
#include "RigEclipseCaseData.h"
#include "RimCase.h"
#include "RimEclipseCase.h"
#include "RimEclipseResultCase.h"
#include "RimEclipseView.h"
#include "RimEclipseWell.h"
#include "RimEllipseFractureTemplate.h"
#include "RimFractureTemplateCollection.h"
#include "RimOilField.h"
#include "RimProject.h"
#include "RimSimWellFracture.h"
#include "RimSimWellFractureCollection.h"
#include "RimEclipseCase.h"
#include "RimSimWellInView.h"
#include "RiuMainWindow.h"
@ -56,7 +56,7 @@ void RicNewSimWellFractureFeature::onActionTriggered(bool isChecked)
caf::PdmObjectHandle* objHandle = dynamic_cast<caf::PdmObjectHandle*>(pdmUiItem);
if (!objHandle) return;
RimEclipseWell* eclipseWell = nullptr;
RimSimWellInView* eclipseWell = nullptr;
objHandle->firstAncestorOrThisOfType(eclipseWell);
RimSimWellFracture* fracture = new RimSimWellFracture();
@ -115,7 +115,7 @@ bool RicNewSimWellFractureFeature::isCommandEnabled()
caf::PdmObjectHandle* objHandle = dynamic_cast<caf::PdmObjectHandle*>(pdmUiItem);
if (!objHandle) return false;
RimEclipseWell* eclipseWell = nullptr;
RimSimWellInView* eclipseWell = nullptr;
objHandle->firstAncestorOrThisOfType(eclipseWell);
if (eclipseWell)

12
ApplicationCode/Commands/RicWellLogTools.cpp
View File

@ -22,11 +22,11 @@
#include "RimCase.h"
#include "RimEclipseResultCase.h"
#include "RimEclipseWell.h"
#include "RimProject.h"
#include "RimSimWellInView.h"
#include "RimWellLogExtractionCurve.h"
#include "RimWellLogFileCurve.h"
#include "RimWellLogFileChannel.h"
#include "RimWellLogFileCurve.h"
#include "RimWellLogRftCurve.h"
#include "RimWellLogTrack.h"
#include "RimWellPath.h"
@ -54,7 +54,7 @@ RimWellLogTrack* RicWellLogTools::selectedWellLogPlotTrack()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimEclipseWell* RicWellLogTools::selectedSimulationWell(int *branchIndex)
RimSimWellInView* RicWellLogTools::selectedSimulationWell(int *branchIndex)
{
RiuSelectionItem* selItem = RiuSelectionManager::instance()->selectedItem(RiuSelectionManager::RUI_TEMPORARY);
RiuSimWellSelectionItem* simWellSelItem = dynamic_cast<RiuSimWellSelectionItem*>(selItem);
@ -65,7 +65,7 @@ RimEclipseWell* RicWellLogTools::selectedSimulationWell(int *branchIndex)
}
else
{
std::vector<RimEclipseWell*> selection;
std::vector<RimSimWellInView*> selection;
caf::SelectionManager::instance()->objectsByType(&selection);
(*branchIndex) = 0;
return selection.size() > 0 ? selection[0] : nullptr;
@ -146,7 +146,7 @@ RimWellPath* RicWellLogTools::selectedWellPathWithLogFile()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimWellLogExtractionCurve* RicWellLogTools::addExtractionCurve(RimWellLogTrack* plotTrack, RimView* view, RimWellPath* wellPath, const RimEclipseWell* simWell, int branchIndex)
RimWellLogExtractionCurve* RicWellLogTools::addExtractionCurve(RimWellLogTrack* plotTrack, RimView* view, RimWellPath* wellPath, const RimSimWellInView* simWell, int branchIndex)
{
CVF_ASSERT(plotTrack);
RimWellLogExtractionCurve* curve = new RimWellLogExtractionCurve();
@ -175,7 +175,7 @@ RimWellLogExtractionCurve* RicWellLogTools::addExtractionCurve(RimWellLogTrack*
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimWellLogRftCurve* RicWellLogTools::addRftCurve(RimWellLogTrack* plotTrack, const RimEclipseWell* simWell)
RimWellLogRftCurve* RicWellLogTools::addRftCurve(RimWellLogTrack* plotTrack, const RimSimWellInView* simWell)
{
CVF_ASSERT(plotTrack);

8
ApplicationCode/Commands/RicWellLogTools.h
View File

@ -18,7 +18,7 @@
#pragma once
class RimEclipseWell;
class RimSimWellInView;
class RimView;
class RimWellLogExtractionCurve;
class RimWellLogFileChannel;
@ -35,14 +35,14 @@ class RicWellLogTools
{
public:
static RimWellLogTrack* selectedWellLogPlotTrack();
static RimEclipseWell* selectedSimulationWell(int *branchIndex);
static RimSimWellInView* selectedSimulationWell(int *branchIndex);
static RimWellPath* selectedWellPath();
static bool wellHasRftData(const QString& wellName);
static void addWellLogChannelsToPlotTrack(RimWellLogTrack* plotTrack, const std::vector<RimWellLogFileChannel*>& wellLogFileChannels);
static RimWellPath* selectedWellPathWithLogFile();
static RimWellLogExtractionCurve* addExtractionCurve(RimWellLogTrack* plotTrack, RimView* view, RimWellPath* wellPath, const RimEclipseWell* simWell, int branchIndex);
static RimWellLogRftCurve* addRftCurve(RimWellLogTrack* plotTrack, const RimEclipseWell* simWell);
static RimWellLogExtractionCurve* addExtractionCurve(RimWellLogTrack* plotTrack, RimView* view, RimWellPath* wellPath, const RimSimWellInView* simWell, int branchIndex);
static RimWellLogRftCurve* addRftCurve(RimWellLogTrack* plotTrack, const RimSimWellInView* simWell);
static RimWellLogFileCurve* addFileCurve(RimWellLogTrack* plotTrack);
};

14
ApplicationCode/Commands/WellLogCommands/RicNewRftPlotFeature.cpp
View File

@ -27,6 +27,7 @@
#include "RigWellLogCurveData.h"
#include "RimProject.h"
#include "RimSimWellInView.h"
#include "RimView.h"
#include "RimWellLogExtractionCurve.h"
#include "RimWellRftPlot.h"
@ -38,14 +39,13 @@
#include "RimEclipseResultCase.h"
#include "RiuMainPlotWindow.h"
#include "RiuSelectionManager.h"
#include "cafSelectionManager.h"
#include <QAction>
#include <vector>
#include "RimEclipseWell.h"
#include "RiuSelectionManager.h"
CAF_CMD_SOURCE_INIT(RicNewRftPlotFeature, "RicNewRftPlotFeature");
@ -78,7 +78,7 @@ bool RicNewRftPlotFeature::isCommandEnabled()
//int branchIndex;
auto eclWell = selectedPdmObject<RimEclipseWell*>();
auto eclWell = selectedPdmObject<RimSimWellInView*>();
auto rimWellPath = eclWell == nullptr ? selectedPdmObject<RimWellPath*>() : nullptr;
bool enable = true;
@ -115,12 +115,12 @@ void RicNewRftPlotFeature::onActionTriggered(bool isChecked)
{
QString wellName;
RimWellPath* wellPath = nullptr;
RimEclipseWell* eclipseWell = nullptr;
RimSimWellInView* eclipseWell = nullptr;
if ((wellPath = selectedPdmObject<RimWellPath*>()) != nullptr)
{
wellName = wellPath->name();
}
else if ((eclipseWell = selectedPdmObject<RimEclipseWell*>()) != nullptr)
else if ((eclipseWell = selectedPdmObject<RimSimWellInView*>()) != nullptr)
{
wellName = eclipseWell->name();
}
@ -181,7 +181,7 @@ RimWellPath* RicNewRftPlotFeature::selectedWellPath() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimEclipseWell* RicNewRftPlotFeature::selectedSimulationWell(int * branchIndex) const
RimSimWellInView* RicNewRftPlotFeature::selectedSimulationWell(int * branchIndex) const
{
RiuSelectionItem* selItem = RiuSelectionManager::instance()->selectedItem(RiuSelectionManager::RUI_TEMPORARY);
RiuSimWellSelectionItem* simWellSelItem = dynamic_cast<RiuSimWellSelectionItem*>(selItem);
@ -192,7 +192,7 @@ RimEclipseWell* RicNewRftPlotFeature::selectedSimulationWell(int * branchIndex)
}
else
{
std::vector<RimEclipseWell*> selection;
std::vector<RimSimWellInView*> selection;
caf::SelectionManager::instance()->objectsByType(&selection);
(*branchIndex) = 0;
return selection.size() > 0 ? selection[0] : NULL;

4
ApplicationCode/Commands/WellLogCommands/RicNewRftPlotFeature.h
View File

@ -21,7 +21,7 @@
#include "cafCmdFeature.h"
class RimEclipseWell;
class RimSimWellInView;
class RimView;
class RimWellLogExtractionCurve;
class RimWellLogTrack;
@ -46,7 +46,7 @@ protected:
private:
RimWellLogTrack* selectedWellLogPlotTrack() const;
RimWellPath* selectedWellPath() const;
RimEclipseWell* selectedSimulationWell(int * branchIndex) const;
RimSimWellInView* selectedSimulationWell(int * branchIndex) const;
bool caseAvailable() const;
};

4
ApplicationCode/Commands/WellLogCommands/RicNewWellLogCurveExtractionFeature.cpp
View File

@ -27,8 +27,8 @@
#include "RigWellLogCurveData.h"
#include "RimEclipseWell.h"
#include "RimProject.h"
#include "RimSimWellInView.h"
#include "RimView.h"
#include "RimWellLogExtractionCurve.h"
#include "RimWellLogPlot.h"
@ -75,7 +75,7 @@ void RicNewWellLogCurveExtractionFeature::onActionTriggered(bool isChecked)
{
RimWellPath* wellPath = RicWellLogTools::selectedWellPath();
int branchIndex = -1;
RimEclipseWell* simWell = RicWellLogTools::selectedSimulationWell(&branchIndex);
RimSimWellInView* simWell = RicWellLogTools::selectedSimulationWell(&branchIndex);
if (wellPath || simWell)
{
RimWellLogTrack* wellLogPlotTrack = RicNewWellLogPlotFeatureImpl::createWellLogPlotTrack();

6
ApplicationCode/Commands/WellLogCommands/RicNewWellLogRftCurveFeature.cpp
View File

@ -19,8 +19,8 @@
#include "RicNewWellLogRftCurveFeature.h"
#include "RimEclipseResultCase.h"
#include "RimEclipseWell.h"
#include "RimProject.h"
#include "RimSimWellInView.h"
#include "RimWellLogCurve.h"
#include "RimWellLogPlot.h"
#include "RimWellLogRftCurve.h"
@ -54,7 +54,7 @@ bool RicNewWellLogRftCurveFeature::isCommandEnabled()
}
int branchIdx;
RimEclipseWell* simulationWell = RicWellLogTools::selectedSimulationWell(&branchIdx);
RimSimWellInView* simulationWell = RicWellLogTools::selectedSimulationWell(&branchIdx);
if (simulationWell != nullptr)
{
@ -78,7 +78,7 @@ void RicNewWellLogRftCurveFeature::onActionTriggered(bool isChecked)
else
{
int branchIndex = -1;
RimEclipseWell* simWell = RicWellLogTools::selectedSimulationWell(&branchIndex);
RimSimWellInView* simWell = RicWellLogTools::selectedSimulationWell(&branchIndex);
if (simWell)
{
RimWellLogTrack* wellLogPlotTrack = RicNewWellLogPlotFeatureImpl::createWellLogPlotTrack();

6
ApplicationCode/ModelVisualization/RivReservoirSimWellsPartMgr.cpp
View File

@ -26,8 +26,8 @@
#include "RimEclipseCellColors.h"
#include "RimEclipsePropertyFilterCollection.h"
#include "RimEclipseView.h"
#include "RimEclipseWell.h"
#include "RimEclipseWellCollection.h"
#include "RimSimWellInView.h"
#include "RivWellHeadPartMgr.h"
#include "RivSimWellPipesPartMgr.h"
@ -139,7 +139,7 @@ void RivReservoirSimWellsPartMgr::appendDynamicGeometryPartsToModel(cvf::ModelBa
{
m_wellSpheresPartMgrs.clear();
for (RimEclipseWell* rimWell : m_reservoirView->wellCollection()->wells())
for (RimSimWellInView* rimWell : m_reservoirView->wellCollection()->wells())
{
RivWellSpheresPartMgr* wppmgr = new RivWellSpheresPartMgr(m_reservoirView, rimWell);
m_wellSpheresPartMgrs.push_back(wppmgr);
@ -157,7 +157,7 @@ void RivReservoirSimWellsPartMgr::appendDynamicGeometryPartsToModel(cvf::ModelBa
// Well Connection Arrows
if ( m_reservoirView->wellCollection()->showWellCommunicationLines() )
{
for ( RimEclipseWell* rimWell : m_reservoirView->wellCollection()->wells() )
for ( RimSimWellInView* rimWell : m_reservoirView->wellCollection()->wells() )
{
cvf::ref<RivWellConnectionsPartMgr> wppmgr = new RivWellConnectionsPartMgr(m_reservoirView, rimWell);
wppmgr->appendDynamicGeometryPartsToModel(model, frameIndex);

6
ApplicationCode/ModelVisualization/RivSimWellPipeSourceInfo.cpp
View File

@ -20,14 +20,14 @@
#include "RivSimWellPipeSourceInfo.h"
#include "RimEclipseView.h"
#include "RimEclipseWell.h"
#include "RimEclipseWellCollection.h"
#include "RimSimWellInView.h"
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RivSimWellPipeSourceInfo::RivSimWellPipeSourceInfo(RimEclipseWell* eclipseWell, size_t branchIndex)
RivSimWellPipeSourceInfo::RivSimWellPipeSourceInfo(RimSimWellInView* eclipseWell, size_t branchIndex)
: m_eclipseWell(eclipseWell),
m_branchIndex(branchIndex)
{
@ -36,7 +36,7 @@ RivSimWellPipeSourceInfo::RivSimWellPipeSourceInfo(RimEclipseWell* eclipseWell,
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimEclipseWell* RivSimWellPipeSourceInfo::well() const
RimSimWellInView* RivSimWellPipeSourceInfo::well() const
{
return m_eclipseWell.p();
}

8
ApplicationCode/ModelVisualization/RivSimWellPipeSourceInfo.h
View File

@ -23,18 +23,18 @@
#include "cvfObject.h"
#include "cafPdmPointer.h"
class RimEclipseWell;
class RimSimWellInView;
class RivSimWellPipeSourceInfo : public cvf::Object
{
public:
RivSimWellPipeSourceInfo(RimEclipseWell* eclipseWell, size_t branchIndex);
RivSimWellPipeSourceInfo(RimSimWellInView* eclipseWell, size_t branchIndex);
RimEclipseWell* well() const;
RimSimWellInView* well() const;
size_t branchIndex() const;
private:
caf::PdmPointer<RimEclipseWell> m_eclipseWell;
caf::PdmPointer<RimSimWellInView> m_eclipseWell;
size_t m_branchIndex;
};

4
ApplicationCode/ModelVisualization/RivSimWellPipesPartMgr.cpp
View File

@ -32,9 +32,9 @@
#include "RimEclipseCellColors.h"
#include "RimEclipsePropertyFilterCollection.h"
#include "RimEclipseView.h"
#include "RimEclipseWell.h"
#include "RimEclipseWellCollection.h"
#include "RimReservoirCellResultsStorage.h"
#include "RimSimWellInView.h"
#include "RivPipeGeometryGenerator.h"
#include "RivWellPathSourceInfo.h"
@ -55,7 +55,7 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RivSimWellPipesPartMgr::RivSimWellPipesPartMgr(RimEclipseView* reservoirView, RimEclipseWell* well)
RivSimWellPipesPartMgr::RivSimWellPipesPartMgr(RimEclipseView* reservoirView, RimSimWellInView* well)
{
m_rimReservoirView = reservoirView;
m_rimWell = well;

6
ApplicationCode/ModelVisualization/RivSimWellPipesPartMgr.h
View File

@ -37,12 +37,12 @@ namespace cvf
class RivPipeGeometryGenerator;
class RimEclipseView;
class RimEclipseWell;
class RimSimWellInView;
class RivSimWellPipesPartMgr : public cvf::Object
{
public:
RivSimWellPipesPartMgr(RimEclipseView* reservoirView, RimEclipseWell* well);
RivSimWellPipesPartMgr(RimEclipseView* reservoirView, RimSimWellInView* well);
~RivSimWellPipesPartMgr();
void setScaleTransform(cvf::Transform * scaleTransform) { m_scaleTransform = scaleTransform; scheduleGeometryRegen();}
@ -56,7 +56,7 @@ public:
private:
caf::PdmPointer<RimEclipseView> m_rimReservoirView;
caf::PdmPointer<RimEclipseWell> m_rimWell;
caf::PdmPointer<RimSimWellInView> m_rimWell;
cvf::ref<cvf::Transform> m_scaleTransform;
bool m_needsTransformUpdate;

6
ApplicationCode/ModelVisualization/RivWellConnectionsPartMgr.cpp
View File

@ -20,8 +20,8 @@
#include "RimEclipseResultCase.h"
#include "RimEclipseView.h"
#include "RimEclipseWell.h"
#include "RimEclipseWellCollection.h"
#include "RimSimWellInView.h"
#include "RigSingleWellResultsData.h"
#include "RigFlowDiagResults.h"
@ -39,7 +39,7 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RivWellConnectionsPartMgr::RivWellConnectionsPartMgr(RimEclipseView* reservoirView, RimEclipseWell* well)
RivWellConnectionsPartMgr::RivWellConnectionsPartMgr(RimEclipseView* reservoirView, RimSimWellInView* well)
{
m_rimReservoirView = reservoirView;
m_rimWell = well;
@ -126,7 +126,7 @@ void RivWellConnectionsPartMgr::appendDynamicGeometryPartsToModel(cvf::ModelBasi
// Create potentially two the arrows to/from m_rimWell for each of the other wells in the model.
// One arrow for the "official" state of the well, and one to account for cross flow contributions
for ( RimEclipseWell * otherWell: wellColl->wells )
for ( RimSimWellInView * otherWell: wellColl->wells )
{
if ( otherWell == m_rimWell ) continue;
if ( !otherWell->wellResults()->hasWellResult(frameIndex) ) continue;

10
ApplicationCode/ModelVisualization/RivWellConnectionsPartMgr.h
View File

@ -36,17 +36,17 @@ namespace cvf
class Part;
}
class RivPipeGeometryGenerator;
class RimEclipseView;
class RimEclipseWell;
class RigWellResultFrame;
class RimEclipseView;
class RimSimWellInView;
class RivPipeGeometryGenerator;
struct RigWellResultPoint;
class RivWellConnectionsPartMgr : public cvf::Object
{
public:
RivWellConnectionsPartMgr(RimEclipseView* reservoirView, RimEclipseWell* well);
RivWellConnectionsPartMgr(RimEclipseView* reservoirView, RimSimWellInView* well);
~RivWellConnectionsPartMgr();
void appendDynamicGeometryPartsToModel(cvf::ModelBasicList* model, size_t frameIndex);
@ -67,7 +67,7 @@ private:
private:
caf::PdmPointer<RimEclipseView> m_rimReservoirView;
caf::PdmPointer<RimEclipseWell> m_rimWell;
caf::PdmPointer<RimSimWellInView> m_rimWell;
bool m_useCurvedArrows;
};

4
ApplicationCode/ModelVisualization/RivWellFracturePartMgr.cpp
View File

@ -25,13 +25,13 @@
#include "RigHexIntersectionTools.h"
#include "RigCellGeometryTools.h"
#include "RigFractureCell.h"
#include "RimEclipseView.h"
#include "RimEclipseWell.h"
#include "RimFracture.h"
#include "RimFractureContainment.h"
#include "RimFractureTemplate.h"
#include "RimLegendConfig.h"
#include "RigFractureCell.h"
#include "RimSimWellInView.h"
#include "RimStimPlanColors.h"
#include "RimStimPlanFractureTemplate.h"

6
ApplicationCode/ModelVisualization/RivWellHeadPartMgr.cpp
View File

@ -32,8 +32,8 @@
#include "RimEclipseCase.h"
#include "RimEclipseView.h"
#include "RimEclipseWell.h"
#include "RimEclipseWellCollection.h"
#include "RimSimWellInView.h"
#include "RivPipeGeometryGenerator.h"
#include "RivPartPriority.h"
@ -56,7 +56,7 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RivWellHeadPartMgr::RivWellHeadPartMgr(RimEclipseView* reservoirView, RimEclipseWell* well)
RivWellHeadPartMgr::RivWellHeadPartMgr(RimEclipseView* reservoirView, RimSimWellInView* well)
{
m_rimReservoirView = reservoirView;
m_rimWell = well;
@ -81,7 +81,7 @@ void RivWellHeadPartMgr::buildWellHeadParts(size_t frameIndex)
RigEclipseCaseData* rigReservoir = m_rimReservoirView->eclipseCase()->eclipseCaseData();
RimEclipseWell* well = m_rimWell;
RimSimWellInView* well = m_rimWell;
double characteristicCellSize = rigReservoir->mainGrid()->characteristicIJCellSize();

6
ApplicationCode/ModelVisualization/RivWellHeadPartMgr.h
View File

@ -31,13 +31,13 @@ namespace cvf
class Font;
}
class RimEclipseWell;
class RimEclipseView;
class RimSimWellInView;
class RivWellHeadPartMgr : public cvf::Object
{
public:
RivWellHeadPartMgr(RimEclipseView* reservoirView, RimEclipseWell* well);
RivWellHeadPartMgr(RimEclipseView* reservoirView, RimSimWellInView* well);
~RivWellHeadPartMgr();
void setScaleTransform(cvf::Transform * scaleTransform) { m_scaleTransform = scaleTransform;}
@ -52,7 +52,7 @@ private:
private:
caf::PdmPointer<RimEclipseView> m_rimReservoirView;
caf::PdmPointer<RimEclipseWell> m_rimWell;
caf::PdmPointer<RimSimWellInView> m_rimWell;
cvf::ref<cvf::Transform> m_scaleTransform;

4
ApplicationCode/ModelVisualization/RivWellSpheresPartMgr.cpp
View File

@ -25,8 +25,8 @@
#include "RimEclipseCase.h"
#include "RimEclipseView.h"
#include "RimEclipseWell.h"
#include "RimEclipseWellCollection.h"
#include "RimSimWellInView.h"
#include "RiuViewer.h"
@ -49,7 +49,7 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RivWellSpheresPartMgr::RivWellSpheresPartMgr(RimEclipseView* reservoirView, RimEclipseWell* well)
RivWellSpheresPartMgr::RivWellSpheresPartMgr(RimEclipseView* reservoirView, RimSimWellInView* well)
{
m_rimReservoirView = reservoirView;
m_rimWell = well;

10
ApplicationCode/ModelVisualization/RivWellSpheresPartMgr.h
View File

@ -39,17 +39,17 @@ namespace cvf
class Color3f;
}
class RivPipeGeometryGenerator;
class RimEclipseView;
class RimEclipseWell;
class RigWellResultFrame;
class RimEclipseView;
class RimSimWellInView;
class RivPipeGeometryGenerator;
struct RigWellResultPoint;
class RivWellSpheresPartMgr : public cvf::Object
{
public:
RivWellSpheresPartMgr(RimEclipseView* reservoirView, RimEclipseWell* well);
RivWellSpheresPartMgr(RimEclipseView* reservoirView, RimSimWellInView* well);
~RivWellSpheresPartMgr();
void appendDynamicGeometryPartsToModel(cvf::ModelBasicList* model, size_t frameIndex);
@ -60,5 +60,5 @@ private:
private:
caf::PdmPointer<RimEclipseView> m_rimReservoirView;
caf::PdmPointer<RimEclipseWell> m_rimWell;
caf::PdmPointer<RimSimWellInView> m_rimWell;
};

22
ApplicationCode/ProjectDataModel/Completions/RimCompletionCellIntersectionCalc.cpp
View File

@ -19,19 +19,19 @@
#include "RimCompletionCellIntersectionCalc.h"
#include "RiaDefines.h"
#include "RimProject.h"
#include "RimOilField.h"
#include "RimWellPathCollection.h"
#include "RimWellPath.h"
#include "RimWellPathCompletions.h"
#include "RimFishbonesCollection.h"
#include "RimFishbonesMultipleSubs.h"
#include "RimPerforationCollection.h"
#include "RimPerforationInterval.h"
#include "RimEclipseCase.h"
#include "RimEclipseView.h"
#include "RimEclipseWellCollection.h"
#include "RimEclipseWell.h"
#include "RimFishbonesCollection.h"
#include "RimFishbonesMultipleSubs.h"
#include "RimOilField.h"
#include "RimPerforationCollection.h"
#include "RimPerforationInterval.h"
#include "RimProject.h"
#include "RimSimWellInView.h"
#include "RimWellPath.h"
#include "RimWellPathCollection.h"
#include "RimWellPathCompletions.h"
#include "RigMainGrid.h"
#include "RigWellPath.h"
@ -68,7 +68,7 @@ void RimCompletionCellIntersectionCalc::calculateIntersections(const RimProject*
#ifdef USE_PROTOTYPE_FEATURE_FRACTURES
for (RimEclipseView* view : eclipseCase->reservoirViews())
{
for (RimEclipseWell* simWell : view->wellCollection()->wells())
for (RimSimWellInView* simWell : view->wellCollection()->wells())
{
for (RimSimWellFracture* fracture : simWell->simwellFractureCollection()->simwellFractures())
{

6
ApplicationCode/ProjectDataModel/Completions/RimFishboneWellPathCollection.cpp
View File

@ -19,11 +19,11 @@
#include "RimFishboneWellPathCollection.h"
#include "RimEclipseWell.h"
#include "RimFishboneWellPath.h"
#include "RimView.h"
#include "RimProject.h"
#include "RimFishbonesCollection.h"
#include "RimProject.h"
#include "RimSimWellInView.h"
#include "RimView.h"
#include "RigWellPath.h"

4
ApplicationCode/ProjectDataModel/Completions/RimPerforationCollection.cpp
View File

@ -19,10 +19,10 @@
#include "RimPerforationCollection.h"
#include "RimEclipseWell.h"
#include "RimPerforationInterval.h"
#include "RimView.h"
#include "RimProject.h"
#include "RimSimWellInView.h"
#include "RimView.h"
#include "RigWellPath.h"

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

@ -23,11 +23,11 @@
#include "RigSingleWellResultsData.h"
#include "RimEclipseView.h"
#include "RimEclipseWell.h"
#include "RimEllipseFractureTemplate.h"
#include "RimFracture.h"
#include "RimFractureTemplate.h"
#include "RimProject.h"
#include "RimSimWellInView.h"
#include "cafPdmUiDoubleSliderEditor.h"
@ -309,7 +309,7 @@ void RimSimWellFracture::setBranchGeometry()
{
m_branchCenterLines.clear();
RimEclipseWell* rimWell = nullptr;
RimSimWellInView* rimWell = nullptr;
this->firstAncestorOrThisOfType(rimWell);
CVF_ASSERT(rimWell);

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

@ -30,8 +30,8 @@
#include "RimEclipseResultCase.h"
#include "RimEclipseView.h"
#include "RimEclipseWell.h"
#include "RimEclipseWellCollection.h"
#include "RimSimWellInView.h"
CAF_PDM_SOURCE_INIT(RimFlowDiagSolution, "FlowDiagSolution");

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

@ -25,8 +25,8 @@
#include "cvfObject.h"
#include "cvfColor3.h"
class RimEclipseWell;
class RigFlowDiagResults;
class RimSimWellInView;
//==================================================================================================
///

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

@ -21,8 +21,8 @@
#include "RiaApplication.h"
#include "RimEclipseView.h"
#include "RimEclipseWell.h"
#include "RimEclipseWellCollection.h"
#include "RimSimWellInView.h"
#include "RimWellAllocationPlot.h"
#include "RigSingleWellResultsData.h"

6
ApplicationCode/ProjectDataModel/Flow/RimTofAccumulatedPhaseFractionsPlot.h
View File

@ -29,11 +29,11 @@
#include <vector>
class RiuWellAllocationPlot;
class RimEclipseWell;
class RimEclipseResultCase;
class RimSimWellInView;
class RimWellLogPlot;
class RiuTofAccumulatedPhaseFractionsPlot;
class RimEclipseResultCase;
class RiuWellAllocationPlot;
namespace caf {
class PdmOptionItemInfo;

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

@ -21,8 +21,8 @@
#include "RiaApplication.h"
#include "RimEclipseView.h"
#include "RimEclipseWell.h"
#include "RimEclipseWellCollection.h"
#include "RimSimWellInView.h"
#include "RigSingleWellResultsData.h"

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

@ -29,10 +29,10 @@
#include <vector>
class RiuWellAllocationPlot;
class RimEclipseWell;
class RimSimWellInView;
class RimWellLogPlot;
class RiuNightchartsWidget;
class RiuWellAllocationPlot;
namespace caf {
class PdmOptionItemInfo;

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

@ -32,16 +32,16 @@
#include "RimEclipseCellColors.h"
#include "RimEclipseResultCase.h"
#include "RimEclipseView.h"
#include "RimEclipseWell.h"
#include "RimEclipseWellCollection.h"
#include "RimFlowDiagSolution.h"
#include "RimProject.h"
#include "RimSimWellInView.h"
#include "RimTofAccumulatedPhaseFractionsPlot.h"
#include "RimTotalWellAllocationPlot.h"
#include "RimWellAllocationPlotLegend.h"
#include "RimWellFlowRateCurve.h"
#include "RimWellLogPlot.h"
#include "RimWellLogTrack.h"
#include "RimWellAllocationPlotLegend.h"
#include "RimTofAccumulatedPhaseFractionsPlot.h"
#include "RiuMainPlotWindow.h"
#include "RiuWellAllocationPlot.h"
@ -127,7 +127,7 @@ RimWellAllocationPlot::~RimWellAllocationPlot()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellAllocationPlot::setFromSimulationWell(RimEclipseWell* simWell)
void RimWellAllocationPlot::setFromSimulationWell(RimSimWellInView* simWell)
{
RimEclipseView* eclView;
simWell->firstAncestorOrThisOfType(eclView);

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

@ -27,16 +27,16 @@
#include <QPointer>
class RigSingleWellResultsData;
class RimEclipseResultCase;
class RimEclipseWell;
class RimFlowDiagSolution;
class RimSimWellInView;
class RimTofAccumulatedPhaseFractionsPlot;
class RimTotalWellAllocationPlot;
class RimWellAllocationPlotLegend;
class RimWellLogPlot;
class RiuWellAllocationPlot;
class RimWellLogTrack;
class RimTofAccumulatedPhaseFractionsPlot;
class RigSingleWellResultsData;
class RiuWellAllocationPlot;
namespace cvf {
class Color3f;
@ -61,7 +61,7 @@ public:
RimWellAllocationPlot();
virtual ~RimWellAllocationPlot();
void setFromSimulationWell(RimEclipseWell* simWell);
void setFromSimulationWell(RimSimWellInView* simWell);
void setDescription(const QString& description);
QString description() const;

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

@ -29,17 +29,17 @@
#include <QDate>
#include <QMetaType>
class RimEclipseResultCase;
class RimEclipseWell;
class RimFlowDiagSolution;
class RimTotalWellAllocationPlot;
class RimWellLogPlot;
class RiuWellRftPlot;
class RimWellLogTrack;
class RimTofAccumulatedPhaseFractionsPlot;
class RigSingleWellResultsData;
class RimWellLogFileChannel;
class RimEclipseResultCase;
class RimFlowDiagSolution;
class RimSimWellInView;
class RimTofAccumulatedPhaseFractionsPlot;
class RimTotalWellAllocationPlot;
class RimWellLogFile;
class RimWellLogFileChannel;
class RimWellLogPlot;
class RimWellLogTrack;
class RiuWellRftPlot;

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

@ -33,20 +33,20 @@
#include <set>
#include <map>
class RimEclipseResultCase;
class RimEclipseCase;
class RimEclipseWell;
class RimFlowDiagSolution;
class RimTotalWellAllocationPlot;
class RimWellLogPlot;
class RiuWellRftPlot;
class RimWellLogTrack;
class RimTofAccumulatedPhaseFractionsPlot;
class RigSingleWellResultsData;
class RimWellLogFileChannel;
class RimWellPath;
class RimWellLogCurve;
class RigWellPath;
class RimEclipseCase;
class RimEclipseResultCase;
class RimFlowDiagSolution;
class RimSimWellInView;
class RimTofAccumulatedPhaseFractionsPlot;
class RimTotalWellAllocationPlot;
class RimWellLogCurve;
class RimWellLogFileChannel;
class RimWellLogPlot;
class RimWellLogTrack;
class RimWellPath;
class RiuWellRftPlot;
namespace cvf {
class Color3f;

6
ApplicationCode/ProjectDataModel/RimContextCommandBuilder.cpp
View File

@ -32,7 +32,6 @@
#include "RimEclipsePropertyFilterCollection.h"
#include "RimEclipseStatisticsCase.h"
#include "RimEclipseView.h"
#include "RimEclipseWell.h"
#include "RimEclipseWellCollection.h"
#include "RimFault.h"
#include "RimFlowCharacteristicsPlot.h"
@ -50,6 +49,7 @@
#include "RimIntersectionCollection.h"
#include "RimObservedData.h"
#include "RimScriptCollection.h"
#include "RimSimWellInView.h"
#include "RimSummaryCase.h"
#include "RimSummaryCurve.h"
#include "RimSummaryCurveCollection.h"
@ -364,7 +364,7 @@ QStringList RimContextCommandBuilder::commandsFromSelection()
commandIds << "RicAppendIntersectionFeature";
commandIds << "RicAppendIntersectionBoxFeature";
}
else if (dynamic_cast<RimEclipseWell*>(uiItem))
else if (dynamic_cast<RimSimWellInView*>(uiItem))
{
commandIds << "RicNewWellLogCurveExtractionFeature";
commandIds << "RicNewWellLogRftCurveFeature";
@ -526,7 +526,7 @@ QStringList RimContextCommandBuilder::commandsFromSelection()
{
commandIds << "RicExportFaultsFeature";
}
else if (dynamic_cast<RimEclipseWell*>(uiItem))
else if (dynamic_cast<RimSimWellInView*>(uiItem))
{
commandIds << "RicPlotProductionRateFeature";
commandIds << "RicShowContributingWellsFeature";

4
ApplicationCode/ProjectDataModel/RimEclipseCellColors.cpp
View File

@ -29,9 +29,9 @@
#include "RimEclipseCase.h"
#include "RimEclipseFaultColors.h"
#include "RimEclipseView.h"
#include "RimEclipseWell.h"
#include "RimEclipseWellCollection.h"
#include "RimLegendConfig.h"
#include "RimSimWellInView.h"
#include "RimTernaryLegendConfig.h"
#include "RimViewController.h"
#include "RimViewLinker.h"
@ -316,7 +316,7 @@ void RimEclipseCellColors::updateLegendData(size_t currentTimeStep)
int tracerIndex = 0;
for (const auto& tracerName : tracerNames)
{
RimEclipseWell* well = m_reservoirView->wellCollection()->findWell(RimFlowDiagSolution::removeCrossFlowEnding(tracerName));
RimSimWellInView* well = m_reservoirView->wellCollection()->findWell(RimFlowDiagSolution::removeCrossFlowEnding(tracerName));
cvf::Color3ub color(cvf::Color3::GRAY);
if (well) color = cvf::Color3ub(well->wellPipeColor());

18
ApplicationCode/ProjectDataModel/RimEclipseView.cpp
View File

@ -41,9 +41,9 @@
#include "RimEclipseFaultColors.h"
#include "RimEclipsePropertyFilterCollection.h"
#include "RimEclipseResultDefinition.h"
#include "RimEclipseWell.h"
#include "RimEclipseWellCollection.h"
#include "RimFaultCollection.h"
#include "RimFlowCharacteristicsPlot.h"
#include "RimFlowDiagSolution.h"
#include "RimGridCollection.h"
#include "RimIntersection.h"
@ -52,12 +52,12 @@
#include "RimOilField.h"
#include "RimProject.h"
#include "RimReservoirCellResultsStorage.h"
#include "RimSimWellInView.h"
#include "RimStimPlanColors.h"
#include "RimTernaryLegendConfig.h"
#include "RimViewController.h"
#include "RimViewLinker.h"
#include "RimWellPathCollection.h"
#include "RimFlowCharacteristicsPlot.h"
#include "RiuMainWindow.h"
#include "RiuSelectionManager.h"
@ -705,7 +705,7 @@ void RimEclipseView::updateCurrentTimeStep()
this->descendantsIncludingThisOfType(fractures);
for (RimFracture* f : fractures)
{
RimEclipseWell* eclWell = nullptr;
RimSimWellInView* eclWell = nullptr;
f->firstAncestorOrThisOfType(eclWell);
if (eclWell)
{
@ -1195,12 +1195,12 @@ void RimEclipseView::syncronizeWellsWithResults()
cvf::Collection<RigSingleWellResultsData> wellResults = m_eclipseCase->eclipseCaseData()->wellResults();
std::vector<caf::PdmPointer<RimEclipseWell> > newWells;
std::vector<caf::PdmPointer<RimSimWellInView> > newWells;
// Clear the possible well results data present
for (size_t wIdx = 0; wIdx < this->wellCollection()->wells().size(); ++wIdx)
{
RimEclipseWell* well = this->wellCollection()->wells()[wIdx];
RimSimWellInView* well = this->wellCollection()->wells()[wIdx];
well->setWellResults(NULL, -1);
}
@ -1210,11 +1210,11 @@ void RimEclipseView::syncronizeWellsWithResults()
for (size_t wIdx = 0; wIdx < wellResults.size(); ++wIdx)
{
RimEclipseWell* well = this->wellCollection()->findWell(wellResults[wIdx]->m_wellName);
RimSimWellInView* well = this->wellCollection()->findWell(wellResults[wIdx]->m_wellName);
if (!well)
{
well = new RimEclipseWell;
well = new RimSimWellInView;
well->name = wellResults[wIdx]->m_wellName;
isAnyWellCreated = true;
@ -1228,7 +1228,7 @@ void RimEclipseView::syncronizeWellsWithResults()
for (size_t wIdx = 0; wIdx < this->wellCollection()->wells().size(); ++wIdx)
{
RimEclipseWell* well = this->wellCollection()->wells()[wIdx];
RimSimWellInView* well = this->wellCollection()->wells()[wIdx];
RigSingleWellResultsData* wellRes = well->wellResults();
if (wellRes == NULL)
{
@ -1289,7 +1289,7 @@ void RimEclipseView::calculateVisibleWellCellsIncFence(cvf::UByteArray* visibleC
// Loop over the wells and find their contribution
for (size_t wIdx = 0; wIdx < this->wellCollection()->wells().size(); ++wIdx)
{
RimEclipseWell* well = this->wellCollection()->wells()[wIdx];
RimSimWellInView* well = this->wellCollection()->wells()[wIdx];
if (well->isWellCellsVisible())
{
RigSingleWellResultsData* wres = well->wellResults();

2
ApplicationCode/ProjectDataModel/RimEclipseView.h
View File

@ -49,11 +49,11 @@ class RimEclipseCellColors;
class RimEclipseFaultColors;
class RimEclipsePropertyFilter;
class RimEclipsePropertyFilterCollection;
class RimEclipseWell;
class RimEclipseWellCollection;
class RimFaultCollection;
class RimReservoirCellResultsStorage;
class RimReservoirCellResultsStorage;
class RimSimWellInView;
#ifdef USE_PROTOTYPE_FEATURE_FRACTURES
class RimStimPlanColors;
#endif // USE_PROTOTYPE_FEATURE_FRACTURES

44
ApplicationCode/ProjectDataModel/RimEclipseWellCollection.cpp
View File

@ -29,8 +29,8 @@
#include "RimEclipseCase.h"
#include "RimEclipseView.h"
#include "RimEclipseWell.h"
#include "RimProject.h"
#include "RimSimWellInView.h"
#include "RimWellAllocationPlot.h"
#ifdef USE_PROTOTYPE_FEATURE_FRACTURES
#include "RimSimWellFracture.h"
@ -231,7 +231,7 @@ RimEclipseWellCollection::~RimEclipseWellCollection()
//--------------------------------------------------------------------------------------------------
void RimEclipseWellCollection::setShowWellCellsState(bool enable)
{
for (RimEclipseWell* w : wells)
for (RimSimWellInView* w : wells)
{
w->showWellCells = enable;
}
@ -263,7 +263,7 @@ bool RimEclipseWellCollection::showWellCells()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimEclipseWell* RimEclipseWellCollection::findWell(QString name)
RimSimWellInView* RimEclipseWellCollection::findWell(QString name)
{
for (size_t i = 0; i < this->wells().size(); ++i)
{
@ -286,7 +286,7 @@ bool RimEclipseWellCollection::hasVisibleWellCells()
bool hasCells = false;
for (size_t i = 0 ; !hasCells && i < this->wells().size(); ++i)
{
RimEclipseWell* well = this->wells()[i];
RimSimWellInView* well = this->wells()[i];
if ( well && well->wellResults() && ((well->showWell() && well->showWellCells())) )
{
for (size_t tIdx = 0; !hasCells && tIdx < well->wellResults()->m_wellCellsTimeSteps.size(); ++tIdx )
@ -330,7 +330,7 @@ void RimEclipseWellCollection::fieldChangedByUi(const caf::PdmFieldHandle* chang
if (&m_showWellLabel == changedField)
{
for (RimEclipseWell* w : wells)
for (RimSimWellInView* w : wells)
{
w->showWellLabel = !(m_showWellLabel().isFalse());
w->updateConnectedEditors();
@ -339,7 +339,7 @@ void RimEclipseWellCollection::fieldChangedByUi(const caf::PdmFieldHandle* chang
if (&m_showWellHead == changedField)
{
for (RimEclipseWell* w : wells)
for (RimSimWellInView* w : wells)
{
w->showWellHead = !(m_showWellHead().isFalse());
w->updateConnectedEditors();
@ -348,7 +348,7 @@ void RimEclipseWellCollection::fieldChangedByUi(const caf::PdmFieldHandle* chang
if (&m_showWellPipe == changedField)
{
for (RimEclipseWell* w : wells)
for (RimSimWellInView* w : wells)
{
w->showWellPipe = !(m_showWellPipe().isFalse());
w->updateConnectedEditors();
@ -357,7 +357,7 @@ void RimEclipseWellCollection::fieldChangedByUi(const caf::PdmFieldHandle* chang
if (&m_showWellSpheres == changedField)
{
for (RimEclipseWell* w : wells)
for (RimSimWellInView* w : wells)
{
w->showWellSpheres = !(m_showWellSpheres().isFalse());
w->updateConnectedEditors();
@ -366,7 +366,7 @@ void RimEclipseWellCollection::fieldChangedByUi(const caf::PdmFieldHandle* chang
if (&m_showWellCells == changedField)
{
for (RimEclipseWell* w : wells)
for (RimSimWellInView* w : wells)
{
w->showWellCells = !(m_showWellCells().isFalse());
w->updateConnectedEditors();
@ -375,7 +375,7 @@ void RimEclipseWellCollection::fieldChangedByUi(const caf::PdmFieldHandle* chang
if (&m_showWellCellFence == changedField)
{
for (RimEclipseWell* w : wells)
for (RimSimWellInView* w : wells)
{
w->showWellCellFence = !(m_showWellCellFence().isFalse());
w->updateConnectedEditors();
@ -464,7 +464,7 @@ void RimEclipseWellCollection::fieldChangedByUi(const caf::PdmFieldHandle* chang
#ifdef USE_PROTOTYPE_FEATURE_FRACTURES
if (&wellPipeCoordType == changedField)
{
for (RimEclipseWell* w : wells)
for (RimSimWellInView* w : wells)
{
for (RimSimWellFracture* frac : w->simwellFractureCollection()->simwellFractures())
{
@ -487,7 +487,7 @@ void RimEclipseWellCollection::assignDefaultWellColors()
for (size_t wIdx = 0; wIdx < wells.size(); ++wIdx)
{
RimEclipseWell* well = wells[wIdx];
RimSimWellInView* well = wells[wIdx];
if (well && well->wellResults() )
{
well->wellPipeColor = ownerCase->defaultWellColor(well->wellResults()->m_wellName);
@ -583,7 +583,7 @@ void RimEclipseWellCollection::updateStateForVisibilityCheckboxes()
size_t showWellCellsCount = 0;
size_t showWellCellFenceCount = 0;
for (RimEclipseWell* w : wells)
for (RimSimWellInView* w : wells)
{
if (w->showWellLabel()) showLabelCount++;
if (w->showWellHead()) showWellHeadCount++;
@ -646,7 +646,7 @@ void RimEclipseWellCollection::initAfterRead()
{
showWellsIntersectingVisibleCells = false;
for (RimEclipseWell* w : wells)
for (RimSimWellInView* w : wells)
{
w->showWellPipe = false;
}
@ -655,7 +655,7 @@ void RimEclipseWellCollection::initAfterRead()
{
showWellsIntersectingVisibleCells = false;
for (RimEclipseWell* w : wells)
for (RimSimWellInView* w : wells)
{
w->showWellPipe = true;
}
@ -663,14 +663,14 @@ void RimEclipseWellCollection::initAfterRead()
if (obsoleteField_wellCellsToRangeFilterMode() == RANGE_ADD_NONE)
{
for (RimEclipseWell* w : wells)
for (RimSimWellInView* w : wells)
{
w->showWellCells = false;
}
}
else if (obsoleteField_wellCellsToRangeFilterMode() == RANGE_ADD_ALL)
{
for (RimEclipseWell* w : wells)
for (RimSimWellInView* w : wells)
{
w->showWellCells = true;
}
@ -678,7 +678,7 @@ void RimEclipseWellCollection::initAfterRead()
if (!obsoleteField_showWellLabel())
{
for (RimEclipseWell* w : wells)
for (RimSimWellInView* w : wells)
{
w->showWellLabel = false;
}
@ -686,7 +686,7 @@ void RimEclipseWellCollection::initAfterRead()
if (!obsoleteField_showWellHead())
{
for (RimEclipseWell* w : wells)
for (RimSimWellInView* w : wells)
{
w->showWellHead = false;
}
@ -694,7 +694,7 @@ void RimEclipseWellCollection::initAfterRead()
if (obsoleteField_showWellCellFence())
{
for (RimEclipseWell* w : wells)
for (RimSimWellInView* w : wells)
{
w->showWellCellFence = true;
}
@ -764,7 +764,7 @@ void RimEclipseWellCollection::calculateWellGeometryVisibility(size_t frameIndex
if (m_framesOfResultWellPipeVisibilities[frameIndex].size() <= wells().size())
m_framesOfResultWellPipeVisibilities[frameIndex].resize(wells().size(), false);
for (const RimEclipseWell* well : wells())
for (const RimSimWellInView* well : wells())
{
bool wellPipeVisible = well->isWellPipeVisible(frameIndex);
bool wellSphereVisible = well->isWellSpheresVisible(frameIndex);
@ -773,7 +773,7 @@ void RimEclipseWellCollection::calculateWellGeometryVisibility(size_t frameIndex
}
}
bool lessEclipseWell(const caf::PdmPointer<RimEclipseWell>& w1, const caf::PdmPointer<RimEclipseWell>& w2)
bool lessEclipseWell(const caf::PdmPointer<RimSimWellInView>& w1, const caf::PdmPointer<RimSimWellInView>& w2)
{
if (w1.notNull() && w2.notNull())
return (w1->name() < w2->name());

6
ApplicationCode/ProjectDataModel/RimEclipseWellCollection.h
View File

@ -29,7 +29,7 @@
#include "cafTristate.h"
class RimEclipseView;
class RimEclipseWell;
class RimSimWellInView;
//==================================================================================================
///
@ -110,9 +110,9 @@ public:
caf::PdmField<bool> isAutoDetectingBranches;
caf::PdmChildArrayField<RimEclipseWell*> wells;
caf::PdmChildArrayField<RimSimWellInView*> wells;
RimEclipseWell* findWell(QString name);
RimSimWellInView* findWell(QString name);
bool hasVisibleWellCells();
bool hasVisibleWellPipes();
void sortWellsByName();

6
ApplicationCode/ProjectDataModel/RimIntersection.cpp
View File

@ -26,10 +26,10 @@
#include "RimCase.h"
#include "RimEclipseView.h"
#include "RimEclipseWell.h"
#include "RimEclipseWellCollection.h"
#include "RimOilField.h"
#include "RimProject.h"
#include "RimSimWellInView.h"
#include "RimTools.h"
#include "RimView.h"
#include "RimWellPath.h"
@ -252,10 +252,10 @@ QList<caf::PdmOptionItemInfo> RimIntersection::calculateValueOptions(const caf::
RimEclipseWellCollection* coll = simulationWellCollection();
if (coll)
{
caf::PdmChildArrayField<RimEclipseWell*>& eclWells = coll->wells;
caf::PdmChildArrayField<RimSimWellInView*>& eclWells = coll->wells;
QIcon simWellIcon(":/Well.png");
for (RimEclipseWell* eclWell : eclWells)
for (RimSimWellInView* eclWell : eclWells)
{
options.push_back(caf::PdmOptionItemInfo(eclWell->name(), eclWell, false, simWellIcon));
}

4
ApplicationCode/ProjectDataModel/RimIntersection.h
View File

@ -29,7 +29,7 @@
#include "cvfObject.h"
#include "cvfVector3.h"
class RimEclipseWell;
class RimSimWellInView;
class RimEclipseWellCollection;
class RimWellPath;
class RivIntersectionPartMgr;
@ -70,7 +70,7 @@ public:
caf::PdmField< bool > showInactiveCells;
caf::PdmPtrField<RimWellPath*> wellPath;
caf::PdmPtrField<RimEclipseWell*> simulationWell;
caf::PdmPtrField<RimSimWellInView*> simulationWell;
caf::PdmField< bool > inputPolyLineFromViewerEnabled;
caf::PdmField< bool > inputExtrusionPointsFromViewerEnabled;

4
ApplicationCode/ProjectDataModel/RimIntersectionCollection.cpp
View File

@ -19,9 +19,9 @@
#include "RimIntersectionCollection.h"
#include "RimEclipseWell.h"
#include "RimIntersection.h"
#include "RimIntersectionBox.h"
#include "RimSimWellInView.h"
#include "RimView.h"
#include "RiuMainWindow.h"
@ -191,7 +191,7 @@ void RimIntersectionCollection::fieldChangedByUi(const caf::PdmFieldHandle* chan
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimIntersectionCollection::hasActiveIntersectionForSimulationWell(const RimEclipseWell* eclipseWell) const
bool RimIntersectionCollection::hasActiveIntersectionForSimulationWell(const RimSimWellInView* eclipseWell) const
{
if (!isActive) return false;

4
ApplicationCode/ProjectDataModel/RimIntersectionCollection.h
View File

@ -26,7 +26,7 @@
class RimIntersection;
class RimIntersectionBox;
class RimEclipseCellColors;
class RimEclipseWell;
class RimSimWellInView;
namespace cvf {
class ModelBasicList;
@ -51,7 +51,7 @@ public:
void appendIntersection(RimIntersection* intersection);
void appendIntersectionBox(RimIntersectionBox* intersectionBox);
bool hasActiveIntersectionForSimulationWell(const RimEclipseWell* eclipseWell) const;
bool hasActiveIntersectionForSimulationWell(const RimSimWellInView* eclipseWell) const;
void updateIntersectionBoxGeometry();

48
ApplicationCode/ProjectDataModel/RimEclipseWell.cpp → ApplicationCode/ProjectDataModel/RimSimWellInView.cpp
View File

@ -18,7 +18,7 @@
//
/////////////////////////////////////////////////////////////////////////////////
#include "RimEclipseWell.h"
#include "RimSimWellInView.h"
#include "RigSimulationWellCenterLineCalculator.h"
#include "RigSingleWellResultsData.h"
@ -46,12 +46,12 @@
#include "RigMainGrid.h"
#include "RigActiveCellInfo.h"
CAF_PDM_SOURCE_INIT(RimEclipseWell, "Well");
CAF_PDM_SOURCE_INIT(RimSimWellInView, "Well");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimEclipseWell::RimEclipseWell()
RimSimWellInView::RimSimWellInView()
{
CAF_PDM_InitObject("Well", ":/Well.png", "", "");
@ -88,7 +88,7 @@ RimEclipseWell::RimEclipseWell()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimEclipseWell::~RimEclipseWell()
RimSimWellInView::~RimSimWellInView()
{
#ifdef USE_PROTOTYPE_FEATURE_FRACTURES
if (simwellFractureCollection()) delete simwellFractureCollection();
@ -98,7 +98,7 @@ RimEclipseWell::~RimEclipseWell()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
caf::PdmFieldHandle* RimEclipseWell::userDescriptionField()
caf::PdmFieldHandle* RimSimWellInView::userDescriptionField()
{
return &name;
}
@ -106,7 +106,7 @@ caf::PdmFieldHandle* RimEclipseWell::userDescriptionField()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEclipseWell::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
void RimSimWellInView::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
{
RimEclipseView* reservoirView = nullptr;
this->firstAncestorOrThisOfType(reservoirView);
@ -157,7 +157,7 @@ void RimEclipseWell::fieldChangedByUi(const caf::PdmFieldHandle* changedField, c
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
caf::PdmFieldHandle* RimEclipseWell::objectToggleField()
caf::PdmFieldHandle* RimSimWellInView::objectToggleField()
{
return &showWell;
}
@ -165,7 +165,7 @@ caf::PdmFieldHandle* RimEclipseWell::objectToggleField()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEclipseWell::calculateWellPipeStaticCenterLine(std::vector< std::vector <cvf::Vec3d> >& pipeBranchesCLCoords,
void RimSimWellInView::calculateWellPipeStaticCenterLine(std::vector< std::vector <cvf::Vec3d> >& pipeBranchesCLCoords,
std::vector< std::vector <RigWellResultPoint> >& pipeBranchesCellIds)
{
RigSimulationWellCenterLineCalculator::calculateWellPipeStaticCenterline(this, pipeBranchesCLCoords, pipeBranchesCellIds);
@ -174,7 +174,7 @@ void RimEclipseWell::calculateWellPipeStaticCenterLine(std::vector< std::vector
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEclipseWell::calculateWellPipeDynamicCenterLine(size_t timeStepIdx,
void RimSimWellInView::calculateWellPipeDynamicCenterLine(size_t timeStepIdx,
std::vector< std::vector <cvf::Vec3d> >& pipeBranchesCLCoords,
std::vector< std::vector <RigWellResultPoint> >& pipeBranchesCellIds) const
{
@ -184,7 +184,7 @@ void RimEclipseWell::calculateWellPipeDynamicCenterLine(size_t timeStepIdx,
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEclipseWell::wellHeadTopBottomPosition(size_t frameIndex, cvf::Vec3d* top, cvf::Vec3d* bottom)
void RimSimWellInView::wellHeadTopBottomPosition(size_t frameIndex, cvf::Vec3d* top, cvf::Vec3d* bottom)
{
RimEclipseView* m_rimReservoirView;
@ -242,7 +242,7 @@ void RimEclipseWell::wellHeadTopBottomPosition(size_t frameIndex, cvf::Vec3d* to
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimEclipseWell::pipeRadius()
double RimSimWellInView::pipeRadius()
{
RimEclipseView* reservoirView;
firstAncestorOrThisOfTypeAsserted(reservoirView);
@ -259,7 +259,7 @@ double RimEclipseWell::pipeRadius()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimEclipseWell::intersectsDynamicWellCellsFilteredCells(size_t frameIndex) const
bool RimSimWellInView::intersectsDynamicWellCellsFilteredCells(size_t frameIndex) const
{
if (this->wellResults() == nullptr) return false;
@ -273,7 +273,7 @@ bool RimEclipseWell::intersectsDynamicWellCellsFilteredCells(size_t frameIndex)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimEclipseWell::intersectsWellCellsFilteredCells(const RigWellResultFrame &wrsf, size_t frameIndex) const
bool RimSimWellInView::intersectsWellCellsFilteredCells(const RigWellResultFrame &wrsf, size_t frameIndex) const
{
RimEclipseView* reservoirView = nullptr;
this->firstAncestorOrThisOfType(reservoirView);
@ -339,7 +339,7 @@ bool RimEclipseWell::intersectsWellCellsFilteredCells(const RigWellResultFrame &
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimEclipseWell::intersectsStaticWellCellsFilteredCells() const
bool RimSimWellInView::intersectsStaticWellCellsFilteredCells() const
{
if (this->wellResults() == nullptr) return false;
@ -355,7 +355,7 @@ bool RimEclipseWell::intersectsStaticWellCellsFilteredCells() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEclipseWell::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
void RimSimWellInView::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
caf::PdmUiGroup* appearanceGroup = uiOrdering.addNewGroup("Visibility");
appearanceGroup->add(&showWellLabel);
@ -381,7 +381,7 @@ void RimEclipseWell::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering&
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEclipseWell::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName /*= ""*/)
void RimSimWellInView::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName /*= ""*/)
{
#ifdef USE_PROTOTYPE_FEATURE_FRACTURES
for (RimSimWellFracture* fracture : simwellFractureCollection()->simwellFractures())
@ -422,7 +422,7 @@ void RimEclipseWell::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimEclipseWell::isWellCellsVisible() const
bool RimSimWellInView::isWellCellsVisible() const
{
const RimEclipseView* reservoirView = nullptr;
this->firstAncestorOrThisOfType(reservoirView);
@ -456,7 +456,7 @@ bool RimEclipseWell::isWellCellsVisible() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimEclipseWell::isWellPipeVisible(size_t frameIndex) const
bool RimSimWellInView::isWellPipeVisible(size_t frameIndex) const
{
const RimEclipseView* reservoirView = nullptr;
this->firstAncestorOrThisOfType(reservoirView);
@ -502,7 +502,7 @@ bool RimEclipseWell::isWellPipeVisible(size_t frameIndex) const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimEclipseWell::isWellSpheresVisible(size_t frameIndex) const
bool RimSimWellInView::isWellSpheresVisible(size_t frameIndex) const
{
const RimEclipseView* reservoirView = nullptr;
this->firstAncestorOrThisOfType(reservoirView);
@ -551,7 +551,7 @@ bool RimEclipseWell::isWellSpheresVisible(size_t frameIndex) const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimEclipseWell::isUsingCellCenterForPipe() const
bool RimSimWellInView::isUsingCellCenterForPipe() const
{
const RimEclipseWellCollection* wellColl = nullptr;
this->firstAncestorOrThisOfType(wellColl);
@ -562,7 +562,7 @@ bool RimEclipseWell::isUsingCellCenterForPipe() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEclipseWell::setWellResults(RigSingleWellResultsData* wellResults, size_t resultWellIndex)
void RimSimWellInView::setWellResults(RigSingleWellResultsData* wellResults, size_t resultWellIndex)
{
m_wellResults = wellResults;
m_resultWellIndex = resultWellIndex;
@ -571,7 +571,7 @@ void RimEclipseWell::setWellResults(RigSingleWellResultsData* wellResults, size_
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigSingleWellResultsData* RimEclipseWell::wellResults()
RigSingleWellResultsData* RimSimWellInView::wellResults()
{
return m_wellResults.p();
}
@ -579,7 +579,7 @@ RigSingleWellResultsData* RimEclipseWell::wellResults()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RigSingleWellResultsData* RimEclipseWell::wellResults() const
const RigSingleWellResultsData* RimSimWellInView::wellResults() const
{
return m_wellResults.p();
}
@ -587,7 +587,7 @@ const RigSingleWellResultsData* RimEclipseWell::wellResults() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RimEclipseWell::resultWellIndex() const
size_t RimSimWellInView::resultWellIndex() const
{
return m_resultWellIndex;
}

6
ApplicationCode/ProjectDataModel/RimEclipseWell.h → ApplicationCode/ProjectDataModel/RimSimWellInView.h
View File

@ -45,13 +45,13 @@ class RimSimWellFractureCollection;
///
///
//==================================================================================================
class RimEclipseWell : public caf::PdmObject
class RimSimWellInView : public caf::PdmObject
{
CAF_PDM_HEADER_INIT;
public:
RimEclipseWell();
virtual ~RimEclipseWell();
RimSimWellInView();
virtual ~RimSimWellInView();
void setWellResults(RigSingleWellResultsData* wellResults, size_t resultWellIndex);
RigSingleWellResultsData* wellResults();

2
ApplicationCode/ProjectDataModel/RimWellLogExtractionCurve.cpp
View File

@ -44,6 +44,7 @@
#include "RimMainPlotCollection.h"
#include "RimOilField.h"
#include "RimProject.h"
#include "RimSimWellInView.h"
#include "RimTools.h"
#include "RimWellLogCurve.h"
#include "RimWellLogPlot.h"
@ -59,7 +60,6 @@
#include "cafUtils.h"
#include <cmath>
#include "RimEclipseWell.h"
//==================================================================================================
///

8
ApplicationCode/ReservoirDataModel/RigSimulationWellCenterLineCalculator.cpp
View File

@ -19,13 +19,13 @@
#include "RigSimulationWellCenterLineCalculator.h"
#include "RigEclipseCaseData.h"
#include "RigCell.h"
#include "RigEclipseCaseData.h"
#include "RimEclipseCase.h"
#include "RimEclipseView.h"
#include "RimEclipseWell.h"
#include "RimEclipseWellCollection.h"
#include "RimSimWellInView.h"
#include "cvfRay.h"
@ -34,7 +34,7 @@
/// The returned CellIds is one less than the number of centerline points,
/// and are describing the lines between the points, starting with the first line
//--------------------------------------------------------------------------------------------------
void RigSimulationWellCenterLineCalculator::calculateWellPipeStaticCenterline(RimEclipseWell* rimWell,
void RigSimulationWellCenterLineCalculator::calculateWellPipeStaticCenterline(RimSimWellInView* rimWell,
std::vector< std::vector <cvf::Vec3d> >& pipeBranchesCLCoords,
std::vector< std::vector <RigWellResultPoint> >& pipeBranchesCellIds)
{
@ -45,7 +45,7 @@ void RigSimulationWellCenterLineCalculator::calculateWellPipeStaticCenterline(Ri
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigSimulationWellCenterLineCalculator::calculateWellPipeDynamicCenterline(const RimEclipseWell* rimWell,
void RigSimulationWellCenterLineCalculator::calculateWellPipeDynamicCenterline(const RimSimWellInView* rimWell,
size_t timeStepIndex,
std::vector< std::vector <cvf::Vec3d> >& pipeBranchesCLCoords,
std::vector< std::vector <RigWellResultPoint> >& pipeBranchesCellIds)

6
ApplicationCode/ReservoirDataModel/RigSimulationWellCenterLineCalculator.h
View File

@ -22,17 +22,17 @@
#include "cvfVector3.h"
#include <vector>
class RimEclipseWell;
class RigEclipseCaseData;
class RimSimWellInView;
class RigSimulationWellCenterLineCalculator
{
public:
static void calculateWellPipeStaticCenterline(RimEclipseWell* rimWell,
static void calculateWellPipeStaticCenterline(RimSimWellInView* rimWell,
std::vector< std::vector <cvf::Vec3d> >& pipeBranchesCLCoords,
std::vector< std::vector <RigWellResultPoint> >& pipeBranchesCellIds) ;
static void calculateWellPipeDynamicCenterline(const RimEclipseWell* rimWell,
static void calculateWellPipeDynamicCenterline(const RimSimWellInView* rimWell,
size_t timeStepIndex,
std::vector< std::vector <cvf::Vec3d> >& pipeBranchesCLCoords,
std::vector< std::vector <RigWellResultPoint> >& pipeBranchesCellIds) ;

3
ApplicationCode/UserInterface/RiuSelectionManager.cpp
View File

@ -21,6 +21,7 @@
#include "RimEclipseView.h"
#include "RimGeoMechView.h"
#include "RimSimWellInView.h"
#include "RimWellPath.h"
#include "RivSimWellPipeSourceInfo.h"
@ -221,7 +222,7 @@ RiuWellPathSelectionItem::RiuWellPathSelectionItem(const RivWellPathSourceInfo*
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiuSimWellSelectionItem::RiuSimWellSelectionItem(RimEclipseWell* simwell,
RiuSimWellSelectionItem::RiuSimWellSelectionItem(RimSimWellInView* simwell,
cvf::Vec3d m_domainCoord,
size_t m_branchIndex)
: m_simWell(simwell),

12
ApplicationCode/UserInterface/RiuSelectionManager.h
View File

@ -28,17 +28,17 @@
#include <vector>
#include <assert.h>
#include <array>
#include "RimEclipseWell.h"
// #include "RivWellPathSourceInfo.h"
// #include "RivWellPipeSourceInfo.h"
class RimEclipseView;
class RimGeoMechView;
class RimSimWellInView;
class RimWellPath;
class RiuSelectionChangedHandler;
class RiuSelectionItem;
class RimGeoMechView;
class RimWellPath;
class RivWellPathSourceInfo;
class RivSimWellPipeSourceInfo;
class RivWellPathSourceInfo;
//==================================================================================================
//
@ -223,7 +223,7 @@ public:
class RiuSimWellSelectionItem : public RiuSelectionItem
{
public:
explicit RiuSimWellSelectionItem(RimEclipseWell* simwell, cvf::Vec3d domainCoord, size_t branchIndex);
explicit RiuSimWellSelectionItem(RimSimWellInView* simwell, cvf::Vec3d domainCoord, size_t branchIndex);
virtual ~RiuSimWellSelectionItem() {};
@ -234,7 +234,7 @@ public:
}
public:
RimEclipseWell* m_simWell;
RimSimWellInView* m_simWell;
cvf::Vec3d m_domainCoord;
size_t m_branchIndex;
};

8
ApplicationCode/UserInterface/RiuViewerCommands.cpp
View File

@ -35,22 +35,22 @@
#include "RigGeoMechCaseData.h"
#include "RigMainGrid.h"
#include "RiaDefines.h"
#include "RimCellEdgeColors.h"
#include "RimContextCommandBuilder.h"
#include "RimIntersection.h"
#include "RiaDefines.h"
#include "RimEclipseCase.h"
#include "RimEclipseCellColors.h"
#include "RimEclipseFaultColors.h"
#include "RimEclipseView.h"
#include "RimEclipseWell.h"
#include "RimFault.h"
#include "RimFaultCollection.h"
#include "RimGeoMechCase.h"
#include "RimGeoMechCellColors.h"
#include "RimGeoMechView.h"
#include "RimIntersection.h"
#include "RimIntersectionBox.h"
#include "RimLegendConfig.h"
#include "RimSimWellInView.h"
#include "RimTernaryLegendConfig.h"
#include "RimViewController.h"
#include "RimWellPath.h"
@ -316,7 +316,7 @@ void RiuViewerCommands::displayContextMenu(QMouseEvent* event)
const RivSimWellPipeSourceInfo* eclipseWellSourceInfo = dynamic_cast<const RivSimWellPipeSourceInfo*>(firstHitPart->sourceInfo());
if (eclipseWellSourceInfo)
{
RimEclipseWell* well = eclipseWellSourceInfo->well();
RimSimWellInView* well = eclipseWellSourceInfo->well();
if (well)
{
caf::SelectionManager::instance()->setSelectedItem(well);