OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

Rename of RimReservoirView to RimEclipseView

Browse Source 
To make the separation to geomech clearer, and alligning it to the
RigCaseNaming
This commit is contained in:
Jacob Støren 2015-05-21 10:05:33 +02:00
parent caa835331f
commit ed74116376
52 changed files with 154 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ApplicationCode/Application/RiaApplication.cpp
View File

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

2
ApplicationCode/Application/RiaApplication.h
View File

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

2
ApplicationCode/ModelVisualization/RivReservoirFaultsPartMgr.cpp
View File

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

6
ApplicationCode/ModelVisualization/RivReservoirFaultsPartMgr.h
View File

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

2
ApplicationCode/ModelVisualization/RivReservoirPartMgr.cpp
View File

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

4
ApplicationCode/ModelVisualization/RivReservoirPartMgr.h
View File

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

2
ApplicationCode/ModelVisualization/RivReservoirPipesPartMgr.cpp
View File

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

6
ApplicationCode/ModelVisualization/RivReservoirPipesPartMgr.h
View File

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

2
ApplicationCode/ModelVisualization/RivReservoirViewPartMgr.cpp
View File

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

6
ApplicationCode/ModelVisualization/RivReservoirViewPartMgr.h
View File

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

2
ApplicationCode/ModelVisualization/RivWellHeadPartMgr.cpp
View File

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

6
ApplicationCode/ModelVisualization/RivWellHeadPartMgr.h
View File

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

2
ApplicationCode/ModelVisualization/RivWellPipesPartMgr.cpp
View File

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

6
ApplicationCode/ModelVisualization/RivWellPipesPartMgr.h
View File

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

4
ApplicationCode/ProjectDataModel/Rim3dOverlayInfoConfig.cpp
View File

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

4
ApplicationCode/ProjectDataModel/Rim3dOverlayInfoConfig.h
View File

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

2
ApplicationCode/ProjectDataModel/RimCellEdgeResultSlot.cpp
View File

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

6
ApplicationCode/ProjectDataModel/RimCellEdgeResultSlot.h
View File

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

2
ApplicationCode/ProjectDataModel/RimCellPropertyFilter.h
View File

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

4
ApplicationCode/ProjectDataModel/RimCellPropertyFilterCollection.cpp
View File

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

6
ApplicationCode/ProjectDataModel/RimCellPropertyFilterCollection.h
View File

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

2
ApplicationCode/ProjectDataModel/RimCellRangeFilter.h
View File

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

4
ApplicationCode/ProjectDataModel/RimCellRangeFilterCollection.cpp
View File

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

6
ApplicationCode/ProjectDataModel/RimCellRangeFilterCollection.h
View File

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

12
ApplicationCode/ProjectDataModel/RimEclipseCase.cpp
View File

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

6
ApplicationCode/ProjectDataModel/RimEclipseCase.h
View File

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

2
ApplicationCode/ProjectDataModel/RimFault.cpp
View File

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

2
ApplicationCode/ProjectDataModel/RimFaultCollection.cpp
View File

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

6
ApplicationCode/ProjectDataModel/RimFaultCollection.h
View File

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

2
ApplicationCode/ProjectDataModel/RimFaultResultSlot.cpp
View File

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

6
ApplicationCode/ProjectDataModel/RimFaultResultSlot.h
View File

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

2
ApplicationCode/ProjectDataModel/RimIdenticalGridCaseGroup.cpp
View File

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

72
ApplicationCode/ProjectDataModel/RimReservoirView.cpp
View File

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

6
ApplicationCode/ProjectDataModel/RimReservoirView.h
View File

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

4
ApplicationCode/ProjectDataModel/RimResultDefinition.cpp
View File

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

8
ApplicationCode/ProjectDataModel/RimResultDefinition.h
View File

@ -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);
RimReservoirView* reservoirView();
virtual void setReservoirView(RimEclipseView* ownerReservoirView);
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();

2
ApplicationCode/ProjectDataModel/RimResultSlot.cpp
View File

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

2
ApplicationCode/ProjectDataModel/RimResultSlot.h
View File

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

4
ApplicationCode/ProjectDataModel/RimStatisticsCase.cpp
View File

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

6
ApplicationCode/ProjectDataModel/RimTernaryLegendConfig.h
View File

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

14
ApplicationCode/ProjectDataModel/RimUiTreeModelPdm.cpp
View File

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

2
ApplicationCode/ProjectDataModel/RimUiTreeModelPdm.h
View File

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

6
ApplicationCode/ProjectDataModel/RimUiTreeView.cpp
View File

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

2
ApplicationCode/ProjectDataModel/RimWell.cpp
View File

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

6
ApplicationCode/ProjectDataModel/RimWell.h
View File

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

2
ApplicationCode/ProjectDataModel/RimWellCollection.cpp
View File

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

6
ApplicationCode/ProjectDataModel/RimWellCollection.h
View File

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

2
ApplicationCode/SocketInterface/RiaSocketServer.cpp
View File

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

8
ApplicationCode/UserInterface/RiuMainWindow.cpp
View File

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

2
ApplicationCode/UserInterface/RiuResultTextBuilder.cpp
View File

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

6
ApplicationCode/UserInterface/RiuResultTextBuilder.h
View File

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

16
ApplicationCode/UserInterface/RiuViewer.cpp
View File

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