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

Renamed globalCellIndex to reservoirCellIndex

Browse Source
This commit is contained in:
Jacob Støren 2014-08-08 10:02:26 +02:00
parent efd571c7de
commit 52383cab6f
9 changed files with 35 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ApplicationCode/ModelVisualization/RivReservoirViewPartMgr.cpp
View File

@ -562,11 +562,11 @@ void RivReservoirViewPartMgr::computeNativeVisibility(cvf::UByteArray* cellVisib
for (int cellIndex = 0; cellIndex < static_cast<int>(grid->cellCount()); cellIndex++)
{
const RigCell& cell = grid->cell(cellIndex);
size_t globalCellIndex = cell.mainGridCellIndex();
size_t reservoirCellIndex = cell.mainGridCellIndex();
if ( !invalidCellsIsVisible && cell.isInvalid()
|| !inactiveCellsIsVisible && !activeCellInfo->isActive(globalCellIndex)
|| !activeCellsIsVisible && activeCellInfo->isActive(globalCellIndex)
|| !inactiveCellsIsVisible && !activeCellInfo->isActive(reservoirCellIndex)
|| !activeCellsIsVisible && activeCellInfo->isActive(reservoirCellIndex)
//|| mainGridIsVisible && (cell.subGrid() != NULL) // this is handled on global level instead
|| (*cellIsInWellStatuses)[cellIndex]
)

12
ApplicationCode/ProjectDataModel/RimIdenticalGridCaseGroup.cpp
View File

@ -254,11 +254,11 @@ void RimIdenticalGridCaseGroup::computeUnionOfActiveCells()
{
for (size_t caseIdx = 0; caseIdx < caseCollection->reservoirs.size(); caseIdx++)
{
size_t globalCellIdx = grid->globalGridCellIndex(localGridCellIdx);
size_t reservoirCellIndex = grid->globalGridCellIndex(localGridCellIdx);
if (activeM[localGridCellIdx] == 0)
{
if (caseCollection->reservoirs[caseIdx]->reservoirData()->activeCellInfo(RifReaderInterface::MATRIX_RESULTS)->isActive(globalCellIdx))
if (caseCollection->reservoirs[caseIdx]->reservoirData()->activeCellInfo(RifReaderInterface::MATRIX_RESULTS)->isActive(reservoirCellIndex))
{
activeM[localGridCellIdx] = 1;
}
@ -266,7 +266,7 @@ void RimIdenticalGridCaseGroup::computeUnionOfActiveCells()
if (activeF[localGridCellIdx] == 0)
{
if (caseCollection->reservoirs[caseIdx]->reservoirData()->activeCellInfo(RifReaderInterface::FRACTURE_RESULTS)->isActive(globalCellIdx))
if (caseCollection->reservoirs[caseIdx]->reservoirData()->activeCellInfo(RifReaderInterface::FRACTURE_RESULTS)->isActive(reservoirCellIndex))
{
activeF[localGridCellIdx] = 1;
}
@ -279,17 +279,17 @@ void RimIdenticalGridCaseGroup::computeUnionOfActiveCells()
for (size_t localGridCellIdx = 0; localGridCellIdx < grid->cellCount(); localGridCellIdx++)
{
size_t globalCellIdx = grid->globalGridCellIndex(localGridCellIdx);
size_t reservoirCellIndex = grid->globalGridCellIndex(localGridCellIdx);
if (activeM[localGridCellIdx] != 0)
{
m_unionOfMatrixActiveCells->setCellResultIndex(globalCellIdx, globalActiveMatrixIndex++);
m_unionOfMatrixActiveCells->setCellResultIndex(reservoirCellIndex, globalActiveMatrixIndex++);
activeMatrixIndex++;
}
if (activeF[localGridCellIdx] != 0)
{
m_unionOfFractureActiveCells->setCellResultIndex(globalCellIdx, globalActiveFractureIndex++);
m_unionOfFractureActiveCells->setCellResultIndex(reservoirCellIndex, globalActiveFractureIndex++);
activeFractureIndex++;
}
}

18
ApplicationCode/ReservoirDataModel/RigActiveCellInfo.cpp
View File

@ -58,41 +58,41 @@ size_t RigActiveCellInfo::globalCellResultCount() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigActiveCellInfo::isActive(size_t globalCellIndex) const
bool RigActiveCellInfo::isActive(size_t reservoirCellIndex) const
{
if (m_cellIndexToResultIndex.size() == 0)
{
return true;
}
CVF_TIGHT_ASSERT(globalCellIndex < m_cellIndexToResultIndex.size());
CVF_TIGHT_ASSERT(reservoirCellIndex < m_cellIndexToResultIndex.size());
return m_cellIndexToResultIndex[globalCellIndex] != cvf::UNDEFINED_SIZE_T;
return m_cellIndexToResultIndex[reservoirCellIndex] != cvf::UNDEFINED_SIZE_T;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RigActiveCellInfo::cellResultIndex(size_t globalCellIndex) const
size_t RigActiveCellInfo::cellResultIndex(size_t reservoirCellIndex) const
{
if (m_cellIndexToResultIndex.size() == 0)
{
return globalCellIndex;
return reservoirCellIndex;
}
CVF_TIGHT_ASSERT(globalCellIndex < m_cellIndexToResultIndex.size());
CVF_TIGHT_ASSERT(reservoirCellIndex < m_cellIndexToResultIndex.size());
return m_cellIndexToResultIndex[globalCellIndex];
return m_cellIndexToResultIndex[reservoirCellIndex];
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigActiveCellInfo::setCellResultIndex(size_t globalCellIndex, size_t globalCellResultIndex)
void RigActiveCellInfo::setCellResultIndex(size_t reservoirCellIndex, size_t globalCellResultIndex)
{
CVF_TIGHT_ASSERT(globalCellResultIndex < m_cellIndexToResultIndex.size());
m_cellIndexToResultIndex[globalCellIndex] = globalCellResultIndex;
m_cellIndexToResultIndex[reservoirCellIndex] = globalCellResultIndex;
if (globalCellResultIndex >= m_globalCellResultCount)
{

6
ApplicationCode/ReservoirDataModel/RigActiveCellInfo.h
View File

@ -38,9 +38,9 @@ public:
size_t globalCellResultCount() const;
bool isCoarseningActive() const;
bool isActive(size_t globalCellIndex) const;
size_t cellResultIndex(size_t globalCellIndex) const;
void setCellResultIndex(size_t globalCellIndex, size_t globalResultCellIndex);
bool isActive(size_t reservoirCellIndex) const;
size_t cellResultIndex(size_t reservoirCellIndex) const;
void setCellResultIndex(size_t reservoirCellIndex, size_t globalResultCellIndex);
void setGridCount(size_t gridCount);
void setGridActiveCellCounts(size_t gridIndex, size_t activeCellCount);

2
ApplicationCode/ReservoirDataModel/RigFault.cpp
View File

@ -115,7 +115,7 @@ void RigFault::computeFaultFacesFromCellRanges(const RigMainGrid* mainGrid)
}
// Do not need to compute global grid cell index as for a maingrid localIndex == globalIndex
//size_t globalCellIndex = grid->globalGridCellIndex(gridLocalCellIndex);
//size_t reservoirCellIndex = grid->globalGridCellIndex(gridLocalCellIndex);
size_t ni, nj, nk;
mainGrid->neighborIJKAtCellFace(i, j, k, faceEnum, &ni, &nj, &nk);

8
ApplicationCode/ReservoirDataModel/RigFault.h
View File

@ -46,14 +46,14 @@ public:
m_faultIdxForCellFace.resize(globalCellCount, initVal);
}
inline int faultIdx(size_t globalCellIdx, cvf::StructGridInterface::FaceType face)
inline int faultIdx(size_t reservoirCellIndex, cvf::StructGridInterface::FaceType face)
{
return m_faultIdxForCellFace[globalCellIdx][face];
return m_faultIdxForCellFace[reservoirCellIndex][face];
}
inline void setFaultIdx(size_t globalCellIdx, cvf::StructGridInterface::FaceType face, int faultIdx)
inline void setFaultIdx(size_t reservoirCellIndex, cvf::StructGridInterface::FaceType face, int faultIdx)
{
m_faultIdxForCellFace[globalCellIdx][face] = faultIdx;
m_faultIdxForCellFace[reservoirCellIndex][face] = faultIdx;
}
private:

4
ApplicationCode/ReservoirDataModel/RigNNCData.cpp
View File

@ -164,12 +164,12 @@ void RigNNCData::processConnections(const RigMainGrid& mainGrid)
//--------------------------------------------------------------------------------------------------
/// TODO: Possibly not needed !
//--------------------------------------------------------------------------------------------------
const std::vector<size_t>& RigNNCData::findConnectionIndices( size_t globalCellIndex, cvf::StructGridInterface::FaceType face) const
const std::vector<size_t>& RigNNCData::findConnectionIndices( size_t reservoirCellIndex, cvf::StructGridInterface::FaceType face) const
{
ConnectionSearchMap::const_iterator it;
static std::vector<size_t> empty;
it = m_cellIdxToFaceToConnectionIdxMap.find(globalCellIndex);
it = m_cellIdxToFaceToConnectionIdxMap.find(reservoirCellIndex);
if (it != m_cellIdxToFaceToConnectionIdxMap.end())
{
return it->second[face];

2
ApplicationCode/ReservoirDataModel/RigNNCData.h
View File

@ -63,7 +63,7 @@ public:
const std::vector<RigConnection>& connections() const { return m_connections; };
private: // This section is possibly not needed
//const std::vector<size_t>& findConnectionIndices(size_t globalCellIndex, cvf::StructGridInterface::FaceType face) const;
//const std::vector<size_t>& findConnectionIndices(size_t reservoirCellIndex, cvf::StructGridInterface::FaceType face) const;
//typedef std::map<size_t, caf::FixedArray<std::vector<size_t>, 7 > > ConnectionSearchMap;
//ConnectionSearchMap m_cellIdxToFaceToConnectionIdxMap;

12
ApplicationCode/SocketInterface/RiaGeometryCommands.cpp
View File

@ -177,11 +177,11 @@ public:
{
quint64 valueIndex = 0;
for (size_t globalCellIdx = 0; globalCellIdx < mainGrid->cells().size(); globalCellIdx++)
for (size_t reservoirCellIndex = 0; reservoirCellIndex < mainGrid->cells().size(); reservoirCellIndex++)
{
if (!actCellInfo->isActive(globalCellIdx)) continue;
if (!actCellInfo->isActive(reservoirCellIndex)) continue;
cvf::Vec3d center = mainGrid->cells()[globalCellIdx].center();
cvf::Vec3d center = mainGrid->cells()[reservoirCellIndex].center();
doubleValues[valueIndex++] = center[coordIdx];
}
@ -351,11 +351,11 @@ public:
quint64 valueIndex = 0;
for (size_t globalCellIdx = 0; globalCellIdx < mainGrid->cells().size(); globalCellIdx++)
for (size_t reservoirCellIndex = 0; reservoirCellIndex < mainGrid->cells().size(); reservoirCellIndex++)
{
if (!actCellInfo->isActive(globalCellIdx)) continue;
if (!actCellInfo->isActive(reservoirCellIndex)) continue;
mainGrid->cellCornerVertices(globalCellIdx, cornerVerts);
mainGrid->cellCornerVertices(reservoirCellIndex, cornerVerts);
doubleValues[valueIndex++] = cornerVerts[cornerIndexMapping][coordIdx];
}