mirror of
https://github.com/OPM/ResInsight.git
synced 2025-02-25 18:55:39 -06:00
Major renaming of classes. Filenames not done yet.
RimReservoir RimCase RimResultReservoir RimResultCase RimInputReservoir RimInputCase RigEclipseCase RigCaseData RigReservoirCellResults RigCaseCellResultsData RigWellResults RigSingleWellResultsData RigGridCollection RigGridManager p4#: 21064
This commit is contained in:
Jacob Støren
@@ -28,17 +28,17 @@
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
TEST(RigGridCollection, BasicTest)
|
||||
TEST(RigGridManager, BasicTest)
|
||||
{
|
||||
cvf::ref<RigMainGrid> mainGridA = new RigMainGrid;
|
||||
|
||||
cvf::ref<RigEclipseCase> eclipseCase = new RigEclipseCase;
|
||||
cvf::ref<RigCaseData> eclipseCase = new RigCaseData;
|
||||
eclipseCase->setMainGrid(mainGridA.p());
|
||||
|
||||
int count = mainGridA->refCount();
|
||||
EXPECT_EQ(mainGridA->refCount(), 2);
|
||||
|
||||
RigGridCollection gridCollection;
|
||||
RigGridManager gridCollection;
|
||||
gridCollection.addCase(eclipseCase.p());
|
||||
EXPECT_EQ(mainGridA->refCount(), 2);
|
||||
|
||||
@@ -52,18 +52,18 @@ TEST(RigGridCollection, BasicTest)
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
TEST(RigGridCollection, EqualTests)
|
||||
TEST(RigGridManager, EqualTests)
|
||||
{
|
||||
cvf::ref<RigMainGrid> mainGridA = new RigMainGrid;
|
||||
mainGridA->nodes().push_back(cvf::Vec3d(0, 0, 0));
|
||||
mainGridA->nodes().push_back(cvf::Vec3d(0, 0, 1));
|
||||
mainGridA->nodes().push_back(cvf::Vec3d(0, 0, 2));
|
||||
|
||||
cvf::ref<RigEclipseCase> eclipseCase = new RigEclipseCase;
|
||||
cvf::ref<RigCaseData> eclipseCase = new RigCaseData;
|
||||
eclipseCase->setMainGrid(mainGridA.p());
|
||||
|
||||
|
||||
RigGridCollection gridCollection;
|
||||
RigGridManager gridCollection;
|
||||
gridCollection.addCase(eclipseCase.p());
|
||||
|
||||
|
||||
|
||||
@@ -24,12 +24,12 @@
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
RigEclipseCase::RigEclipseCase()
|
||||
RigCaseData::RigCaseData()
|
||||
{
|
||||
m_mainGrid = new RigMainGrid();
|
||||
|
||||
m_matrixModelResults = new RigReservoirCellResults(m_mainGrid.p());
|
||||
m_fractureModelResults = new RigReservoirCellResults(m_mainGrid.p());
|
||||
m_matrixModelResults = new RigCaseCellResultsData(m_mainGrid.p());
|
||||
m_fractureModelResults = new RigCaseCellResultsData(m_mainGrid.p());
|
||||
|
||||
m_activeCellInfo = new RigActiveCellInfo;
|
||||
m_fractureActiveCellInfo = new RigActiveCellInfo;
|
||||
@@ -38,7 +38,7 @@ RigEclipseCase::RigEclipseCase()
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
RigEclipseCase::~RigEclipseCase()
|
||||
RigCaseData::~RigCaseData()
|
||||
{
|
||||
|
||||
}
|
||||
@@ -46,7 +46,7 @@ RigEclipseCase::~RigEclipseCase()
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigEclipseCase::setMainGrid(RigMainGrid* mainGrid)
|
||||
void RigCaseData::setMainGrid(RigMainGrid* mainGrid)
|
||||
{
|
||||
m_mainGrid = mainGrid;
|
||||
|
||||
@@ -57,7 +57,7 @@ void RigEclipseCase::setMainGrid(RigMainGrid* mainGrid)
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigEclipseCase::allGrids(std::vector<RigGridBase*>* grids)
|
||||
void RigCaseData::allGrids(std::vector<RigGridBase*>* grids)
|
||||
{
|
||||
CVF_ASSERT(grids);
|
||||
|
||||
@@ -76,7 +76,7 @@ void RigEclipseCase::allGrids(std::vector<RigGridBase*>* grids)
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigEclipseCase::allGrids(std::vector<const RigGridBase*>* grids) const
|
||||
void RigCaseData::allGrids(std::vector<const RigGridBase*>* grids) const
|
||||
{
|
||||
CVF_ASSERT(grids);
|
||||
|
||||
@@ -95,7 +95,7 @@ void RigEclipseCase::allGrids(std::vector<const RigGridBase*>* grids) const
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Get grid by index. The main grid has index 0, so the first lgr has index 1
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
const RigGridBase* RigEclipseCase::grid(size_t index) const
|
||||
const RigGridBase* RigCaseData::grid(size_t index) const
|
||||
{
|
||||
CVF_ASSERT(m_mainGrid.notNull());
|
||||
return m_mainGrid->gridByIndex(index);
|
||||
@@ -105,7 +105,7 @@ const RigGridBase* RigEclipseCase::grid(size_t index) const
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Get grid by index. The main grid has index 0, so the first lgr has index 1
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
RigGridBase* RigEclipseCase::grid(size_t index)
|
||||
RigGridBase* RigCaseData::grid(size_t index)
|
||||
{
|
||||
CVF_ASSERT(m_mainGrid.notNull());
|
||||
return m_mainGrid->gridByIndex(index);
|
||||
@@ -114,7 +114,7 @@ RigGridBase* RigEclipseCase::grid(size_t index)
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
size_t RigEclipseCase::gridCount() const
|
||||
size_t RigCaseData::gridCount() const
|
||||
{
|
||||
CVF_ASSERT(m_mainGrid.notNull());
|
||||
return m_mainGrid->gridCount();
|
||||
@@ -124,7 +124,7 @@ size_t RigEclipseCase::gridCount() const
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigEclipseCase::computeWellCellsPrGrid()
|
||||
void RigCaseData::computeWellCellsPrGrid()
|
||||
{
|
||||
// If we have computed this already, return
|
||||
if (m_wellCellsInGrid.size()) return;
|
||||
@@ -185,7 +185,7 @@ void RigEclipseCase::computeWellCellsPrGrid()
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigEclipseCase::setWellResults(const cvf::Collection<RigWellResults>& data)
|
||||
void RigCaseData::setWellResults(const cvf::Collection<RigSingleWellResultsData>& data)
|
||||
{
|
||||
m_wellResults = data;
|
||||
m_wellCellsInGrid.clear();
|
||||
@@ -195,7 +195,7 @@ void RigEclipseCase::setWellResults(const cvf::Collection<RigWellResults>& data)
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
cvf::UByteArray* RigEclipseCase::wellCellsInGrid(size_t gridIndex)
|
||||
cvf::UByteArray* RigCaseData::wellCellsInGrid(size_t gridIndex)
|
||||
{
|
||||
computeWellCellsPrGrid();
|
||||
CVF_ASSERT(gridIndex < m_wellCellsInGrid.size());
|
||||
@@ -206,7 +206,7 @@ cvf::UByteArray* RigEclipseCase::wellCellsInGrid(size_t gridIndex)
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
RigCell& RigEclipseCase::cellFromWellResultCell(const RigWellResultCell& wellResultCell)
|
||||
RigCell& RigCaseData::cellFromWellResultCell(const RigWellResultCell& wellResultCell)
|
||||
{
|
||||
size_t gridIndex = wellResultCell.m_gridIndex;
|
||||
size_t gridCellIndex = wellResultCell.m_gridCellIndex;
|
||||
@@ -220,7 +220,7 @@ RigCell& RigEclipseCase::cellFromWellResultCell(const RigWellResultCell& wellRes
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
bool RigEclipseCase::findSharedSourceFace(cvf::StructGridInterface::FaceType& sharedSourceFace,const RigWellResultCell& sourceWellCellResult, const RigWellResultCell& otherWellCellResult) const
|
||||
bool RigCaseData::findSharedSourceFace(cvf::StructGridInterface::FaceType& sharedSourceFace,const RigWellResultCell& sourceWellCellResult, const RigWellResultCell& otherWellCellResult) const
|
||||
{
|
||||
size_t gridIndex = sourceWellCellResult.m_gridIndex;
|
||||
size_t gridCellIndex = sourceWellCellResult.m_gridCellIndex;
|
||||
@@ -291,7 +291,7 @@ public:
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigEclipseCase::computeActiveCellIJKBBox()
|
||||
void RigCaseData::computeActiveCellIJKBBox()
|
||||
{
|
||||
if (m_mainGrid.notNull() && m_activeCellInfo.notNull() && m_fractureActiveCellInfo.notNull())
|
||||
{
|
||||
@@ -322,7 +322,7 @@ void RigEclipseCase::computeActiveCellIJKBBox()
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigEclipseCase::computeActiveCellBoundingBoxes()
|
||||
void RigCaseData::computeActiveCellBoundingBoxes()
|
||||
{
|
||||
computeActiveCellIJKBBox();
|
||||
computeActiveCellsGeometryBoundingBox();
|
||||
@@ -331,7 +331,7 @@ void RigEclipseCase::computeActiveCellBoundingBoxes()
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
RigActiveCellInfo* RigEclipseCase::activeCellInfo(RifReaderInterface::PorosityModelResultType porosityModel)
|
||||
RigActiveCellInfo* RigCaseData::activeCellInfo(RifReaderInterface::PorosityModelResultType porosityModel)
|
||||
{
|
||||
if (porosityModel == RifReaderInterface::MATRIX_RESULTS)
|
||||
{
|
||||
@@ -344,7 +344,7 @@ RigActiveCellInfo* RigEclipseCase::activeCellInfo(RifReaderInterface::PorosityMo
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
const RigActiveCellInfo* RigEclipseCase::activeCellInfo(RifReaderInterface::PorosityModelResultType porosityModel) const
|
||||
const RigActiveCellInfo* RigCaseData::activeCellInfo(RifReaderInterface::PorosityModelResultType porosityModel) const
|
||||
{
|
||||
if (porosityModel == RifReaderInterface::MATRIX_RESULTS)
|
||||
{
|
||||
@@ -357,7 +357,7 @@ const RigActiveCellInfo* RigEclipseCase::activeCellInfo(RifReaderInterface::Poro
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigEclipseCase::setActiveCellInfo(RifReaderInterface::PorosityModelResultType porosityModel, RigActiveCellInfo* activeCellInfo)
|
||||
void RigCaseData::setActiveCellInfo(RifReaderInterface::PorosityModelResultType porosityModel, RigActiveCellInfo* activeCellInfo)
|
||||
{
|
||||
if (porosityModel == RifReaderInterface::MATRIX_RESULTS)
|
||||
{
|
||||
@@ -373,7 +373,7 @@ void RigEclipseCase::setActiveCellInfo(RifReaderInterface::PorosityModelResultTy
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigEclipseCase::computeActiveCellsGeometryBoundingBox()
|
||||
void RigCaseData::computeActiveCellsGeometryBoundingBox()
|
||||
{
|
||||
if (m_activeCellInfo.notNull() || m_fractureActiveCellInfo.notNull())
|
||||
{
|
||||
@@ -427,7 +427,7 @@ void RigEclipseCase::computeActiveCellsGeometryBoundingBox()
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
RigReservoirCellResults* RigEclipseCase::results(RifReaderInterface::PorosityModelResultType porosityModel)
|
||||
RigCaseCellResultsData* RigCaseData::results(RifReaderInterface::PorosityModelResultType porosityModel)
|
||||
{
|
||||
if (porosityModel == RifReaderInterface::MATRIX_RESULTS)
|
||||
{
|
||||
@@ -440,7 +440,7 @@ RigReservoirCellResults* RigEclipseCase::results(RifReaderInterface::PorosityMod
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
const RigReservoirCellResults* RigEclipseCase::results(RifReaderInterface::PorosityModelResultType porosityModel) const
|
||||
const RigCaseCellResultsData* RigCaseData::results(RifReaderInterface::PorosityModelResultType porosityModel) const
|
||||
{
|
||||
if (porosityModel == RifReaderInterface::MATRIX_RESULTS)
|
||||
{
|
||||
@@ -453,7 +453,7 @@ const RigReservoirCellResults* RigEclipseCase::results(RifReaderInterface::Poros
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
cvf::ref<cvf::StructGridScalarDataAccess> RigEclipseCase::dataAccessObject(const RigGridBase* grid,
|
||||
cvf::ref<cvf::StructGridScalarDataAccess> RigCaseData::dataAccessObject(const RigGridBase* grid,
|
||||
RifReaderInterface::PorosityModelResultType porosityModel,
|
||||
size_t timeStepIndex,
|
||||
size_t scalarSetIndex)
|
||||
|
||||
@@ -27,14 +27,14 @@
|
||||
#include "RigWellResults.h"
|
||||
#include "RigActiveCellInfo.h"
|
||||
|
||||
class RigReservoirCellResults;
|
||||
class RigCaseCellResultsData;
|
||||
|
||||
|
||||
class RigEclipseCase: public cvf::Object
|
||||
class RigCaseData: public cvf::Object
|
||||
{
|
||||
public:
|
||||
RigEclipseCase();
|
||||
~RigEclipseCase();
|
||||
RigCaseData();
|
||||
~RigCaseData();
|
||||
|
||||
RigMainGrid* mainGrid() { return m_mainGrid.p(); }
|
||||
const RigMainGrid* mainGrid() const { return m_mainGrid.p(); }
|
||||
@@ -46,8 +46,8 @@ public:
|
||||
RigGridBase* grid(size_t index);
|
||||
size_t gridCount() const;
|
||||
|
||||
RigReservoirCellResults* results(RifReaderInterface::PorosityModelResultType porosityModel);
|
||||
const RigReservoirCellResults* results(RifReaderInterface::PorosityModelResultType porosityModel) const;
|
||||
RigCaseCellResultsData* results(RifReaderInterface::PorosityModelResultType porosityModel);
|
||||
const RigCaseCellResultsData* results(RifReaderInterface::PorosityModelResultType porosityModel) const;
|
||||
|
||||
RigActiveCellInfo* activeCellInfo(RifReaderInterface::PorosityModelResultType porosityModel);
|
||||
const RigActiveCellInfo* activeCellInfo(RifReaderInterface::PorosityModelResultType porosityModel) const;
|
||||
@@ -59,8 +59,8 @@ public:
|
||||
size_t timeStepIndex,
|
||||
size_t scalarSetIndex);
|
||||
|
||||
void setWellResults(const cvf::Collection<RigWellResults>& data);
|
||||
const cvf::Collection<RigWellResults>& wellResults() { return m_wellResults; }
|
||||
void setWellResults(const cvf::Collection<RigSingleWellResultsData>& data);
|
||||
const cvf::Collection<RigSingleWellResultsData>& wellResults() { return m_wellResults; }
|
||||
|
||||
cvf::UByteArray* wellCellsInGrid(size_t gridIndex);
|
||||
|
||||
@@ -80,9 +80,9 @@ private:
|
||||
cvf::ref<RigActiveCellInfo> m_activeCellInfo;
|
||||
cvf::ref<RigActiveCellInfo> m_fractureActiveCellInfo;
|
||||
|
||||
cvf::ref<RigReservoirCellResults> m_matrixModelResults;
|
||||
cvf::ref<RigReservoirCellResults> m_fractureModelResults;
|
||||
cvf::ref<RigCaseCellResultsData> m_matrixModelResults;
|
||||
cvf::ref<RigCaseCellResultsData> m_fractureModelResults;
|
||||
|
||||
cvf::Collection<RigWellResults> m_wellResults; //< A WellResults object for each well in the reservoir
|
||||
cvf::Collection<RigSingleWellResultsData> m_wellResults; //< A WellResults object for each well in the reservoir
|
||||
cvf::Collection<cvf::UByteArray> m_wellCellsInGrid; //< A bool array pr grid with one bool pr cell telling wether the cell is a well cell or not
|
||||
};
|
||||
|
||||
@@ -24,7 +24,7 @@
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigGridCollection::addCase(RigEclipseCase* eclipseCase)
|
||||
void RigGridManager::addCase(RigCaseData* eclipseCase)
|
||||
{
|
||||
cvf::ref<CaseToGridMap> caseAndGrid = new CaseToGridMap(eclipseCase, eclipseCase->mainGrid());
|
||||
m_caseToGrid.push_back(caseAndGrid.p());
|
||||
@@ -33,7 +33,7 @@ void RigGridCollection::addCase(RigEclipseCase* eclipseCase)
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigGridCollection::removeCase(RigEclipseCase* eclipseCase)
|
||||
void RigGridManager::removeCase(RigCaseData* eclipseCase)
|
||||
{
|
||||
size_t indexToErase = cvf::UNDEFINED_SIZE_T;
|
||||
|
||||
@@ -50,12 +50,12 @@ void RigGridCollection::removeCase(RigEclipseCase* eclipseCase)
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
RigMainGrid* RigGridCollection::findEqualGrid(RigMainGrid* candidateGrid)
|
||||
RigMainGrid* RigGridManager::findEqualGrid(RigMainGrid* candidateGrid)
|
||||
{
|
||||
for (size_t i = 0; i < m_caseToGrid.size(); i++)
|
||||
{
|
||||
RigMainGrid* mainGrid = m_caseToGrid.at(i)->m_mainGrid;
|
||||
if (RigGridCollection::isEqual(mainGrid, candidateGrid))
|
||||
if (RigGridManager::isEqual(mainGrid, candidateGrid))
|
||||
{
|
||||
return mainGrid;
|
||||
}
|
||||
@@ -67,7 +67,7 @@ RigMainGrid* RigGridCollection::findEqualGrid(RigMainGrid* candidateGrid)
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
bool RigGridCollection::isEqual(RigMainGrid* gridA, RigMainGrid* gridB)
|
||||
bool RigGridManager::isEqual(RigMainGrid* gridA, RigMainGrid* gridB)
|
||||
{
|
||||
if (gridA == NULL || gridB == NULL) return false;
|
||||
|
||||
@@ -91,7 +91,7 @@ bool RigGridCollection::isEqual(RigMainGrid* gridA, RigMainGrid* gridB)
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigGridCollection::clear()
|
||||
void RigGridManager::clear()
|
||||
{
|
||||
m_caseToGrid.clear();
|
||||
}
|
||||
@@ -99,7 +99,7 @@ void RigGridCollection::clear()
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
RigGridCollection::CaseToGridMap::CaseToGridMap(RigEclipseCase* eclipseCase, RigMainGrid* mainGrid) :
|
||||
RigGridManager::CaseToGridMap::CaseToGridMap(RigCaseData* eclipseCase, RigMainGrid* mainGrid) :
|
||||
m_eclipseCase(eclipseCase),
|
||||
m_mainGrid(mainGrid)
|
||||
{
|
||||
|
||||
@@ -25,14 +25,14 @@
|
||||
#include <vector>
|
||||
|
||||
class RigMainGrid;
|
||||
class RigEclipseCase;
|
||||
class RigCaseData;
|
||||
|
||||
class RigGridCollection : public cvf::Object
|
||||
class RigGridManager : public cvf::Object
|
||||
{
|
||||
public:
|
||||
void addCase(RigEclipseCase* eclipseCase);
|
||||
void addCase(RigCaseData* eclipseCase);
|
||||
|
||||
void removeCase(RigEclipseCase* eclipseCase);
|
||||
void removeCase(RigCaseData* eclipseCase);
|
||||
|
||||
RigMainGrid* findEqualGrid(RigMainGrid* candidateGrid);
|
||||
|
||||
@@ -45,9 +45,9 @@ private:
|
||||
class CaseToGridMap : public cvf::Object
|
||||
{
|
||||
public:
|
||||
CaseToGridMap(RigEclipseCase* eclipseCase, RigMainGrid* mainGrid);
|
||||
CaseToGridMap(RigCaseData* eclipseCase, RigMainGrid* mainGrid);
|
||||
|
||||
RigEclipseCase* m_eclipseCase;
|
||||
RigCaseData* m_eclipseCase;
|
||||
RigMainGrid* m_mainGrid;
|
||||
};
|
||||
|
||||
|
||||
@@ -133,7 +133,7 @@ private:
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
cvf::ref<cvf::StructGridScalarDataAccess> RigGridScalarDataAccessFactory::createPerGridDataAccessObject(RigEclipseCase* eclipseCase,
|
||||
cvf::ref<cvf::StructGridScalarDataAccess> RigGridScalarDataAccessFactory::createPerGridDataAccessObject(RigCaseData* eclipseCase,
|
||||
size_t gridIndex,
|
||||
RifReaderInterface::PorosityModelResultType porosityModel,
|
||||
size_t timeStepIndex,
|
||||
|
||||
@@ -30,7 +30,7 @@ class RigGridScalarDataAccessFactory
|
||||
{
|
||||
public:
|
||||
static cvf::ref<cvf::StructGridScalarDataAccess>
|
||||
createPerGridDataAccessObject(RigEclipseCase* eclipseCase,
|
||||
createPerGridDataAccessObject(RigCaseData* eclipseCase,
|
||||
size_t gridIndex,
|
||||
RifReaderInterface::PorosityModelResultType porosityModel,
|
||||
size_t timeStepIndex,
|
||||
|
||||
@@ -172,7 +172,7 @@ void RigReservoirBuilderMock::appendCells(size_t nodeStartIndex, size_t cellCoun
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigReservoirBuilderMock::populateReservoir(RigEclipseCase* eclipseCase)
|
||||
void RigReservoirBuilderMock::populateReservoir(RigCaseData* eclipseCase)
|
||||
{
|
||||
std::vector<cvf::Vec3d>& mainGridNodes = eclipseCase->mainGrid()->nodes();
|
||||
appendNodes(m_minWorldCoordinate, m_maxWorldCoordinate, cellDimension(), mainGridNodes);
|
||||
@@ -278,7 +278,7 @@ void RigReservoirBuilderMock::setWorldCoordinates(cvf::Vec3d minWorldCoordinate,
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
bool RigReservoirBuilderMock::inputProperty(RigEclipseCase* eclipseCase, const QString& propertyName, std::vector<double>* values)
|
||||
bool RigReservoirBuilderMock::inputProperty(RigCaseData* eclipseCase, const QString& propertyName, std::vector<double>* values)
|
||||
{
|
||||
size_t k;
|
||||
|
||||
@@ -299,7 +299,7 @@ bool RigReservoirBuilderMock::inputProperty(RigEclipseCase* eclipseCase, const Q
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
bool RigReservoirBuilderMock::staticResult(RigEclipseCase* eclipseCase, const QString& result, std::vector<double>* values)
|
||||
bool RigReservoirBuilderMock::staticResult(RigCaseData* eclipseCase, const QString& result, std::vector<double>* values)
|
||||
{
|
||||
size_t k;
|
||||
|
||||
@@ -316,7 +316,7 @@ bool RigReservoirBuilderMock::staticResult(RigEclipseCase* eclipseCase, const QS
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
bool RigReservoirBuilderMock::dynamicResult(RigEclipseCase* eclipseCase, const QString& result, size_t stepIndex, std::vector<double>* values)
|
||||
bool RigReservoirBuilderMock::dynamicResult(RigCaseData* eclipseCase, const QString& result, size_t stepIndex, std::vector<double>* values)
|
||||
{
|
||||
int resultIndex = 1;
|
||||
|
||||
@@ -352,19 +352,19 @@ bool RigReservoirBuilderMock::dynamicResult(RigEclipseCase* eclipseCase, const Q
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigReservoirBuilderMock::addWellData(RigEclipseCase* eclipseCase, RigGridBase* grid)
|
||||
void RigReservoirBuilderMock::addWellData(RigCaseData* eclipseCase, RigGridBase* grid)
|
||||
{
|
||||
CVF_ASSERT(eclipseCase);
|
||||
CVF_ASSERT(grid);
|
||||
|
||||
cvf::Vec3st dim = grid->gridPointDimensions();
|
||||
|
||||
cvf::Collection<RigWellResults> wells;
|
||||
cvf::Collection<RigSingleWellResultsData> wells;
|
||||
|
||||
int wellIdx;
|
||||
for (wellIdx = 0; wellIdx < 1; wellIdx++)
|
||||
{
|
||||
cvf::ref<RigWellResults> wellCellsTimeHistory = new RigWellResults;
|
||||
cvf::ref<RigSingleWellResultsData> wellCellsTimeHistory = new RigSingleWellResultsData;
|
||||
wellCellsTimeHistory->m_wellName = QString("Well %1").arg(wellIdx);
|
||||
|
||||
wellCellsTimeHistory->m_wellCellsTimeSteps.resize(m_timeStepCount);
|
||||
|
||||
@@ -55,14 +55,14 @@ public:
|
||||
|
||||
void addLocalGridRefinement(const cvf::Vec3st& minCellPosition, const cvf::Vec3st& maxCellPosition, const cvf::Vec3st& singleCellRefinementFactors);
|
||||
|
||||
void populateReservoir(RigEclipseCase* eclipseCase);
|
||||
void populateReservoir(RigCaseData* eclipseCase);
|
||||
|
||||
bool inputProperty(RigEclipseCase* eclipseCase, const QString& propertyName, std::vector<double>* values );
|
||||
bool staticResult(RigEclipseCase* eclipseCase, const QString& result, std::vector<double>* values );
|
||||
bool dynamicResult(RigEclipseCase* eclipseCase, const QString& result, size_t stepIndex, std::vector<double>* values );
|
||||
bool inputProperty(RigCaseData* eclipseCase, const QString& propertyName, std::vector<double>* values );
|
||||
bool staticResult(RigCaseData* eclipseCase, const QString& result, std::vector<double>* values );
|
||||
bool dynamicResult(RigCaseData* eclipseCase, const QString& result, size_t stepIndex, std::vector<double>* values );
|
||||
|
||||
private:
|
||||
void addWellData(RigEclipseCase* eclipseCase, RigGridBase* grid);
|
||||
void addWellData(RigCaseData* eclipseCase, RigGridBase* grid);
|
||||
static void appendCells(size_t nodeStartIndex, size_t cellCount, RigGridBase* hostGrid, std::vector<RigCell>& cells);
|
||||
|
||||
static void appendNodes(const cvf::Vec3d& min, const cvf::Vec3d& max, const cvf::Vec3st& cubeDimension, std::vector<cvf::Vec3d>& nodes);
|
||||
|
||||
@@ -27,7 +27,7 @@
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
RigReservoirCellResults::RigReservoirCellResults(RigMainGrid* ownerGrid)
|
||||
RigCaseCellResultsData::RigCaseCellResultsData(RigMainGrid* ownerGrid)
|
||||
{
|
||||
CVF_ASSERT(ownerGrid != NULL);
|
||||
m_ownerMainGrid = ownerGrid;
|
||||
@@ -37,7 +37,7 @@ RigReservoirCellResults::RigReservoirCellResults(RigMainGrid* ownerGrid)
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigReservoirCellResults::setMainGrid(RigMainGrid* ownerGrid)
|
||||
void RigCaseCellResultsData::setMainGrid(RigMainGrid* ownerGrid)
|
||||
{
|
||||
m_ownerMainGrid = ownerGrid;
|
||||
}
|
||||
@@ -45,7 +45,7 @@ void RigReservoirCellResults::setMainGrid(RigMainGrid* ownerGrid)
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigReservoirCellResults::minMaxCellScalarValues( size_t scalarResultIndex, double& min, double& max )
|
||||
void RigCaseCellResultsData::minMaxCellScalarValues( size_t scalarResultIndex, double& min, double& max )
|
||||
{
|
||||
min = HUGE_VAL;
|
||||
max = -HUGE_VAL;
|
||||
@@ -83,7 +83,7 @@ void RigReservoirCellResults::minMaxCellScalarValues( size_t scalarResultIndex,
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigReservoirCellResults::minMaxCellScalarValues(size_t scalarResultIndex, size_t timeStepIndex, double& min, double& max)
|
||||
void RigCaseCellResultsData::minMaxCellScalarValues(size_t scalarResultIndex, size_t timeStepIndex, double& min, double& max)
|
||||
{
|
||||
min = HUGE_VAL;
|
||||
max = -HUGE_VAL;
|
||||
@@ -137,7 +137,7 @@ void RigReservoirCellResults::minMaxCellScalarValues(size_t scalarResultIndex, s
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
const std::vector<size_t>& RigReservoirCellResults::cellScalarValuesHistogram(size_t scalarResultIndex)
|
||||
const std::vector<size_t>& RigCaseCellResultsData::cellScalarValuesHistogram(size_t scalarResultIndex)
|
||||
{
|
||||
CVF_ASSERT(scalarResultIndex < resultCount());
|
||||
|
||||
@@ -178,7 +178,7 @@ const std::vector<size_t>& RigReservoirCellResults::cellScalarValuesHistogram(si
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigReservoirCellResults::p10p90CellScalarValues(size_t scalarResultIndex, double& p10, double& p90)
|
||||
void RigCaseCellResultsData::p10p90CellScalarValues(size_t scalarResultIndex, double& p10, double& p90)
|
||||
{
|
||||
const std::vector<size_t>& histogr = cellScalarValuesHistogram( scalarResultIndex);
|
||||
p10 = m_p10p90[scalarResultIndex].first;
|
||||
@@ -188,7 +188,7 @@ void RigReservoirCellResults::p10p90CellScalarValues(size_t scalarResultIndex, d
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigReservoirCellResults::meanCellScalarValues(size_t scalarResultIndex, double& meanValue)
|
||||
void RigCaseCellResultsData::meanCellScalarValues(size_t scalarResultIndex, double& meanValue)
|
||||
{
|
||||
CVF_ASSERT(scalarResultIndex < resultCount());
|
||||
|
||||
@@ -224,7 +224,7 @@ void RigReservoirCellResults::meanCellScalarValues(size_t scalarResultIndex, dou
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
size_t RigReservoirCellResults::resultCount() const
|
||||
size_t RigCaseCellResultsData::resultCount() const
|
||||
{
|
||||
return m_cellScalarResults.size();
|
||||
}
|
||||
@@ -232,7 +232,7 @@ size_t RigReservoirCellResults::resultCount() const
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
size_t RigReservoirCellResults::timeStepCount(size_t scalarResultIndex) const
|
||||
size_t RigCaseCellResultsData::timeStepCount(size_t scalarResultIndex) const
|
||||
{
|
||||
CVF_TIGHT_ASSERT(scalarResultIndex < resultCount());
|
||||
|
||||
@@ -242,7 +242,7 @@ size_t RigReservoirCellResults::timeStepCount(size_t scalarResultIndex) const
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
const std::vector< std::vector<double> > & RigReservoirCellResults::cellScalarResults( size_t scalarResultIndex ) const
|
||||
const std::vector< std::vector<double> > & RigCaseCellResultsData::cellScalarResults( size_t scalarResultIndex ) const
|
||||
{
|
||||
CVF_TIGHT_ASSERT(scalarResultIndex < resultCount());
|
||||
|
||||
@@ -252,7 +252,7 @@ const std::vector< std::vector<double> > & RigReservoirCellResults::cellScalarRe
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
std::vector< std::vector<double> > & RigReservoirCellResults::cellScalarResults( size_t scalarResultIndex )
|
||||
std::vector< std::vector<double> > & RigCaseCellResultsData::cellScalarResults( size_t scalarResultIndex )
|
||||
{
|
||||
CVF_TIGHT_ASSERT(scalarResultIndex < resultCount());
|
||||
|
||||
@@ -262,7 +262,7 @@ std::vector< std::vector<double> > & RigReservoirCellResults::cellScalarResults(
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
std::vector<double>& RigReservoirCellResults::cellScalarResults(size_t scalarResultIndex, size_t timeStepIndex)
|
||||
std::vector<double>& RigCaseCellResultsData::cellScalarResults(size_t scalarResultIndex, size_t timeStepIndex)
|
||||
{
|
||||
CVF_TIGHT_ASSERT(scalarResultIndex < resultCount());
|
||||
CVF_TIGHT_ASSERT(timeStepIndex < m_cellScalarResults[scalarResultIndex].size());
|
||||
@@ -273,7 +273,7 @@ std::vector<double>& RigReservoirCellResults::cellScalarResults(size_t scalarRes
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
double RigReservoirCellResults::cellScalarResult( size_t scalarResultIndex, size_t timeStepIndex, size_t resultValueIndex)
|
||||
double RigCaseCellResultsData::cellScalarResult( size_t scalarResultIndex, size_t timeStepIndex, size_t resultValueIndex)
|
||||
{
|
||||
if (scalarResultIndex < resultCount() &&
|
||||
timeStepIndex < m_cellScalarResults[scalarResultIndex].size() &&
|
||||
@@ -292,7 +292,7 @@ double RigReservoirCellResults::cellScalarResult( size_t scalarResultIndex, size
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
size_t RigReservoirCellResults::findScalarResultIndex(RimDefines::ResultCatType type, const QString& resultName) const
|
||||
size_t RigCaseCellResultsData::findScalarResultIndex(RimDefines::ResultCatType type, const QString& resultName) const
|
||||
{
|
||||
std::vector<ResultInfo>::const_iterator it;
|
||||
for (it = m_resultInfos.begin(); it != m_resultInfos.end(); it++)
|
||||
@@ -309,7 +309,7 @@ size_t RigReservoirCellResults::findScalarResultIndex(RimDefines::ResultCatType
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
size_t RigReservoirCellResults::findScalarResultIndex(const QString& resultName) const
|
||||
size_t RigCaseCellResultsData::findScalarResultIndex(const QString& resultName) const
|
||||
{
|
||||
size_t scalarResultIndex = cvf::UNDEFINED_SIZE_T;
|
||||
|
||||
@@ -337,7 +337,7 @@ size_t RigReservoirCellResults::findScalarResultIndex(const QString& resultName)
|
||||
/// Adds an empty scalar set, and returns the scalarResultIndex to it.
|
||||
/// if resultName already exists, it returns the scalarResultIndex to the existing result.
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
size_t RigReservoirCellResults::addEmptyScalarResult(RimDefines::ResultCatType type, const QString& resultName, bool needsToBeStored)
|
||||
size_t RigCaseCellResultsData::addEmptyScalarResult(RimDefines::ResultCatType type, const QString& resultName, bool needsToBeStored)
|
||||
{
|
||||
size_t scalarResultIndex = cvf::UNDEFINED_SIZE_T;
|
||||
|
||||
@@ -356,7 +356,7 @@ size_t RigReservoirCellResults::addEmptyScalarResult(RimDefines::ResultCatType t
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
QStringList RigReservoirCellResults::resultNames(RimDefines::ResultCatType resType) const
|
||||
QStringList RigCaseCellResultsData::resultNames(RimDefines::ResultCatType resType) const
|
||||
{
|
||||
QStringList varList;
|
||||
std::vector<ResultInfo>::const_iterator it;
|
||||
@@ -373,7 +373,7 @@ QStringList RigReservoirCellResults::resultNames(RimDefines::ResultCatType resTy
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigReservoirCellResults::recalculateMinMax(size_t scalarResultIndex)
|
||||
void RigCaseCellResultsData::recalculateMinMax(size_t scalarResultIndex)
|
||||
{
|
||||
// Make sure cached max min values are recalculated next time asked for, since
|
||||
// the data could be changed.
|
||||
@@ -392,7 +392,7 @@ void RigReservoirCellResults::recalculateMinMax(size_t scalarResultIndex)
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Returns whether the result data in question is addressed by Active Cell Index
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
bool RigReservoirCellResults::isUsingGlobalActiveIndex(size_t scalarResultIndex) const
|
||||
bool RigCaseCellResultsData::isUsingGlobalActiveIndex(size_t scalarResultIndex) const
|
||||
{
|
||||
CVF_TIGHT_ASSERT(scalarResultIndex < m_cellScalarResults.size());
|
||||
|
||||
@@ -407,7 +407,7 @@ bool RigReservoirCellResults::isUsingGlobalActiveIndex(size_t scalarResultIndex)
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
QDateTime RigReservoirCellResults::timeStepDate(size_t scalarResultIndex, size_t timeStepIndex) const
|
||||
QDateTime RigCaseCellResultsData::timeStepDate(size_t scalarResultIndex, size_t timeStepIndex) const
|
||||
{
|
||||
if (scalarResultIndex < m_resultInfos.size() && (size_t)(m_resultInfos[scalarResultIndex].m_timeStepDates.size()) > timeStepIndex)
|
||||
return m_resultInfos[scalarResultIndex].m_timeStepDates[static_cast<int>(timeStepIndex)];
|
||||
@@ -418,7 +418,7 @@ QDateTime RigReservoirCellResults::timeStepDate(size_t scalarResultIndex, size_t
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
std::vector<QDateTime> RigReservoirCellResults::timeStepDates(size_t scalarResultIndex) const
|
||||
std::vector<QDateTime> RigCaseCellResultsData::timeStepDates(size_t scalarResultIndex) const
|
||||
{
|
||||
if (scalarResultIndex < m_resultInfos.size() )
|
||||
return m_resultInfos[scalarResultIndex].m_timeStepDates;
|
||||
@@ -429,7 +429,7 @@ std::vector<QDateTime> RigReservoirCellResults::timeStepDates(size_t scalarResul
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigReservoirCellResults::setTimeStepDates(size_t scalarResultIndex, const std::vector<QDateTime>& dates)
|
||||
void RigCaseCellResultsData::setTimeStepDates(size_t scalarResultIndex, const std::vector<QDateTime>& dates)
|
||||
{
|
||||
CVF_ASSERT(scalarResultIndex < m_resultInfos.size() );
|
||||
|
||||
@@ -442,7 +442,7 @@ void RigReservoirCellResults::setTimeStepDates(size_t scalarResultIndex, const s
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
size_t RigReservoirCellResults::maxTimeStepCount(size_t* scalarResultIndexWithMostTimeSteps) const
|
||||
size_t RigCaseCellResultsData::maxTimeStepCount(size_t* scalarResultIndexWithMostTimeSteps) const
|
||||
{
|
||||
size_t maxTsCount = 0;
|
||||
size_t scalarResultIndexWithMaxTsCount = cvf::UNDEFINED_SIZE_T;
|
||||
@@ -467,7 +467,7 @@ size_t RigReservoirCellResults::maxTimeStepCount(size_t* scalarResultIndexWithMo
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
QString RigReservoirCellResults::makeResultNameUnique(const QString& resultNameProposal) const
|
||||
QString RigCaseCellResultsData::makeResultNameUnique(const QString& resultNameProposal) const
|
||||
{
|
||||
QString newResultName = resultNameProposal;
|
||||
size_t resultIndex = cvf::UNDEFINED_SIZE_T;
|
||||
@@ -489,7 +489,7 @@ QString RigReservoirCellResults::makeResultNameUnique(const QString& resultNameP
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigReservoirCellResults::removeResult(const QString& resultName)
|
||||
void RigCaseCellResultsData::removeResult(const QString& resultName)
|
||||
{
|
||||
size_t resultIdx = findScalarResultIndex(resultName);
|
||||
if (resultIdx == cvf::UNDEFINED_SIZE_T) return;
|
||||
@@ -502,7 +502,7 @@ void RigReservoirCellResults::removeResult(const QString& resultName)
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigReservoirCellResults::clearAllResults()
|
||||
void RigCaseCellResultsData::clearAllResults()
|
||||
{
|
||||
m_cellScalarResults.clear();
|
||||
m_maxMinValues.clear();
|
||||
@@ -516,7 +516,7 @@ void RigReservoirCellResults::clearAllResults()
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Add a result with given type and name, and allocate one result vector for the static result values
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
size_t RigReservoirCellResults::addStaticScalarResult(RimDefines::ResultCatType type, const QString& resultName, bool needsToBeStored, size_t resultValueCount)
|
||||
size_t RigCaseCellResultsData::addStaticScalarResult(RimDefines::ResultCatType type, const QString& resultName, bool needsToBeStored, size_t resultValueCount)
|
||||
{
|
||||
size_t resultIdx = addEmptyScalarResult(type, resultName, needsToBeStored);
|
||||
|
||||
@@ -529,7 +529,7 @@ size_t RigReservoirCellResults::addStaticScalarResult(RimDefines::ResultCatType
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
RifReaderInterface::PorosityModelResultType RigReservoirCellResults::convertFromProjectModelPorosityModel(RimDefines::PorosityModelType porosityModel)
|
||||
RifReaderInterface::PorosityModelResultType RigCaseCellResultsData::convertFromProjectModelPorosityModel(RimDefines::PorosityModelType porosityModel)
|
||||
{
|
||||
if (porosityModel == RimDefines::MATRIX_MODEL) return RifReaderInterface::MATRIX_RESULTS;
|
||||
|
||||
|
||||
@@ -30,10 +30,10 @@ class RigMainGrid;
|
||||
//==================================================================================================
|
||||
/// Class containing the results for the complete number of active cells. Both main grid and LGR's
|
||||
//==================================================================================================
|
||||
class RigReservoirCellResults : public cvf::Object
|
||||
class RigCaseCellResultsData : public cvf::Object
|
||||
{
|
||||
public:
|
||||
RigReservoirCellResults(RigMainGrid* ownerGrid);
|
||||
RigCaseCellResultsData(RigMainGrid* ownerGrid);
|
||||
|
||||
void setMainGrid(RigMainGrid* ownerGrid);
|
||||
|
||||
|
||||
@@ -24,7 +24,7 @@
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
const RigWellResultFrame& RigWellResults::wellResultFrame(size_t resultTimeStepIndex) const
|
||||
const RigWellResultFrame& RigSingleWellResultsData::wellResultFrame(size_t resultTimeStepIndex) const
|
||||
{
|
||||
CVF_ASSERT(resultTimeStepIndex < m_resultTimeStepIndexToWellTimeStepIndex.size());
|
||||
|
||||
@@ -37,7 +37,7 @@ const RigWellResultFrame& RigWellResults::wellResultFrame(size_t resultTimeStepI
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigWellResults::computeMappingFromResultTimeIndicesToWellTimeIndices(const std::vector<QDateTime>& resultTimes)
|
||||
void RigSingleWellResultsData::computeMappingFromResultTimeIndicesToWellTimeIndices(const std::vector<QDateTime>& resultTimes)
|
||||
{
|
||||
m_resultTimeStepIndexToWellTimeStepIndex.clear();
|
||||
if (m_wellCellsTimeSteps.size() == 0) return;
|
||||
@@ -83,7 +83,7 @@ void RigWellResults::computeMappingFromResultTimeIndicesToWellTimeIndices(const
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
bool RigWellResults::hasWellResult(size_t resultTimeStepIndex) const
|
||||
bool RigSingleWellResultsData::hasWellResult(size_t resultTimeStepIndex) const
|
||||
{
|
||||
size_t wellTimeStepIndex = m_resultTimeStepIndexToWellTimeStepIndex[resultTimeStepIndex];
|
||||
|
||||
@@ -93,7 +93,7 @@ bool RigWellResults::hasWellResult(size_t resultTimeStepIndex) const
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
size_t RigWellResults::firstResultTimeStep() const
|
||||
size_t RigSingleWellResultsData::firstResultTimeStep() const
|
||||
{
|
||||
size_t i = 0;
|
||||
for(i = 0; i < m_resultTimeStepIndexToWellTimeStepIndex.size(); ++i)
|
||||
@@ -108,7 +108,7 @@ size_t RigWellResults::firstResultTimeStep() const
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RigWellResults::computeStaticWellCellPath()
|
||||
void RigSingleWellResultsData::computeStaticWellCellPath()
|
||||
{
|
||||
if (m_wellCellsTimeSteps.size() == 0) return;
|
||||
|
||||
|
||||
@@ -99,7 +99,7 @@ public:
|
||||
//==================================================================================================
|
||||
///
|
||||
//==================================================================================================
|
||||
class RigWellResults : public cvf::Object
|
||||
class RigSingleWellResultsData : public cvf::Object
|
||||
{
|
||||
public:
|
||||
bool hasWellResult(size_t resultTimeStepIndex) const;
|
||||
|
||||
Reference in New Issue
Block a user