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

Removed out-commented code from the ActiveCellInfo refactoring

Browse Source 
p4#: 20886
This commit is contained in:
Jacob Støren 2013-03-13 13:42:27 +01:00
parent ec889920d5
commit 3c446c4018
3 changed files with 7 additions and 188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

113
ApplicationCode/ReservoirDataModel/RigActiveCellInfo.cpp
View File

@ -24,7 +24,6 @@
//--------------------------------------------------------------------------------------------------
RigActiveCellInfo::RigActiveCellInfo()
: m_globalMatrixModelActiveCellCount(0),
// m_globalFractureModelActiveCellCount(0),
m_activeCellPositionMin(cvf::Vec3d::ZERO),
m_activeCellPositionMax(cvf::Vec3d::ZERO)
{
@ -37,7 +36,6 @@ RigActiveCellInfo::RigActiveCellInfo()
void RigActiveCellInfo::setGlobalCellCount(size_t globalCellCount)
{
m_activeInMatrixModel.resize(globalCellCount, cvf::UNDEFINED_SIZE_T);
// m_activeInFractureModel.resize(globalCellCount, cvf::UNDEFINED_SIZE_T);
}
//--------------------------------------------------------------------------------------------------
@ -79,47 +77,7 @@ void RigActiveCellInfo::setActiveIndexInMatrixModel(size_t globalCellIndex, size
m_activeInMatrixModel[globalCellIndex] = globalActiveCellIndex;
}
/*
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigActiveCellInfo::isActiveInFractureModel(size_t globalCellIndex) const
{
if (m_activeInFractureModel.size() == 0)
{
return false;
}
CVF_TIGHT_ASSERT(globalCellIndex < m_activeInFractureModel.size());
return m_activeInFractureModel[globalCellIndex] != cvf::UNDEFINED_SIZE_T;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RigActiveCellInfo::activeIndexInFractureModel(size_t globalCellIndex) const
{
if (m_activeInFractureModel.size() == 0)
{
return cvf::UNDEFINED_SIZE_T;
}
CVF_TIGHT_ASSERT(globalCellIndex < m_activeInFractureModel.size());
return m_activeInFractureModel[globalCellIndex];
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigActiveCellInfo::setActiveIndexInFractureModel(size_t globalCellIndex, size_t globalActiveCellIndex)
{
CVF_TIGHT_ASSERT(globalActiveCellIndex < m_activeInFractureModel.size());
m_activeInFractureModel[globalCellIndex] = globalActiveCellIndex;
}
*/
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -127,18 +85,6 @@ void RigActiveCellInfo::setGridCount(size_t gridCount)
{
m_perGridActiveCellInfo.resize(gridCount);
}
/*
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigActiveCellInfo::setGridActiveCellCounts(size_t gridIndex, size_t matrixActiveCellCount, size_t fractureActiveCellCount)
{
CVF_ASSERT(gridIndex < m_perGridActiveCellInfo.size());
m_perGridActiveCellInfo[gridIndex].setMatrixModelActiveCellCount(matrixActiveCellCount);
//m_perGridActiveCellInfo[gridIndex].setFractureModelActiveCellCount(fractureActiveCellCount);
}
*/
//--------------------------------------------------------------------------------------------------
///
@ -148,7 +94,6 @@ void RigActiveCellInfo::setGridActiveCellCounts(size_t gridIndex, size_t matrixA
CVF_ASSERT(gridIndex < m_perGridActiveCellInfo.size());
m_perGridActiveCellInfo[gridIndex].setMatrixModelActiveCellCount(matrixActiveCellCount);
//m_perGridActiveCellInfo[gridIndex].setFractureModelActiveCellCount(fractureActiveCellCount);
}
//--------------------------------------------------------------------------------------------------
@ -157,12 +102,10 @@ void RigActiveCellInfo::setGridActiveCellCounts(size_t gridIndex, size_t matrixA
void RigActiveCellInfo::computeDerivedData()
{
m_globalMatrixModelActiveCellCount = 0;
//m_globalFractureModelActiveCellCount = 0;
for (size_t i = 0; i < m_perGridActiveCellInfo.size(); i++)
{
m_globalMatrixModelActiveCellCount += m_perGridActiveCellInfo[i].matrixModelActiveCellCount();
// m_globalFractureModelActiveCellCount += m_perGridActiveCellInfo[i].fractureModelActiveCellCount();
}
}
@ -173,15 +116,7 @@ size_t RigActiveCellInfo::globalMatrixModelActiveCellCount() const
{
return m_globalMatrixModelActiveCellCount;
}
/*
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RigActiveCellInfo::globalFractureModelActiveCellCount() const
{
return m_globalFractureModelActiveCellCount;
}
*/
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -199,34 +134,6 @@ void RigActiveCellInfo::matrixModelActiveCellsBoundingBox(cvf::Vec3st& min, cvf:
min = m_activeCellPositionMin;
max = m_activeCellPositionMax;
}
/*
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigActiveCellInfo::setFractureModelActiveCellsBoundingBox(const cvf::Vec3st& min, const cvf::Vec3st& max)
{
m_fractureModelActiveCellPositionMin = min;
m_fractureModelActiveCellPositionMax = max;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigActiveCellInfo::fractureModelActiveCellsBoundingBox(cvf::Vec3st& min, cvf::Vec3st& max) const
{
min = m_fractureModelActiveCellPositionMin;
max = m_fractureModelActiveCellPositionMax;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigActiveCellInfo::gridActiveCellCounts(size_t gridIndex, size_t& matrixActiveCellCount, size_t& fractureActiveCellCount)
{
matrixActiveCellCount = m_perGridActiveCellInfo[gridIndex].matrixModelActiveCellCount();
fractureActiveCellCount = m_perGridActiveCellInfo[gridIndex].fractureModelActiveCellCount();
}
*/
//--------------------------------------------------------------------------------------------------
///
@ -234,7 +141,6 @@ void RigActiveCellInfo::gridActiveCellCounts(size_t gridIndex, size_t& matrixAct
void RigActiveCellInfo::gridActiveCellCounts(size_t gridIndex, size_t& matrixActiveCellCount)
{
matrixActiveCellCount = m_perGridActiveCellInfo[gridIndex].matrixModelActiveCellCount();
//fractureActiveCellCount = m_perGridActiveCellInfo[gridIndex].fractureModelActiveCellCount();
}
//--------------------------------------------------------------------------------------------------
///
@ -267,20 +173,3 @@ void RigActiveCellInfo::GridActiveCellCounts::setMatrixModelActiveCellCount(size
{
m_matrixModelActiveCellCount = activeMatrixModelCellCount;
}
/*
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RigActiveCellInfo::GridActiveCellCounts::fractureModelActiveCellCount() const
{
return m_fractureModelActiveCellCount;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigActiveCellInfo::GridActiveCellCounts::setFractureModelActiveCellCount(size_t activeFractureModelCellCount)
{
m_fractureModelActiveCellCount = activeFractureModelCellCount;
}
*/

29
ApplicationCode/ReservoirDataModel/RigActiveCellInfo.h
View File

@ -38,57 +38,40 @@ public:
size_t activeIndexInMatrixModel(size_t globalCellIndex) const;
void setActiveIndexInMatrixModel(size_t globalCellIndex, size_t globalActiveCellIndex);
//bool isActiveInFractureModel(size_t globalCellIndex) const;
//size_t activeIndexInFractureModel(size_t globalCellIndex) const;
//void setActiveIndexInFractureModel(size_t globalCellIndex, size_t globalActiveCellIndex);
void setGridCount(size_t gridCount);
//void setGridActiveCellCounts(size_t gridIndex, size_t matrixActiveCellCount, size_t fractureActiveCellCount);
void setGridActiveCellCounts(size_t gridIndex, size_t matrixActiveCellCount);
//void gridActiveCellCounts(size_t gridIndex, size_t& matrixActiveCellCount, size_t& fractureActiveCellCount);
void gridActiveCellCounts(size_t gridIndex, size_t& matrixActiveCellCount);
void gridActiveCellCounts(size_t gridIndex, size_t& matrixActiveCellCount);
void computeDerivedData();
size_t globalMatrixModelActiveCellCount() const;
//size_t globalFractureModelActiveCellCount() const;
void setMatrixModelActiveCellsBoundingBox(const cvf::Vec3st& min, const cvf::Vec3st& max);
void matrixModelActiveCellsBoundingBox(cvf::Vec3st& min, cvf::Vec3st& max) const;
//void setFractureModelActiveCellsBoundingBox(const cvf::Vec3st& min, const cvf::Vec3st& max);
//void fractureModelActiveCellsBoundingBox(cvf::Vec3st& min, cvf::Vec3st& max) const;
cvf::BoundingBox matrixActiveCellsGeometryBoundingBox() const;
void setMatrixActiveCellsGeometryBoundingBox(cvf::BoundingBox bb);
private:
class GridActiveCellCounts
{
public:
size_t matrixModelActiveCellCount() const;
void setMatrixModelActiveCellCount(size_t activeMatrixModelCellCount);
//size_t fractureModelActiveCellCount() const;
//void setFractureModelActiveCellCount(size_t activeFractureModelCellCount);
private:
size_t m_matrixModelActiveCellCount;
//size_t m_fractureModelActiveCellCount;
};
private:
std::vector<GridActiveCellCounts> m_perGridActiveCellInfo;
std::vector<size_t> m_activeInMatrixModel;
//std::vector<size_t> m_activeInFractureModel;
std::vector<size_t> m_activeInMatrixModel;
size_t m_globalMatrixModelActiveCellCount;
//size_t m_globalFractureModelActiveCellCount;
size_t m_globalMatrixModelActiveCellCount;
cvf::Vec3st m_activeCellPositionMin;
cvf::Vec3st m_activeCellPositionMax;
//cvf::Vec3st m_fractureModelActiveCellPositionMin;
//cvf::Vec3st m_fractureModelActiveCellPositionMax;
cvf::Vec3st m_activeCellPositionMin;
cvf::Vec3st m_activeCellPositionMax;
cvf::BoundingBox m_matrixActiveCellsBoundingBox;
cvf::BoundingBox m_matrixActiveCellsBoundingBox;
};

53
ApplicationCode/ReservoirDataModel/RigGridScalarDataAccess.cpp
View File

@ -128,59 +128,6 @@ private:
};
/*
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
class RigGridFractureActiveCellsScalarDataAccess : public cvf::StructGridScalarDataAccess
{
public:
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 gridLocalCellIndex) const
{
if (m_reservoirResultValues->size() == 0 ) return HUGE_VAL;
size_t globalGridCellIndex = m_grid->globalGridCellIndex(gridLocalCellIndex);
size_t resultValueIndex = m_activeCellInfo->activeIndexInFractureModel(globalGridCellIndex);
if (resultValueIndex == cvf::UNDEFINED_SIZE_T) return HUGE_VAL;
CVF_TIGHT_ASSERT (resultValueIndex < m_reservoirResultValues->size());
return m_reservoirResultValues->at(resultValueIndex);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
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;
};
*/
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------