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

Whitespace

Browse Source
This commit is contained in:
Magne Sjaastad 2019-02-18 11:15:34 +01:00
parent 7fe0b92839
commit 3acd426ead
3 changed files with 629 additions and 580 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

140
ApplicationCode/ModelVisualization/RivReservoirViewPartMgr.cpp
View File

@ -22,9 +22,9 @@
#include "RigActiveCellInfo.h"
#include "RigCaseCellResultsData.h"
#include "RigEclipseCaseData.h"
#include "RigCaseToCaseCellMapper.h"
#include "RigCell.h"
#include "RigEclipseCaseData.h"
#include "RigGridBase.h"
#include "RigResultAccessorFactory.h"
@ -51,14 +51,13 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RivReservoirViewPartMgr::RivReservoirViewPartMgr(RimEclipseView * resv) :
m_reservoirView(resv)
RivReservoirViewPartMgr::RivReservoirViewPartMgr(RimEclipseView* resv)
: m_reservoirView(resv)
{
m_scaleTransform = new cvf::Transform();
clearGeometryCache();
}
//--------------------------------------------------------------------------------------------------
/// Clears the geometry cache for the given, and the dependent geometryTypes (from a visibility standpoint)
//--------------------------------------------------------------------------------------------------
@ -212,7 +211,8 @@ void RivReservoirViewPartMgr::clearGeometryCache()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivReservoirViewPartMgr::appendStaticGeometryPartsToModel(cvf::ModelBasicList* model, RivCellSetEnum geometryType,
void RivReservoirViewPartMgr::appendStaticGeometryPartsToModel(cvf::ModelBasicList* model,
RivCellSetEnum geometryType,
const std::vector<size_t>& gridIndices)
{
ensureStaticGeometryPartsCreated(geometryType);
@ -234,8 +234,10 @@ void RivReservoirViewPartMgr::ensureStaticGeometryPartsCreated(RivCellSetEnum ge
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivReservoirViewPartMgr::appendDynamicGeometryPartsToModel(cvf::ModelBasicList* model, RivCellSetEnum geometryType,
size_t frameIndex, const std::vector<size_t>& gridIndices)
void RivReservoirViewPartMgr::appendDynamicGeometryPartsToModel(cvf::ModelBasicList* model,
RivCellSetEnum geometryType,
size_t frameIndex,
const std::vector<size_t>& gridIndices)
{
ensureDynamicGeometryPartsCreated(geometryType, frameIndex);
@ -263,7 +265,8 @@ void RivReservoirViewPartMgr::ensureDynamicGeometryPartsCreated(RivCellSetEnum g
}
else if (geometryType == PROPERTY_FILTERED_WELL_CELLS)
{
if (frameIndex >= m_propFilteredWellGeometryFramesNeedsRegen.size() || m_propFilteredWellGeometryFramesNeedsRegen[frameIndex])
if (frameIndex >= m_propFilteredWellGeometryFramesNeedsRegen.size() ||
m_propFilteredWellGeometryFramesNeedsRegen[frameIndex])
{
createPropertyFilteredWellGeometry(frameIndex);
}
@ -297,7 +300,10 @@ void RivReservoirViewPartMgr::createGeometry(RivCellSetEnum geometryType)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivReservoirViewPartMgr::computeVisibility(cvf::UByteArray* cellVisibility, RivCellSetEnum geometryType, RigGridBase* grid, size_t gridIdx)
void RivReservoirViewPartMgr::computeVisibility(cvf::UByteArray* cellVisibility,
RivCellSetEnum geometryType,
RigGridBase* grid,
size_t gridIdx)
{
RigEclipseCaseData* eclipseCase = m_reservoirView->eclipseCase()->eclipseCaseData();
auto activeCellInfo = m_reservoirView->currentActiveCellInfo();
@ -308,7 +314,8 @@ void RivReservoirViewPartMgr::computeVisibility(cvf::UByteArray* cellVisibility,
computeOverriddenCellVisibility(cellVisibility, grid);
break;
case ACTIVE:
computeNativeVisibility(cellVisibility, grid, activeCellInfo, eclipseCase->wellCellsInGrid(gridIdx), false, false, true);
computeNativeVisibility(
cellVisibility, grid, activeCellInfo, eclipseCase->wellCellsInGrid(gridIdx), false, false, true);
break;
case ALL_WELL_CELLS:
copyByteArray(cellVisibility, eclipseCase->wellCellsInGrid(gridIdx));
@ -346,7 +353,13 @@ void RivReservoirViewPartMgr::computeVisibility(cvf::UByteArray* cellVisibility,
}
break;
case INACTIVE:
computeNativeVisibility(cellVisibility, grid, activeCellInfo, eclipseCase->wellCellsInGrid(gridIdx), m_reservoirView->showInvalidCells(), true, false);
computeNativeVisibility(cellVisibility,
grid,
activeCellInfo,
eclipseCase->wellCellsInGrid(gridIdx),
m_reservoirView->showInvalidCells(),
true,
false);
break;
case RANGE_FILTERED:
{
@ -354,7 +367,8 @@ void RivReservoirViewPartMgr::computeVisibility(cvf::UByteArray* cellVisibility,
ensureStaticGeometryPartsCreated(ACTIVE);
nativeVisibility = m_geometries[ACTIVE].cellVisibility(gridIdx);
computeRangeVisibility(geometryType, cellVisibility, grid, nativeVisibility.p(), m_reservoirView->rangeFilterCollection());
computeRangeVisibility(
geometryType, cellVisibility, grid, nativeVisibility.p(), m_reservoirView->rangeFilterCollection());
}
break;
case RANGE_FILTERED_INACTIVE:
@ -363,7 +377,8 @@ void RivReservoirViewPartMgr::computeVisibility(cvf::UByteArray* cellVisibility,
ensureStaticGeometryPartsCreated(INACTIVE);
nativeVisibility = m_geometries[INACTIVE].cellVisibility(gridIdx);
computeRangeVisibility(geometryType, cellVisibility, grid, nativeVisibility.p(), m_reservoirView->rangeFilterCollection());
computeRangeVisibility(
geometryType, cellVisibility, grid, nativeVisibility.p(), m_reservoirView->rangeFilterCollection());
}
break;
case RANGE_FILTERED_WELL_CELLS:
@ -372,7 +387,8 @@ void RivReservoirViewPartMgr::computeVisibility(cvf::UByteArray* cellVisibility,
ensureStaticGeometryPartsCreated(ALL_WELL_CELLS);
nativeVisibility = m_geometries[ALL_WELL_CELLS].cellVisibility(gridIdx);
computeRangeVisibility(geometryType, cellVisibility, grid, nativeVisibility.p(), m_reservoirView->rangeFilterCollection());
computeRangeVisibility(
geometryType, cellVisibility, grid, nativeVisibility.p(), m_reservoirView->rangeFilterCollection());
}
break;
case VISIBLE_WELL_CELLS_OUTSIDE_RANGE_FILTER:
@ -436,7 +452,8 @@ void RivReservoirViewPartMgr::createPropertyFilteredNoneWellCellGeometry(size_t
if (m_propFilteredGeometryFrames[frameIndex].isNull()) m_propFilteredGeometryFrames[frameIndex] = new RivReservoirPartMgr;
m_propFilteredGeometryFrames[frameIndex]->clearAndSetReservoir(PROPERTY_FILTERED, m_reservoirView->eclipseCase(), m_reservoirView);
m_propFilteredGeometryFrames[frameIndex]->clearAndSetReservoir(
PROPERTY_FILTERED, m_reservoirView->eclipseCase(), m_reservoirView);
m_propFilteredGeometryFrames[frameIndex]->setTransform(m_scaleTransform.p());
std::vector<RigGridBase*> grids;
@ -489,7 +506,8 @@ void RivReservoirViewPartMgr::createPropertyFilteredNoneWellCellGeometry(size_t
(*cellVisibility)[cellIdx] = (*rangeVisibility)[cellIdx] || (*fenceVisibility)[cellIdx];
}
computePropertyVisibility(cellVisibility.p(), grids[gIdx], frameIndex, cellVisibility.p(), m_reservoirView->eclipsePropertyFilterCollection());
computePropertyVisibility(
cellVisibility.p(), grids[gIdx], frameIndex, cellVisibility.p(), m_reservoirView->eclipsePropertyFilterCollection());
m_propFilteredGeometryFrames[frameIndex]->setCellVisibility(gIdx, cellVisibility.p());
}
@ -510,9 +528,11 @@ void RivReservoirViewPartMgr::createPropertyFilteredWellGeometry(size_t frameInd
m_propFilteredWellGeometryFramesNeedsRegen.resize(frameIndex + 1, true);
}
if ( m_propFilteredWellGeometryFrames[frameIndex].isNull()) m_propFilteredWellGeometryFrames[frameIndex] = new RivReservoirPartMgr;
if (m_propFilteredWellGeometryFrames[frameIndex].isNull())
m_propFilteredWellGeometryFrames[frameIndex] = new RivReservoirPartMgr;
m_propFilteredWellGeometryFrames[frameIndex]->clearAndSetReservoir(PROPERTY_FILTERED_WELL_CELLS, m_reservoirView->eclipseCase(), m_reservoirView);
m_propFilteredWellGeometryFrames[frameIndex]->clearAndSetReservoir(
PROPERTY_FILTERED_WELL_CELLS, m_reservoirView->eclipseCase(), m_reservoirView);
m_propFilteredWellGeometryFrames[frameIndex]->setTransform(m_scaleTransform.p());
std::vector<RigGridBase*> grids;
@ -538,7 +558,6 @@ void RivReservoirViewPartMgr::createPropertyFilteredWellGeometry(size_t frameInd
ensureStaticGeometryPartsCreated(VISIBLE_WELL_FENCE_CELLS_OUTSIDE_RANGE_FILTER);
wellFenceCells = m_geometries[VISIBLE_WELL_FENCE_CELLS_OUTSIDE_RANGE_FILTER].cellVisibility(gIdx);
}
else if (hasActiveRangeFilters && !hasVisibleWellCells)
{
@ -570,10 +589,12 @@ void RivReservoirViewPartMgr::createPropertyFilteredWellGeometry(size_t frameInd
#pragma omp parallel for
for (int cellIdx = 0; cellIdx < static_cast<int>(cellVisibility->size()); ++cellIdx)
{
(*cellVisibility)[cellIdx] = (*wellFenceCells)[cellIdx] || (*rangeVisibility)[cellIdx] || (*wellCellsOutsideRange)[cellIdx];
(*cellVisibility)[cellIdx] =
(*wellFenceCells)[cellIdx] || (*rangeVisibility)[cellIdx] || (*wellCellsOutsideRange)[cellIdx];
}
computePropertyVisibility(cellVisibility.p(), grids[gIdx], frameIndex, cellVisibility.p(), m_reservoirView->eclipsePropertyFilterCollection());
computePropertyVisibility(
cellVisibility.p(), grids[gIdx], frameIndex, cellVisibility.p(), m_reservoirView->eclipsePropertyFilterCollection());
m_propFilteredWellGeometryFrames[frameIndex]->setCellVisibility(gIdx, cellVisibility.p());
}
@ -584,7 +605,10 @@ void RivReservoirViewPartMgr::createPropertyFilteredWellGeometry(size_t frameInd
//--------------------------------------------------------------------------------------------------
/// Evaluate visibility based on cell state
//--------------------------------------------------------------------------------------------------
void RivReservoirViewPartMgr::computeNativeVisibility(cvf::UByteArray* cellVisibility, const RigGridBase* grid, const RigActiveCellInfo* activeCellInfo, const cvf::UByteArray* cellIsInWellStatuses,
void RivReservoirViewPartMgr::computeNativeVisibility(cvf::UByteArray* cellVisibility,
const RigGridBase* grid,
const RigActiveCellInfo* activeCellInfo,
const cvf::UByteArray* cellIsInWellStatuses,
bool invalidCellsIsVisible,
bool inactiveCellsIsVisible,
bool activeCellsIsVisible)
@ -603,11 +627,9 @@ void RivReservoirViewPartMgr::computeNativeVisibility(cvf::UByteArray* cellVisib
const RigCell& cell = grid->cell(cellIndex);
size_t reservoirCellIndex = cell.mainGridCellIndex();
if ( !invalidCellsIsVisible && cell.isInvalid()
|| !inactiveCellsIsVisible && !activeCellInfo->isActive(reservoirCellIndex)
|| !activeCellsIsVisible && activeCellInfo->isActive(reservoirCellIndex)
|| (*cellIsInWellStatuses)[cellIndex]
)
if (!invalidCellsIsVisible && cell.isInvalid() ||
!inactiveCellsIsVisible && !activeCellInfo->isActive(reservoirCellIndex) ||
!activeCellsIsVisible && activeCellInfo->isActive(reservoirCellIndex) || (*cellIsInWellStatuses)[cellIndex])
{
(*cellVisibility)[cellIndex] = false;
}
@ -623,7 +645,6 @@ void RivReservoirViewPartMgr::computeNativeVisibility(cvf::UByteArray* cellVisib
//--------------------------------------------------------------------------------------------------
void RivReservoirViewPartMgr::computeOverriddenCellVisibility(cvf::UByteArray* cellVisibility, const RigGridBase* grid)
{
RimViewController* masterViewLink = m_reservoirView->viewController();
CVF_ASSERT(masterViewLink);
@ -635,7 +656,8 @@ void RivReservoirViewPartMgr::computeOverriddenCellVisibility(cvf::UByteArray* c
cvf::ref<cvf::UByteArray> totCellVisibility = masterView->currentTotalCellVisibility();
#else
// Could get something more like
std::vector<std::vector<cvf::UByteArray*> > gridsWithCellSetVisibility = masterView->getAllGridsCurrentCellSetsCellVisibility();
std::vector<std::vector<cvf::UByteArray*>> gridsWithCellSetVisibility =
masterView->getAllGridsCurrentCellSetsCellVisibility();
#endif
CVF_ASSERT(cellVisibility != nullptr);
@ -668,16 +690,14 @@ void RivReservoirViewPartMgr::computeOverriddenCellVisibility(cvf::UByteArray* c
int cellSetCount = gridsWithCellSetVisibility[masterCaseCells.gridIndex[mcIdx]].size();
for (int csIdx = 0; csIdx < cellSetCount; ++csIdx)
{
(*cellVisibility)[lcIdx] |= gridsWithCellSetVisibility[masterCaseCells.gridIndex[mcIdx]][masterCaseCells.cellIndex[mcIdx]];
(*cellVisibility)[lcIdx] |=
gridsWithCellSetVisibility[masterCaseCells.gridIndex[mcIdx]][masterCaseCells.cellIndex[mcIdx]];
}
}
#endif
}
}
//--------------------------------------------------------------------------------------------------
/// Copy the data from source into destination. This is not trivial to do using cvf::Array ...
/// using parallelized operator [] and not memcopy. Do not know what is faster.
@ -699,7 +719,6 @@ void RivReservoirViewPartMgr::copyByteArray(cvf::UByteArray* destination, const
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -737,7 +756,8 @@ void RivReservoirViewPartMgr::computeRangeVisibility(RivCellSetEnum geometryType
if (geometryType == RANGE_FILTERED_WELL_CELLS)
{
geometryType = RANGE_FILTERED; // Use the range filtering in the parent grid, not the well cells in the parent grid
geometryType =
RANGE_FILTERED; // Use the range filtering in the parent grid, not the well cells in the parent grid
}
RivReservoirPartMgr* reservoirGridPartMgr = &m_geometries[geometryType];
@ -745,7 +765,8 @@ void RivReservoirViewPartMgr::computeRangeVisibility(RivCellSetEnum geometryType
parentGridVisibilities = reservoirGridPartMgr->cellVisibility(parentGridIndex);
}
bool hasAdditiveRangeFilters = rangeFilterColl->hasActiveIncludeFilters() || m_reservoirView->wellCollection()->hasVisibleWellCells();
bool hasAdditiveRangeFilters =
rangeFilterColl->hasActiveIncludeFilters() || m_reservoirView->wellCollection()->hasVisibleWellCells();
#pragma omp parallel for
for (int cellIndex = 0; cellIndex < static_cast<int>(grid->cellCount()); cellIndex++)
@ -780,8 +801,9 @@ void RivReservoirViewPartMgr::computeRangeVisibility(RivCellSetEnum geometryType
nativeRangeVisibility = (*nativeVisibility)[cellIndex];
}
(*cellVisibility)[cellIndex] = (visibleDueToParentGrid || nativeRangeVisibility)
&& !gridCellRangeFilter.isCellExcluded(mainGridI, mainGridJ, mainGridK, isInSubGridArea);
(*cellVisibility)[cellIndex] =
(visibleDueToParentGrid || nativeRangeVisibility) &&
!gridCellRangeFilter.isCellExcluded(mainGridI, mainGridJ, mainGridK, isInSubGridArea);
}
}
}
@ -790,8 +812,11 @@ void RivReservoirViewPartMgr::computeRangeVisibility(RivCellSetEnum geometryType
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivReservoirViewPartMgr::computePropertyVisibility(cvf::UByteArray* cellVisibility, const RigGridBase* grid, size_t timeStepIndex,
const cvf::UByteArray* rangeFilterVisibility, RimEclipsePropertyFilterCollection* propFilterColl)
void RivReservoirViewPartMgr::computePropertyVisibility(cvf::UByteArray* cellVisibility,
const RigGridBase* grid,
size_t timeStepIndex,
const cvf::UByteArray* rangeFilterVisibility,
RimEclipsePropertyFilterCollection* propFilterColl)
{
CVF_ASSERT(cellVisibility != nullptr);
CVF_ASSERT(rangeFilterVisibility != nullptr);
@ -815,7 +840,8 @@ void RivReservoirViewPartMgr::computePropertyVisibility(cvf::UByteArray* cellVis
RigEclipseCaseData* eclipseCase = propFilterColl->reservoirView()->eclipseCase()->eclipseCaseData();
cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createFromResultDefinition(eclipseCase, grid->gridIndex(), timeStepIndex, propertyFilter->resultDefinition());
cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createFromResultDefinition(
eclipseCase, grid->gridIndex(), timeStepIndex, propertyFilter->resultDefinition());
CVF_ASSERT(resultAccessor.notNull());
@ -899,7 +925,9 @@ void RivReservoirViewPartMgr::updateCellColor(RivCellSetEnum geometryType, size_
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivReservoirViewPartMgr::updateCellResultColor(RivCellSetEnum geometryType, size_t timeStepIndex, RimEclipseCellColors* cellResultColors)
void RivReservoirViewPartMgr::updateCellResultColor(RivCellSetEnum geometryType,
size_t timeStepIndex,
RimEclipseCellColors* cellResultColors)
{
RivReservoirPartMgr* pmgr = reservoirPartManager(geometryType, timeStepIndex);
pmgr->updateCellResultColor(timeStepIndex, cellResultColors);
@ -908,7 +936,10 @@ void RivReservoirViewPartMgr::updateCellResultColor(RivCellSetEnum geometryType,
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivReservoirViewPartMgr::updateCellEdgeResultColor(RivCellSetEnum geometryType, size_t timeStepIndex, RimEclipseCellColors* cellResultColors, RimCellEdgeColors* cellEdgeResultColors)
void RivReservoirViewPartMgr::updateCellEdgeResultColor(RivCellSetEnum geometryType,
size_t timeStepIndex,
RimEclipseCellColors* cellResultColors,
RimCellEdgeColors* cellEdgeResultColors)
{
RivReservoirPartMgr* pmgr = reservoirPartManager(geometryType, timeStepIndex);
pmgr->updateCellEdgeResultColor(timeStepIndex, cellResultColors, cellEdgeResultColors);
@ -917,7 +948,10 @@ void RivReservoirViewPartMgr::updateCellEdgeResultColor(RivCellSetEnum geometryT
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivReservoirViewPartMgr::updateFaultCellEdgeResultColor(RivCellSetEnum geometryType, size_t timeStepIndex, RimEclipseCellColors* cellResultColors, RimCellEdgeColors* cellEdgeResultColors)
void RivReservoirViewPartMgr::updateFaultCellEdgeResultColor(RivCellSetEnum geometryType,
size_t timeStepIndex,
RimEclipseCellColors* cellResultColors,
RimCellEdgeColors* cellEdgeResultColors)
{
RivReservoirPartMgr* pmgr = reservoirPartManager(geometryType, timeStepIndex);
pmgr->updateFaultCellEdgeResultColor(timeStepIndex, cellResultColors, cellEdgeResultColors);
@ -926,7 +960,8 @@ void RivReservoirViewPartMgr::updateFaultCellEdgeResultColor(RivCellSetEnum geom
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const cvf::UByteArray* RivReservoirViewPartMgr::cellVisibility(RivCellSetEnum geometryType, size_t gridIndex, size_t timeStepIndex)
const cvf::UByteArray*
RivReservoirViewPartMgr::cellVisibility(RivCellSetEnum geometryType, size_t gridIndex, size_t timeStepIndex)
{
ensureDynamicGeometryPartsCreated(geometryType, timeStepIndex);
ensureStaticGeometryPartsCreated(geometryType);
@ -958,7 +993,9 @@ RivReservoirPartMgr* RivReservoirViewPartMgr::reservoirPartManager(RivCellSetEnu
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivReservoirViewPartMgr::updateFaultColors(RivCellSetEnum geometryType, size_t timeStepIndex, RimEclipseCellColors* cellResultColors)
void RivReservoirViewPartMgr::updateFaultColors(RivCellSetEnum geometryType,
size_t timeStepIndex,
RimEclipseCellColors* cellResultColors)
{
if (geometryType == PROPERTY_FILTERED && timeStepIndex >= m_propFilteredGeometryFrames.size())
{
@ -1042,7 +1079,9 @@ void RivReservoirViewPartMgr::appendFaultsStaticGeometryPartsToModel(cvf::ModelB
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivReservoirViewPartMgr::appendFaultsDynamicGeometryPartsToModel(cvf::ModelBasicList* model, RivCellSetEnum geometryType, size_t frameIndex)
void RivReservoirViewPartMgr::appendFaultsDynamicGeometryPartsToModel(cvf::ModelBasicList* model,
RivCellSetEnum geometryType,
size_t frameIndex)
{
if (geometryType == PROPERTY_FILTERED)
{
@ -1061,7 +1100,8 @@ void RivReservoirViewPartMgr::appendFaultsDynamicGeometryPartsToModel(cvf::Model
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RivCellSetEnum RivReservoirViewPartMgr::geometryTypeForFaultLabels(const std::set<RivCellSetEnum>& geometryTypes, bool showFaultsOutsideFilters) const
RivCellSetEnum RivReservoirViewPartMgr::geometryTypeForFaultLabels(const std::set<RivCellSetEnum>& geometryTypes,
bool showFaultsOutsideFilters) const
{
for (RivCellSetEnum cellSetType : geometryTypes)
{
@ -1094,7 +1134,9 @@ void RivReservoirViewPartMgr::appendFaultLabelsStaticGeometryPartsToModel(cvf::M
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivReservoirViewPartMgr::appendFaultLabelsDynamicGeometryPartsToModel(cvf::ModelBasicList* model, RivCellSetEnum geometryType, size_t frameIndex)
void RivReservoirViewPartMgr::appendFaultLabelsDynamicGeometryPartsToModel(cvf::ModelBasicList* model,
RivCellSetEnum geometryType,
size_t frameIndex)
{
m_propFilteredGeometryFrames[frameIndex]->appendFaultLabelPartsToModel(model);
}

27
ApplicationCode/ProjectDataModel/RimEclipsePropertyFilterCollection.cpp
View File

@ -29,7 +29,6 @@
#include "cafPdmUiEditorHandle.h"
CAF_PDM_SOURCE_INIT(RimEclipsePropertyFilterCollection, "CellPropertyFilters");
//--------------------------------------------------------------------------------------------------
@ -67,9 +66,8 @@ RimEclipseView* RimEclipsePropertyFilterCollection::reservoirView()
//--------------------------------------------------------------------------------------------------
void RimEclipsePropertyFilterCollection::loadAndInitializePropertyFilters()
{
for (size_t i = 0; i < propertyFilters.size(); i++)
for (RimEclipsePropertyFilter* propertyFilter : propertyFilters)
{
RimEclipsePropertyFilter* propertyFilter = propertyFilters[i];
propertyFilter->resultDefinition()->setEclipseCase(reservoirView()->eclipseCase());
propertyFilter->initAfterRead();
if (isActive() && propertyFilter->isActive())
@ -95,9 +93,8 @@ bool RimEclipsePropertyFilterCollection::hasActiveFilters() const
{
if (!isActive) return false;
for (size_t i = 0; i < propertyFilters.size(); i++)
for (RimEclipsePropertyFilter* propertyFilter : propertyFilters)
{
RimEclipsePropertyFilter* propertyFilter = propertyFilters[i];
if (propertyFilter->isActive() && propertyFilter->resultDefinition()->hasResult()) return true;
}
@ -111,16 +108,14 @@ bool RimEclipsePropertyFilterCollection::hasActiveDynamicFilters() const
{
if (!isActive) return false;
for (size_t i = 0; i < propertyFilters.size(); i++)
for (RimEclipsePropertyFilter* propertyFilter : propertyFilters)
{
RimEclipsePropertyFilter* propertyFilter = propertyFilters[i];
if (propertyFilter->isActive() && propertyFilter->resultDefinition()->hasDynamicResult()) return true;
}
return false;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -128,12 +123,11 @@ bool RimEclipsePropertyFilterCollection::isUsingFormationNames() const
{
if (!isActive) return false;
for ( size_t i = 0; i < propertyFilters.size(); i++ )
for (RimEclipsePropertyFilter* propertyFilter : propertyFilters)
{
RimEclipsePropertyFilter* propertyFilter = propertyFilters[i];
if ( propertyFilter->isActive()
&& propertyFilter->resultDefinition()->resultType() == RiaDefines::FORMATION_NAMES
&& propertyFilter->resultDefinition()->resultVariable() != RiaDefines::undefinedResultName()) return true;
if (propertyFilter->isActive() && propertyFilter->resultDefinition()->resultType() == RiaDefines::FORMATION_NAMES &&
propertyFilter->resultDefinition()->resultVariable() != RiaDefines::undefinedResultName())
return true;
}
return false;
@ -151,8 +145,7 @@ void RimEclipsePropertyFilterCollection::updateIconState()
if (view)
{
RimViewController* viewController = view->viewController();
if (viewController && (viewController->isPropertyFilterOveridden()
|| viewController->isVisibleCellsOveridden()))
if (viewController && (viewController->isPropertyFilterOveridden() || viewController->isVisibleCellsOveridden()))
{
activeIcon = false;
}
@ -165,9 +158,8 @@ void RimEclipsePropertyFilterCollection::updateIconState()
updateUiIconFromState(activeIcon);
for (size_t i = 0; i < propertyFilters.size(); i++)
for (RimEclipsePropertyFilter* cellFilter : propertyFilters)
{
RimEclipsePropertyFilter* cellFilter = propertyFilters[i];
cellFilter->updateActiveState();
cellFilter->updateIconState();
}
@ -183,4 +175,3 @@ void RimEclipsePropertyFilterCollection::updateFromCurrentTimeStep()
cellFilter->updateFromCurrentTimeStep();
}
}

164
ApplicationCode/ProjectDataModel/RimEclipseView.cpp
View File

@ -53,6 +53,8 @@
#include "RimFaultInViewCollection.h"
#include "RimFlowCharacteristicsPlot.h"
#include "RimFlowDiagSolution.h"
#include "RimFracture.h"
#include "RimFractureTemplateCollection.h"
#include "RimGridCollection.h"
#include "RimIntersection.h"
#include "RimIntersectionCollection.h"
@ -60,38 +62,34 @@
#include "RimProject.h"
#include "RimRegularLegendConfig.h"
#include "RimReservoirCellResultsStorage.h"
#include "RimSimWellFracture.h"
#include "RimSimWellInView.h"
#include "RimSimWellInViewCollection.h"
#include "RimStimPlanColors.h"
#include "RimTernaryLegendConfig.h"
#include "RimViewController.h"
#include "RimViewLinker.h"
#include "RimViewNameConfig.h"
#include "RimVirtualPerforationResults.h"
#include "RimWellPathCollection.h"
#include "RimViewNameConfig.h"
#include "RiuMainWindow.h"
#include "Riu3dSelectionManager.h"
#include "RiuMainWindow.h"
#include "RiuViewer.h"
#include "RivReservoirSimWellsPartMgr.h"
#include "RivReservoirViewPartMgr.h"
#include "RivSingleCellPartGenerator.h"
#include "RivTernarySaturationOverlayItem.h"
#include "RivWellPathsPartMgr.h"
#include "RimFracture.h"
#include "RimFractureTemplateCollection.h"
#include "RimSimWellFracture.h"
#include "RivWellFracturePartMgr.h"
#include "RivWellPathsPartMgr.h"
#include "cafCadNavigation.h"
#include "cafCeetronPlusNavigation.h"
#include "cafDisplayCoordTransform.h"
#include "cafFrameAnimationControl.h"
#include "cafPdmUiTreeOrdering.h"
#include "cafOverlayScalarMapperLegend.h"
#include "cafPdmUiTreeOrdering.h"
#include "cvfDrawable.h"
#include "cvfModelBasicList.h"
@ -104,8 +102,6 @@
#include <climits>
CAF_PDM_SOURCE_INIT(RimEclipseView, "ReservoirView");
//--------------------------------------------------------------------------------------------------
///
@ -199,7 +195,6 @@ RimEclipseView::~RimEclipseView()
m_eclipseCase = nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -379,16 +374,13 @@ void RimEclipseView::createDisplayModel()
timeStepIndices.push_back(i);
}
}
else if (this->cellResult()->hasStaticResult()
|| this->cellEdgeResult()->hasResult()
|| this->eclipsePropertyFilterCollection()->hasActiveFilters())
else if (this->cellResult()->hasStaticResult() || this->cellEdgeResult()->hasResult() ||
this->eclipsePropertyFilterCollection()->hasActiveFilters())
{
// The one and only result entry
timeStepIndices.push_back(0);
}
cvf::Collection<cvf::ModelBasicList> frameModels;
size_t timeIdx;
for (timeIdx = 0; timeIdx < timeStepIndices.size(); timeIdx++)
@ -411,10 +403,8 @@ void RimEclipseView::createDisplayModel()
// For property filtered geometry : just set all the models as empty scenes
// updateCurrentTimeStep requests the actual parts
if (!this->eclipsePropertyFilterCollection()->hasActiveFilters()
|| ( this->viewController()
&& this->viewController()->isVisibleCellsOveridden()) )
if (!this->eclipsePropertyFilterCollection()->hasActiveFilters() ||
(this->viewController() && this->viewController()->isVisibleCellsOveridden()))
{
std::vector<RivCellSetEnum> geometryTypesToAdd;
@ -469,7 +459,8 @@ void RimEclipseView::createDisplayModel()
{
if (isGridVisualizationMode())
{
m_reservoirGridPartManager->appendStaticGeometryPartsToModel(frameModels[frameIdx].p(), geometryTypesToAdd[gtIdx], gridIndices);
m_reservoirGridPartManager->appendStaticGeometryPartsToModel(
frameModels[frameIdx].p(), geometryTypesToAdd[gtIdx], gridIndices);
}
else
{
@ -488,13 +479,13 @@ void RimEclipseView::createDisplayModel()
m_reservoirGridPartManager->clearWatertightGeometryFlags();
if ( faultCollection()->showFaultCollection()
|| !this->eclipsePropertyFilterCollection()->hasActiveFilters() )
if (faultCollection()->showFaultCollection() || !this->eclipsePropertyFilterCollection()->hasActiveFilters())
{
setVisibleGridPartsWatertight();
std::set<RivCellSetEnum> faultGeometryTypesToAppend = allVisibleFaultGeometryTypes();
RivCellSetEnum faultLabelType = m_reservoirGridPartManager->geometryTypeForFaultLabels(faultGeometryTypesToAppend, faultCollection()->isShowingFaultsAndFaultsOutsideFilters());
RivCellSetEnum faultLabelType = m_reservoirGridPartManager->geometryTypeForFaultLabels(
faultGeometryTypesToAppend, faultCollection()->isShowingFaultsAndFaultsOutsideFilters());
for (size_t frameIdx = 0; frameIdx < frameModels.size(); ++frameIdx)
{
@ -509,7 +500,6 @@ void RimEclipseView::createDisplayModel()
}
}
// Cross sections
m_crossSectionVizModel->removeAllParts();
@ -527,14 +517,14 @@ void RimEclipseView::createDisplayModel()
addWellPathsToModel(m_wellPathPipeVizModel.p(), currentActiveCellInfo()->geometryBoundingBox());
m_wellPathsPartManager->appendStaticFracturePartsToModel(m_wellPathPipeVizModel.p(), currentActiveCellInfo()->geometryBoundingBox());
m_wellPathsPartManager->appendStaticFracturePartsToModel(m_wellPathPipeVizModel.p(),
currentActiveCellInfo()->geometryBoundingBox());
m_wellPathPipeVizModel->updateBoundingBoxesRecursive();
m_viewer->addStaticModelOnce(m_wellPathPipeVizModel.p());
// Create Scenes from the frameModels
// Animation frames for results display, starts from frame 1
size_t frameIndex;
for (frameIndex = 0; frameIndex < frameModels.size(); frameIndex++)
{
@ -620,8 +610,10 @@ void RimEclipseView::updateVisibleGeometriesAndCellColors()
if (isGridVisualizationMode())
{
m_reservoirGridPartManager->appendDynamicGeometryPartsToModel(frameParts.p(), PROPERTY_FILTERED, m_currentTimeStep, gridIndices);
m_reservoirGridPartManager->appendDynamicGeometryPartsToModel(frameParts.p(), PROPERTY_FILTERED_WELL_CELLS, m_currentTimeStep, gridIndices);
m_reservoirGridPartManager->appendDynamicGeometryPartsToModel(
frameParts.p(), PROPERTY_FILTERED, m_currentTimeStep, gridIndices);
m_reservoirGridPartManager->appendDynamicGeometryPartsToModel(
frameParts.p(), PROPERTY_FILTERED_WELL_CELLS, m_currentTimeStep, gridIndices);
}
else
{
@ -637,7 +629,8 @@ void RimEclipseView::updateVisibleGeometriesAndCellColors()
{
if (geometryType == PROPERTY_FILTERED || geometryType == PROPERTY_FILTERED_WELL_CELLS)
{
m_reservoirGridPartManager->appendFaultsDynamicGeometryPartsToModel(frameParts.p(), geometryType, m_currentTimeStep);
m_reservoirGridPartManager->appendFaultsDynamicGeometryPartsToModel(
frameParts.p(), geometryType, m_currentTimeStep);
}
else
{
@ -645,10 +638,12 @@ void RimEclipseView::updateVisibleGeometriesAndCellColors()
}
}
RivCellSetEnum faultLabelType = m_reservoirGridPartManager->geometryTypeForFaultLabels(faultGeometryTypesToAppend, faultCollection()->isShowingFaultsAndFaultsOutsideFilters());
RivCellSetEnum faultLabelType = m_reservoirGridPartManager->geometryTypeForFaultLabels(
faultGeometryTypesToAppend, faultCollection()->isShowingFaultsAndFaultsOutsideFilters());
if (faultLabelType == PROPERTY_FILTERED)
{
m_reservoirGridPartManager->appendFaultLabelsDynamicGeometryPartsToModel(frameParts.p(), faultLabelType, m_currentTimeStep);
m_reservoirGridPartManager->appendFaultLabelsDynamicGeometryPartsToModel(
frameParts.p(), faultLabelType, m_currentTimeStep);
}
else
{
@ -657,14 +652,16 @@ void RimEclipseView::updateVisibleGeometriesAndCellColors()
// Set the transparency on all the Wellcell parts before setting the result color
float opacity = static_cast<float>(1 - cvf::Math::clamp(this->wellCollection()->wellCellTransparencyLevel(), 0.0, 1.0));
m_reservoirGridPartManager->updateCellColor(PROPERTY_FILTERED_WELL_CELLS, m_currentTimeStep, cvf::Color4f(cvf::Color3f(cvf::Color3::WHITE), opacity));
m_reservoirGridPartManager->updateCellColor(
PROPERTY_FILTERED_WELL_CELLS, m_currentTimeStep, cvf::Color4f(cvf::Color3f(cvf::Color3::WHITE), opacity));
if (this->showInactiveCells())
{
if (this->rangeFilterCollection()->hasActiveFilters()) // Wells not considered, because we do not have a INACTIVE_WELL_CELLS group yet.
if (this->rangeFilterCollection()
->hasActiveFilters()) // Wells not considered, because we do not have a INACTIVE_WELL_CELLS group yet.
{
m_reservoirGridPartManager->appendStaticGeometryPartsToModel(frameParts.p(), RANGE_FILTERED_INACTIVE, gridIndices);
m_reservoirGridPartManager->appendStaticGeometryPartsToModel(
frameParts.p(), RANGE_FILTERED_INACTIVE, gridIndices);
if (!faultCollection()->isShowingFaultsAndFaultsOutsideFilters())
{
@ -720,9 +717,11 @@ void RimEclipseView::updateVisibleGeometriesAndCellColors()
{
if (this->hasUserRequestedAnimation() && this->cellEdgeResult()->hasResult())
{
m_reservoirGridPartManager->updateCellEdgeResultColor(geometriesToRecolor[i], m_currentTimeStep, this->cellResult(), this->cellEdgeResult());
m_reservoirGridPartManager->updateCellEdgeResultColor(
geometriesToRecolor[i], m_currentTimeStep, this->cellResult(), this->cellEdgeResult());
}
else if ((this->hasUserRequestedAnimation() && this->cellResult()->hasResult()) || this->cellResult()->isTernarySaturationSelected())
else if ((this->hasUserRequestedAnimation() && this->cellResult()->hasResult()) ||
this->cellResult()->isTernarySaturationSelected())
{
m_reservoirGridPartManager->updateCellResultColor(geometriesToRecolor[i], m_currentTimeStep, this->cellResult());
}
@ -734,8 +733,8 @@ void RimEclipseView::updateVisibleGeometriesAndCellColors()
this->updateFaultColors();
if ((this->hasUserRequestedAnimation() && this->cellResult()->hasResult()) || this->cellResult()->isTernarySaturationSelected())
if ((this->hasUserRequestedAnimation() && this->cellResult()->hasResult()) ||
this->cellResult()->isTernarySaturationSelected())
{
m_crossSectionCollection->updateCellResultColor(m_currentTimeStep,
this->cellResult()->legendConfig()->scalarMapper(),
@ -805,7 +804,8 @@ void RimEclipseView::appendWellsAndFracturesToModel()
f->firstAncestorOrThisOfType(simWell);
if (simWell)
{
bool isAnyGeometryPresent = simWell->isWellPipeVisible(m_currentTimeStep) || simWell->isWellSpheresVisible(m_currentTimeStep);
bool isAnyGeometryPresent =
simWell->isWellPipeVisible(m_currentTimeStep) || simWell->isWellSpheresVisible(m_currentTimeStep);
if (!isAnyGeometryPresent)
{
continue;
@ -882,8 +882,6 @@ void RimEclipseView::onLoadDataAndUpdate()
this->scheduleCreateDisplayModelAndRedraw();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -911,7 +909,6 @@ void RimEclipseView::initAfterRead()
this->updateUiIconFromToggleField();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -959,18 +956,36 @@ cvf::Color4f RimEclipseView::colorFromCellCategory(RivCellSetEnum geometryType)
switch (geometryType)
{
case ACTIVE: color = cvf::Color4f(cvf::Color3::ORANGE); break;
case ALL_WELL_CELLS: color = cvf::Color4f(cvf::Color3f(cvf::Color3::BROWN), opacity); break;
case VISIBLE_WELL_CELLS: color = cvf::Color4f(cvf::Color3f(cvf::Color3::BROWN), opacity); break;
case VISIBLE_WELL_FENCE_CELLS: color = cvf::Color4f(cvf::Color3::ORANGE); break;
case ACTIVE:
color = cvf::Color4f(cvf::Color3::ORANGE);
break;
case ALL_WELL_CELLS:
color = cvf::Color4f(cvf::Color3f(cvf::Color3::BROWN), opacity);
break;
case VISIBLE_WELL_CELLS:
color = cvf::Color4f(cvf::Color3f(cvf::Color3::BROWN), opacity);
break;
case VISIBLE_WELL_FENCE_CELLS:
color = cvf::Color4f(cvf::Color3::ORANGE);
break;
case VISIBLE_WELL_CELLS_OUTSIDE_RANGE_FILTER:
color = cvf::Color4f(cvf::Color3f(cvf::Color3::BROWN), opacity); break;
color = cvf::Color4f(cvf::Color3f(cvf::Color3::BROWN), opacity);
break;
case VISIBLE_WELL_FENCE_CELLS_OUTSIDE_RANGE_FILTER:
color = cvf::Color4f(cvf::Color3::ORANGE); break;
case INACTIVE: color = cvf::Color4f(RiaColorTables::undefinedCellColor()); break;
case RANGE_FILTERED: color = cvf::Color4f(cvf::Color3::ORANGE); break;
case RANGE_FILTERED_WELL_CELLS: color = cvf::Color4f(cvf::Color3f(cvf::Color3::BROWN), opacity); break;
case RANGE_FILTERED_INACTIVE: color = cvf::Color4f(RiaColorTables::undefinedCellColor()); break;
color = cvf::Color4f(cvf::Color3::ORANGE);
break;
case INACTIVE:
color = cvf::Color4f(RiaColorTables::undefinedCellColor());
break;
case RANGE_FILTERED:
color = cvf::Color4f(cvf::Color3::ORANGE);
break;
case RANGE_FILTERED_WELL_CELLS:
color = cvf::Color4f(cvf::Color3f(cvf::Color3::BROWN), opacity);
break;
case RANGE_FILTERED_INACTIVE:
color = cvf::Color4f(RiaColorTables::undefinedCellColor());
break;
}
return color;
@ -1045,9 +1060,7 @@ RigCaseCellResultsData* RimEclipseView::currentGridCellResults()
//--------------------------------------------------------------------------------------------------
const RigActiveCellInfo* RimEclipseView::currentActiveCellInfo() const
{
if (m_eclipseCase &&
m_eclipseCase->eclipseCaseData()
)
if (m_eclipseCase && m_eclipseCase->eclipseCaseData())
{
return m_eclipseCase->eclipseCaseData()->activeCellInfo(cellResult()->porosityModel());
}
@ -1055,7 +1068,6 @@ const RigActiveCellInfo* RimEclipseView::currentActiveCellInfo() const
return nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -1092,7 +1104,6 @@ void RimEclipseView::scheduleSimWellGeometryRegen()
m_simWellsPartManager->scheduleGeometryRegen();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -1146,14 +1157,16 @@ void RimEclipseView::updateLegends()
this->cellEdgeResult()->minMaxCellEdgeValues(globalMin, globalMax);
this->cellEdgeResult()->posNegClosestToZero(globalPosClosestToZero, globalNegClosestToZero);
this->cellEdgeResult()->legendConfig()->setClosestToZeroValues(globalPosClosestToZero, globalNegClosestToZero, globalPosClosestToZero, globalNegClosestToZero);
this->cellEdgeResult()->legendConfig()->setClosestToZeroValues(
globalPosClosestToZero, globalNegClosestToZero, globalPosClosestToZero, globalNegClosestToZero);
this->cellEdgeResult()->legendConfig()->setAutomaticRanges(globalMin, globalMax, globalMin, globalMax);
if (this->cellEdgeResult()->hasCategoryResult())
{
if (cellEdgeResult()->singleVarEdgeResultColors()->resultType() != RiaDefines::FORMATION_NAMES)
{
cellEdgeResult()->legendConfig()->setIntegerCategories(results->uniqueCellScalarValues(cellEdgeResult()->singleVarEdgeResultColors()->eclipseResultAddress()));
cellEdgeResult()->legendConfig()->setIntegerCategories(results->uniqueCellScalarValues(
cellEdgeResult()->singleVarEdgeResultColors()->eclipseResultAddress()));
}
else
{
@ -1163,13 +1176,15 @@ void RimEclipseView::updateLegends()
}
}
this->cellEdgeResult()->legendConfig()->setTitle(QString("Edge Results: \n") + this->cellEdgeResult()->resultVariableUiShortName());
this->cellEdgeResult()->legendConfig()->setTitle(QString("Edge Results: \n") +
this->cellEdgeResult()->resultVariableUiShortName());
m_viewer->addColorLegendToBottomLeftCorner(this->cellEdgeResult()->legendConfig()->titledOverlayFrame());
}
else
{
this->cellEdgeResult()->legendConfig()->setClosestToZeroValues(0, 0, 0, 0);
this->cellEdgeResult()->legendConfig()->setAutomaticRanges(cvf::UNDEFINED_DOUBLE, cvf::UNDEFINED_DOUBLE, cvf::UNDEFINED_DOUBLE, cvf::UNDEFINED_DOUBLE);
this->cellEdgeResult()->legendConfig()->setAutomaticRanges(
cvf::UNDEFINED_DOUBLE, cvf::UNDEFINED_DOUBLE, cvf::UNDEFINED_DOUBLE, cvf::UNDEFINED_DOUBLE);
}
}
@ -1264,7 +1279,6 @@ void RimEclipseView::syncronizeWellsWithResults()
cvf::Collection<RigSimWellData> wellResults = m_eclipseCase->eclipseCaseData()->wellResults();
std::vector<caf::PdmPointer<RimSimWellInView>> newWells;
// Clear the possible well results data present
@ -1468,10 +1482,8 @@ void RimEclipseView::updateDisplayModelForWellResults()
}
RiuMainWindow::instance()->refreshAnimationActions();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -1553,7 +1565,8 @@ bool RimEclipseView::isVirtualConnectionFactorGeometryVisible() const
bool RimEclipseView::isMainGridVisible() const
{
auto indicesToVisibleGrids = m_gridCollection->indicesToVisibleGrids();
bool isMainGridVisible = std::find(indicesToVisibleGrids.begin(), indicesToVisibleGrids.end(), 0) != indicesToVisibleGrids.end();
bool isMainGridVisible =
std::find(indicesToVisibleGrids.begin(), indicesToVisibleGrids.end(), 0) != indicesToVisibleGrids.end();
if (!isMainGridVisible) return false;
@ -1656,7 +1669,8 @@ void RimEclipseView::updateFaultColors()
{
if (this->hasUserRequestedAnimation() && this->cellEdgeResult()->hasResult())
{
m_reservoirGridPartManager->updateFaultCellEdgeResultColor(cellSetType, m_currentTimeStep, faultResultColors, this->cellEdgeResult());
m_reservoirGridPartManager->updateFaultCellEdgeResultColor(
cellSetType, m_currentTimeStep, faultResultColors, this->cellEdgeResult());
}
else
{
@ -1665,7 +1679,6 @@ void RimEclipseView::updateFaultColors()
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -1693,7 +1706,6 @@ bool RimEclipseView::isTimeStepDependentDataVisible() const
return false;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -1737,7 +1749,8 @@ void RimEclipseView::updateVirtualConnectionLegendRanges()
{
if (!eclipseCase()) return;
const RigVirtualPerforationTransmissibilities* virtualTransmissibilities = eclipseCase()->computeAndGetVirtualPerforationTransmissibilities();
const RigVirtualPerforationTransmissibilities* virtualTransmissibilities =
eclipseCase()->computeAndGetVirtualPerforationTransmissibilities();
if (virtualTransmissibilities)
{
double minValue = HUGE_VAL;
@ -1849,7 +1862,8 @@ void RimEclipseView::calculateCurrentTotalCellVisibility(cvf::UByteArray* totalV
for (size_t gpIdx = 0; gpIdx < m_visibleGridParts.size(); ++gpIdx)
{
const cvf::UByteArray* visibility = m_reservoirGridPartManager->cellVisibility(m_visibleGridParts[gpIdx], gridIdx, timeStep);
const cvf::UByteArray* visibility =
m_reservoirGridPartManager->cellVisibility(m_visibleGridParts[gpIdx], gridIdx, timeStep);
for (int lcIdx = 0; lcIdx < gridCellCount; ++lcIdx)
{
@ -1904,7 +1918,9 @@ void RimEclipseView::createPartCollectionFromSelection(cvf::Collection<cvf::Part
CVF_ASSERT(eclipseSelItem->m_view->eclipseCase());
CVF_ASSERT(eclipseSelItem->m_view->eclipseCase()->eclipseCaseData());
RivSingleCellPartGenerator partGen(eclipseSelItem->m_view->eclipseCase()->eclipseCaseData(), eclipseSelItem->m_gridIndex, eclipseSelItem->m_gridLocalCellIndex);
RivSingleCellPartGenerator partGen(eclipseSelItem->m_view->eclipseCase()->eclipseCaseData(),
eclipseSelItem->m_gridIndex,
eclipseSelItem->m_gridLocalCellIndex);
cvf::ref<cvf::Part> part = partGen.createPart(eclipseSelItem->m_color);
part->setTransform(this->scaleTransform());