Rename of RimReservoirView to RimEclipseView

To make the separation to geomech clearer, and alligning it to the
RigCaseNaming

ApplicationCode/Application/RiaApplication.cpp

@@ -642,7 +642,7 @@ bool RiaApplication::openEclipseCase(const QString& caseName, const QString& cas
 
     analysisModels->cases.push_back(rimResultReservoir);
 
-    RimReservoirView* riv = rimResultReservoir->createAndAddReservoirView();
+    RimEclipseView* riv = rimResultReservoir->createAndAddReservoirView();
 
     // Select SOIL as default result variable
     riv->cellResult()->setResultType(RimDefines::DYNAMIC_NATIVE);
@@ -685,7 +685,7 @@ bool RiaApplication::openInputEclipseCaseFromFileNames(const QStringList& fileNa
 
     analysisModels->cases.push_back(rimInputReservoir);
 
-    RimReservoirView* riv = rimInputReservoir->createAndAddReservoirView();
+    RimEclipseView* riv = rimInputReservoir->createAndAddReservoirView();
 
     riv->cellResult()->setResultType(RimDefines::INPUT_PROPERTY);
     riv->animationMode = true;
@@ -2127,7 +2127,7 @@ void RiaApplication::regressionTestConfigureProject()
                 riv->viewer()->setFixedSize(1000, 745);
             }
 
-            RimReservoirView* resvView = dynamic_cast<RimReservoirView*>(riv);
+            RimEclipseView* resvView = dynamic_cast<RimEclipseView*>(riv);
 
             if (resvView)
             {

ApplicationCode/Application/RiaApplication.h

@@ -37,7 +37,7 @@ class RimEclipseCase;
 class Drawable;
 class RiaSocketServer;
 class RiaPreferences;
-class RimReservoirView;
+class RimEclipseView;
 class RimView;
 class RimProject;
 class RimCommandObject;

ApplicationCode/ModelVisualization/RivReservoirFaultsPartMgr.cpp

@@ -37,7 +37,7 @@
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RivReservoirFaultsPartMgr::RivReservoirFaultsPartMgr(const RigMainGrid* grid,  RimReservoirView* reservoirView)
+RivReservoirFaultsPartMgr::RivReservoirFaultsPartMgr(const RigMainGrid* grid,  RimEclipseView* reservoirView)
 :   m_reservoirView(reservoirView)
 {
     CVF_ASSERT(grid);

ApplicationCode/ModelVisualization/RivReservoirFaultsPartMgr.h

@@ -32,7 +32,7 @@ namespace cvf
 
 class RimResultSlot;
 class RimCellEdgeResultSlot;
-class RimReservoirView;
+class RimEclipseView;
 
 //==================================================================================================
 ///
@@ -40,7 +40,7 @@ class RimReservoirView;
 class RivReservoirFaultsPartMgr : public cvf::Object
 {
 public:
-    RivReservoirFaultsPartMgr(const RigMainGrid* grid, RimReservoirView* reservoirView);
+    RivReservoirFaultsPartMgr(const RigMainGrid* grid, RimEclipseView* reservoirView);
     ~RivReservoirFaultsPartMgr();
 
     void setTransform(cvf::Transform* scaleTransform);
@@ -60,7 +60,7 @@ public:
 
 private:
     cvf::ref<cvf::Transform>            m_scaleTransform;
-    caf::PdmPointer<RimReservoirView>   m_reservoirView;
+    caf::PdmPointer<RimEclipseView>   m_reservoirView;
     cvf::Collection<RivFaultPartMgr>    m_faultParts;
     bool                                m_forceVisibility;
 };

ApplicationCode/ModelVisualization/RivReservoirPartMgr.cpp

@@ -30,7 +30,7 @@
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RivReservoirPartMgr::clearAndSetReservoir(const RigCaseData* eclipseCase, RimReservoirView* reservoirView)
+void RivReservoirPartMgr::clearAndSetReservoir(const RigCaseData* eclipseCase, RimEclipseView* reservoirView)
 {
     m_allGrids.clear();
 

ApplicationCode/ModelVisualization/RivReservoirPartMgr.h

@@ -35,7 +35,7 @@ namespace cvf
 class RimResultSlot;
 class RimCellEdgeResultSlot;
 class RigCaseData;
-class RimReservoirView;
+class RimEclipseView;
 
 //==================================================================================================
 ///
@@ -47,7 +47,7 @@ class RimReservoirView;
 class RivReservoirPartMgr: public cvf::Object
 {
 public:
-    void   clearAndSetReservoir(const RigCaseData* eclipseCase, RimReservoirView* reservoirView);
+    void   clearAndSetReservoir(const RigCaseData* eclipseCase, RimEclipseView* reservoirView);
     void   setTransform(cvf::Transform* scaleTransform);
     void   setCellVisibility(size_t gridIndex, cvf::UByteArray* cellVisibilities );
     void   setFaultForceVisibility(bool isGeneratedByFilter);

ApplicationCode/ModelVisualization/RivReservoirPipesPartMgr.cpp

@@ -38,7 +38,7 @@
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RivReservoirPipesPartMgr::RivReservoirPipesPartMgr(RimReservoirView* reservoirView)
+RivReservoirPipesPartMgr::RivReservoirPipesPartMgr(RimEclipseView* reservoirView)
 {
     m_reservoirView = reservoirView;
 

ApplicationCode/ModelVisualization/RivReservoirPipesPartMgr.h

@@ -23,14 +23,14 @@
 
 #include "cvfCollection.h"
 
-class RimReservoirView;
+class RimEclipseView;
 class RivWellPipesPartMgr;
 class RivWellHeadPartMgr;
 
 class RivReservoirPipesPartMgr : public cvf::Object
 {
 public:
-    RivReservoirPipesPartMgr(RimReservoirView* reservoirView);
+    RivReservoirPipesPartMgr(RimEclipseView* reservoirView);
     ~RivReservoirPipesPartMgr();
 
     void clearGeometryCache();
@@ -42,7 +42,7 @@ public:
     void updatePipeResultColor(size_t frameIndex);
 
 private:
-    caf::PdmPointer<RimReservoirView>   m_reservoirView;
+    caf::PdmPointer<RimEclipseView>   m_reservoirView;
     cvf::ref<cvf::Transform>            m_scaleTransform; 
 
     cvf::Collection< RivWellPipesPartMgr >  m_wellPipesPartMgrs;

ApplicationCode/ModelVisualization/RivReservoirViewPartMgr.cpp

@@ -44,7 +44,7 @@
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RivReservoirViewPartMgr::RivReservoirViewPartMgr(RimReservoirView * resv) :
+RivReservoirViewPartMgr::RivReservoirViewPartMgr(RimEclipseView * resv) :
 m_reservoirView(resv)
 {
     m_scaleTransform = new cvf::Transform();

ApplicationCode/ModelVisualization/RivReservoirViewPartMgr.h

@@ -25,7 +25,7 @@
 #include "cvfArray.h"
 #include "cafPdmObject.h"
 
-class RimReservoirView;
+class RimEclipseView;
 class RigGridBase;
 class RimCellRangeFilterCollection;
 class RimCellPropertyFilterCollection;
@@ -34,7 +34,7 @@ class RigActiveCellInfo;
 class RivReservoirViewPartMgr: public cvf::Object
 {
 public:
-    RivReservoirViewPartMgr(RimReservoirView * resv);
+    RivReservoirViewPartMgr(RimEclipseView * resv);
 
     cvf::Transform*             scaleTransform() { return m_scaleTransform.p();}
 
@@ -114,6 +114,6 @@ private:
     std::vector<uchar>                                      m_propFilteredWellGeometryFramesNeedsRegen;
 
     cvf::ref<cvf::Transform>                                m_scaleTransform;
-    caf::PdmPointer<RimReservoirView>                       m_reservoirView;
+    caf::PdmPointer<RimEclipseView>                       m_reservoirView;
 
 };

ApplicationCode/ModelVisualization/RivWellHeadPartMgr.cpp

@@ -61,7 +61,7 @@
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RivWellHeadPartMgr::RivWellHeadPartMgr(RimReservoirView* reservoirView, RimWell* well)
+RivWellHeadPartMgr::RivWellHeadPartMgr(RimEclipseView* reservoirView, RimWell* well)
 {
     m_rimReservoirView = reservoirView;
     m_rimWell = well;

ApplicationCode/ModelVisualization/RivWellHeadPartMgr.h

@@ -33,12 +33,12 @@ namespace cvf
 }
 
 class RimWell;
-class RimReservoirView;
+class RimEclipseView;
 
 class RivWellHeadPartMgr : public cvf::Object
 {
 public:
-    RivWellHeadPartMgr(RimReservoirView* reservoirView, RimWell* well);
+    RivWellHeadPartMgr(RimEclipseView* reservoirView, RimWell* well);
     ~RivWellHeadPartMgr();
 
     void setScaleTransform(cvf::Transform * scaleTransform) { m_scaleTransform = scaleTransform;}
@@ -51,7 +51,7 @@ private:
 
 
 private:
-    caf::PdmPointer<RimReservoirView>   m_rimReservoirView;
+    caf::PdmPointer<RimEclipseView>   m_rimReservoirView;
     caf::PdmPointer<RimWell>            m_rimWell;
     
     cvf::ref<cvf::Transform>            m_scaleTransform; 

ApplicationCode/ModelVisualization/RivWellPipesPartMgr.cpp

@@ -53,7 +53,7 @@
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RivWellPipesPartMgr::RivWellPipesPartMgr(RimReservoirView* reservoirView, RimWell* well)
+RivWellPipesPartMgr::RivWellPipesPartMgr(RimEclipseView* reservoirView, RimWell* well)
 {
     m_rimReservoirView = reservoirView;
     m_rimWell      = well;

ApplicationCode/ModelVisualization/RivWellPipesPartMgr.h

@@ -37,13 +37,13 @@ namespace cvf
 }
 
 class RivPipeGeometryGenerator;
-class RimReservoirView;
+class RimEclipseView;
 class RimWell;
 
 class RivWellPipesPartMgr : public cvf::Object
 {
 public:
-    RivWellPipesPartMgr(RimReservoirView* reservoirView, RimWell* well);
+    RivWellPipesPartMgr(RimEclipseView* reservoirView, RimWell* well);
     ~RivWellPipesPartMgr();
 
     void setScaleTransform(cvf::Transform * scaleTransform) { m_scaleTransform = scaleTransform; scheduleGeometryRegen();}
@@ -55,7 +55,7 @@ public:
 
 
 private:
-    caf::PdmPointer<RimReservoirView>   m_rimReservoirView;
+    caf::PdmPointer<RimEclipseView>   m_rimReservoirView;
     caf::PdmPointer<RimWell>            m_rimWell;
     
     cvf::ref<cvf::Transform>    m_scaleTransform; 

ApplicationCode/ProjectDataModel/Rim3dOverlayInfoConfig.cpp

@@ -104,7 +104,7 @@ void Rim3dOverlayInfoConfig::update3DInfo()
     m_viewDef->viewer()->showHistogram(false);
     m_viewDef->viewer()->showAnimationProgress(showAnimProgress());
 
-    RimReservoirView * reservoirView = dynamic_cast<RimReservoirView*>(m_viewDef.p());
+    RimEclipseView * reservoirView = dynamic_cast<RimEclipseView*>(m_viewDef.p());
     if (reservoirView) updateReservoir3DInfo(reservoirView);
     RimGeoMechView * geoMechView = dynamic_cast<RimGeoMechView*>(m_viewDef.p());
     if (geoMechView) updateGeoMech3DInfo(geoMechView);
@@ -129,7 +129,7 @@ void Rim3dOverlayInfoConfig::setReservoirView(RimView* ownerReservoirView)
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void Rim3dOverlayInfoConfig::updateReservoir3DInfo(RimReservoirView * reservoirView)
+void Rim3dOverlayInfoConfig::updateReservoir3DInfo(RimEclipseView * reservoirView)
 {
     if (showInfoText())
     {

ApplicationCode/ProjectDataModel/Rim3dOverlayInfoConfig.h

@@ -27,7 +27,7 @@
 
 #include "cvfVector2.h"
 
-class RimReservoirView;
+class RimEclipseView;
 class RimGeoMechView;
 class RimView;
 
@@ -57,7 +57,7 @@ protected:
     virtual caf::PdmFieldHandle*                objectToggleField();
 private:
 
-    void updateReservoir3DInfo(RimReservoirView * reservoirView);
+    void updateReservoir3DInfo(RimEclipseView * reservoirView);
     void updateGeoMech3DInfo(RimGeoMechView * geoMechView);
 
 

ApplicationCode/ProjectDataModel/RimCellEdgeResultSlot.cpp

@@ -64,7 +64,7 @@ RimCellEdgeResultSlot::~RimCellEdgeResultSlot()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimCellEdgeResultSlot::setReservoirView(RimReservoirView* ownerReservoirView)
+void RimCellEdgeResultSlot::setReservoirView(RimEclipseView* ownerReservoirView)
 {
     m_reservoirView = ownerReservoirView;
     this->legendConfig()->setReservoirView(ownerReservoirView);

ApplicationCode/ProjectDataModel/RimCellEdgeResultSlot.h

@@ -28,7 +28,7 @@
 
 class RigCaseCellResultsData;
 class RimLegendConfig;
-class RimReservoirView;
+class RimEclipseView;
 
 
 //==================================================================================================
@@ -51,7 +51,7 @@ public:
 
     typedef  caf::AppEnum<RimCellEdgeResultSlot::EdgeFaceType> EdgeFaceEnum;
 
-    void                                  setReservoirView(RimReservoirView* ownerReservoirView);
+    void                                  setReservoirView(RimEclipseView* ownerReservoirView);
 
     caf::PdmField<QString>                resultVariable;
     caf::PdmField<bool>                   useXVariable;
@@ -78,7 +78,7 @@ private:
     void                                  updateIgnoredScalarValue();
 protected:
     caf::FixedArray<std::pair<QString, size_t>, 6 >  m_resultNameToIndexPairs;
-    caf::PdmPointer<RimReservoirView>                m_reservoirView;
+    caf::PdmPointer<RimEclipseView>                m_reservoirView;
     double                                           m_ignoredResultScalar;
 };
 

ApplicationCode/ProjectDataModel/RimCellPropertyFilter.h

@@ -22,7 +22,7 @@
 
 #include "RimCellFilter.h"
 
-class RimReservoirView;
+class RimEclipseView;
 class RimCellPropertyFilterCollection;
 class RimResultDefinition;
 

ApplicationCode/ProjectDataModel/RimCellPropertyFilterCollection.cpp

@@ -51,7 +51,7 @@ RimCellPropertyFilterCollection::~RimCellPropertyFilterCollection()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimCellPropertyFilterCollection::setReservoirView(RimReservoirView* reservoirView)
+void RimCellPropertyFilterCollection::setReservoirView(RimEclipseView* reservoirView)
 {
     m_reservoirView = reservoirView;
 
@@ -67,7 +67,7 @@ void RimCellPropertyFilterCollection::setReservoirView(RimReservoirView* reservo
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimReservoirView* RimCellPropertyFilterCollection::reservoirView()
+RimEclipseView* RimCellPropertyFilterCollection::reservoirView()
 {
     CVF_ASSERT(!m_reservoirView.isNull());
     return m_reservoirView;

ApplicationCode/ProjectDataModel/RimCellPropertyFilterCollection.h

@@ -43,8 +43,8 @@ public:
     bool                    hasActiveFilters() const; 
     bool                    hasActiveDynamicFilters() const; 
 
-    void                    setReservoirView(RimReservoirView* reservoirView);
+    void                    setReservoirView(RimEclipseView* reservoirView);
-    RimReservoirView*       reservoirView();
+    RimEclipseView*       reservoirView();
 
     void                    loadAndInitializePropertyFilters();
 
@@ -58,5 +58,5 @@ protected:
     virtual void initAfterRead();
 
 private:
-    caf::PdmPointer<RimReservoirView> m_reservoirView;
+    caf::PdmPointer<RimEclipseView> m_reservoirView;
 };

ApplicationCode/ProjectDataModel/RimCellRangeFilter.h

@@ -25,7 +25,7 @@
 class RigGridBase;
 class RigMainGrid;
 class RimCellRangeFilterCollection;
-class RimReservoirView;
+class RimEclipseView;
 
 namespace cvf
 {

ApplicationCode/ProjectDataModel/RimCellRangeFilterCollection.cpp

@@ -55,7 +55,7 @@ RimCellRangeFilterCollection::~RimCellRangeFilterCollection()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimCellRangeFilterCollection::setReservoirView(RimReservoirView* reservoirView)
+void RimCellRangeFilterCollection::setReservoirView(RimEclipseView* reservoirView)
 {
     m_reservoirView = reservoirView;
 }
@@ -170,7 +170,7 @@ RimCellRangeFilter* RimCellRangeFilterCollection::createAndAppendRangeFilter()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimReservoirView* RimCellRangeFilterCollection::reservoirView()
+RimEclipseView* RimCellRangeFilterCollection::reservoirView()
 {
     return m_reservoirView;
 }

ApplicationCode/ProjectDataModel/RimCellRangeFilterCollection.h

@@ -46,8 +46,8 @@ public:
     bool                hasActiveFilters() const;
     bool                hasActiveIncludeFilters() const;
 
-    void                setReservoirView(RimReservoirView* reservoirView);
+    void                setReservoirView(RimEclipseView* reservoirView);
-    RimReservoirView*   reservoirView();
+    RimEclipseView*   reservoirView();
     RigMainGrid*        mainGrid() const;
     RigActiveCellInfo*  activeCellInfo() const;
 
@@ -61,5 +61,5 @@ protected:
 
 
 private:
-    RimReservoirView* m_reservoirView;
+    RimEclipseView* m_reservoirView;
 };

ApplicationCode/ProjectDataModel/RimEclipseCase.cpp

@@ -119,7 +119,7 @@ void RimEclipseCase::initAfterRead()
     size_t j;
     for (j = 0; j < reservoirViews().size(); j++)
     {
-        RimReservoirView* riv = reservoirViews()[j];
+        RimEclipseView* riv = reservoirViews()[j];
         CVF_ASSERT(riv);
 
         riv->setEclipseCase(this);
@@ -134,9 +134,9 @@ void RimEclipseCase::initAfterRead()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimReservoirView* RimEclipseCase::createAndAddReservoirView()
+RimEclipseView* RimEclipseCase::createAndAddReservoirView()
 {
-    RimReservoirView* riv = new RimReservoirView();
+    RimEclipseView* riv = new RimEclipseView();
     riv->setEclipseCase(this);
 
     caf::PdmDocument::updateUiIconStateRecursively(riv);
@@ -157,7 +157,7 @@ void RimEclipseCase::removeResult(const QString& resultName)
     size_t i;
     for (i = 0; i < reservoirViews().size(); i++)
     {
-        RimReservoirView* reservoirView = reservoirViews()[i];
+        RimEclipseView* reservoirView = reservoirViews()[i];
         CVF_ASSERT(reservoirView);
 
         RimResultSlot* result = reservoirView->cellResult;
@@ -211,7 +211,7 @@ void RimEclipseCase::fieldChangedByUi(const caf::PdmFieldHandle* changedField, c
         {
             for (size_t i = 0; i < reservoirViews().size(); i++)
             {
-                RimReservoirView* reservoirView = reservoirViews()[i];
+                RimEclipseView* reservoirView = reservoirViews()[i];
                 CVF_ASSERT(reservoirView);
 
                 RimResultSlot* result = reservoirView->cellResult;
@@ -255,7 +255,7 @@ void RimEclipseCase::fieldChangedByUi(const caf::PdmFieldHandle* changedField, c
 
             for (size_t i = 0; i < reservoirViews().size(); i++)
             {
-                RimReservoirView* reservoirView = reservoirViews()[i];
+                RimEclipseView* reservoirView = reservoirViews()[i];
 
                 reservoirView->scheduleReservoirGridGeometryRegen();
                 reservoirView->schedulePipeGeometryRegen();

ApplicationCode/ProjectDataModel/RimEclipseCase.h

@@ -31,7 +31,7 @@ class QString;
 
 class RigCaseData;
 class RigGridBase;
-class RimReservoirView;
+class RimEclipseView;
 class RimCaseCollection;
 class RimIdenticalGridCaseGroup;
 class RimReservoirCellResultsStorage;
@@ -52,7 +52,7 @@ public:
 
     // Fields:                                        
     caf::PdmField<bool>                         releaseResultMemory;
-    caf::PdmPointersField<RimReservoirView*>    reservoirViews;
+    caf::PdmPointersField<RimEclipseView*>    reservoirViews;
     caf::PdmField<bool>                         flipXAxis;
     caf::PdmField<bool>                         flipYAxis;
     
@@ -67,7 +67,7 @@ public:
 
     RimReservoirCellResultsStorage*		        results(RifReaderInterface::PorosityModelResultType porosityModel);
                                                       
-    RimReservoirView*                           createAndAddReservoirView();
+    RimEclipseView*                           createAndAddReservoirView();
 
     void                                        removeResult(const QString& resultName);
 

ApplicationCode/ProjectDataModel/RimFault.cpp

@@ -68,7 +68,7 @@ void RimFault::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const Q
 
     if (&faultColor == changedField || &showFault == changedField)
     {
-        RimReservoirView* reservoirView = NULL;
+        RimEclipseView* reservoirView = NULL;
         this->firstAncestorOfType(reservoirView);
 
         if (reservoirView) 

ApplicationCode/ProjectDataModel/RimFaultCollection.cpp

@@ -132,7 +132,7 @@ void RimFaultCollection::fieldChangedByUi(const caf::PdmFieldHandle* changedFiel
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimFaultCollection::setReservoirView(RimReservoirView* ownerReservoirView)
+void RimFaultCollection::setReservoirView(RimEclipseView* ownerReservoirView)
 {
     m_reservoirView = ownerReservoirView;
 }

ApplicationCode/ProjectDataModel/RimFaultCollection.h

@@ -33,7 +33,7 @@
 #include <QString>
 
 class RimFault;
-class RimReservoirView;
+class RimEclipseView;
 class RimNoCommonAreaNncCollection;
 
 //==================================================================================================
@@ -55,7 +55,7 @@ public:
     RimFaultCollection();
     virtual ~RimFaultCollection();
 
-    void                                setReservoirView(RimReservoirView* ownerReservoirView);
+    void                                setReservoirView(RimEclipseView* ownerReservoirView);
     void                                syncronizeFaults();
 
     void                                addMockData();
@@ -91,6 +91,6 @@ private:
 
 private:
     caf::PdmField<bool>     m_showFaultsOutsideFilters;
-    RimReservoirView*       m_reservoirView;
+    RimEclipseView*       m_reservoirView;
 
 };

ApplicationCode/ProjectDataModel/RimFaultResultSlot.cpp

@@ -66,7 +66,7 @@ RimFaultResultSlot::~RimFaultResultSlot()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimFaultResultSlot::setReservoirView(RimReservoirView* ownerReservoirView)
+void RimFaultResultSlot::setReservoirView(RimEclipseView* ownerReservoirView)
 {
     m_reservoirView = ownerReservoirView;
     m_customFaultResult->setReservoirView(ownerReservoirView);

ApplicationCode/ProjectDataModel/RimFaultResultSlot.h

@@ -24,7 +24,7 @@
 #include "cafPdmObject.h"
 
 class RimResultSlot;
-class RimReservoirView;
+class RimEclipseView;
 
 //==================================================================================================
 ///  
@@ -38,7 +38,7 @@ public:
     RimFaultResultSlot();
     virtual ~RimFaultResultSlot();
     
-    void setReservoirView(RimReservoirView* ownerReservoirView);
+    void setReservoirView(RimEclipseView* ownerReservoirView);
 
     caf::PdmField<bool>     showCustomFaultResult;
 
@@ -57,6 +57,6 @@ protected:
 
 private:
     caf::PdmField<RimResultSlot*>       m_customFaultResult;
-    caf::PdmPointer<RimReservoirView>   m_reservoirView;
+    caf::PdmPointer<RimEclipseView>   m_reservoirView;
 };
 

ApplicationCode/ProjectDataModel/RimIdenticalGridCaseGroup.cpp

@@ -401,7 +401,7 @@ void RimIdenticalGridCaseGroup::clearStatisticsResults()
 
         for (size_t j = 0; j < rimStaticsCase->reservoirViews.size(); j++)
         {
-            RimReservoirView* rimReservoirView = rimStaticsCase->reservoirViews[j];
+            RimEclipseView* rimReservoirView = rimStaticsCase->reservoirViews[j];
             rimReservoirView->cellResult()->setResultVariable(RimDefines::undefinedResultName());
             rimReservoirView->cellEdgeResult()->resultVariable = RimDefines::undefinedResultName();
             rimReservoirView->loadDataAndUpdate();

ApplicationCode/ProjectDataModel/RimReservoirView.cpp

@@ -65,11 +65,11 @@
 
 
 
-CAF_PDM_SOURCE_INIT(RimReservoirView, "ReservoirView");
+CAF_PDM_SOURCE_INIT(RimEclipseView, "ReservoirView");
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimReservoirView::RimReservoirView()
+RimEclipseView::RimEclipseView()
 {
     RiaApplication* app = RiaApplication::instance();
     RiaPreferences* preferences = app->preferences();
@@ -126,7 +126,7 @@ RimReservoirView::RimReservoirView()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimReservoirView::~RimReservoirView()
+RimEclipseView::~RimEclipseView()
 {
     delete this->faultResultSettings();
     delete this->cellResult();
@@ -146,7 +146,7 @@ RimReservoirView::~RimReservoirView()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimReservoirView::updateViewerWidgetWindowTitle()
+void RimEclipseView::updateViewerWidgetWindowTitle()
 {
     if (m_viewer)
     {
@@ -167,7 +167,7 @@ void RimReservoirView::updateViewerWidgetWindowTitle()
 //--------------------------------------------------------------------------------------------------
 /// Clamp the current timestep to actual possibilities
 //--------------------------------------------------------------------------------------------------
-void RimReservoirView::clampCurrentTimestep()
+void RimEclipseView::clampCurrentTimestep()
 {
     if (this->currentGridCellResults() && this->currentGridCellResults()->cellResults()) 
     {
@@ -184,7 +184,7 @@ void RimReservoirView::clampCurrentTimestep()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimReservoirView::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
+void RimEclipseView::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
 {
     RimView::fieldChangedByUi(changedField, oldValue, newValue);
 
@@ -247,7 +247,7 @@ void RimReservoirView::fieldChangedByUi(const caf::PdmFieldHandle* changedField,
 
 }
 
-void RimReservoirView::updateScaleTransform()
+void RimEclipseView::updateScaleTransform()
 {
     cvf::Mat4d scale = cvf::Mat4d::IDENTITY;
     scale(2, 2) = scaleZ();
@@ -265,7 +265,7 @@ void RimReservoirView::updateScaleTransform()
 /// or at least empty scenes as frames that is delivered to the viewer
 /// The real geometry generation is done inside RivReservoirViewGeometry and friends
 //--------------------------------------------------------------------------------------------------
-void RimReservoirView::createDisplayModel()
+void RimEclipseView::createDisplayModel()
 {
     if (m_viewer.isNull()) return;
 
@@ -461,7 +461,7 @@ void RimReservoirView::createDisplayModel()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimReservoirView::updateCurrentTimeStep()
+void RimEclipseView::updateCurrentTimeStep()
 {
     std::vector<RivReservoirViewPartMgr::ReservoirGeometryCacheType> geometriesToRecolor;
 
@@ -661,7 +661,7 @@ void RimReservoirView::updateCurrentTimeStep()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimReservoirView::loadDataAndUpdate()
+void RimEclipseView::loadDataAndUpdate()
 {
     updateScaleTransform();
 
@@ -711,7 +711,7 @@ void RimReservoirView::loadDataAndUpdate()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimReservoirView::initAfterRead()
+void RimEclipseView::initAfterRead()
 {
     this->faultResultSettings()->setReservoirView(this);
     this->cellResult()->setReservoirView(this);
@@ -726,7 +726,7 @@ void RimReservoirView::initAfterRead()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimReservoirView::updateStaticCellColors()
+void RimEclipseView::updateStaticCellColors()
 {
     updateStaticCellColors( RivReservoirViewPartMgr::ACTIVE);
     updateStaticCellColors( RivReservoirViewPartMgr::ALL_WELL_CELLS);
@@ -743,7 +743,7 @@ void RimReservoirView::updateStaticCellColors()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimReservoirView::updateStaticCellColors(unsigned short geometryType)
+void RimEclipseView::updateStaticCellColors(unsigned short geometryType)
 {
     float opacity = static_cast< float> (1 - cvf::Math::clamp(this->wellCollection()->wellCellTransparencyLevel(), 0.0, 1.0));
     cvf::Color4f color(cvf::Color3::ORANGE);
@@ -770,7 +770,7 @@ void RimReservoirView::updateStaticCellColors(unsigned short geometryType)
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimReservoirView::updateDisplayModelVisibility()
+void RimEclipseView::updateDisplayModelVisibility()
 {
     if (m_viewer.isNull()) return;
 
@@ -813,7 +813,7 @@ void RimReservoirView::updateDisplayModelVisibility()
 //--------------------------------------------------------------------------------------------------
 /// Convenience for quick access to results
 //--------------------------------------------------------------------------------------------------
-RimReservoirCellResultsStorage* RimReservoirView::currentGridCellResults()
+RimReservoirCellResultsStorage* RimEclipseView::currentGridCellResults()
 {
     if (m_reservoir)
     {
@@ -828,7 +828,7 @@ RimReservoirCellResultsStorage* RimReservoirView::currentGridCellResults()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RigActiveCellInfo* RimReservoirView::currentActiveCellInfo()
+RigActiveCellInfo* RimEclipseView::currentActiveCellInfo()
 {
     if (m_reservoir &&
         m_reservoir->reservoirData()
@@ -846,7 +846,7 @@ RigActiveCellInfo* RimReservoirView::currentActiveCellInfo()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimReservoirView::scheduleGeometryRegen(unsigned short geometryType)
+void RimEclipseView::scheduleGeometryRegen(unsigned short geometryType)
 {
     m_reservoirGridPartManager->scheduleGeometryRegen(static_cast<RivReservoirViewPartMgr::ReservoirGeometryCacheType>(geometryType));
 }
@@ -854,7 +854,7 @@ void RimReservoirView::scheduleGeometryRegen(unsigned short geometryType)
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimReservoirView::scheduleReservoirGridGeometryRegen()
+void RimEclipseView::scheduleReservoirGridGeometryRegen()
 {
     m_reservoirGridPartManager->clearGeometryCache();
 }
@@ -862,7 +862,7 @@ void RimReservoirView::scheduleReservoirGridGeometryRegen()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimReservoirView::schedulePipeGeometryRegen()
+void RimEclipseView::schedulePipeGeometryRegen()
 {
     m_pipesPartManager->scheduleGeometryRegen();
 }
@@ -871,7 +871,7 @@ void RimReservoirView::schedulePipeGeometryRegen()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimReservoirView::indicesToVisibleGrids(std::vector<size_t>* gridIndices)
+void RimEclipseView::indicesToVisibleGrids(std::vector<size_t>* gridIndices)
 {
     CVF_ASSERT(gridIndices != NULL);
 
@@ -895,7 +895,7 @@ void RimReservoirView::indicesToVisibleGrids(std::vector<size_t>* gridIndices)
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimReservoirView::updateLegends()
+void RimEclipseView::updateLegends()
 {
     if (m_viewer)
     {
@@ -943,7 +943,7 @@ void RimReservoirView::updateLegends()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimReservoirView::updateMinMaxValuesAndAddLegendToView(QString legendLabel, RimResultSlot* resultSlot, RigCaseCellResultsData* cellResultsData)
+void RimEclipseView::updateMinMaxValuesAndAddLegendToView(QString legendLabel, RimResultSlot* resultSlot, RigCaseCellResultsData* cellResultsData)
 {
     if (resultSlot->hasResult())
     {
@@ -1043,7 +1043,7 @@ void RimReservoirView::updateMinMaxValuesAndAddLegendToView(QString legendLabel,
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimReservoirView::setEclipseCase(RimEclipseCase* reservoir)
+void RimEclipseView::setEclipseCase(RimEclipseCase* reservoir)
 {
     m_reservoir = reservoir;
 }
@@ -1051,7 +1051,7 @@ void RimReservoirView::setEclipseCase(RimEclipseCase* reservoir)
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimEclipseCase* RimReservoirView::eclipseCase()
+RimEclipseCase* RimEclipseView::eclipseCase()
 {
     return m_reservoir;
 }
@@ -1069,7 +1069,7 @@ RimEclipseCase* RimReservoirView::eclipseCase()
 
 */
 //--------------------------------------------------------------------------------------------------
-void RimReservoirView::syncronizeWellsWithResults()
+void RimEclipseView::syncronizeWellsWithResults()
 {
     if (!(m_reservoir && m_reservoir->reservoirData()) ) return;
 
@@ -1130,7 +1130,7 @@ void RimReservoirView::syncronizeWellsWithResults()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimReservoirView::calculateVisibleWellCellsIncFence(cvf::UByteArray* visibleCells, RigGridBase * grid)
+void RimEclipseView::calculateVisibleWellCellsIncFence(cvf::UByteArray* visibleCells, RigGridBase * grid)
 {
     CVF_ASSERT(visibleCells != NULL);
 
@@ -1240,7 +1240,7 @@ void RimReservoirView::calculateVisibleWellCellsIncFence(cvf::UByteArray* visibl
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimReservoirView::updateDisplayModelForWellResults()
+void RimEclipseView::updateDisplayModelForWellResults()
 {
     m_reservoirGridPartManager->clearGeometryCache();
     m_pipesPartManager->clearGeometryCache();
@@ -1263,7 +1263,7 @@ void RimReservoirView::updateDisplayModelForWellResults()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimReservoirView::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
+void RimEclipseView::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
 {
     caf::PdmUiGroup* viewGroup = uiOrdering.addNewGroup("Viewer");
     viewGroup->add(&name);
@@ -1283,7 +1283,7 @@ void RimReservoirView::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering
 //--------------------------------------------------------------------------------------------------
 ///     
 //--------------------------------------------------------------------------------------------------
-void RimReservoirView::updateFaultForcedVisibility()
+void RimEclipseView::updateFaultForcedVisibility()
 {
     // Force visibility of faults based on application state
     // As fault geometry is visible in grid visualization mode, fault geometry must be forced visible
@@ -1302,7 +1302,7 @@ void RimReservoirView::updateFaultForcedVisibility()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-std::vector<RivReservoirViewPartMgr::ReservoirGeometryCacheType> RimReservoirView::visibleFaultGeometryTypes() const
+std::vector<RivReservoirViewPartMgr::ReservoirGeometryCacheType> RimEclipseView::visibleFaultGeometryTypes() const
 {
     std::vector<RivReservoirViewPartMgr::ReservoirGeometryCacheType> faultParts;
 
@@ -1377,7 +1377,7 @@ std::vector<RivReservoirViewPartMgr::ReservoirGeometryCacheType> RimReservoirVie
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimReservoirView::updateFaultColors()
+void RimEclipseView::updateFaultColors()
 {
     // Update all fault geometry
     std::vector<RivReservoirViewPartMgr::ReservoirGeometryCacheType> faultGeometriesToRecolor = visibleFaultGeometryTypes();
@@ -1401,7 +1401,7 @@ void RimReservoirView::updateFaultColors()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimReservoirView::isTimeStepDependentDataVisible() const
+bool RimEclipseView::isTimeStepDependentDataVisible() const
 {
     if (this->cellResult()->hasDynamicResult()) return true;
 
@@ -1425,7 +1425,7 @@ bool RimReservoirView::isTimeStepDependentDataVisible() const
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimResultSlot* RimReservoirView::currentFaultResultSlot()
+RimResultSlot* RimEclipseView::currentFaultResultSlot()
 {
     RimResultSlot* faultResultSlot = this->cellResult();
 
@@ -1440,7 +1440,7 @@ RimResultSlot* RimReservoirView::currentFaultResultSlot()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimReservoirView::resetLegendsInViewer()
+void RimEclipseView::resetLegendsInViewer()
 {
     this->cellResult()->legendConfig->recreateLegend();
     this->cellResult()->ternaryLegendConfig->recreateLegend();
@@ -1454,7 +1454,7 @@ void RimReservoirView::resetLegendsInViewer()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-cvf::Transform* RimReservoirView::scaleTransform()
+cvf::Transform* RimEclipseView::scaleTransform()
 {
     return m_reservoirGridPartManager->scaleTransform();
 }
@@ -1462,7 +1462,7 @@ cvf::Transform* RimReservoirView::scaleTransform()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimCase* RimReservoirView::ownerCase()
+RimCase* RimEclipseView::ownerCase()
 {
     return eclipseCase();
 }

ApplicationCode/ProjectDataModel/RimReservoirView.h

@@ -75,12 +75,12 @@ enum PartRenderMaskEnum
 ///  
 ///  
 //==================================================================================================
-class RimReservoirView : public RimView
+class RimEclipseView : public RimView
 {
     CAF_PDM_HEADER_INIT;
 public:
-    RimReservoirView(void);
+    RimEclipseView(void);
-    virtual ~RimReservoirView(void);
+    virtual ~RimEclipseView(void);
 
     // Fields containing child objects :
 

ApplicationCode/ProjectDataModel/RimResultDefinition.cpp

@@ -70,7 +70,7 @@ RimResultDefinition::~RimResultDefinition()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimResultDefinition::setReservoirView(RimReservoirView* ownerReservoirView)
+void RimResultDefinition::setReservoirView(RimEclipseView* ownerReservoirView)
 {
     m_reservoirView = ownerReservoirView;
 
@@ -290,7 +290,7 @@ bool RimResultDefinition::hasDynamicResult() const
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimReservoirView* RimResultDefinition::reservoirView()
+RimEclipseView* RimResultDefinition::reservoirView()
 {
     return m_reservoirView;
 }

ApplicationCode/ProjectDataModel/RimResultDefinition.h

@@ -28,7 +28,7 @@
 #include "cafPdmPointer.h"
 
 
-class RimReservoirView;
+class RimEclipseView;
 class RigCaseCellResultsData;
 class RimReservoirCellResultsStorage;
 //==================================================================================================
@@ -42,8 +42,8 @@ public:
     RimResultDefinition();
     virtual ~RimResultDefinition();
 
-    virtual void                    setReservoirView(RimReservoirView* ownerReservoirView);
+    virtual void                    setReservoirView(RimEclipseView* ownerReservoirView);
-    RimReservoirView*               reservoirView();
+    RimEclipseView*               reservoirView();
 
     RimDefines::ResultCatType       resultType() const { return m_resultType(); }
     void                            setResultType(RimDefines::ResultCatType val);
@@ -78,7 +78,7 @@ protected:
     caf::PdmField< caf::AppEnum< RimDefines::PorosityModelType > >  m_porosityModelUiField;
     caf::PdmField<QString>                                          m_resultVariableUiField;
 
-    caf::PdmPointer<RimReservoirView>                               m_reservoirView;
+    caf::PdmPointer<RimEclipseView>                               m_reservoirView;
 
 protected:
     void updateFieldVisibility();

ApplicationCode/ProjectDataModel/RimResultSlot.cpp

@@ -154,7 +154,7 @@ void RimResultSlot::initAfterRead()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimResultSlot::setReservoirView(RimReservoirView* ownerReservoirView)
+void RimResultSlot::setReservoirView(RimEclipseView* ownerReservoirView)
 {
     RimResultDefinition::setReservoirView(ownerReservoirView);
 

ApplicationCode/ProjectDataModel/RimResultSlot.h

@@ -37,7 +37,7 @@ public:
     RimResultSlot();
     virtual ~RimResultSlot();
 
-    virtual void setReservoirView(RimReservoirView* ownerReservoirView);
+    virtual void setReservoirView(RimEclipseView* ownerReservoirView);
     caf::PdmField<RimLegendConfig*> legendConfig;
     caf::PdmField<RimTernaryLegendConfig*> ternaryLegendConfig;
 

ApplicationCode/ProjectDataModel/RimStatisticsCase.cpp

@@ -270,7 +270,7 @@ void RimStatisticsCase::scheduleACTIVEGeometryRegenOnReservoirViews()
 {
     for (size_t i = 0; i < reservoirViews().size(); i++)
     {
-        RimReservoirView* reservoirView = reservoirViews()[i];
+        RimEclipseView* reservoirView = reservoirViews()[i];
         CVF_ASSERT(reservoirView);
 
         reservoirView->scheduleGeometryRegen(RivReservoirViewPartMgr::ACTIVE);
@@ -496,7 +496,7 @@ void RimStatisticsCase::setWellResultsAndUpdateViews(const cvf::Collection<RigSi
     // Update views
     for (size_t i = 0; i < reservoirViews().size(); i++)
     {
-        RimReservoirView* reservoirView = reservoirViews()[i];
+        RimEclipseView* reservoirView = reservoirViews()[i];
         CVF_ASSERT(reservoirView);
 
         reservoirView->wellCollection()->wells.deleteAllChildObjects();

ApplicationCode/ProjectDataModel/RimTernaryLegendConfig.h

@@ -26,7 +26,7 @@
 #include "cafPdmField.h"
 #include "cafPdmObject.h"
 
-class RimReservoirView;
+class RimEclipseView;
 class RivTernarySaturationOverlayItem;
 class RivTernaryScalarMapper;
 
@@ -65,7 +65,7 @@ public:
     RimTernaryLegendConfig();
     virtual ~RimTernaryLegendConfig();
 
-    void                setReservoirView(RimReservoirView* ownerReservoirView) {m_reservoirView = ownerReservoirView; }
+    void                setReservoirView(RimEclipseView* ownerReservoirView) {m_reservoirView = ownerReservoirView; }
 
     void                setAutomaticRanges(TernaryArrayIndex ternaryIndex, double globalMin, double globalMax, double localMin, double localMax);
     void                ternaryRanges(double& soilLower, double& soilUpper, double& sgasLower, double& sgasUpper, double& swatLower, double& swatUpper) const;
@@ -107,7 +107,7 @@ private:
     std::vector<double>             m_localAutoMax;
     std::vector<double>             m_localAutoMin;
 
-    caf::PdmPointer<RimReservoirView>           m_reservoirView;
+    caf::PdmPointer<RimEclipseView>           m_reservoirView;
     cvf::ref<RivTernarySaturationOverlayItem>   m_legend;
 	cvf::ref<RivTernaryScalarMapper>			m_scalarMapper;
 };

ApplicationCode/ProjectDataModel/RimUiTreeModelPdm.cpp

@@ -368,7 +368,7 @@ RimView* RimUiTreeModelPdm::addReservoirView(const std::vector<caf::PdmUiItem*>&
     RimEclipseCase* eclipseCase = dynamic_cast<RimEclipseCase*>(currentItem);
     RimGeoMechCase* geomCase = dynamic_cast<RimGeoMechCase*>(currentItem);
     RimGeoMechView* geoMechView = dynamic_cast<RimGeoMechView*>(currentItem);
-    RimReservoirView* reservoirView = dynamic_cast<RimReservoirView*>(currentItem);
+    RimEclipseView* reservoirView = dynamic_cast<RimEclipseView*>(currentItem);
 
     // Find case to insert into
 
@@ -682,14 +682,14 @@ void RimUiTreeModelPdm::addObjects(const QModelIndex& itemIndex, const caf::PdmO
 
             for (size_t rvIdx = 0; rvIdx < rimResultReservoir->reservoirViews.size(); rvIdx++)
             {
-                RimReservoirView* riv = rimResultReservoir->reservoirViews()[rvIdx];
+                RimEclipseView* riv = rimResultReservoir->reservoirViews()[rvIdx];
                 riv->loadDataAndUpdate();
             }
         }
     }
     else if (caseFromItemIndex(itemIndex))
     {
-        std::vector<caf::PdmPointer<RimReservoirView> > typedObjects;
+        std::vector<caf::PdmPointer<RimEclipseView> > typedObjects;
         pdmObjects.createCopyByType(&typedObjects);
 
         if (typedObjects.size() == 0)
@@ -704,7 +704,7 @@ void RimUiTreeModelPdm::addObjects(const QModelIndex& itemIndex, const caf::PdmO
         // Add cases to case group
         for (size_t i = 0; i < typedObjects.size(); i++)
         {
-            RimReservoirView* rimReservoirView = typedObjects[i];
+            RimEclipseView* rimReservoirView = typedObjects[i];
             QString nameOfCopy = QString("Copy of ") + rimReservoirView->name;
             rimReservoirView->name = nameOfCopy;
             rimCase->reservoirViews().push_back(rimReservoirView);
@@ -962,9 +962,9 @@ RimEclipseCase* RimUiTreeModelPdm::caseFromItemIndex(const QModelIndex& itemInde
     {
         rimCase = dynamic_cast<RimEclipseCase*>(currentItem->dataObject().p());
     }
-    else if (dynamic_cast<RimReservoirView*>(currentItem->dataObject().p()))
+    else if (dynamic_cast<RimEclipseView*>(currentItem->dataObject().p()))
     {
-        RimReservoirView* reservoirView = dynamic_cast<RimReservoirView*>(currentItem->dataObject().p());
+        RimEclipseView* reservoirView = dynamic_cast<RimEclipseView*>(currentItem->dataObject().p());
         CVF_ASSERT(reservoirView);
 
         rimCase = reservoirView->eclipseCase();
@@ -980,7 +980,7 @@ void RimUiTreeModelPdm::setObjectToggleStateForSelection(QModelIndexList selecte
 {
     bool toggleOn = (state == Qt::Checked);
 
-    std::set<RimReservoirView*> resViewsToUpdate;
+    std::set<RimEclipseView*> resViewsToUpdate;
 
     foreach (QModelIndex index, selectedIndexes)
     {

ApplicationCode/ProjectDataModel/RimUiTreeModelPdm.h

@@ -30,7 +30,7 @@ class QFileSystemWatcher;
 class RimCellPropertyFilter;
 class RimCellRangeFilter;
 class RimEclipseCase;
-class RimReservoirView;
+class RimEclipseView;
 class RimInputProperty;
 class RimStatisticsCase;
 class RimIdenticalGridCaseGroup;

ApplicationCode/ProjectDataModel/RimUiTreeView.cpp

@@ -123,7 +123,7 @@ void RimUiTreeView::contextMenuEvent(QContextMenuEvent* event)
                 //menu.addAction(m_pasteAction);
                 menu.addAction(QString("Delete"), this, SLOT(slotDeleteView()));
             }
-            else if (dynamic_cast<RimReservoirView*>(uiItem->dataObject().p()))
+            else if (dynamic_cast<RimEclipseView*>(uiItem->dataObject().p()))
             {
                 menu.addAction(QString("New View"), this, SLOT(slotAddView()));
                 menu.addAction(QString("Copy View"), this, SLOT(slotCopyPdmObjectToClipboard()));
@@ -1063,7 +1063,7 @@ void RimUiTreeView::keyPressEvent(QKeyEvent* keyEvent)
     if (uiItem)
     {
         if (dynamic_cast<RimEclipseCase*>(uiItem->dataObject().p())
-            || dynamic_cast<RimReservoirView*>(uiItem->dataObject().p()))
+            || dynamic_cast<RimEclipseView*>(uiItem->dataObject().p()))
         {
             if (keyEvent->matches(QKeySequence::Copy))
             {
@@ -1077,7 +1077,7 @@ void RimUiTreeView::keyPressEvent(QKeyEvent* keyEvent)
         if (dynamic_cast<RimIdenticalGridCaseGroup*>(uiItem->dataObject().p())
             || dynamic_cast<RimCaseCollection*>(uiItem->dataObject().p())
             || dynamic_cast<RimEclipseCase*>(uiItem->dataObject().p())
-            || dynamic_cast<RimReservoirView*>(uiItem->dataObject().p()))
+            || dynamic_cast<RimEclipseView*>(uiItem->dataObject().p()))
         {
             if (keyEvent->matches(QKeySequence::Paste))
             {

ApplicationCode/ProjectDataModel/RimWell.cpp

@@ -74,7 +74,7 @@ caf::PdmFieldHandle* RimWell::userDescriptionField()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimWell::setReservoirView(RimReservoirView* ownerReservoirView)
+void RimWell::setReservoirView(RimEclipseView* ownerReservoirView)
 {
     m_reservoirView = ownerReservoirView;
 }

ApplicationCode/ProjectDataModel/RimWell.h

@@ -31,7 +31,7 @@
 #include "cafPdmFieldCvfColor.h"    
 
 class RigSingleWellResultsData;
-class RimReservoirView;
+class RimEclipseView;
 
 //==================================================================================================
 ///  
@@ -45,7 +45,7 @@ public:
     RimWell();
     virtual ~RimWell();
     
-    void                                setReservoirView(RimReservoirView* ownerReservoirView);
+    void                                setReservoirView(RimEclipseView* ownerReservoirView);
     void                                setWellIndex(size_t val) { m_wellIndex = val; }
 
     void                                setWellResults(RigSingleWellResultsData* wellResults) { m_wellResults = wellResults;}
@@ -77,5 +77,5 @@ private:
     cvf::ref<RigSingleWellResultsData>  m_wellResults;
     size_t                              m_wellIndex;
 
-    RimReservoirView*                   m_reservoirView;
+    RimEclipseView*                   m_reservoirView;
 };

ApplicationCode/ProjectDataModel/RimWellCollection.cpp

@@ -257,7 +257,7 @@ void RimWellCollection::fieldChangedByUi(const caf::PdmFieldHandle* changedField
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimWellCollection::setReservoirView(RimReservoirView* ownerReservoirView)
+void RimWellCollection::setReservoirView(RimEclipseView* ownerReservoirView)
 {
     m_reservoirView = ownerReservoirView;
 }

ApplicationCode/ProjectDataModel/RimWellCollection.h

@@ -30,7 +30,7 @@
 
 #include <QString>
 
-class RimReservoirView;
+class RimEclipseView;
 class RimWell;
 
 //==================================================================================================
@@ -45,7 +45,7 @@ public:
     RimWellCollection();
     virtual ~RimWellCollection();
 
-    void                                setReservoirView(RimReservoirView* ownerReservoirView);
+    void                                setReservoirView(RimEclipseView* ownerReservoirView);
 
     enum WellVisibilityType
     {
@@ -117,7 +117,7 @@ private:
 
     void                                calculateIsWellPipesVisible(size_t frameIndex);
 
-    RimReservoirView*   m_reservoirView;
+    RimEclipseView*   m_reservoirView;
     std::vector< std::vector< cvf::ubyte > >             
                                         m_isWellPipesVisible;  
 };

ApplicationCode/SocketInterface/RiaSocketServer.cpp

@@ -152,7 +152,7 @@ RimEclipseCase* RiaSocketServer::findReservoir(int caseId)
 
     if (currCaseId < 0)
     {
-        RimReservoirView* riv = dynamic_cast<RimReservoirView*>(RiaApplication::instance()->activeReservoirView());
+        RimEclipseView* riv = dynamic_cast<RimEclipseView*>(RiaApplication::instance()->activeReservoirView());
         if (riv)
         {
             return riv->eclipseCase();

ApplicationCode/UserInterface/RiuMainWindow.cpp

@@ -721,7 +721,7 @@ void RiuMainWindow::refreshAnimationActions()
         activeView->viewer()->frameCount())
     {
         enableAnimControls = true;
-        RimReservoirView * activeRiv = dynamic_cast<RimReservoirView*>(activeView);
+        RimEclipseView * activeRiv = dynamic_cast<RimEclipseView*>(activeView);
 
         if (activeRiv)
         {
@@ -1722,7 +1722,7 @@ void RiuMainWindow::slotToggleFaultsAction(bool showFaults)
 //--------------------------------------------------------------------------------------------------
 void RiuMainWindow::slotToggleFaultLabelsAction(bool showLabels)
 {
-    RimReservoirView* activeRiv = dynamic_cast<RimReservoirView*>(RiaApplication::instance()->activeReservoirView());
+    RimEclipseView* activeRiv = dynamic_cast<RimEclipseView*>(RiaApplication::instance()->activeReservoirView());
     if (!activeRiv) return;
 
     activeRiv->faultCollection->showFaultLabel.setValueFromUi(showLabels);
@@ -1742,7 +1742,7 @@ void RiuMainWindow::refreshDrawStyleActions()
     m_drawStyleSurfOnlyAction->setEnabled(enable);
     m_drawStyleFaultLinesSolidAction->setEnabled(enable);
 
-    RimReservoirView* riv = dynamic_cast<RimReservoirView*>(RiaApplication::instance()->activeReservoirView());
+    RimEclipseView* riv = dynamic_cast<RimEclipseView*>(RiaApplication::instance()->activeReservoirView());
     
     enable = enable && riv;
 
@@ -2042,7 +2042,7 @@ void RiuMainWindow::setDefaultWindowSize()
 //--------------------------------------------------------------------------------------------------
 void RiuMainWindow::slotAddWellCellsToRangeFilterAction(bool doAdd)
 {
-    RimReservoirView* riv = dynamic_cast<RimReservoirView*>(RiaApplication::instance()->activeReservoirView());
+    RimEclipseView* riv = dynamic_cast<RimEclipseView*>(RiaApplication::instance()->activeReservoirView());
     if (riv)
     {
         caf::AppEnum<RimWellCollection::WellCellsRangeFilterType> rangeAddType;

ApplicationCode/UserInterface/RiuResultTextBuilder.cpp

@@ -37,7 +37,7 @@
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RiuResultTextBuilder::RiuResultTextBuilder(RimReservoirView* reservoirView, size_t gridIndex, size_t cellIndex, size_t timeStepIndex)
+RiuResultTextBuilder::RiuResultTextBuilder(RimEclipseView* reservoirView, size_t gridIndex, size_t cellIndex, size_t timeStepIndex)
 {
     CVF_ASSERT(reservoirView);
     

ApplicationCode/UserInterface/RiuResultTextBuilder.h

@@ -24,7 +24,7 @@
 #include "cvfStructGrid.h"
 
 
-class RimReservoirView;
+class RimEclipseView;
 class RimResultSlot;
 class QString;
 class RigCaseData;
@@ -40,7 +40,7 @@ namespace cvf {
 class RiuResultTextBuilder
 {
 public:
-	RiuResultTextBuilder(RimReservoirView* reservoirView, size_t gridIndex, size_t cellIndex, size_t timeStepIndex);
+	RiuResultTextBuilder(RimEclipseView* reservoirView, size_t gridIndex, size_t cellIndex, size_t timeStepIndex);
     void setFace(cvf::StructGridInterface::FaceType face);
     void setNncIndex(size_t nncIndex);
     void setIntersectionPoint(cvf::Vec3d intersectionPoint);
@@ -67,7 +67,7 @@ private:
 	void appendTextFromResultSlot(RigCaseData* eclipseCase, size_t gridIndex, size_t cellIndex, size_t timeStepIndex, RimResultSlot* resultSlot, QString* resultInfoText);
 
 private:
-    caf::PdmPointer<RimReservoirView> m_reservoirView;
+    caf::PdmPointer<RimEclipseView> m_reservoirView;
 
 	size_t m_gridIndex;
 	size_t m_cellIndex;

ApplicationCode/UserInterface/RiuViewer.cpp

@@ -204,7 +204,7 @@ void RiuViewer::mouseReleaseEvent(QMouseEvent* event)
     }
     else if (event->button() == Qt::RightButton)
     {
-        RimReservoirView* eclipseView = dynamic_cast<RimReservoirView*>(m_reservoirView.p());
+        RimEclipseView* eclipseView = dynamic_cast<RimEclipseView*>(m_reservoirView.p());
         if (!eclipseView) return;
 
         m_currentGridIdx = cvf::UNDEFINED_SIZE_T;
@@ -272,7 +272,7 @@ void RiuViewer::mouseReleaseEvent(QMouseEvent* event)
 //--------------------------------------------------------------------------------------------------
 void RiuViewer::slotRangeFilterI()
 {
-    RimReservoirView* eclipseView = dynamic_cast<RimReservoirView*>(m_reservoirView.p());
+    RimEclipseView* eclipseView = dynamic_cast<RimEclipseView*>(m_reservoirView.p());
     if (!eclipseView) return;
 
     size_t i, j, k;
@@ -310,7 +310,7 @@ void RiuViewer::slotRangeFilterI()
 //--------------------------------------------------------------------------------------------------
 void RiuViewer::slotRangeFilterJ()
 {
-    RimReservoirView* eclipseView = dynamic_cast<RimReservoirView*>(m_reservoirView.p());
+    RimEclipseView* eclipseView = dynamic_cast<RimEclipseView*>(m_reservoirView.p());
     if (!eclipseView) return;
 
     size_t i, j, k;
@@ -348,7 +348,7 @@ void RiuViewer::slotRangeFilterJ()
 //--------------------------------------------------------------------------------------------------
 void RiuViewer::slotRangeFilterK()
 {
-    RimReservoirView* eclipseView = dynamic_cast<RimReservoirView*>(m_reservoirView.p());
+    RimEclipseView* eclipseView = dynamic_cast<RimEclipseView*>(m_reservoirView.p());
     if (!eclipseView) return;
 
     size_t i, j, k;
@@ -398,7 +398,7 @@ void RiuViewer::keyPressEvent(QKeyEvent* event)
 //--------------------------------------------------------------------------------------------------
 void RiuViewer::handlePickAction(int winPosX, int winPosY)
 {
-    RimReservoirView* eclipseView = dynamic_cast<RimReservoirView*>(m_reservoirView.p());
+    RimEclipseView* eclipseView = dynamic_cast<RimEclipseView*>(m_reservoirView.p());
 
     RiaApplication* app = RiaApplication::instance();
 
@@ -538,7 +538,7 @@ void RiuViewer::setEnableMask(unsigned int mask)
 //--------------------------------------------------------------------------------------------------
 void RiuViewer::pickPointAndFace(int winPosX, int winPosY, cvf::Vec3d* localIntersectionPoint, cvf::Part** firstPart, uint* firstPartFaceHit, cvf::Part** nncPart, uint* nncPartFaceHit)
 {
-    RimReservoirView* eclipseView = dynamic_cast<RimReservoirView*>(m_reservoirView.p());
+    RimEclipseView* eclipseView = dynamic_cast<RimEclipseView*>(m_reservoirView.p());
     if(!eclipseView) return;
 
     cvf::HitItemCollection hitItems;
@@ -735,7 +735,7 @@ void RiuViewer::showHistogram(bool enable)
 //--------------------------------------------------------------------------------------------------
 void RiuViewer::ijkFromCellIndex(size_t gridIdx, size_t cellIndex,  size_t* i, size_t* j, size_t* k)
 {
-    RimReservoirView* eclipseView = dynamic_cast<RimReservoirView*>(m_reservoirView.p());
+    RimEclipseView* eclipseView = dynamic_cast<RimEclipseView*>(m_reservoirView.p());
     if(!eclipseView) return;
 
 
@@ -759,7 +759,7 @@ void RiuViewer::mousePressEvent(QMouseEvent* event)
 //--------------------------------------------------------------------------------------------------
 void RiuViewer::slotHideFault()
 {
-    RimReservoirView* eclipseView = dynamic_cast<RimReservoirView*>(m_reservoirView.p());
+    RimEclipseView* eclipseView = dynamic_cast<RimEclipseView*>(m_reservoirView.p());
     if(!eclipseView) return;