#1996 Rename RimEclipseWell -> RimSimWellInView

ApplicationCode/CommandFileInterface/RicfExportSimWellCompletions.cpp

@@ -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 "RimOilField.h"
-#include "RimWellPathCollection.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);

ApplicationCode/CommandFileInterface/RicfExportWellPathCompletions.cpp

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

ApplicationCode/Commands/CompletionCommands/RicExportFractureCompletionsImpl.cpp

@@ -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 "RimFracture.h"
-#include "RimSimWellFractureCollection.h"
+#include "RimFractureTemplate.h"
-#include "RimStimPlanFractureTemplate.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;

ApplicationCode/Commands/CompletionCommands/RicExportFractureCompletionsImpl.h

@@ -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:

ApplicationCode/Commands/CompletionCommands/RicWellPathExportCompletionDataFeature.cpp

@@ -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 "RimSimWellInView.h"
-#include "RimEclipseWellCollection.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);

ApplicationCode/Commands/CompletionCommands/RicWellPathExportCompletionDataFeature.h

@@ -31,13 +31,13 @@
 #include "cvfBoundingBox.h"
 
 
-class RimWellPath;
+class RigCell;
-class RimEclipseCase;
-class RimEclipseWell;
 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, 

ApplicationCode/Commands/CrossSectionCommands/RicNewSimWellIntersectionFeature.cpp

@@ -19,10 +19,10 @@
 
 #include "RicNewSimWellIntersectionFeature.h"
 
+#include "RimEclipseView.h"
 #include "RimIntersection.h"
 #include "RimIntersectionCollection.h"
-#include "RimEclipseView.h"
+#include "RimSimWellInView.h"
-#include "RimEclipseWell.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)

ApplicationCode/Commands/CrossSectionCommands/RicNewSimWellIntersectionFeature.h

@@ -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;
 };
 
 

ApplicationCode/Commands/EclipseCommands/EclipseWell/RicEclipseWellFeatureImpl.cpp

@@ -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);

ApplicationCode/Commands/EclipseCommands/EclipseWell/RicEclipseWellFeatureImpl.h

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

ApplicationCode/Commands/EclipseCommands/EclipseWell/RicEclipseWellShowFeatures.cpp

@@ -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();
+    std::vector<RimSimWellInView*> selection = RicEclipseWellFeatureImpl::selectedWells();
-    for (RimEclipseWell* w : selection)
+    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();
+    std::vector<RimSimWellInView*> selection = RicEclipseWellFeatureImpl::selectedWells();
-    for (RimEclipseWell* w : selection)
+    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();
+    std::vector<RimSimWellInView*> selection = RicEclipseWellFeatureImpl::selectedWells();
-    for (RimEclipseWell* w : selection)
+    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();
+    std::vector<RimSimWellInView*> selection = RicEclipseWellFeatureImpl::selectedWells();
-    for (RimEclipseWell* w : selection)
+    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();
+    std::vector<RimSimWellInView*> selection = RicEclipseWellFeatureImpl::selectedWells();
-    for (RimEclipseWell* w : selection)
+    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();
+    std::vector<RimSimWellInView*> selection = RicEclipseWellFeatureImpl::selectedWells();
-    for (RimEclipseWell* w : selection)
+    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();
     }

ApplicationCode/Commands/FlowCommands/RicPlotProductionRateFeature.cpp

@@ -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)
 {

ApplicationCode/Commands/FlowCommands/RicPlotProductionRateFeature.h

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

ApplicationCode/Commands/FlowCommands/RicShowContributingWellsFeature.cpp

@@ -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);
 

ApplicationCode/Commands/FlowCommands/RicShowContributingWellsFeatureImpl.cpp

@@ -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())

ApplicationCode/Commands/FlowCommands/RicShowContributingWellsFeatureImpl.h

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

ApplicationCode/Commands/FlowCommands/RicShowFlowCharacteristicsPlotFeature.h

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

ApplicationCode/Commands/FlowCommands/RicShowWellAllocationPlotFeature.cpp

@@ -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())
         {

ApplicationCode/Commands/FlowCommands/RicShowWellAllocationPlotFeature.h

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

ApplicationCode/Commands/RicDeleteItemExec.cpp

@@ -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)
         {

ApplicationCode/Commands/RicNewSimWellFractureAtPosFeature.cpp

@@ -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)

ApplicationCode/Commands/RicNewSimWellFractureFeature.cpp

@@ -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)

ApplicationCode/Commands/RicWellLogTools.cpp

@@ -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);
 

ApplicationCode/Commands/RicWellLogTools.h

@@ -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 RimWellLogExtractionCurve*   addExtractionCurve(RimWellLogTrack* plotTrack, RimView* view, RimWellPath* wellPath, const RimSimWellInView* simWell, int branchIndex);
-    static RimWellLogRftCurve*          addRftCurve(RimWellLogTrack* plotTrack, const RimEclipseWell* simWell);
+    static RimWellLogRftCurve*          addRftCurve(RimWellLogTrack* plotTrack, const RimSimWellInView* simWell);
     static RimWellLogFileCurve*         addFileCurve(RimWellLogTrack* plotTrack);
 };

ApplicationCode/Commands/WellLogCommands/RicNewRftPlotFeature.cpp

@@ -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;

ApplicationCode/Commands/WellLogCommands/RicNewRftPlotFeature.h

@@ -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;
 };
 

ApplicationCode/Commands/WellLogCommands/RicNewWellLogCurveExtractionFeature.cpp

@@ -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();

ApplicationCode/Commands/WellLogCommands/RicNewWellLogRftCurveFeature.cpp

@@ -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();

ApplicationCode/ModelVisualization/RivReservoirSimWellsPartMgr.cpp

@@ -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);

ApplicationCode/ModelVisualization/RivSimWellPipeSourceInfo.cpp

@@ -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();
 }

ApplicationCode/ModelVisualization/RivSimWellPipeSourceInfo.h

@@ -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;
 };

ApplicationCode/ModelVisualization/RivSimWellPipesPartMgr.cpp

@@ -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;

ApplicationCode/ModelVisualization/RivSimWellPipesPartMgr.h

@@ -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;

ApplicationCode/ModelVisualization/RivWellConnectionsPartMgr.cpp

@@ -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;

ApplicationCode/ModelVisualization/RivWellConnectionsPartMgr.h

@@ -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;
 };

ApplicationCode/ModelVisualization/RivWellFracturePartMgr.cpp

@@ -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"
 

ApplicationCode/ModelVisualization/RivWellHeadPartMgr.cpp

@@ -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();
 

ApplicationCode/ModelVisualization/RivWellHeadPartMgr.h

@@ -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; 
 

ApplicationCode/ModelVisualization/RivWellSpheresPartMgr.cpp

@@ -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;

ApplicationCode/ModelVisualization/RivWellSpheresPartMgr.h

@@ -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;
 };

ApplicationCode/ProjectDataModel/Completions/RimCompletionCellIntersectionCalc.cpp

@@ -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())
             {

ApplicationCode/ProjectDataModel/Completions/RimFishboneWellPathCollection.cpp

@@ -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"
 

ApplicationCode/ProjectDataModel/Completions/RimPerforationCollection.cpp

@@ -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"
 

ApplicationCode/ProjectDataModel/Completions/RimSimWellFracture.cpp

@@ -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);
 

ApplicationCode/ProjectDataModel/Flow/RimFlowDiagSolution.cpp

@@ -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");
 

ApplicationCode/ProjectDataModel/Flow/RimFlowDiagSolution.h

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

ApplicationCode/ProjectDataModel/Flow/RimTofAccumulatedPhaseFractionsPlot.cpp

@@ -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"

ApplicationCode/ProjectDataModel/Flow/RimTofAccumulatedPhaseFractionsPlot.h

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

ApplicationCode/ProjectDataModel/Flow/RimTotalWellAllocationPlot.cpp

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

ApplicationCode/ProjectDataModel/Flow/RimTotalWellAllocationPlot.h

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

ApplicationCode/ProjectDataModel/Flow/RimWellAllocationPlot.cpp

@@ -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);

ApplicationCode/ProjectDataModel/Flow/RimWellAllocationPlot.h

@@ -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 RiuWellAllocationPlot;
-class RigSingleWellResultsData;
 
 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;

ApplicationCode/ProjectDataModel/Flow/RimWellRftAddress.h

@@ -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;
 
 
 

ApplicationCode/ProjectDataModel/Flow/RimWellRftPlot.h

@@ -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;

ApplicationCode/ProjectDataModel/RimContextCommandBuilder.cpp

@@ -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";

ApplicationCode/ProjectDataModel/RimEclipseCellColors.cpp

@@ -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());
 

ApplicationCode/ProjectDataModel/RimEclipseView.cpp

@@ -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();

ApplicationCode/ProjectDataModel/RimEclipseView.h

@@ -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

ApplicationCode/ProjectDataModel/RimEclipseWellCollection.cpp

@@ -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());

ApplicationCode/ProjectDataModel/RimEclipseWellCollection.h

@@ -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();

ApplicationCode/ProjectDataModel/RimIntersection.cpp

@@ -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));
             }

ApplicationCode/ProjectDataModel/RimIntersection.h

@@ -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;

ApplicationCode/ProjectDataModel/RimIntersectionCollection.cpp

@@ -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;
 

ApplicationCode/ProjectDataModel/RimIntersectionCollection.h

@@ -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();
 

ApplicationCode/ProjectDataModel/RimSimWellInView.cpp

@@ -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;
 }

ApplicationCode/ProjectDataModel/RimSimWellInView.h

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

ApplicationCode/ProjectDataModel/RimWellLogExtractionCurve.cpp

@@ -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"
 
 //==================================================================================================
 ///  

ApplicationCode/ReservoirDataModel/RigSimulationWellCenterLineCalculator.cpp

@@ -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)

ApplicationCode/ReservoirDataModel/RigSimulationWellCenterLineCalculator.h

@@ -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) ;

ApplicationCode/UserInterface/RiuSelectionManager.cpp

@@ -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),

ApplicationCode/UserInterface/RiuSelectionManager.h

@@ -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;
 };

ApplicationCode/UserInterface/RiuViewerCommands.cpp

@@ -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);