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

Renamed base class RimCase to RimEclipseCase

Browse Source 
To make room for a RimCase base class that can be used as base class for
RimGeoMechCase as well.
This commit is only the class rename not the file rename.
This commit is contained in:
Jacob Støren 2015-05-15 08:40:27 +02:00
parent 750fc5182c
commit 223f8385d2
38 changed files with 164 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
ApplicationCode/Application/RiaApplication.cpp
View File

@ -363,14 +363,14 @@ bool RiaApplication::loadProject(const QString& projectFileName, ProjectLoadActi
// Now load the ReservoirViews for the cases
// Add all "native" cases in the project
std::vector<RimCase*> casesToLoad;
std::vector<RimEclipseCase*> casesToLoad;
m_project->allCases(casesToLoad);
caf::ProgressInfo caseProgress(casesToLoad.size() , "Reading Cases");
for (size_t cIdx = 0; cIdx < casesToLoad.size(); ++cIdx)
{
RimCase* ri = casesToLoad[cIdx];
RimEclipseCase* ri = casesToLoad[cIdx];
CVF_ASSERT(ri);
caseProgress.setProgressDescription(ri->caseUserDescription());
@ -1526,12 +1526,12 @@ void RiaApplication::saveSnapshotForAllViews(const QString& snapshotFolderName)
const QString absSnapshotPath = snapshotPath.absolutePath();
std::vector<RimCase*> projectCases;
std::vector<RimEclipseCase*> projectCases;
m_project->allCases(projectCases);
for (size_t i = 0; i < projectCases.size(); i++)
{
RimCase* ri = projectCases[i];
RimEclipseCase* ri = projectCases[i];
if (!ri) continue;
for (size_t j = 0; j < ri->reservoirViews().size(); j++)
@ -2104,12 +2104,12 @@ void RiaApplication::regressionTestConfigureProject()
if (m_project.isNull()) return;
std::vector<RimCase*> projectCases;
std::vector<RimEclipseCase*> projectCases;
m_project->allCases(projectCases);
for (size_t i = 0; i < projectCases.size(); i++)
{
RimCase* ri = projectCases[i];
RimEclipseCase* ri = projectCases[i];
if (!ri) continue;
for (size_t j = 0; j < ri->reservoirViews().size(); j++)

2
ApplicationCode/Application/RiaApplication.h
View File

@ -33,7 +33,7 @@
class RIProcess;
class RigCaseData;
class RimCase;
class RimEclipseCase;
class Drawable;
class RiaSocketServer;
class RiaPreferences;

2
ApplicationCode/Application/RiaProjectModifier.cpp
View File

@ -191,7 +191,7 @@ bool RiaProjectModifier::replaceSourceCases(RimProject* project)
bool RiaProjectModifier::replaceCase(RimProject* project)
{
bool didReplacement = false;
std::vector<RimCase*> allCases;
std::vector<RimEclipseCase*> allCases;
project->allCases(allCases);
for (size_t caseIdx = 0; caseIdx < allCases.size(); ++caseIdx)

10
ApplicationCode/ProjectDataModel/RimAnalysisModels.cpp
View File

@ -66,7 +66,7 @@ void RimAnalysisModels::close()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimIdenticalGridCaseGroup* RimAnalysisModels::createIdenticalCaseGroupFromMainCase(RimCase* mainCase)
RimIdenticalGridCaseGroup* RimAnalysisModels::createIdenticalCaseGroupFromMainCase(RimEclipseCase* mainCase)
{
CVF_ASSERT(mainCase);
@ -78,7 +78,7 @@ RimIdenticalGridCaseGroup* RimAnalysisModels::createIdenticalCaseGroupFromMainCa
assert(RiaApplication::instance()->project());
RiaApplication::instance()->project()->assignIdToCaseGroup(group);
RimCase* createdCase = group->createAndAppendStatisticsCase();
RimEclipseCase* createdCase = group->createAndAppendStatisticsCase();
RiaApplication::instance()->project()->assignCaseIdToCase(createdCase);
group->addCase(mainCase);
@ -90,7 +90,7 @@ RimIdenticalGridCaseGroup* RimAnalysisModels::createIdenticalCaseGroupFromMainCa
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimAnalysisModels::moveEclipseCaseIntoCaseGroup(RimCase* rimReservoir)
void RimAnalysisModels::moveEclipseCaseIntoCaseGroup(RimEclipseCase* rimReservoir)
{
CVF_ASSERT(rimReservoir);
@ -130,7 +130,7 @@ void RimAnalysisModels::moveEclipseCaseIntoCaseGroup(RimCase* rimReservoir)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimAnalysisModels::removeCaseFromAllGroups(RimCase* reservoir)
void RimAnalysisModels::removeCaseFromAllGroups(RimEclipseCase* reservoir)
{
m_gridCollection->removeCase(reservoir->reservoirData());
@ -177,7 +177,7 @@ RigMainGrid* RimAnalysisModels::registerCaseInGridCollection(RigCaseData* rigEcl
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimAnalysisModels::insertCaseInCaseGroup(RimIdenticalGridCaseGroup* caseGroup, RimCase* rimReservoir)
void RimAnalysisModels::insertCaseInCaseGroup(RimIdenticalGridCaseGroup* caseGroup, RimEclipseCase* rimReservoir)
{
CVF_ASSERT(rimReservoir);

12
ApplicationCode/ProjectDataModel/RimAnalysisModels.h
View File

@ -26,7 +26,7 @@
#include "cvfObject.h"
class RimCase;
class RimEclipseCase;
class RigGridManager;
class RimIdenticalGridCaseGroup;
class RigMainGrid;
@ -45,15 +45,15 @@ public:
RimAnalysisModels(void);
virtual ~RimAnalysisModels(void);
caf::PdmPointersField<RimCase*> cases;
caf::PdmPointersField<RimEclipseCase*> cases;
caf::PdmPointersField<RimIdenticalGridCaseGroup*> caseGroups;
void close();
RimIdenticalGridCaseGroup* createIdenticalCaseGroupFromMainCase(RimCase* mainCase);
void insertCaseInCaseGroup(RimIdenticalGridCaseGroup* caseGroup, RimCase* rimReservoir);
void moveEclipseCaseIntoCaseGroup(RimCase* rimReservoir);
void removeCaseFromAllGroups(RimCase* rimReservoir);
RimIdenticalGridCaseGroup* createIdenticalCaseGroupFromMainCase(RimEclipseCase* mainCase);
void insertCaseInCaseGroup(RimIdenticalGridCaseGroup* caseGroup, RimEclipseCase* rimReservoir);
void moveEclipseCaseIntoCaseGroup(RimEclipseCase* rimReservoir);
void removeCaseFromAllGroups(RimEclipseCase* rimReservoir);
void recomputeStatisticsForAllCaseGroups();

34
ApplicationCode/ProjectDataModel/RimCase.cpp
View File

@ -43,12 +43,12 @@
#include <QDebug>
CAF_PDM_SOURCE_INIT(RimCase, "RimReservoir");
CAF_PDM_SOURCE_INIT(RimEclipseCase, "RimReservoir");
//------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimCase::RimCase()
RimEclipseCase::RimEclipseCase()
{
CAF_PDM_InitField(&caseUserDescription, "CaseUserDescription", QString(), "Case name", "", "" ,"");
@ -82,7 +82,7 @@ RimCase::RimCase()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimCase::~RimCase()
RimEclipseCase::~RimEclipseCase()
{
reservoirViews.deleteAllChildObjects();
@ -99,7 +99,7 @@ RimCase::~RimCase()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigCaseData* RimCase::reservoirData()
RigCaseData* RimEclipseCase::reservoirData()
{
return m_rigEclipseCase.p();
}
@ -107,7 +107,7 @@ RigCaseData* RimCase::reservoirData()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RigCaseData* RimCase::reservoirData() const
const RigCaseData* RimEclipseCase::reservoirData() const
{
return m_rigEclipseCase.p();
}
@ -115,7 +115,7 @@ const RigCaseData* RimCase::reservoirData() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimCase::initAfterRead()
void RimEclipseCase::initAfterRead()
{
size_t j;
for (j = 0; j < reservoirViews().size(); j++)
@ -135,7 +135,7 @@ void RimCase::initAfterRead()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimReservoirView* RimCase::createAndAddReservoirView()
RimReservoirView* RimEclipseCase::createAndAddReservoirView()
{
RimReservoirView* riv = new RimReservoirView();
riv->setEclipseCase(this);
@ -153,7 +153,7 @@ RimReservoirView* RimCase::createAndAddReservoirView()
//--------------------------------------------------------------------------------------------------
/// TODO: Move this functionality to PdmPointersField
//--------------------------------------------------------------------------------------------------
void RimCase::removeReservoirView(RimReservoirView* reservoirView)
void RimEclipseCase::removeReservoirView(RimReservoirView* reservoirView)
{
std::vector<size_t> indices;
@ -177,7 +177,7 @@ void RimCase::removeReservoirView(RimReservoirView* reservoirView)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimCase::removeResult(const QString& resultName)
void RimEclipseCase::removeResult(const QString& resultName)
{
size_t i;
for (i = 0; i < reservoirViews().size(); i++)
@ -228,7 +228,7 @@ void RimCase::removeResult(const QString& resultName)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimCase::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
void RimEclipseCase::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
{
if (changedField == &releaseResultMemory)
{
@ -293,7 +293,7 @@ void RimCase::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QV
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimCase::computeCachedData()
void RimEclipseCase::computeCachedData()
{
RigCaseData* rigEclipseCase = reservoirData();
if (rigEclipseCase)
@ -317,7 +317,7 @@ void RimCase::computeCachedData()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimCaseCollection* RimCase::parentCaseCollection()
RimCaseCollection* RimEclipseCase::parentCaseCollection()
{
std::vector<RimCaseCollection*> parentObjects;
this->parentObjectsOfType(parentObjects);
@ -333,7 +333,7 @@ RimCaseCollection* RimCase::parentCaseCollection()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimIdenticalGridCaseGroup* RimCase::parentGridCaseGroup()
RimIdenticalGridCaseGroup* RimEclipseCase::parentGridCaseGroup()
{
RimCaseCollection* caseColl = parentCaseCollection();
if (caseColl)
@ -350,7 +350,7 @@ RimIdenticalGridCaseGroup* RimCase::parentGridCaseGroup()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimCase::setReservoirData(RigCaseData* eclipseCase)
void RimEclipseCase::setReservoirData(RigCaseData* eclipseCase)
{
m_rigEclipseCase = eclipseCase;
if (this->reservoirData())
@ -372,7 +372,7 @@ void RimCase::setReservoirData(RigCaseData* eclipseCase)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimReservoirCellResultsStorage* RimCase::results(RifReaderInterface::PorosityModelResultType porosityModel)
RimReservoirCellResultsStorage* RimEclipseCase::results(RifReaderInterface::PorosityModelResultType porosityModel)
{
if (porosityModel == RifReaderInterface::MATRIX_RESULTS)
{
@ -394,7 +394,7 @@ RimReservoirCellResultsStorage* RimCase::results(RifReaderInterface::PorosityMod
/// such that the common start of oldProjectPath and m_gridFileName is removed from m_gridFileName
/// and replaced with the start of newProjectPath up to where newProjectPath starts to be equal to oldProjectPath
//--------------------------------------------------------------------------------------------------
QString RimCase::relocateFile(const QString& orgFileName, const QString& orgNewProjectPath, const QString& orgOldProjectPath,
QString RimEclipseCase::relocateFile(const QString& orgFileName, const QString& orgNewProjectPath, const QString& orgOldProjectPath,
bool* foundFile, std::vector<QString>* searchedPaths)
{
if (foundFile) *foundFile = true;
@ -541,7 +541,7 @@ QString RimCase::relocateFile(const QString& orgFileName, const QString& orgNew
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimCase::openReserviorCase()
bool RimEclipseCase::openReserviorCase()
{
// If read already, return

6
ApplicationCode/ProjectDataModel/RimCase.h
View File

@ -40,12 +40,12 @@ class RimReservoirCellResultsStorage;
// Interface for reservoirs.
//
//==================================================================================================
class RimCase : public caf::PdmObject
class RimEclipseCase : public caf::PdmObject
{
CAF_PDM_HEADER_INIT;
public:
RimCase();
virtual ~RimCase();
RimEclipseCase();
virtual ~RimEclipseCase();
// Fields:

2
ApplicationCode/ProjectDataModel/RimCaseCollection.cpp
View File

@ -63,7 +63,7 @@ RimIdenticalGridCaseGroup* RimCaseCollection::parentCaseGroup()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimCase* RimCaseCollection::findByDescription(const QString& caseDescription) const
RimEclipseCase* RimCaseCollection::findByDescription(const QString& caseDescription) const
{
for (size_t i = 0; i < reservoirs.size(); i++)
{

6
ApplicationCode/ProjectDataModel/RimCaseCollection.h
View File

@ -21,7 +21,7 @@
#include "cafPdmField.h"
#include "cafPdmObject.h"
class RimCase;
class RimEclipseCase;
class RimIdenticalGridCaseGroup;
//==================================================================================================
@ -36,10 +36,10 @@ class RimCaseCollection : public caf::PdmObject
public:
RimCaseCollection();
virtual ~RimCaseCollection();
caf::PdmPointersField<RimCase*> reservoirs;
caf::PdmPointersField<RimEclipseCase*> reservoirs;
RimIdenticalGridCaseGroup* parentCaseGroup();
RimCase* findByDescription(const QString& caseDescription) const;
RimEclipseCase* findByDescription(const QString& caseDescription) const;
private:

22
ApplicationCode/ProjectDataModel/RimIdenticalGridCaseGroup.cpp
View File

@ -79,7 +79,7 @@ RimIdenticalGridCaseGroup::~RimIdenticalGridCaseGroup()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimIdenticalGridCaseGroup::addCase(RimCase* reservoir)
void RimIdenticalGridCaseGroup::addCase(RimEclipseCase* reservoir)
{
CVF_ASSERT(reservoir);
@ -104,7 +104,7 @@ void RimIdenticalGridCaseGroup::addCase(RimCase* reservoir)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimIdenticalGridCaseGroup::removeCase(RimCase* reservoir)
void RimIdenticalGridCaseGroup::removeCase(RimEclipseCase* reservoir)
{
if (caseCollection()->reservoirs().count(reservoir) == 0)
{
@ -155,7 +155,7 @@ void RimIdenticalGridCaseGroup::loadMainCaseAndActiveCellInfo()
// The mainGrid from the first case is reused directly in for the other cases.
// When reading active cell info, only the total cell count is tested for consistency
RimCase* mainCase = caseCollection()->reservoirs[0];
RimEclipseCase* mainCase = caseCollection()->reservoirs[0];
mainCase->openEclipseGridFile();
RigCaseData* rigCaseData = mainCase->reservoirData();
if (rigCaseData)
@ -198,7 +198,7 @@ void RimIdenticalGridCaseGroup::loadMainCaseAndActiveCellInfo()
bool foundResultsInCache = false;
for (size_t i = 0; i < statisticsCaseCollection()->reservoirs.size(); i++)
{
RimCase* rimReservoir = statisticsCaseCollection()->reservoirs[i];
RimEclipseCase* rimReservoir = statisticsCaseCollection()->reservoirs[i];
// Check if any results are stored in cache
if (rimReservoir->results(RifReaderInterface::MATRIX_RESULTS)->storedResultsCount() > 0 ||
@ -257,7 +257,7 @@ void RimIdenticalGridCaseGroup::loadMainCaseAndActiveCellInfo()
for (size_t i = 0; i < statisticsCaseCollection()->reservoirs.size(); i++)
{
RimCase* rimReservoir = statisticsCaseCollection()->reservoirs[i];
RimEclipseCase* rimReservoir = statisticsCaseCollection()->reservoirs[i];
rimReservoir->openEclipseGridFile();
@ -375,7 +375,7 @@ void RimIdenticalGridCaseGroup::updateMainGridAndActiveCellsForStatisticsCases()
{
for (size_t i = 0; i < statisticsCaseCollection->reservoirs().size(); i++)
{
RimCase* rimStaticsCase = statisticsCaseCollection->reservoirs[i];
RimEclipseCase* rimStaticsCase = statisticsCaseCollection->reservoirs[i];
rimStaticsCase->reservoirData()->setMainGrid(this->mainGrid());
@ -393,7 +393,7 @@ void RimIdenticalGridCaseGroup::clearStatisticsResults()
{
for (size_t i = 0; i < statisticsCaseCollection->reservoirs().size(); i++)
{
RimCase* rimStaticsCase = statisticsCaseCollection->reservoirs[i];
RimEclipseCase* rimStaticsCase = statisticsCaseCollection->reservoirs[i];
if (!rimStaticsCase) continue;
rimStaticsCase->results(RifReaderInterface::MATRIX_RESULTS)->cellResults()->clearAllResults();
@ -421,13 +421,13 @@ void RimIdenticalGridCaseGroup::clearActiveCellUnions()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimIdenticalGridCaseGroup::contains(RimCase* reservoir) const
bool RimIdenticalGridCaseGroup::contains(RimEclipseCase* reservoir) const
{
CVF_ASSERT(reservoir);
for (size_t i = 0; i < caseCollection()->reservoirs().size(); i++)
{
RimCase* rimReservoir = caseCollection()->reservoirs()[i];
RimEclipseCase* rimReservoir = caseCollection()->reservoirs()[i];
if (reservoir->gridFileName() == rimReservoir->gridFileName())
{
return true;
@ -473,7 +473,7 @@ bool RimIdenticalGridCaseGroup::isStatisticsCaseCollection(RimCaseCollection* ri
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimCase* RimIdenticalGridCaseGroup::mainCase()
RimEclipseCase* RimIdenticalGridCaseGroup::mainCase()
{
if(caseCollection()->reservoirs().size())
{
@ -488,7 +488,7 @@ RimCase* RimIdenticalGridCaseGroup::mainCase()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimIdenticalGridCaseGroup::canCaseBeAdded(RimCase* reservoir) const
bool RimIdenticalGridCaseGroup::canCaseBeAdded(RimEclipseCase* reservoir) const
{
CVF_ASSERT(reservoir && reservoir->reservoirData() && reservoir->reservoirData()->mainGrid());

12
ApplicationCode/ProjectDataModel/RimIdenticalGridCaseGroup.h
View File

@ -30,7 +30,7 @@
class RimCaseCollection;
class RimStatisticsCase;
class RimCase;
class RimEclipseCase;
class RigMainGrid;
class RigActiveCellInfo;
@ -52,16 +52,16 @@ public:
caf::PdmField<RimCaseCollection*> caseCollection;
caf::PdmField<RimCaseCollection*> statisticsCaseCollection;
void addCase(RimCase* reservoir);
void removeCase(RimCase* reservoir);
void addCase(RimEclipseCase* reservoir);
void removeCase(RimEclipseCase* reservoir);
bool contains(RimCase* reservoir) const;
bool canCaseBeAdded(RimCase* reservoir) const;
bool contains(RimEclipseCase* reservoir) const;
bool canCaseBeAdded(RimEclipseCase* reservoir) const;
RimStatisticsCase* createAndAppendStatisticsCase();
RimCase* mainCase();
RimEclipseCase* mainCase();
void loadMainCaseAndActiveCellInfo();
RigMainGrid* mainGrid();

2
ApplicationCode/ProjectDataModel/RimInputCase.cpp
View File

@ -42,7 +42,7 @@ CAF_PDM_SOURCE_INIT(RimInputCase, "RimInputReservoir");
///
//--------------------------------------------------------------------------------------------------
RimInputCase::RimInputCase()
: RimCase()
: RimEclipseCase()
{
CAF_PDM_InitObject("RimInputCase", ":/EclipseInput48x48.png", "", "");
CAF_PDM_InitField(&m_gridFileName, "GridFileName", QString(), "Case grid filename", "", "" ,"");

2
ApplicationCode/ProjectDataModel/RimInputCase.h
View File

@ -34,7 +34,7 @@ class RimInputProperty;
//
//
//==================================================================================================
class RimInputCase : public RimCase
class RimInputCase : public RimEclipseCase
{
CAF_PDM_HEADER_INIT;

18
ApplicationCode/ProjectDataModel/RimProject.cpp
View File

@ -137,7 +137,7 @@ void RimProject::initScriptDirectories()
{
int largestId = -1;
std::vector<RimCase*> cases;
std::vector<RimEclipseCase*> cases;
allCases(cases);
for (size_t i = 0; i < cases.size(); i++)
@ -234,7 +234,7 @@ void RimProject::initAfterRead()
bool movedOneRimCase = false;
for (size_t cIdx = 0; cIdx < casesObsolete().size(); ++cIdx)
{
RimCase* sourceCase = casesObsolete[cIdx];
RimEclipseCase* sourceCase = casesObsolete[cIdx];
if (analysisModels)
{
analysisModels->cases.push_back(sourceCase);
@ -324,7 +324,7 @@ void RimProject::setProjectFileNameAndUpdateDependencies(const QString& fileName
// Loop over all cases and update file path
std::vector<RimCase*> cases;
std::vector<RimEclipseCase*> cases;
allCases(cases);
for (size_t i = 0; i < cases.size(); i++)
{
@ -345,7 +345,7 @@ void RimProject::setProjectFileNameAndUpdateDependencies(const QString& fileName
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimProject::assignCaseIdToCase(RimCase* reservoirCase)
void RimProject::assignCaseIdToCase(RimEclipseCase* reservoirCase)
{
if (reservoirCase)
{
@ -371,7 +371,7 @@ void RimProject::assignIdToCaseGroup(RimIdenticalGridCaseGroup* caseGroup)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimProject::allCases(std::vector<RimCase*>& cases)
void RimProject::allCases(std::vector<RimEclipseCase*>& cases)
{
for (size_t oilFieldIdx = 0; oilFieldIdx < oilFields().size(); oilFieldIdx++)
{
@ -408,11 +408,11 @@ void RimProject::allCases(std::vector<RimCase*>& cases)
//--------------------------------------------------------------------------------------------------
void RimProject::createDisplayModelAndRedrawAllViews()
{
std::vector<RimCase*> cases;
std::vector<RimEclipseCase*> cases;
allCases(cases);
for (size_t caseIdx = 0; caseIdx < cases.size(); caseIdx++)
{
RimCase* rimCase = cases[caseIdx];
RimEclipseCase* rimCase = cases[caseIdx];
if (rimCase == NULL) continue;
for (size_t viewIdx = 0; viewIdx < rimCase->reservoirViews.size(); viewIdx++)
@ -439,14 +439,14 @@ RimOilField* RimProject::activeOilField()
//--------------------------------------------------------------------------------------------------
void RimProject::computeUtmAreaOfInterest()
{
std::vector<RimCase*> cases;
std::vector<RimEclipseCase*> cases;
allCases(cases);
cvf::BoundingBox projectBB;
for (size_t i = 0; i < cases.size(); i++)
{
RimCase* rimCase = cases[i];
RimEclipseCase* rimCase = cases[i];
if (rimCase && rimCase->reservoirData())
{

8
ApplicationCode/ProjectDataModel/RimProject.h
View File

@ -23,7 +23,7 @@
#include "cafPdmDocument.h"
class RimOilField;
class RimCase;
class RimEclipseCase;
class RigGridManager;
class RimScriptCollection;
class RimIdenticalGridCaseGroup;
@ -57,10 +57,10 @@ public:
void setProjectFileNameAndUpdateDependencies(const QString& fileName);
void assignCaseIdToCase(RimCase* reservoirCase);
void assignCaseIdToCase(RimEclipseCase* reservoirCase);
void assignIdToCaseGroup(RimIdenticalGridCaseGroup* caseGroup);
void allCases(std::vector<RimCase*>& cases); // VL endre impl
void allCases(std::vector<RimEclipseCase*>& cases); // VL endre impl
void createDisplayModelAndRedrawAllViews(); // VL endre impl
void computeUtmAreaOfInterest();
@ -79,7 +79,7 @@ private:
caf::PdmField<int> nextValidCaseId; // Unique case ID within a project, used to identify a case from Octave scripts
caf::PdmField<int> nextValidCaseGroupId; // Unique case group ID within a project, used to identify a case group from Octave scripts
caf::PdmPointersField<RimCase*> casesObsolete; // obsolete
caf::PdmPointersField<RimEclipseCase*> casesObsolete; // obsolete
caf::PdmPointersField<RimIdenticalGridCaseGroup*> caseGroupsObsolete; // obsolete
};

2
ApplicationCode/ProjectDataModel/RimReservoirCellResultsStorage.cpp
View File

@ -1489,7 +1489,7 @@ double RimReservoirCellResultsStorage::darchysValue()
double darchy = 0.008527; // (ECLIPSE 100) (METRIC)
RimCase* rimCase = NULL;
RimEclipseCase* rimCase = NULL;
this->firstAncestorOfType(rimCase);
if (rimCase && rimCase->reservoirData())

4
ApplicationCode/ProjectDataModel/RimReservoirView.cpp
View File

@ -1043,7 +1043,7 @@ void RimReservoirView::updateMinMaxValuesAndAddLegendToView(QString legendLabel,
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimReservoirView::setEclipseCase(RimCase* reservoir)
void RimReservoirView::setEclipseCase(RimEclipseCase* reservoir)
{
m_reservoir = reservoir;
}
@ -1051,7 +1051,7 @@ void RimReservoirView::setEclipseCase(RimCase* reservoir)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimCase* RimReservoirView::eclipseCase()
RimEclipseCase* RimReservoirView::eclipseCase()
{
return m_reservoir;
}

8
ApplicationCode/ProjectDataModel/RimReservoirView.h
View File

@ -40,7 +40,7 @@ class RigCaseCellResultsData;
class RigGridBase;
class RigGridCellFaceVisibilityFilter;
class Rim3dOverlayInfoConfig;
class RimCase;
class RimEclipseCase;
class RimCellEdgeResultSlot;
class RimCellPropertyFilter;
class RimCellPropertyFilterCollection;
@ -106,8 +106,8 @@ public:
RimResultSlot* currentFaultResultSlot();
void setEclipseCase(RimCase* reservoir);
RimCase* eclipseCase();
void setEclipseCase(RimEclipseCase* reservoir);
RimEclipseCase* eclipseCase();
public:
@ -171,7 +171,7 @@ private:
void clampCurrentTimestep();
private:
caf::PdmPointer<RimCase> m_reservoir;
caf::PdmPointer<RimEclipseCase> m_reservoir;
std::vector<RivReservoirViewPartMgr::ReservoirGeometryCacheType> m_visibleGridParts;

4
ApplicationCode/ProjectDataModel/RimResultCase.cpp
View File

@ -44,7 +44,7 @@ CAF_PDM_SOURCE_INIT(RimResultCase, "EclipseCase");
///
//--------------------------------------------------------------------------------------------------
RimResultCase::RimResultCase()
: RimCase()
: RimEclipseCase()
{
CAF_PDM_InitObject("Eclipse Case", ":/Case48x48.png", "", "");
@ -358,7 +358,7 @@ void RimResultCase::setCaseInfo(const QString& userDescription, const QString& c
//--------------------------------------------------------------------------------------------------
void RimResultCase::initAfterRead()
{
RimCase::initAfterRead();
RimEclipseCase::initAfterRead();
// Convert from old (9.0.2) way of storing the case file
if (caseFileName().isEmpty())

2
ApplicationCode/ProjectDataModel/RimResultCase.h
View File

@ -30,7 +30,7 @@ class RigMainGrid;
//
//
//==================================================================================================
class RimResultCase : public RimCase
class RimResultCase : public RimEclipseCase
{
CAF_PDM_HEADER_INIT;

10
ApplicationCode/ProjectDataModel/RimStatisticsCase.cpp
View File

@ -54,7 +54,7 @@ CAF_PDM_SOURCE_INIT(RimStatisticsCase, "RimStatisticalCalculation");
///
//--------------------------------------------------------------------------------------------------
RimStatisticsCase::RimStatisticsCase()
: RimCase()
: RimEclipseCase()
{
CAF_PDM_InitObject("Case Group Statistics", ":/Histogram16x16.png", "", "");
@ -186,7 +186,7 @@ void RimStatisticsCase::computeStatistics()
CVF_ASSERT(gridCaseGroup);
gridCaseGroup->computeUnionOfActiveCells();
std::vector<RimCase*> sourceCases;
std::vector<RimEclipseCase*> sourceCases;
getSourceCases(sourceCases);
@ -279,7 +279,7 @@ void RimStatisticsCase::scheduleACTIVEGeometryRegenOnReservoirViews()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimStatisticsCase::getSourceCases(std::vector<RimCase*>& sourceCases)
void RimStatisticsCase::getSourceCases(std::vector<RimEclipseCase*>& sourceCases)
{
RimIdenticalGridCaseGroup* gridCaseGroup = caseGroup();
if (gridCaseGroup)
@ -290,7 +290,7 @@ void RimStatisticsCase::getSourceCases(std::vector<RimCase*>& sourceCases)
CVF_ASSERT(gridCaseGroup->caseCollection);
CVF_ASSERT(gridCaseGroup->caseCollection->reservoirs[i]);
RimCase* sourceCase = gridCaseGroup->caseCollection->reservoirs[i];
RimEclipseCase* sourceCase = gridCaseGroup->caseCollection->reservoirs[i];
sourceCases.push_back(sourceCase);
}
}
@ -462,7 +462,7 @@ void RimStatisticsCase::fieldChangedByUi(const caf::PdmFieldHandle* changedField
RimUiTreeModelPdm* treeModel = RiuMainWindow::instance()->uiPdmModel();
// Find or load well data for given case
RimCase* sourceResultCase = caseGroup()->caseCollection()->findByDescription(m_wellDataSourceCase);
RimEclipseCase* sourceResultCase = caseGroup()->caseCollection()->findByDescription(m_wellDataSourceCase);
if (sourceResultCase)
{
sourceResultCase->openEclipseGridFile();

4
ApplicationCode/ProjectDataModel/RimStatisticsCase.h
View File

@ -41,7 +41,7 @@ class RigSingleWellResultsData;
//
//
//==================================================================================================
class RimStatisticsCase : public RimCase
class RimStatisticsCase : public RimEclipseCase
{
CAF_PDM_HEADER_INIT;
@ -74,7 +74,7 @@ public:
private:
RimIdenticalGridCaseGroup* caseGroup();
void getSourceCases(std::vector<RimCase*>& sourceCases);
void getSourceCases(std::vector<RimEclipseCase*>& sourceCases);
void populateWithDefaultsIfNeeded();

6
ApplicationCode/ProjectDataModel/RimStatisticsCaseEvaluator.cpp
View File

@ -153,7 +153,7 @@ void RimStatisticsCaseEvaluator::evaluateForResults(const QList<ResSpec>& result
cvf::Collection<RigResultAccessor> sourceDataAccessList;
for (size_t caseIdx = 0; caseIdx < m_sourceCases.size(); caseIdx++)
{
RimCase* sourceCase = m_sourceCases.at(caseIdx);
RimEclipseCase* sourceCase = m_sourceCases.at(caseIdx);
// Trigger loading of dataset
sourceCase->results(poroModel)->findOrLoadScalarResultForTimeStep(resultType, resultName, dataAccessTimeStepIndex);
@ -282,7 +282,7 @@ void RimStatisticsCaseEvaluator::evaluateForResults(const QList<ResSpec>& result
for (size_t caseIdx = 0; caseIdx < m_sourceCases.size(); caseIdx++)
{
RimCase* eclipseCase = m_sourceCases.at(caseIdx);
RimEclipseCase* eclipseCase = m_sourceCases.at(caseIdx);
if (!eclipseCase->reservoirViews.size())
{
@ -303,7 +303,7 @@ void RimStatisticsCaseEvaluator::evaluateForResults(const QList<ResSpec>& result
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimStatisticsCaseEvaluator::RimStatisticsCaseEvaluator(const std::vector<RimCase*>& sourceCases, const std::vector<size_t>& timeStepIndices, const RimStatisticsConfig& statisticsConfig, RigCaseData* destinationCase)
RimStatisticsCaseEvaluator::RimStatisticsCaseEvaluator(const std::vector<RimEclipseCase*>& sourceCases, const std::vector<size_t>& timeStepIndices, const RimStatisticsConfig& statisticsConfig, RigCaseData* destinationCase)
: m_sourceCases(sourceCases),
m_statisticsConfig(statisticsConfig),
m_destinationCase(destinationCase),

6
ApplicationCode/ProjectDataModel/RimStatisticsCaseEvaluator.h
View File

@ -27,7 +27,7 @@
#include <math.h>
class RimCase;
class RimEclipseCase;
class RigCaseData;
class RigCaseCellResultsData;
@ -56,7 +56,7 @@ public:
class RimStatisticsCaseEvaluator
{
public:
RimStatisticsCaseEvaluator(const std::vector<RimCase*>& sourceCases,
RimStatisticsCaseEvaluator(const std::vector<RimEclipseCase*>& sourceCases,
const std::vector<size_t>& timeStepIndices,
const RimStatisticsConfig& statisticsConfig,
RigCaseData* destinationCase);
@ -82,7 +82,7 @@ private:
enum StatisticsParamType { MIN, MAX, RANGE, MEAN, STDEV, PMIN, PMID, PMAX, STAT_PARAM_COUNT };
private:
std::vector<RimCase*> m_sourceCases;
std::vector<RimEclipseCase*> m_sourceCases;
std::vector<size_t> m_timeStepIndices;
size_t m_reservoirCellCount;

26
ApplicationCode/ProjectDataModel/RimUiTreeModelPdm.cpp
View File

@ -228,7 +228,7 @@ bool RimUiTreeModelPdm::deleteReservoirView(const QModelIndex& itemIndex)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimUiTreeModelPdm::deleteReservoir(RimCase* reservoir)
void RimUiTreeModelPdm::deleteReservoir(RimEclipseCase* reservoir)
{
if (reservoir->parentCaseCollection())
{
@ -394,7 +394,7 @@ RimReservoirView* RimUiTreeModelPdm::addReservoirView(const QModelIndex& itemInd
collectionIndex = itemIndex.parent();
position = itemIndex.row();
}
else if (dynamic_cast<RimCase*>(currentItem->dataObject().p()))
else if (dynamic_cast<RimEclipseCase*>(currentItem->dataObject().p()))
{
collectionItem = currentItem;
collectionIndex = itemIndex;
@ -403,7 +403,7 @@ RimReservoirView* RimUiTreeModelPdm::addReservoirView(const QModelIndex& itemInd
if (collectionItem)
{
RimCase* rimReservoir = dynamic_cast<RimCase*>(collectionItem->dataObject().p());
RimEclipseCase* rimReservoir = dynamic_cast<RimEclipseCase*>(collectionItem->dataObject().p());
RimReservoirView* insertedView = rimReservoir->createAndAddReservoirView();
// Must be run before buildViewItems, as wells are created in this function
@ -590,7 +590,7 @@ RimIdenticalGridCaseGroup* RimUiTreeModelPdm::addCaseGroup(QModelIndex& inserted
RimIdenticalGridCaseGroup* createdObject = new RimIdenticalGridCaseGroup;
proj->assignIdToCaseGroup(createdObject);
RimCase* createdReservoir = createdObject->createAndAppendStatisticsCase();
RimEclipseCase* createdReservoir = createdObject->createAndAppendStatisticsCase();
proj->assignCaseIdToCase(createdReservoir);
createdObject->name = QString("Grid Case Group %1").arg(analysisModels->caseGroups().size() + 1);
@ -725,7 +725,7 @@ void RimUiTreeModelPdm::addObjects(const QModelIndex& itemIndex, const caf::PdmO
return;
}
RimCase* rimCase = caseFromItemIndex(itemIndex);
RimEclipseCase* rimCase = caseFromItemIndex(itemIndex);
QModelIndex collectionIndex = getModelIndexFromPdmObject(rimCase);
caf::PdmUiTreeItem* collectionItem = getTreeItemFromIndex(collectionIndex);
@ -770,7 +770,7 @@ void RimUiTreeModelPdm::moveObjects(const QModelIndex& itemIndex, caf::PdmObject
for (size_t i = 0; i < typedObjects.size(); i++)
{
RimCase* rimReservoir = typedObjects[i];
RimEclipseCase* rimReservoir = typedObjects[i];
deleteReservoir(rimReservoir);
}
}
@ -859,7 +859,7 @@ Qt::ItemFlags RimUiTreeModelPdm::flags(const QModelIndex &index) const
{
return Qt::ItemIsDropEnabled | defaultFlags;
}
else if (dynamic_cast<RimCase*>(currentItem->dataObject().p()))
else if (dynamic_cast<RimEclipseCase*>(currentItem->dataObject().p()))
{
// TODO: Remember to handle reservoir holding the main grid
return Qt::ItemIsDragEnabled | defaultFlags;
@ -943,9 +943,9 @@ RimIdenticalGridCaseGroup* RimUiTreeModelPdm::gridCaseGroupFromItemIndex(const Q
gridCaseGroup = caseCollection->parentCaseGroup();
}
else if (dynamic_cast<RimCase*>(currentItem->dataObject().p()))
else if (dynamic_cast<RimEclipseCase*>(currentItem->dataObject().p()))
{
RimCase* rimReservoir = dynamic_cast<RimCase*>(currentItem->dataObject().p());
RimEclipseCase* rimReservoir = dynamic_cast<RimEclipseCase*>(currentItem->dataObject().p());
CVF_ASSERT(rimReservoir);
RimCaseCollection* caseCollection = rimReservoir->parentCaseCollection();
@ -980,15 +980,15 @@ void RimUiTreeModelPdm::addToParentAndBuildUiItems(caf::PdmUiTreeItem* parentTre
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimCase* RimUiTreeModelPdm::caseFromItemIndex(const QModelIndex& itemIndex)
RimEclipseCase* RimUiTreeModelPdm::caseFromItemIndex(const QModelIndex& itemIndex)
{
caf::PdmUiTreeItem* currentItem = getTreeItemFromIndex(itemIndex);
RimCase* rimCase = NULL;
RimEclipseCase* rimCase = NULL;
if (dynamic_cast<RimCase*>(currentItem->dataObject().p()))
if (dynamic_cast<RimEclipseCase*>(currentItem->dataObject().p()))
{
rimCase = dynamic_cast<RimCase*>(currentItem->dataObject().p());
rimCase = dynamic_cast<RimEclipseCase*>(currentItem->dataObject().p());
}
else if (dynamic_cast<RimReservoirView*>(currentItem->dataObject().p()))
{

6
ApplicationCode/ProjectDataModel/RimUiTreeModelPdm.h
View File

@ -29,7 +29,7 @@ class QFileSystemWatcher;
class RimCellPropertyFilter;
class RimCellRangeFilter;
class RimCase;
class RimEclipseCase;
class RimReservoirView;
class RimInputProperty;
class RimStatisticsCase;
@ -56,7 +56,7 @@ public:
bool deletePropertyFilter(const QModelIndex& itemIndex);
bool deleteReservoirView(const QModelIndex& itemIndex);
void deleteInputProperty(const QModelIndex& itemIndex);
void deleteReservoir(RimCase* reservoir);
void deleteReservoir(RimEclipseCase* reservoir);
void deleteAllWellPaths(const QModelIndex& itemIndex);
RimCellPropertyFilter* addPropertyFilter(const QModelIndex& itemIndex, QModelIndex& insertedModelIndex);
@ -91,7 +91,7 @@ private slots:
private:
void clearClipboard();
RimCase* caseFromItemIndex(const QModelIndex& itemIndex);
RimEclipseCase* caseFromItemIndex(const QModelIndex& itemIndex);
private:
QFileSystemWatcher* m_scriptChangeDetector;
};

16
ApplicationCode/ProjectDataModel/RimUiTreeView.cpp
View File

@ -193,7 +193,7 @@ void RimUiTreeView::contextMenuEvent(QContextMenuEvent* event)
menu.addAction(QString("Compute"), this, SLOT(slotComputeStatistics()));
menu.addAction(QString("Close"), this, SLOT(slotCloseCase()));
}
else if (dynamic_cast<RimCase*>(uiItem->dataObject().p()))
else if (dynamic_cast<RimEclipseCase*>(uiItem->dataObject().p()))
{
menu.addAction(QString("Copy"), this, SLOT(slotCopyPdmObjectToClipboard()));
menu.addAction(m_pasteAction);
@ -241,7 +241,7 @@ void RimUiTreeView::contextMenuEvent(QContextMenuEvent* event)
RiuMainWindow* ruiMainWindow = RiuMainWindow::instance();
if (ruiMainWindow)
{
std::vector<RimCase*> cases;
std::vector<RimEclipseCase*> cases;
ruiMainWindow->selectedCases(cases);
if (cases.size() > 0)
@ -604,12 +604,12 @@ void RimUiTreeView::slotExecuteScriptForSelectedCases()
myModel->populateObjectGroupFromModelIndexList(mil, &group);
std::vector<caf::PdmPointer<RimCase> > typedObjects;
std::vector<caf::PdmPointer<RimEclipseCase> > typedObjects;
group.objectsByType(&typedObjects);
for (size_t i = 0; i < typedObjects.size(); i++)
{
RimCase* rimReservoir = typedObjects[i];
RimEclipseCase* rimReservoir = typedObjects[i];
caseIdsInSelection.push_back(rimReservoir->caseId);
}
}
@ -895,12 +895,12 @@ void RimUiTreeView::slotCloseCase()
QModelIndexList mil = m->selectedRows();
myModel->populateObjectGroupFromModelIndexList(mil, &group);
std::vector<caf::PdmPointer<RimCase> > typedObjects;
std::vector<caf::PdmPointer<RimEclipseCase> > typedObjects;
group.objectsByType(&typedObjects);
for (size_t i = 0; i < typedObjects.size(); i++)
{
RimCase* rimReservoir = typedObjects[i];
RimEclipseCase* rimReservoir = typedObjects[i];
myModel->deleteReservoir(rimReservoir);
}
}
@ -1050,7 +1050,7 @@ void RimUiTreeView::keyPressEvent(QKeyEvent* keyEvent)
caf::PdmUiTreeItem* uiItem = myModel->getTreeItemFromIndex(currentIndex());
if (uiItem)
{
if (dynamic_cast<RimCase*>(uiItem->dataObject().p())
if (dynamic_cast<RimEclipseCase*>(uiItem->dataObject().p())
|| dynamic_cast<RimReservoirView*>(uiItem->dataObject().p()))
{
if (keyEvent->matches(QKeySequence::Copy))
@ -1064,7 +1064,7 @@ void RimUiTreeView::keyPressEvent(QKeyEvent* keyEvent)
if (dynamic_cast<RimIdenticalGridCaseGroup*>(uiItem->dataObject().p())
|| dynamic_cast<RimCaseCollection*>(uiItem->dataObject().p())
|| dynamic_cast<RimCase*>(uiItem->dataObject().p())
|| dynamic_cast<RimEclipseCase*>(uiItem->dataObject().p())
|| dynamic_cast<RimReservoirView*>(uiItem->dataObject().p()))
{
if (keyEvent->matches(QKeySequence::Paste))

14
ApplicationCode/SocketInterface/RiaCaseInfoCommands.cpp
View File

@ -55,7 +55,7 @@ public:
virtual bool interpretCommand(RiaSocketServer* server, const QList<QByteArray>& args, QDataStream& socketStream)
{
RimCase* rimCase = RiaSocketTools::findCaseFromArgs(server, args);
RimEclipseCase* rimCase = RiaSocketTools::findCaseFromArgs(server, args);
if (!rimCase) return true;
// Write data back to octave: I, J, K dimensions
@ -91,7 +91,7 @@ public:
virtual bool interpretCommand(RiaSocketServer* server, const QList<QByteArray>& args, QDataStream& socketStream)
{
RimCase* rimCase = RiaSocketTools::findCaseFromArgs(server, args);
RimEclipseCase* rimCase = RiaSocketTools::findCaseFromArgs(server, args);
if (!rimCase) return true;
RifReaderInterface::PorosityModelResultType porosityModel = RifReaderInterface::MATRIX_RESULTS;
@ -143,7 +143,7 @@ public:
return true;
}
static void calculateMatrixModelActiveCellInfo(RimCase* reservoirCase, RifReaderInterface::PorosityModelResultType porosityModel, std::vector<qint32>& gridNumber, std::vector<qint32>& cellI, std::vector<qint32>& cellJ, std::vector<qint32>& cellK, std::vector<qint32>& parentGridNumber, std::vector<qint32>& hostCellI, std::vector<qint32>& hostCellJ, std::vector<qint32>& hostCellK, std::vector<qint32>& globalCoarseningBoxIdx)
static void calculateMatrixModelActiveCellInfo(RimEclipseCase* reservoirCase, RifReaderInterface::PorosityModelResultType porosityModel, std::vector<qint32>& gridNumber, std::vector<qint32>& cellI, std::vector<qint32>& cellJ, std::vector<qint32>& cellK, std::vector<qint32>& parentGridNumber, std::vector<qint32>& hostCellI, std::vector<qint32>& hostCellJ, std::vector<qint32>& hostCellK, std::vector<qint32>& globalCoarseningBoxIdx)
{
gridNumber.clear();
cellI.clear();
@ -268,7 +268,7 @@ public:
argCaseGroupId = args[1].toInt();
}
RimCase* rimCase = server->findReservoir(argCaseGroupId);
RimEclipseCase* rimCase = server->findReservoir(argCaseGroupId);
if (!rimCase || !rimCase->reservoirData() || !rimCase->reservoirData()->mainGrid())
{
quint64 byteCount = 0;
@ -340,7 +340,7 @@ public:
argCaseGroupId = args[1].toInt();
}
RimCase* rimCase = server->findReservoir(argCaseGroupId);
RimEclipseCase* rimCase = server->findReservoir(argCaseGroupId);
if (!rimCase || !rimCase->reservoirData() || !rimCase->reservoirData()->mainGrid())
{
quint64 byteCount = 0;
@ -399,7 +399,7 @@ public:
argCaseGroupId = args[1].toInt();
}
RimCase* rimCase = server->findReservoir(argCaseGroupId);
RimEclipseCase* rimCase = server->findReservoir(argCaseGroupId);
bool canFetchData = true;
@ -486,7 +486,7 @@ public:
argCaseGroupId = args[1].toInt();
}
RimCase* rimCase = server->findReservoir(argCaseGroupId);
RimEclipseCase* rimCase = server->findReservoir(argCaseGroupId);
bool canFetchData = true;

8
ApplicationCode/SocketInterface/RiaGeometryCommands.cpp
View File

@ -52,7 +52,7 @@ public:
virtual bool interpretCommand(RiaSocketServer* server, const QList<QByteArray>& args, QDataStream& socketStream)
{
RimCase* rimCase = RiaSocketTools::findCaseFromArgs(server, args);
RimEclipseCase* rimCase = RiaSocketTools::findCaseFromArgs(server, args);
size_t argGridIndex = args[2].toUInt();
if (!rimCase || !rimCase->reservoirData() || (argGridIndex >= rimCase->reservoirData()->gridCount()) )
@ -134,7 +134,7 @@ public:
virtual bool interpretCommand(RiaSocketServer* server, const QList<QByteArray>& args, QDataStream& socketStream)
{
RimCase* rimCase = RiaSocketTools::findCaseFromArgs(server, args);
RimEclipseCase* rimCase = RiaSocketTools::findCaseFromArgs(server, args);
QString porosityModelName;
porosityModelName = args[2];
@ -214,7 +214,7 @@ public:
virtual bool interpretCommand(RiaSocketServer* server, const QList<QByteArray>& args, QDataStream& socketStream)
{
RimCase* rimCase = RiaSocketTools::findCaseFromArgs(server, args);
RimEclipseCase* rimCase = RiaSocketTools::findCaseFromArgs(server, args);
size_t argGridIndex = args[2].toUInt();
if (!rimCase || !rimCase->reservoirData() || (argGridIndex >= rimCase->reservoirData()->gridCount()) )
@ -303,7 +303,7 @@ public:
virtual bool interpretCommand(RiaSocketServer* server, const QList<QByteArray>& args, QDataStream& socketStream)
{
RimCase* rimCase = RiaSocketTools::findCaseFromArgs(server, args);
RimEclipseCase* rimCase = RiaSocketTools::findCaseFromArgs(server, args);
QString porosityModelName;
porosityModelName = args[2];

10
ApplicationCode/SocketInterface/RiaProjectInfoCommands.cpp
View File

@ -50,11 +50,11 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void getCaseInfoFromCases(std::vector<RimCase*>& cases, std::vector<qint64>& caseIds, std::vector<QString>& caseNames, std::vector<QString> &caseTypes, std::vector<qint64>& caseGroupIds)
void getCaseInfoFromCases(std::vector<RimEclipseCase*>& cases, std::vector<qint64>& caseIds, std::vector<QString>& caseNames, std::vector<QString> &caseTypes, std::vector<qint64>& caseGroupIds)
{
for (size_t i = 0; i < cases.size(); i++)
{
RimCase* rimCase = cases[i];
RimEclipseCase* rimCase = cases[i];
qint64 caseId = -1;
QString caseName;
@ -84,7 +84,7 @@ public:
QString caseType;
qint64 caseGroupId = -1;
RimCase* rimCase = server->findReservoir(caseId);
RimEclipseCase* rimCase = server->findReservoir(caseId);
if (rimCase)
{
@ -125,7 +125,7 @@ public:
RiuMainWindow* ruiMainWindow = RiuMainWindow::instance();
if (ruiMainWindow)
{
std::vector<RimCase*> cases;
std::vector<RimEclipseCase*> cases;
ruiMainWindow->selectedCases(cases);
std::vector<qint64> caseIds;
@ -243,7 +243,7 @@ public:
if (analysisModels)
{
std::vector<RimCase*> cases;
std::vector<RimEclipseCase*> cases;
if (argCaseGroupId == -1)
{
proj->allCases(cases);

14
ApplicationCode/SocketInterface/RiaPropertyDataCommands.cpp
View File

@ -57,7 +57,7 @@ public:
virtual bool interpretCommand(RiaSocketServer* server, const QList<QByteArray>& args, QDataStream& socketStream)
{
RimCase* rimCase = RiaSocketTools::findCaseFromArgs(server, args);
RimEclipseCase* rimCase = RiaSocketTools::findCaseFromArgs(server, args);
QString propertyName = args[2];
QString porosityModelName = args[3];
@ -225,7 +225,7 @@ public:
QString propertyName = args[3];
QString porosityModelName = args[4];
RimCase*rimCase = server->findReservoir(caseId);
RimEclipseCase*rimCase = server->findReservoir(caseId);
if (rimCase == NULL)
{
server->errorMessageDialog()->showMessage(RiaSocketServer::tr("ResInsight SocketServer: \n") + RiaSocketServer::tr("Could not find the case with ID: \"%1\"").arg(caseId));
@ -392,7 +392,7 @@ public:
virtual bool interpretCommand(RiaSocketServer* server, const QList<QByteArray>& args, QDataStream& socketStream)
{
RimCase* rimCase = RiaSocketTools::findCaseFromArgs(server, args);
RimEclipseCase* rimCase = RiaSocketTools::findCaseFromArgs(server, args);
QString propertyName = args[2];
QString porosityModelName = args[3];
@ -680,7 +680,7 @@ public:
}
private:
RimCase* m_currentReservoir;
RimEclipseCase* m_currentReservoir;
std::vector< std::vector<double> >* m_scalarResultsToAdd;
size_t m_currentScalarIndex;
QString m_currentPropertyName;
@ -720,7 +720,7 @@ public:
virtual bool interpretCommand(RiaSocketServer* server, const QList<QByteArray>& args, QDataStream& socketStream)
{
int caseId = args[1].toInt();
RimCase* rimCase = server->findReservoir(caseId);
RimEclipseCase* rimCase = server->findReservoir(caseId);
if (!rimCase)
{
server->errorMessageDialog()->showMessage(RiaSocketServer::tr("ResInsight SocketServer: \n") + RiaSocketServer::tr("Could not find the case with ID : \"%1\"").arg(caseId));
@ -1026,7 +1026,7 @@ public:
}
private:
RimCase* m_currentReservoir;
RimEclipseCase* m_currentReservoir;
std::vector< std::vector<double> >* m_scalarResultsToAdd;
size_t m_currentGridIndex;
size_t m_currentScalarIndex;
@ -1054,7 +1054,7 @@ public:
virtual bool interpretCommand(RiaSocketServer* server, const QList<QByteArray>& args, QDataStream& socketStream)
{
int caseId = args[1].toInt();
RimCase* rimCase = server->findReservoir(caseId);
RimEclipseCase* rimCase = server->findReservoir(caseId);
if (!rimCase)
{
server->errorMessageDialog()->showMessage(RiaSocketServer::tr("ResInsight SocketServer: \n") + RiaSocketServer::tr("Could not find the case with ID : \"%1\"").arg(caseId));

4
ApplicationCode/SocketInterface/RiaSocketServer.cpp
View File

@ -142,7 +142,7 @@ void RiaSocketServer::slotNewClientConnection()
//--------------------------------------------------------------------------------------------------
/// Find the requested reservoir by caseId
//--------------------------------------------------------------------------------------------------
RimCase* RiaSocketServer::findReservoir(int caseId)
RimEclipseCase* RiaSocketServer::findReservoir(int caseId)
{
int currCaseId = caseId;
if (caseId < 0)
@ -163,7 +163,7 @@ RimCase* RiaSocketServer::findReservoir(int caseId)
RimProject* project = RiaApplication::instance()->project();
if (!project) return NULL;
std::vector<RimCase*> cases;
std::vector<RimEclipseCase*> cases;
project->allCases(cases);
for (size_t i = 0; i < cases.size(); i++)

4
ApplicationCode/SocketInterface/RiaSocketServer.h
View File

@ -31,7 +31,7 @@ class QTcpSocket;
class QNetworkSession;
class QErrorMessage;
class QTimer;
class RimCase;
class RimEclipseCase;
class RiaSocketCommand;
namespace riOctavePlugin
@ -51,7 +51,7 @@ public:
~RiaSocketServer();
unsigned short serverPort();
RimCase* findReservoir(int caseId);
RimEclipseCase* findReservoir(int caseId);
QErrorMessage* errorMessageDialog() { return m_errorMessageDialog; }
QTcpSocket* currentClient() { return m_currentClient; }

6
ApplicationCode/SocketInterface/RiaSocketTools.cpp
View File

@ -48,9 +48,9 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimCase* RiaSocketTools::findCaseFromArgs(RiaSocketServer* server, const QList<QByteArray>& args)
RimEclipseCase* RiaSocketTools::findCaseFromArgs(RiaSocketServer* server, const QList<QByteArray>& args)
{
RimCase* rimCase = NULL;
RimEclipseCase* rimCase = NULL;
int caseId = -1;
if (args.size() > 1)
@ -72,7 +72,7 @@ RimCase* RiaSocketTools::findCaseFromArgs(RiaSocketServer* server, const QList<Q
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiaSocketTools::getCaseInfoFromCase(RimCase* rimCase, qint64& caseId, QString& caseName, QString& caseType, qint64& caseGroupId)
void RiaSocketTools::getCaseInfoFromCase(RimEclipseCase* rimCase, qint64& caseId, QString& caseName, QString& caseType, qint64& caseGroupId)
{
CVF_ASSERT(rimCase);

6
ApplicationCode/SocketInterface/RiaSocketTools.h
View File

@ -18,7 +18,7 @@
//
/////////////////////////////////////////////////////////////////////////////////
class RimCase;
class RimEclipseCase;
class RiaSocketServer;
class QTcpSocket;
@ -27,8 +27,8 @@ class QTcpSocket;
class RiaSocketTools
{
public:
static RimCase* findCaseFromArgs(RiaSocketServer* server, const QList<QByteArray>& args);
static void getCaseInfoFromCase(RimCase* rimCase, qint64& caseId, QString& caseName, QString& caseType, qint64& caseGroupId);
static RimEclipseCase* findCaseFromArgs(RiaSocketServer* server, const QList<QByteArray>& args);
static void getCaseInfoFromCase(RimEclipseCase* rimCase, qint64& caseId, QString& caseName, QString& caseType, qint64& caseGroupId);
static bool writeBlockData(RiaSocketServer* server, QTcpSocket* socket, const char* data, quint64 bytesToWrite);
};

6
ApplicationCode/SocketInterface/RiaWellDataCommands.cpp
View File

@ -55,7 +55,7 @@ public:
virtual bool interpretCommand(RiaSocketServer* server, const QList<QByteArray>& args, QDataStream& socketStream)
{
int caseId = args[1].toInt();
RimCase* rimCase = server->findReservoir(caseId);
RimEclipseCase* rimCase = server->findReservoir(caseId);
if (!rimCase)
{
server->errorMessageDialog()->showMessage(RiaSocketServer::tr("ResInsight SocketServer: \n") + RiaSocketServer::tr("Could not find the case with ID : \"%1\"").arg(caseId));
@ -109,7 +109,7 @@ public:
int caseId = args[1].toInt();
QString wellName = args[2];
RimCase* rimCase = server->findReservoir(caseId);
RimEclipseCase* rimCase = server->findReservoir(caseId);
if (!rimCase)
{
server->errorMessageDialog()->showMessage(RiaSocketServer::tr("ResInsight SocketServer: \n") + RiaSocketServer::tr("Could not find the case with ID : \"%1\"").arg(caseId));
@ -248,7 +248,7 @@ public:
QString wellName = args[2];
size_t timeStepIdx = args[3].toInt() - 1; // Interpret timeStepIdx from octave as 1-based
RimCase* rimCase = server->findReservoir(caseId);
RimEclipseCase* rimCase = server->findReservoir(caseId);
if (!rimCase)
{
server->errorMessageDialog()->showMessage(RiaSocketServer::tr("ResInsight SocketServer: \n") + RiaSocketServer::tr("Could not find the case with ID : \"%1\"").arg(caseId));

8
ApplicationCode/UserInterface/RiuMainWindow.cpp
View File

@ -1329,12 +1329,12 @@ void RiuMainWindow::slotSubWindowActivated(QMdiSubWindow* subWindow)
if (!proj) return;
// Iterate all cases in each oil field
std::vector<RimCase*> allCases;
std::vector<RimEclipseCase*> allCases;
proj->allCases(allCases);
for (size_t caseIdx = 0; caseIdx < allCases.size(); ++caseIdx)
{
RimCase* reservoirCase = allCases[caseIdx];
RimEclipseCase* reservoirCase = allCases[caseIdx];
if (reservoirCase == NULL) continue;
size_t viewIdx;
@ -1858,7 +1858,7 @@ void RiuMainWindow::updateScaleValue()
//--------------------------------------------------------------------------------------------------
/// TODO: This function will be moved to a class responsible for handling the application selection concept
//--------------------------------------------------------------------------------------------------
void RiuMainWindow::selectedCases(std::vector<RimCase*>& cases)
void RiuMainWindow::selectedCases(std::vector<RimEclipseCase*>& cases)
{
if (m_treeView && m_treeView->selectionModel())
{
@ -1867,7 +1867,7 @@ void RiuMainWindow::selectedCases(std::vector<RimCase*>& cases)
caf::PdmObjectGroup group;
m_treeModelPdm->populateObjectGroupFromModelIndexList(selectedModelIndexes, &group);
std::vector<caf::PdmPointer<RimCase> > typedObjects;
std::vector<caf::PdmPointer<RimEclipseCase> > typedObjects;
group.objectsByType(&typedObjects);
for (size_t i = 0; i < typedObjects.size(); i++)

4
ApplicationCode/UserInterface/RiuMainWindow.h
View File

@ -42,7 +42,7 @@ class RiuResultInfoPanel;
class RiuProcessMonitor;
class RimUiTreeModelPdm;
class RimUiTreeView;
class RimCase;
class RimEclipseCase;
namespace caf
{
@ -93,7 +93,7 @@ public:
void setCurrentObjectInTreeView(caf::PdmObject* object);
void selectedCases(std::vector<RimCase*>& cases);
void selectedCases(std::vector<RimEclipseCase*>& cases);
void setDefaultWindowSize();