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

(#707) Renamed to make the use of resultWellIndex more clear

Browse Source
This commit is contained in:
Jacob Støren 2015-12-11 17:45:09 +01:00
parent d01367a932
commit 2a98f5b116
9 changed files with 39 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ApplicationCode/ModelVisualization/RivCellEdgeGeometryUtils.cpp
View File

@ -86,12 +86,12 @@ void RivCellEdgeGeometryUtils::addCellEdgeResultsToDrawableGeo(
double ignoredScalarValue = cellEdgeResultColors->ignoredScalarValue();
const std::vector<cvf::ubyte>* isWellPipeVisible = NULL;
cvf::ref<cvf::UIntArray> gridCellToWellindexMap;
cvf::cref<cvf::UIntArray> gridCellToWellindexMap;
if (opacityLevel < 1.0f)
{
isWellPipeVisible = &(cellResultColors->reservoirView()->wellCollection()->isWellPipesVisible(timeStepIndex));
gridCellToWellindexMap = eclipseCase->gridCellToWellIndex(gridIndex);
isWellPipeVisible = &(cellResultColors->reservoirView()->wellCollection()->resultWellPipeVisibilities(timeStepIndex));
gridCellToWellindexMap = eclipseCase->gridCellToResultWellIndex(gridIndex);
}
#pragma omp parallel for

5
ApplicationCode/ModelVisualization/RivTernaryTextureCoordsCreator.cpp
View File

@ -62,8 +62,9 @@ RivTernaryTextureCoordsCreator::RivTernaryTextureCoordsCreator(
m_resultAccessor = new RigTernaryResultAccessor();
m_resultAccessor->setTernaryResultAccessors(soil.p(), sgas.p(), swat.p());
cvf::ref<RigPipeInCellEvaluator> pipeInCellEval = new RigPipeInCellEvaluator(cellResultColors->reservoirView()->wellCollection()->isWellPipesVisible(timeStepIndex),
eclipseCase->gridCellToWellIndex(gridIndex));
cvf::ref<RigPipeInCellEvaluator> pipeInCellEval =
new RigPipeInCellEvaluator(cellResultColors->reservoirView()->wellCollection()->resultWellPipeVisibilities(timeStepIndex),
eclipseCase->gridCellToResultWellIndex(gridIndex));
const RivTernaryScalarMapper* mapper = ternaryLegendConfig->scalarMapper();

5
ApplicationCode/ModelVisualization/RivTextureCoordsCreator.cpp
View File

@ -41,8 +41,9 @@ RivTextureCoordsCreator::RivTextureCoordsCreator(RimEclipseCellColors* cellResul
m_resultAccessor = RigResultAccessorFactory::createResultAccessor(eclipseCase, gridIndex, timeStepIndex, cellResultColors);
cvf::ref<RigPipeInCellEvaluator> pipeInCellEval = new RigPipeInCellEvaluator(cellResultColors->reservoirView()->wellCollection()->isWellPipesVisible(timeStepIndex),
eclipseCase->gridCellToWellIndex(gridIndex));
cvf::ref<RigPipeInCellEvaluator> pipeInCellEval =
new RigPipeInCellEvaluator(cellResultColors->reservoirView()->wellCollection()->resultWellPipeVisibilities(timeStepIndex),
eclipseCase->gridCellToResultWellIndex(gridIndex));
const cvf::ScalarMapper* mapper = cellResultColors->legendConfig()->scalarMapper();

2
ApplicationCode/ProjectDataModel/RimEclipseWell.cpp
View File

@ -257,7 +257,7 @@ bool RimEclipseWell::isWellPipeVisible(size_t frameIndex)
CVF_ASSERT(m_resultWellIndex != cvf::UNDEFINED_SIZE_T);
// Return the possibly cached value
return m_reservoirView->wellCollection()->isWellPipesVisible(frameIndex)[m_resultWellIndex];
return m_reservoirView->wellCollection()->resultWellPipeVisibilities(frameIndex)[m_resultWellIndex];
}
//--------------------------------------------------------------------------------------------------

18
ApplicationCode/ProjectDataModel/RimEclipseWellCollection.cpp
View File

@ -301,10 +301,10 @@ caf::PdmFieldHandle* RimEclipseWellCollection::objectToggleField()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<cvf::ubyte>& RimEclipseWellCollection::isWellPipesVisible(size_t frameIndex)
const std::vector<cvf::ubyte>& RimEclipseWellCollection::resultWellPipeVisibilities(size_t frameIndex)
{
calculateIsWellPipesVisible(frameIndex);
return m_isWellPipesVisible[frameIndex];
return m_framesOfResultWellPipeVisibilities[frameIndex];
}
//--------------------------------------------------------------------------------------------------
@ -312,7 +312,7 @@ const std::vector<cvf::ubyte>& RimEclipseWellCollection::isWellPipesVisible(size
//--------------------------------------------------------------------------------------------------
void RimEclipseWellCollection::scheduleIsWellPipesVisibleRecalculation()
{
m_isWellPipesVisible.clear();
m_framesOfResultWellPipeVisibilities.clear();
}
//--------------------------------------------------------------------------------------------------
@ -320,17 +320,17 @@ void RimEclipseWellCollection::scheduleIsWellPipesVisibleRecalculation()
//--------------------------------------------------------------------------------------------------
void RimEclipseWellCollection::calculateIsWellPipesVisible(size_t frameIndex)
{
if (m_isWellPipesVisible.size() > frameIndex && m_isWellPipesVisible[frameIndex].size()) return;
if (m_framesOfResultWellPipeVisibilities.size() > frameIndex && m_framesOfResultWellPipeVisibilities[frameIndex].size()) return;
if (m_isWellPipesVisible.size() <= frameIndex)
m_isWellPipesVisible.resize(frameIndex+1);
if (m_framesOfResultWellPipeVisibilities.size() <= frameIndex)
m_framesOfResultWellPipeVisibilities.resize(frameIndex+1);
if (m_isWellPipesVisible[frameIndex].size() <= wells().size())
m_isWellPipesVisible[frameIndex].resize(wells().size(), false);
if (m_framesOfResultWellPipeVisibilities[frameIndex].size() <= wells().size())
m_framesOfResultWellPipeVisibilities[frameIndex].resize(wells().size(), false);
for (size_t i = 0; i < wells().size(); ++i)
{
m_isWellPipesVisible[frameIndex][wells[i]->resultWellIndex()] = wells[i]->calculateWellPipeVisibility(frameIndex);
m_framesOfResultWellPipeVisibilities[frameIndex][wells[i]->resultWellIndex()] = wells[i]->calculateWellPipeVisibility(frameIndex);
}
}

4
ApplicationCode/ProjectDataModel/RimEclipseWellCollection.h
View File

@ -109,7 +109,7 @@ public:
bool hasVisibleWellPipes();
void sortWellsByName();
const std::vector<cvf::ubyte>& isWellPipesVisible(size_t frameIndex);
const std::vector<cvf::ubyte>& resultWellPipeVisibilities(size_t frameIndex);
void scheduleIsWellPipesVisibleRecalculation();
protected:
@ -122,5 +122,5 @@ private:
RimEclipseView* m_reservoirView;
std::vector< std::vector< cvf::ubyte > >
m_isWellPipesVisible;
m_framesOfResultWellPipeVisibilities;
};

22
ApplicationCode/ReservoirDataModel/RigCaseData.cpp
View File

@ -143,7 +143,7 @@ void RigCaseData::computeWellCellsPrGrid()
// Allocate and initialize the arrays
m_wellCellsInGrid.resize(grids.size());
m_gridCellToWellIndex.resize(grids.size());
m_gridCellToResultWellIndex.resize(grids.size());
for (gIdx = 0; gIdx < grids.size(); ++gIdx)
{
@ -152,11 +152,11 @@ void RigCaseData::computeWellCellsPrGrid()
m_wellCellsInGrid[gIdx] = new cvf::UByteArray;
m_wellCellsInGrid[gIdx]->resize(grids[gIdx]->cellCount());
m_gridCellToWellIndex[gIdx] = new cvf::UIntArray;
m_gridCellToWellIndex[gIdx]->resize(grids[gIdx]->cellCount());
m_gridCellToResultWellIndex[gIdx] = new cvf::UIntArray;
m_gridCellToResultWellIndex[gIdx]->resize(grids[gIdx]->cellCount());
}
m_wellCellsInGrid[gIdx]->setAll(false);
m_gridCellToWellIndex[gIdx]->setAll(cvf::UNDEFINED_UINT);
m_gridCellToResultWellIndex[gIdx]->setAll(cvf::UNDEFINED_UINT);
}
// Fill arrays with data
@ -178,7 +178,7 @@ void RigCaseData::computeWellCellsPrGrid()
|| m_fractureActiveCellInfo->isActive(reservoirCellIndex))
{
m_wellCellsInGrid[gridIndex]->set(gridCellIndex, true);
m_gridCellToWellIndex[gridIndex]->set(gridCellIndex, static_cast<cvf::uint>(wIdx));
m_gridCellToResultWellIndex[gridIndex]->set(gridCellIndex, static_cast<cvf::uint>(wIdx));
}
}
@ -195,7 +195,7 @@ void RigCaseData::computeWellCellsPrGrid()
if(gridIndex < m_wellCellsInGrid.size() && gridCellIndex < m_wellCellsInGrid[gridIndex]->size())
{
m_wellCellsInGrid[gridIndex]->set(gridCellIndex, true);
m_gridCellToWellIndex[gridIndex]->set(gridCellIndex, static_cast<cvf::uint>(wIdx));
m_gridCellToResultWellIndex[gridIndex]->set(gridCellIndex, static_cast<cvf::uint>(wIdx));
}
}
}
@ -210,7 +210,7 @@ void RigCaseData::setWellResults(const cvf::Collection<RigSingleWellResultsData>
{
m_wellResults = data;
m_wellCellsInGrid.clear();
m_gridCellToWellIndex.clear();
m_gridCellToResultWellIndex.clear();
computeWellCellsPrGrid();
}
@ -218,7 +218,7 @@ void RigCaseData::setWellResults(const cvf::Collection<RigSingleWellResultsData>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::UByteArray* RigCaseData::wellCellsInGrid(size_t gridIndex)
const cvf::UByteArray* RigCaseData::wellCellsInGrid(size_t gridIndex)
{
computeWellCellsPrGrid();
CVF_ASSERT(gridIndex < m_wellCellsInGrid.size());
@ -230,12 +230,12 @@ cvf::UByteArray* RigCaseData::wellCellsInGrid(size_t gridIndex)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::UIntArray* RigCaseData::gridCellToWellIndex(size_t gridIndex)
const cvf::UIntArray* RigCaseData::gridCellToResultWellIndex(size_t gridIndex)
{
computeWellCellsPrGrid();
CVF_ASSERT(gridIndex < m_gridCellToWellIndex.size());
CVF_ASSERT(gridIndex < m_gridCellToResultWellIndex.size());
return m_gridCellToWellIndex[gridIndex].p();
return m_gridCellToResultWellIndex[gridIndex].p();
}
//--------------------------------------------------------------------------------------------------

6
ApplicationCode/ReservoirDataModel/RigCaseData.h
View File

@ -66,8 +66,8 @@ public:
void setWellResults(const cvf::Collection<RigSingleWellResultsData>& data);
const cvf::Collection<RigSingleWellResultsData>& wellResults() { return m_wellResults; }
cvf::UByteArray* wellCellsInGrid(size_t gridIndex);
cvf::UIntArray* gridCellToWellIndex(size_t gridIndex);
const cvf::UByteArray* wellCellsInGrid(size_t gridIndex);
const cvf::UIntArray* gridCellToResultWellIndex(size_t gridIndex);
RigCell& cellFromWellResultCell(const RigWellResultPoint& wellResultCell);
bool findSharedSourceFace(cvf::StructGridInterface::FaceType& sharedSourceFace, const RigWellResultPoint& sourceWellCellResult, const RigWellResultPoint& otherWellCellResult) const;
@ -92,7 +92,7 @@ private:
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
cvf::Collection<cvf::UIntArray> m_gridCellToWellIndex; //< Array pr grid with index to well pr cell telling which well a cell is in
cvf::Collection<cvf::UIntArray> m_gridCellToResultWellIndex; //< Array pr grid with index to well pr cell telling which well a cell is in
UnitsType m_unitsType;
};

8
ApplicationCode/ReservoirDataModel/RigPipeInCellEvaluator.h
View File

@ -27,10 +27,10 @@
class RigPipeInCellEvaluator: public cvf::Object
{
public:
RigPipeInCellEvaluator(const std::vector<cvf::ubyte>& isWellPipeVisibleForWellIndex,
const cvf::UIntArray* gridCellToWellIndexMap)
: m_isWellPipeVisibleForWellIndex(isWellPipeVisibleForWellIndex),
m_gridCellToWellIndexMap(gridCellToWellIndexMap)
RigPipeInCellEvaluator(const std::vector<cvf::ubyte>& isWellPipeVisibleForResultWellIndex,
const cvf::UIntArray* gridCellToResultWellIndexMap)
: m_isWellPipeVisibleForWellIndex(isWellPipeVisibleForResultWellIndex),
m_gridCellToWellIndexMap(gridCellToResultWellIndexMap)
{
}