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

Reviewed and simplified DataAccess classes.

Browse Source 
Includes some const changes and some renaming
p4#: 20687
This commit is contained in:
Jacob Støren 2013-03-01 16:00:34 +01:00
parent cd0b40ef20
commit 1181d62b75
12 changed files with 138 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ApplicationCode/FileInterface/RifEclipseInputFileTools.cpp
View File

@ -432,7 +432,7 @@ bool RifEclipseInputFileTools::writeBinaryResultToTextFile(const QString& fileNa
{
for (i = 0; i < eclipseCase->mainGrid()->cellCountI(); i++)
{
double resultValue = dataAccessObject->cellScalar(i, j, k);
double resultValue = dataAccessObject->cellScalar(eclipseCase->mainGrid()->cellIndexFromIJK(i, j, k));
if (resultValue == HUGE_VAL)
{
resultValue = undefinedValue;

8
ApplicationCode/ProjectDataModel/RimReservoirView.cpp
View File

@ -874,15 +874,15 @@ bool RimReservoirView::pickInfo(size_t gridIndex, size_t cellIndex, const cvf::V
//--------------------------------------------------------------------------------------------------
/// Get the current scalar value for the display face at the given index
//--------------------------------------------------------------------------------------------------
void RimReservoirView::appendCellResultInfo(size_t gridIndex, size_t cellIndex, QString* resultInfoText) const
void RimReservoirView::appendCellResultInfo(size_t gridIndex, size_t cellIndex, QString* resultInfoText)
{
CVF_ASSERT(resultInfoText);
if (m_reservoir && m_reservoir->reservoirData())
{
const RigEclipseCase* eclipseCase = m_reservoir->reservoirData();
const RigGridBase* grid = eclipseCase->grid(gridIndex);
const RigActiveCellInfo* activeCellInfo = eclipseCase->activeCellInfo();
RigEclipseCase* eclipseCase = m_reservoir->reservoirData();
RigGridBase* grid = eclipseCase->grid(gridIndex);
RigActiveCellInfo* activeCellInfo = eclipseCase->activeCellInfo();
if (this->cellResult()->hasResult())
{

2
ApplicationCode/ProjectDataModel/RimReservoirView.h
View File

@ -137,7 +137,7 @@ public:
// Picking info
bool pickInfo(size_t gridIndex, size_t cellIndex, const cvf::Vec3d& point, QString* pickInfoText) const;
void appendCellResultInfo(size_t gridIndex, size_t cellIndex, QString* resultInfoText) const;
void appendCellResultInfo(size_t gridIndex, size_t cellIndex, QString* resultInfoText) ;
// Does this belong here, really ?
void calculateVisibleWellCellsIncFence(cvf::UByteArray* visibleCells, RigGridBase * grid);

12
ApplicationCode/ReservoirDataModel/RigActiveCellInfo.cpp
View File

@ -45,7 +45,7 @@ void RigActiveCellInfo::setGlobalCellCount(size_t globalCellCount)
//--------------------------------------------------------------------------------------------------
bool RigActiveCellInfo::isActiveInMatrixModel(size_t globalCellIndex) const
{
if (globalCellIndex >= m_activeInMatrixModel.size()) return false;
CVF_TIGHT_ASSERT(globalCellIndex < m_activeInMatrixModel.size());
return m_activeInMatrixModel[globalCellIndex] != cvf::UNDEFINED_SIZE_T;
}
@ -55,7 +55,7 @@ bool RigActiveCellInfo::isActiveInMatrixModel(size_t globalCellIndex) const
//--------------------------------------------------------------------------------------------------
size_t RigActiveCellInfo::activeIndexInMatrixModel(size_t globalCellIndex) const
{
if (globalCellIndex >= m_activeInMatrixModel.size()) return cvf::UNDEFINED_SIZE_T;
CVF_TIGHT_ASSERT(globalCellIndex < m_activeInMatrixModel.size());
return m_activeInMatrixModel[globalCellIndex];
}
@ -75,7 +75,7 @@ void RigActiveCellInfo::setActiveIndexInMatrixModel(size_t globalCellIndex, size
//--------------------------------------------------------------------------------------------------
bool RigActiveCellInfo::isActiveInFractureModel(size_t globalCellIndex) const
{
if (globalCellIndex >= m_activeInFractureModel.size()) return false;
CVF_TIGHT_ASSERT(globalCellIndex < m_activeInFractureModel.size());
return m_activeInFractureModel[globalCellIndex] != cvf::UNDEFINED_SIZE_T;
}
@ -85,7 +85,7 @@ bool RigActiveCellInfo::isActiveInFractureModel(size_t globalCellIndex) const
//--------------------------------------------------------------------------------------------------
size_t RigActiveCellInfo::activeIndexInFractureModel(size_t globalCellIndex) const
{
if (globalCellIndex >= m_activeInFractureModel.size()) return cvf::UNDEFINED_SIZE_T;
CVF_TIGHT_ASSERT(globalCellIndex < m_activeInFractureModel.size());
return m_activeInFractureModel[globalCellIndex];
}
@ -133,10 +133,6 @@ void RigActiveCellInfo::computeDerivedData()
m_globalFractureModelActiveCellCount += m_perGridActiveCellInfo[i].fractureModelActiveCellCount();
}
if (m_globalFractureModelActiveCellCount == 0)
{
m_activeInFractureModel.resize(0);
}
}
//--------------------------------------------------------------------------------------------------

26
ApplicationCode/ReservoirDataModel/RigEclipseCase.cpp
View File

@ -83,6 +83,24 @@ const RigGridBase* RigEclipseCase::grid(size_t index) const
return m_mainGrid->gridByIndex(index);
}
//--------------------------------------------------------------------------------------------------
/// Get grid by index. The main grid has index 0, so the first lgr has index 1
//--------------------------------------------------------------------------------------------------
RigGridBase* RigEclipseCase::grid(size_t index)
{
return m_mainGrid->gridByIndex(index);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RigEclipseCase::gridCount() const
{
return m_mainGrid->gridCount();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -375,16 +393,18 @@ const RigReservoirCellResults* RigEclipseCase::results(RifReaderInterface::Poros
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::ref<cvf::StructGridScalarDataAccess> RigEclipseCase::dataAccessObject(const RigGridBase* grid, RifReaderInterface::PorosityModelResultType porosityModel, size_t timeStepIndex, size_t scalarSetIndex) const
cvf::ref<cvf::StructGridScalarDataAccess> RigEclipseCase::dataAccessObject(const RigGridBase* grid,
RifReaderInterface::PorosityModelResultType porosityModel,
size_t timeStepIndex,
size_t scalarSetIndex)
{
if (timeStepIndex != cvf::UNDEFINED_SIZE_T &&
scalarSetIndex != cvf::UNDEFINED_SIZE_T)
{
cvf::ref<cvf::StructGridScalarDataAccess> dataAccess = RigGridScalarDataAccessFactory::createDataAccessObject(grid, this, porosityModel, timeStepIndex, scalarSetIndex);
cvf::ref<cvf::StructGridScalarDataAccess> dataAccess = RigGridScalarDataAccessFactory::createPerGridDataAccessObject( this, grid->gridIndex(), porosityModel, timeStepIndex, scalarSetIndex);
return dataAccess;
}
return NULL;
}

13
ApplicationCode/ReservoirDataModel/RigEclipseCase.h
View File

@ -40,16 +40,19 @@ public:
const RigMainGrid* mainGrid() const { return m_mainGrid.p(); }
void setMainGrid(RigMainGrid* mainGrid);
void allGrids(std::vector<RigGridBase*>* grids);
void allGrids(std::vector<const RigGridBase*>* grids) const;
void allGrids(std::vector<RigGridBase*>* grids); // To be removed
void allGrids(std::vector<const RigGridBase*>* grids) const;// To be removed
const RigGridBase* grid(size_t index) const;
RigGridBase* grid(size_t index);
size_t gridCount() const;
RigReservoirCellResults* results(RifReaderInterface::PorosityModelResultType porosityModel);
const RigReservoirCellResults* results(RifReaderInterface::PorosityModelResultType porosityModel) const;
cvf::ref<cvf::StructGridScalarDataAccess> dataAccessObject(const RigGridBase* grid, RifReaderInterface::PorosityModelResultType porosityModel, size_t timeStepIndex, size_t scalarSetIndex) const;
cvf::ref<cvf::StructGridScalarDataAccess> dataAccessObject(const RigGridBase* grid,
RifReaderInterface::PorosityModelResultType porosityModel,
size_t timeStepIndex,
size_t scalarSetIndex);
void computeCachedData();

2
ApplicationCode/ReservoirDataModel/RigGridBase.h
View File

@ -53,7 +53,7 @@ public:
void setIndexToStartOfCells(size_t indexToStartOfCells) { m_indexToStartOfCells = indexToStartOfCells; }
void setGridIndex(size_t index) { m_gridIndex = index; }
size_t gridIndex() { return m_gridIndex; }
size_t gridIndex() const { return m_gridIndex; }
double characteristicIJCellSize();

169
ApplicationCode/ReservoirDataModel/RigGridScalarDataAccess.cpp
View File

@ -31,132 +31,100 @@
#include "RigEclipseCase.h"
#include <math.h>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
class RigGridAllCellsScalarDataAccess : public cvf::StructGridScalarDataAccess
{
public:
RigGridAllCellsScalarDataAccess(const RigGridBase* grid, const std::vector<double>* resultValues);
RigGridAllCellsScalarDataAccess(const RigGridBase* grid, std::vector<double>* reservoirResultValues);
virtual double cellScalar(size_t i, size_t j, size_t k) const;
virtual double cellScalar(size_t cellIndex) const;
virtual void cellCornerScalars(size_t i, size_t j, size_t k, double scalars[8]) const;
virtual double gridPointScalar(size_t i, size_t j, size_t k) const;
virtual bool pointScalar(const cvf::Vec3d& p, double* scalarValue) const;
virtual double cellScalar(size_t gridLocalCellIndex) const;
virtual void setCellScalar(size_t cellIndex, double value);
virtual const cvf::Vec3d* cellVector(size_t i, size_t j, size_t k) const;
protected:
private:
cvf::cref<RigGridBase> m_grid;
const std::vector<double>* m_resultValues;
std::vector<double>* m_reservoirResultValues;
};
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigGridAllCellsScalarDataAccess::RigGridAllCellsScalarDataAccess(const RigGridBase* grid, const std::vector<double>* resultValues) :
m_grid(grid),
m_resultValues(resultValues)
RigGridAllCellsScalarDataAccess::RigGridAllCellsScalarDataAccess(const RigGridBase* grid, std::vector<double>* reservoirResultValues)
: m_grid(grid),
m_reservoirResultValues(reservoirResultValues)
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigGridAllCellsScalarDataAccess::cellScalar(size_t i, size_t j, size_t k) const
{
size_t cellIndex = m_grid->cellIndexFromIJK(i, j, k);
return cellScalar(cellIndex);
CVF_ASSERT(reservoirResultValues != NULL);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigGridAllCellsScalarDataAccess::cellScalar(size_t cellIndex) const
double RigGridAllCellsScalarDataAccess::cellScalar(size_t gridLocalCellIndex) const
{
if (m_resultValues->size() == 0 ) return HUGE_VAL;
if (m_reservoirResultValues->size() == 0 ) return HUGE_VAL;
if (m_resultValues->size() <= cellIndex) return HUGE_VAL;
size_t globalGridCellIndex = m_grid->globalGridCellIndex(gridLocalCellIndex);
CVF_TIGHT_ASSERT(globalGridCellIndex < m_reservoirResultValues->size() );
return m_resultValues->at(cellIndex);
return m_reservoirResultValues->at(globalGridCellIndex);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigGridAllCellsScalarDataAccess::gridPointScalar(size_t i, size_t j, size_t k) const
void RigGridAllCellsScalarDataAccess::setCellScalar(size_t gridLocalCellIndex, double scalarValue)
{
CVF_ASSERT(false);
return 0.0;
size_t globalGridCellIndex = m_grid->globalGridCellIndex(gridLocalCellIndex);
CVF_TIGHT_ASSERT(globalGridCellIndex < m_reservoirResultValues->size() );
(*m_reservoirResultValues)[globalGridCellIndex] = scalarValue;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigGridAllCellsScalarDataAccess::cellCornerScalars(size_t i, size_t j, size_t k, double scalars[8]) const
{
CVF_ASSERT(false);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigGridAllCellsScalarDataAccess::pointScalar(const cvf::Vec3d& p, double* scalarValue) const
{
CVF_ASSERT(false);
return false;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const cvf::Vec3d* RigGridAllCellsScalarDataAccess::cellVector(size_t i, size_t j, size_t k) const
{
CVF_ASSERT(false);
return new cvf::Vec3d();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
class RigGridMatrixActiveCellsScalarDataAccess : public RigGridAllCellsScalarDataAccess
class RigGridMatrixActiveCellsScalarDataAccess : public cvf::StructGridScalarDataAccess
{
public:
RigGridMatrixActiveCellsScalarDataAccess(const RigGridBase* grid, const std::vector<double>* resultValues, const RigActiveCellInfo* activeCellInfo) :
RigGridAllCellsScalarDataAccess(grid, resultValues),
RigGridMatrixActiveCellsScalarDataAccess(const RigGridBase* grid, std::vector<double>* reservoirResultValues, const RigActiveCellInfo* activeCellInfo)
: m_grid(grid),
m_reservoirResultValues(reservoirResultValues),
m_activeCellInfo(activeCellInfo)
{
}
virtual double cellScalar(size_t cellIndex) const
virtual double cellScalar(size_t gridLocalCellIndex) const
{
if (m_resultValues->size() == 0 ) return HUGE_VAL;
if (m_reservoirResultValues->size() == 0 ) return HUGE_VAL;
size_t globalGridCellIndex = m_grid->globalGridCellIndex(cellIndex);
size_t globalGridCellIndex = m_grid->globalGridCellIndex(gridLocalCellIndex);
size_t resultValueIndex = m_activeCellInfo->activeIndexInMatrixModel(globalGridCellIndex);
if (resultValueIndex == cvf::UNDEFINED_SIZE_T) return HUGE_VAL;
if (m_resultValues->size() <= resultValueIndex) return HUGE_VAL;
CVF_TIGHT_ASSERT (resultValueIndex < m_reservoirResultValues->size());
return m_resultValues->at(resultValueIndex);
return m_reservoirResultValues->at(resultValueIndex);
}
protected:
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
virtual void setCellScalar(size_t gridLocalCellIndex, double scalarValue)
{
size_t globalGridCellIndex = m_grid->globalGridCellIndex(gridLocalCellIndex);
size_t resultValueIndex = m_activeCellInfo->activeIndexInMatrixModel(globalGridCellIndex);
CVF_TIGHT_ASSERT (resultValueIndex < m_reservoirResultValues->size());
(*m_reservoirResultValues)[resultValueIndex] = scalarValue;
}
private:
const RigActiveCellInfo* m_activeCellInfo;
cvf::cref<RigGridBase> m_grid;
std::vector<double>* m_reservoirResultValues;
};
@ -167,30 +135,46 @@ protected:
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
class RigGridFractureActiveCellsScalarDataAccess : public RigGridAllCellsScalarDataAccess
class RigGridFractureActiveCellsScalarDataAccess : public cvf::StructGridScalarDataAccess
{
public:
RigGridFractureActiveCellsScalarDataAccess(const RigGridBase* grid, const std::vector<double>* resultValues, const RigActiveCellInfo* activeCellInfo) :
RigGridAllCellsScalarDataAccess(grid, resultValues),
RigGridFractureActiveCellsScalarDataAccess(const RigGridBase* grid, std::vector<double>* reservoirResultValues, const RigActiveCellInfo* activeCellInfo)
: m_grid(grid),
m_reservoirResultValues(reservoirResultValues),
m_activeCellInfo(activeCellInfo)
{
}
virtual double cellScalar(size_t cellIndex) const
virtual double cellScalar(size_t gridLocalCellIndex) const
{
if (m_resultValues->size() == 0 ) return HUGE_VAL;
if (m_reservoirResultValues->size() == 0 ) return HUGE_VAL;
size_t globalGridCellIndex = m_grid->globalGridCellIndex(cellIndex);
size_t globalGridCellIndex = m_grid->globalGridCellIndex(gridLocalCellIndex);
size_t resultValueIndex = m_activeCellInfo->activeIndexInFractureModel(globalGridCellIndex);
if (resultValueIndex == cvf::UNDEFINED_SIZE_T) return HUGE_VAL;
if (m_resultValues->size() <= resultValueIndex) return HUGE_VAL;
CVF_TIGHT_ASSERT (resultValueIndex < m_reservoirResultValues->size());
return m_resultValues->at(resultValueIndex);
return m_reservoirResultValues->at(resultValueIndex);
}
protected:
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
virtual void setCellScalar(size_t gridLocalCellIndex, double scalarValue)
{
size_t globalGridCellIndex = m_grid->globalGridCellIndex(gridLocalCellIndex);
size_t resultValueIndex = m_activeCellInfo->activeIndexInFractureModel(globalGridCellIndex);
CVF_TIGHT_ASSERT (resultValueIndex < m_reservoirResultValues->size());
(*m_reservoirResultValues)[resultValueIndex] = scalarValue;
}
private:
const RigActiveCellInfo* m_activeCellInfo;
cvf::cref<RigGridBase> m_grid;
std::vector<double>* m_reservoirResultValues;
};
@ -200,29 +184,32 @@ protected:
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::ref<cvf::StructGridScalarDataAccess> RigGridScalarDataAccessFactory::createDataAccessObject(const RigGridBase* grid,
const RigEclipseCase* eclipseCase,
cvf::ref<cvf::StructGridScalarDataAccess> RigGridScalarDataAccessFactory::createPerGridDataAccessObject(RigEclipseCase* eclipseCase,
size_t gridIndex,
RifReaderInterface::PorosityModelResultType porosityModel,
size_t timeStepIndex,
size_t scalarSetIndex)
{
CVF_ASSERT(grid);
CVF_ASSERT(gridIndex < eclipseCase->gridCount());
CVF_ASSERT(eclipseCase);
CVF_ASSERT(eclipseCase->results(porosityModel));
CVF_ASSERT(eclipseCase->activeCellInfo());
if (!grid || !eclipseCase || !eclipseCase->results(porosityModel) || !eclipseCase->activeCellInfo())
RigGridBase *grid = eclipseCase->grid(gridIndex);
if ( !eclipseCase || !eclipseCase->results(porosityModel) || !eclipseCase->activeCellInfo())
{
return NULL;
}
const std::vector< std::vector<double> > & scalarSetResults = eclipseCase->results(porosityModel)->cellScalarResults(scalarSetIndex);
std::vector< std::vector<double> > & scalarSetResults = eclipseCase->results(porosityModel)->cellScalarResults(scalarSetIndex);
if (timeStepIndex >= scalarSetResults.size())
{
return NULL;
}
const std::vector<double>* resultValues = &(scalarSetResults[timeStepIndex]);
std::vector<double>* resultValues = &(scalarSetResults[timeStepIndex]);
bool useGlobalActiveIndex = eclipseCase->results(porosityModel)->isUsingGlobalActiveIndex(scalarSetIndex);

5
ApplicationCode/ReservoirDataModel/RigGridScalarDataAccess.h
View File

@ -29,8 +29,9 @@ class RigGridBase;
class RigGridScalarDataAccessFactory
{
public:
static cvf::ref<cvf::StructGridScalarDataAccess> createDataAccessObject(const RigGridBase* grid,
const RigEclipseCase* eclipseCase,
static cvf::ref<cvf::StructGridScalarDataAccess>
createPerGridDataAccessObject(RigEclipseCase* eclipseCase,
size_t gridIndex,
RifReaderInterface::PorosityModelResultType porosityModel,
size_t timeStepIndex,
size_t scalarSetIndex);

2
ApplicationCode/ReservoirDataModel/RigReservoirCellResults.cpp
View File

@ -253,7 +253,7 @@ std::vector< std::vector<double> > & RigReservoirCellResults::cellScalarResults(
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigReservoirCellResults::cellScalarResult(size_t timeStepIndex, size_t scalarResultIndex, size_t resultValueIndex)
double RigReservoirCellResults::cellScalarResult( size_t scalarResultIndex, size_t timeStepIndex, size_t resultValueIndex)
{
if (scalarResultIndex < resultCount() &&
timeStepIndex < m_cellScalarResults[scalarResultIndex].size() &&

2
ApplicationCode/ReservoirDataModel/RigReservoirCellResults.h
View File

@ -73,7 +73,7 @@ public:
// Access the results data
const std::vector< std::vector<double> > & cellScalarResults(size_t scalarResultIndex) const;
std::vector< std::vector<double> > & cellScalarResults(size_t scalarResultIndex);
double cellScalarResult(size_t timeStepIndex, size_t scalarResultIndex, size_t resultValueIndex);
double cellScalarResult(size_t scalarResultIndex, size_t timeStepIndex, size_t resultValueIndex);
static RifReaderInterface::PorosityModelResultType convertFromProjectModelPorosityModel(RimDefines::PorosityModelType porosityModel);

10
CommonCode/cvfStructGridScalarDataAccess.h
View File

@ -30,16 +30,8 @@ namespace cvf {
class StructGridScalarDataAccess : public Object
{
public:
virtual double cellScalar(size_t i, size_t j, size_t k) const = 0;
virtual double cellScalar(size_t cellIndex) const = 0;
virtual void cellCornerScalars(size_t i, size_t j, size_t k, double scalars[8]) const = 0;
// Trenger vi denne? Kan erstattes av cellCornerScalars for kuttplan
virtual double gridPointScalar(size_t i, size_t j, size_t k) const = 0;
virtual bool pointScalar(const cvf::Vec3d& p, double* scalarValue) const = 0;
// Vector results
virtual const cvf::Vec3d* cellVector(size_t i, size_t j, size_t k) const = 0;
virtual void setCellScalar(size_t cellIndex, double value) = 0;
};