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

Read grid dimensions and verify equality before adding a result case

Browse Source 
Harmonized and refactored creation of RimResultCases
p4#: 21156
This commit is contained in:
Magne Sjaastad 2013-04-07 17:27:45 +02:00
parent da8480a91b
commit 95d1c98bee
6 changed files with 117 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
ApplicationCode/Application/RiaApplication.cpp
View File

@ -56,6 +56,7 @@
#include "RiaImageCompareReporter.h"
#include "RiaImageFileCompare.h"
#include "cafProgressInfo.h"
#include "RigGridManager.h"
namespace caf
{
@ -494,10 +495,7 @@ bool RiaApplication::openEclipseCase(const QString& caseName, const QString& cas
QFileInfo gridFileName(caseFileName);
QString casePath = gridFileName.absolutePath();
RimResultCase* rimResultReservoir = new RimResultCase();
rimResultReservoir->caseName = caseName;
rimResultReservoir->caseFileName = caseFileName;
rimResultReservoir->caseDirectory = casePath;
RimResultCase* rimResultReservoir = new RimResultCase(caseName, caseFileName, casePath);
m_project->reservoirs.push_back(rimResultReservoir);
@ -1356,11 +1354,11 @@ bool RiaApplication::addEclipseCases(const QStringList& fileNames)
{
if (fileNames.size() == 0) return true;
// First file is read completely including grid.
// The main grid 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
RigCaseData* mainEclipseCase = NULL;
RimResultCase* mainResultCase = NULL;
std::vector< std::vector<int> > mainCaseGridDimensions;
{
QString firstFileName = fileNames[0];
@ -1369,46 +1367,54 @@ bool RiaApplication::addEclipseCases(const QStringList& fileNames)
QString caseName = gridFileName.completeBaseName();
QString casePath = gridFileName.absolutePath();
RimResultCase* rimResultReservoir = new RimResultCase();
rimResultReservoir->caseName = caseName;
rimResultReservoir->caseFileName = firstFileName;
rimResultReservoir->caseDirectory = casePath;
m_project->reservoirs.push_back(rimResultReservoir);
RimResultCase* rimResultReservoir = new RimResultCase(caseName, firstFileName, casePath);
if (!rimResultReservoir->openEclipseGridFile())
{
delete rimResultReservoir;
return false;
}
rimResultReservoir->readGridDimensions(mainCaseGridDimensions);
m_project->reservoirs.push_back(rimResultReservoir);
m_project->moveEclipseCaseIntoCaseGroup(rimResultReservoir);
mainEclipseCase = rimResultReservoir->reservoirData();
mainResultCase = rimResultReservoir;
}
caf::ProgressInfo info(fileNames.size(), "Reading Active Cell data");
for (int i = 1; i < fileNames.size(); i++)
{
QString fileName = fileNames[i];
QFileInfo gridFileName(fileName);
QString caseFileName = fileNames[i];
QFileInfo gridFileName(caseFileName);
QString caseName = gridFileName.completeBaseName();
QString casePath = gridFileName.absolutePath();
RimResultCase* rimResultReservoir = new RimResultCase();
rimResultReservoir->caseName = caseName;
rimResultReservoir->caseFileName = fileName;
rimResultReservoir->caseDirectory = casePath;
RimResultCase* rimResultReservoir = new RimResultCase(caseName, caseFileName, casePath);
m_project->reservoirs.push_back(rimResultReservoir);
std::vector< std::vector<int> > caseGridDimensions;
rimResultReservoir->readGridDimensions(caseGridDimensions);
if (!rimResultReservoir->openAndReadActiveCellData(mainEclipseCase))
bool identicalGrid = RigGridManager::isGridDimensionsEqual(mainCaseGridDimensions, caseGridDimensions);
if (identicalGrid)
{
return false;
if (rimResultReservoir->openAndReadActiveCellData(mainResultCase->reservoirData()))
{
m_project->reservoirs.push_back(rimResultReservoir);
m_project->moveEclipseCaseIntoCaseGroup(rimResultReservoir);
}
else
{
delete rimResultReservoir;
}
}
else
{
delete rimResultReservoir;
}
m_project->moveEclipseCaseIntoCaseGroup(rimResultReservoir);
info.setProgress(i);
}

34
ApplicationCode/ProjectDataModel/RimIdenticalGridCaseGroup.cpp
View File

@ -30,6 +30,7 @@
#include "RimResultCase.h"
#include "cafProgressInfo.h"
#include "RigActiveCellInfo.h"
#include "RigGridManager.h"
CAF_PDM_SOURCE_INIT(RimIdenticalGridCaseGroup, "RimIdenticalGridCaseGroup");
@ -78,15 +79,15 @@ void RimIdenticalGridCaseGroup::addCase(RimCase* reservoir)
if (!reservoir) return;
RigMainGrid* incomingMainGrid = reservoir->reservoirData()->mainGrid();
if (!m_mainGrid)
{
m_mainGrid = incomingMainGrid;
m_mainGrid = reservoir->reservoirData()->mainGrid();
}
else
{
reservoir->reservoirData()->setMainGrid(m_mainGrid);
}
CVF_ASSERT(m_mainGrid == incomingMainGrid);
caseCollection()->reservoirs().push_back(reservoir);
if (statisticsCaseCollection->reservoirs().size() == 0)
@ -423,3 +424,26 @@ RimCase* RimIdenticalGridCaseGroup::mainCase()
return NULL;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimIdenticalGridCaseGroup::canCaseBeAdded(RimCase* reservoir) const
{
CVF_ASSERT(reservoir && reservoir->reservoirData() && reservoir->reservoirData()->mainGrid());
if (!m_mainGrid)
{
// Empty case group, reservoir can be added
return true;
}
RigMainGrid* incomingMainGrid = reservoir->reservoirData()->mainGrid();
if (RigGridManager::isEqual(m_mainGrid, incomingMainGrid))
{
return true;
}
return false;
}

2
ApplicationCode/ProjectDataModel/RimIdenticalGridCaseGroup.h
View File

@ -49,7 +49,9 @@ public:
void addCase(RimCase* reservoir);
void removeCase(RimCase* reservoir);
bool contains(RimCase* reservoir) const;
bool canCaseBeAdded(RimCase* reservoir) const;
RimStatisticsCase* createAndAppendStatisticsCase();

38
ApplicationCode/ProjectDataModel/RimUiTreeModelPdm.cpp
View File

@ -37,6 +37,7 @@
#include "RimInputCase.h"
#include "RimStatisticsCase.h"
#include "RimResultCase.h"
#include "RigGridManager.h"
//--------------------------------------------------------------------------------------------------
///
@ -592,19 +593,29 @@ void RimUiTreeModelPdm::addObjects(const QModelIndex& itemIndex, caf::PdmObjectG
CVF_ASSERT(proj);
RimIdenticalGridCaseGroup* gridCaseGroup = gridCaseGroupFromItemIndex(itemIndex);
if (gridCaseGroup)
{
std::vector<caf::PdmPointer<RimResultCase> > typedObjects;
pdmObjects.createCopyByType(&typedObjects);
RigCaseData* mainEclipseCase = NULL;
if (gridCaseGroup->caseCollection()->reservoirs().size() > 0)
if (typedObjects.size() == 0)
{
RimCase* mainReservoir = gridCaseGroup->caseCollection()->reservoirs()[0];
mainEclipseCase = mainReservoir->reservoirData();
return;
}
RimResultCase* mainResultCase = NULL;
std::vector< std::vector<int> > mainCaseGridDimensions;
// Read out main grid and main grid dimensions if present in case group
if (gridCaseGroup->mainCase())
{
mainResultCase = dynamic_cast<RimResultCase*>(gridCaseGroup->mainCase());
CVF_ASSERT(mainResultCase);
mainResultCase->readGridDimensions(mainCaseGridDimensions);
}
// Add cases to case group
for (size_t i = 0; i < typedObjects.size(); i++)
{
RimResultCase* rimResultReservoir = typedObjects[i];
@ -614,14 +625,25 @@ void RimUiTreeModelPdm::addObjects(const QModelIndex& itemIndex, caf::PdmObjectG
continue;
}
if (gridCaseGroup->mainGrid() == NULL)
if (!mainResultCase)
{
rimResultReservoir->openEclipseGridFile();
mainEclipseCase = rimResultReservoir->reservoirData();
rimResultReservoir->readGridDimensions(mainCaseGridDimensions);
mainResultCase = rimResultReservoir;
}
else
{
if (!rimResultReservoir->openAndReadActiveCellData(mainEclipseCase))
std::vector< std::vector<int> > caseGridDimensions;
rimResultReservoir->readGridDimensions(caseGridDimensions);
bool identicalGrid = RigGridManager::isGridDimensionsEqual(mainCaseGridDimensions, caseGridDimensions);
if (!identicalGrid)
{
continue;
}
if (!rimResultReservoir->openAndReadActiveCellData(mainResultCase->reservoirData()))
{
CVF_ASSERT(false);
}

23
ApplicationCode/ReservoirDataModel/RigGridManager.cpp
View File

@ -96,6 +96,29 @@ void RigGridManager::clear()
m_caseToGrid.clear();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigGridManager::isGridDimensionsEqual(const std::vector< std::vector<int> >& mainCaseGridDimensions, const std::vector< std::vector<int> >& caseGridDimensions)
{
if (mainCaseGridDimensions.size() != caseGridDimensions.size())
{
return false;
}
for (size_t j = 0; j < mainCaseGridDimensions.size(); j++)
{
if (mainCaseGridDimensions[j].size() != 3) return false;
if (caseGridDimensions[j].size() != 3) return false;
if (mainCaseGridDimensions[j][0] != caseGridDimensions[j][0]) return false;
if (mainCaseGridDimensions[j][1] != caseGridDimensions[j][1]) return false;
if (mainCaseGridDimensions[j][2] != caseGridDimensions[j][2]) return false;
}
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

5
ApplicationCode/ReservoirDataModel/RigGridManager.h
View File

@ -38,10 +38,9 @@ public:
void clear();
private:
static bool isEqual(RigMainGrid* gridA, RigMainGrid* gridB);
static bool isGridDimensionsEqual(const std::vector< std::vector<int> >& mainCaseGridDimensions, const std::vector< std::vector<int> >& caseGridDimensions);
private:
class CaseToGridMap : public cvf::Object
{
public: