mirror of
https://github.com/OPM/ResInsight.git
synced 2025-01-03 20:57:39 -06:00
4cf6a26083
* Show timing for geoBuilder.generateSurface() * Check state of element vector result before geometry is created * Improve performance for isFaceVisible Avoid calling costly function cell() when possible Remove check on fault geometry as this does not affect the visualization * Performance: Avoid traversal of all cells when computing visibility When we have an active cell grid, we can skip checking for inactive and invalid state. Use the list of active grid cells when looping through cells.
1230 lines
53 KiB
C++
1230 lines
53 KiB
C++
/////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (C) 2011- Statoil ASA
|
|
// Copyright (C) 2013- Ceetron Solutions AS
|
|
// Copyright (C) 2011-2012 Ceetron AS
|
|
//
|
|
// ResInsight is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
// FITNESS FOR A PARTICULAR PURPOSE.
|
|
//
|
|
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
|
|
// for more details.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "RivReservoirViewPartMgr.h"
|
|
|
|
#include "RigActiveCellGrid.h"
|
|
#include "RigActiveCellInfo.h"
|
|
#include "RigCaseCellResultsData.h"
|
|
#include "RigCaseToCaseCellMapper.h"
|
|
#include "RigCell.h"
|
|
#include "RigEclipseCaseData.h"
|
|
#include "RigGridBase.h"
|
|
#include "RigResultAccessorFactory.h"
|
|
|
|
#include "Rim3dOverlayInfoConfig.h"
|
|
#include "RimCellEdgeColors.h"
|
|
#include "RimCellFilterCollection.h"
|
|
#include "RimEclipseCase.h"
|
|
#include "RimEclipseCellColors.h"
|
|
#include "RimEclipsePropertyFilter.h"
|
|
#include "RimEclipsePropertyFilterCollection.h"
|
|
#include "RimEclipseResultDefinition.h"
|
|
#include "RimEclipseView.h"
|
|
#include "RimFaultInViewCollection.h"
|
|
#include "RimReservoirCellResultsStorage.h"
|
|
#include "RimSimWellInViewCollection.h"
|
|
#include "RimViewController.h"
|
|
#include "RimViewLinker.h"
|
|
|
|
#include "RivElementVectorResultPartMgr.h"
|
|
#include "RivGridPartMgr.h"
|
|
#include "RivReservoirFaultsPartMgr.h"
|
|
|
|
#include <QDebug>
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
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)
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::scheduleGeometryRegen( RivCellSetEnum geometryType )
|
|
{
|
|
switch ( geometryType )
|
|
{
|
|
case OVERRIDDEN_CELL_VISIBILITY:
|
|
clearGeometryCache( OVERRIDDEN_CELL_VISIBILITY );
|
|
break;
|
|
case INACTIVE:
|
|
clearGeometryCache( INACTIVE );
|
|
clearGeometryCache( RANGE_FILTERED_INACTIVE );
|
|
break;
|
|
case RANGE_FILTERED_INACTIVE:
|
|
clearGeometryCache( RANGE_FILTERED_INACTIVE );
|
|
break;
|
|
case ACTIVE:
|
|
clearGeometryCache( ACTIVE );
|
|
clearGeometryCache( ALL_WELL_CELLS );
|
|
clearGeometryCache( VISIBLE_WELL_CELLS );
|
|
clearGeometryCache( VISIBLE_WELL_FENCE_CELLS );
|
|
clearGeometryCache( RANGE_FILTERED );
|
|
clearGeometryCache( RANGE_FILTERED_WELL_CELLS );
|
|
clearGeometryCache( VISIBLE_WELL_CELLS_OUTSIDE_RANGE_FILTER );
|
|
clearGeometryCache( VISIBLE_WELL_FENCE_CELLS_OUTSIDE_RANGE_FILTER );
|
|
clearGeometryCache( PROPERTY_FILTERED );
|
|
clearGeometryCache( PROPERTY_FILTERED_WELL_CELLS );
|
|
break;
|
|
case ALL_WELL_CELLS:
|
|
clearGeometryCache( ALL_WELL_CELLS );
|
|
clearGeometryCache( VISIBLE_WELL_CELLS );
|
|
clearGeometryCache( VISIBLE_WELL_FENCE_CELLS );
|
|
clearGeometryCache( RANGE_FILTERED );
|
|
clearGeometryCache( RANGE_FILTERED_WELL_CELLS );
|
|
clearGeometryCache( VISIBLE_WELL_CELLS_OUTSIDE_RANGE_FILTER );
|
|
clearGeometryCache( VISIBLE_WELL_FENCE_CELLS_OUTSIDE_RANGE_FILTER );
|
|
clearGeometryCache( PROPERTY_FILTERED_WELL_CELLS );
|
|
break;
|
|
case VISIBLE_WELL_CELLS:
|
|
clearGeometryCache( VISIBLE_WELL_CELLS );
|
|
clearGeometryCache( VISIBLE_WELL_FENCE_CELLS );
|
|
clearGeometryCache( VISIBLE_WELL_CELLS_OUTSIDE_RANGE_FILTER );
|
|
clearGeometryCache( VISIBLE_WELL_FENCE_CELLS_OUTSIDE_RANGE_FILTER );
|
|
clearGeometryCache( PROPERTY_FILTERED );
|
|
clearGeometryCache( PROPERTY_FILTERED_WELL_CELLS );
|
|
break;
|
|
case VISIBLE_WELL_FENCE_CELLS:
|
|
clearGeometryCache( VISIBLE_WELL_FENCE_CELLS );
|
|
clearGeometryCache( VISIBLE_WELL_FENCE_CELLS_OUTSIDE_RANGE_FILTER );
|
|
clearGeometryCache( PROPERTY_FILTERED_WELL_CELLS );
|
|
break;
|
|
case RANGE_FILTERED:
|
|
clearGeometryCache( RANGE_FILTERED );
|
|
clearGeometryCache( RANGE_FILTERED_INACTIVE );
|
|
clearGeometryCache( RANGE_FILTERED_WELL_CELLS );
|
|
clearGeometryCache( VISIBLE_WELL_CELLS_OUTSIDE_RANGE_FILTER );
|
|
clearGeometryCache( VISIBLE_WELL_FENCE_CELLS_OUTSIDE_RANGE_FILTER );
|
|
clearGeometryCache( PROPERTY_FILTERED );
|
|
clearGeometryCache( PROPERTY_FILTERED_WELL_CELLS );
|
|
break;
|
|
case RANGE_FILTERED_WELL_CELLS:
|
|
clearGeometryCache( RANGE_FILTERED_WELL_CELLS );
|
|
clearGeometryCache( RANGE_FILTERED );
|
|
clearGeometryCache( VISIBLE_WELL_CELLS_OUTSIDE_RANGE_FILTER );
|
|
clearGeometryCache( VISIBLE_WELL_FENCE_CELLS_OUTSIDE_RANGE_FILTER );
|
|
clearGeometryCache( PROPERTY_FILTERED_WELL_CELLS );
|
|
break;
|
|
case VISIBLE_WELL_CELLS_OUTSIDE_RANGE_FILTER:
|
|
clearGeometryCache( VISIBLE_WELL_CELLS_OUTSIDE_RANGE_FILTER );
|
|
clearGeometryCache( VISIBLE_WELL_FENCE_CELLS_OUTSIDE_RANGE_FILTER );
|
|
clearGeometryCache( PROPERTY_FILTERED_WELL_CELLS );
|
|
break;
|
|
case VISIBLE_WELL_FENCE_CELLS_OUTSIDE_RANGE_FILTER:
|
|
clearGeometryCache( VISIBLE_WELL_FENCE_CELLS_OUTSIDE_RANGE_FILTER );
|
|
clearGeometryCache( PROPERTY_FILTERED_WELL_CELLS );
|
|
break;
|
|
case PROPERTY_FILTERED:
|
|
clearGeometryCache( PROPERTY_FILTERED );
|
|
clearGeometryCache( PROPERTY_FILTERED_WELL_CELLS );
|
|
break;
|
|
case PROPERTY_FILTERED_WELL_CELLS:
|
|
clearGeometryCache( PROPERTY_FILTERED_WELL_CELLS );
|
|
break;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::clearGeometryCache( RivCellSetEnum geomType )
|
|
{
|
|
if ( geomType == PROPERTY_FILTERED )
|
|
{
|
|
for ( size_t i = 0; i < m_propFilteredGeometryFramesNeedsRegen.size(); ++i )
|
|
{
|
|
m_propFilteredGeometryFramesNeedsRegen[i] = true;
|
|
}
|
|
}
|
|
else if ( geomType == PROPERTY_FILTERED_WELL_CELLS )
|
|
{
|
|
for ( size_t i = 0; i < m_propFilteredWellGeometryFramesNeedsRegen.size(); ++i )
|
|
{
|
|
m_propFilteredWellGeometryFramesNeedsRegen[i] = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_geometriesNeedsRegen[geomType] = true;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::clearGeometryCache()
|
|
{
|
|
clearGeometryCache( OVERRIDDEN_CELL_VISIBILITY );
|
|
clearGeometryCache( ACTIVE );
|
|
clearGeometryCache( ALL_WELL_CELLS );
|
|
clearGeometryCache( VISIBLE_WELL_CELLS );
|
|
clearGeometryCache( VISIBLE_WELL_FENCE_CELLS );
|
|
clearGeometryCache( INACTIVE );
|
|
clearGeometryCache( RANGE_FILTERED );
|
|
clearGeometryCache( RANGE_FILTERED_WELL_CELLS );
|
|
clearGeometryCache( RANGE_FILTERED_INACTIVE );
|
|
clearGeometryCache( VISIBLE_WELL_CELLS_OUTSIDE_RANGE_FILTER );
|
|
clearGeometryCache( VISIBLE_WELL_FENCE_CELLS_OUTSIDE_RANGE_FILTER );
|
|
clearGeometryCache( PROPERTY_FILTERED );
|
|
clearGeometryCache( PROPERTY_FILTERED_WELL_CELLS );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::appendStaticGeometryPartsToModel( cvf::ModelBasicList* model,
|
|
RivCellSetEnum geometryType,
|
|
const std::vector<size_t>& gridIndices )
|
|
{
|
|
ensureStaticGeometryPartsCreated( geometryType );
|
|
|
|
m_geometries[geometryType].appendGridPartsToModel( model, gridIndices );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::ensureStaticGeometryPartsCreated( RivCellSetEnum geometryType )
|
|
{
|
|
if ( geometryType < PROPERTY_FILTERED && m_geometriesNeedsRegen[geometryType] )
|
|
{
|
|
createGeometry( geometryType );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::appendDynamicGeometryPartsToModel( cvf::ModelBasicList* model,
|
|
RivCellSetEnum geometryType,
|
|
size_t frameIndex,
|
|
const std::vector<size_t>& gridIndices )
|
|
{
|
|
ensureDynamicGeometryPartsCreated( geometryType, frameIndex );
|
|
|
|
if ( geometryType == PROPERTY_FILTERED )
|
|
{
|
|
m_propFilteredGeometryFrames[frameIndex]->appendGridPartsToModel( model, gridIndices );
|
|
}
|
|
else if ( geometryType == PROPERTY_FILTERED_WELL_CELLS )
|
|
{
|
|
m_propFilteredWellGeometryFrames[frameIndex]->appendGridPartsToModel( model, gridIndices );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::ensureDynamicGeometryPartsCreated( RivCellSetEnum geometryType, size_t frameIndex )
|
|
{
|
|
if ( geometryType == PROPERTY_FILTERED )
|
|
{
|
|
if ( frameIndex >= m_propFilteredGeometryFramesNeedsRegen.size() || m_propFilteredGeometryFramesNeedsRegen[frameIndex] )
|
|
{
|
|
createPropertyFilteredNoneWellCellGeometry( frameIndex );
|
|
}
|
|
}
|
|
else if ( geometryType == PROPERTY_FILTERED_WELL_CELLS )
|
|
{
|
|
if ( frameIndex >= m_propFilteredWellGeometryFramesNeedsRegen.size() || m_propFilteredWellGeometryFramesNeedsRegen[frameIndex] )
|
|
{
|
|
createPropertyFilteredWellGeometry( frameIndex );
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::createGeometry( RivCellSetEnum geometryType )
|
|
{
|
|
RigEclipseCaseData* res = m_reservoirView->eclipseCase()->eclipseCaseData();
|
|
|
|
m_geometries[geometryType].clearAndSetReservoir( geometryType, m_reservoirView->eclipseCase(), m_reservoirView );
|
|
m_geometries[geometryType].setTransform( m_scaleTransform.p() );
|
|
|
|
std::vector<RigGridBase*> grids;
|
|
res->allGrids( &grids );
|
|
|
|
for ( size_t i = 0; i < grids.size(); ++i )
|
|
{
|
|
cvf::ref<cvf::UByteArray> cellVisibility = m_geometries[geometryType].cellVisibility( i );
|
|
computeVisibility( cellVisibility.p(), geometryType, grids[i], i );
|
|
|
|
m_geometries[geometryType].setCellVisibility( i, cellVisibility.p() );
|
|
}
|
|
|
|
m_geometriesNeedsRegen[geometryType] = false;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::computeVisibility( cvf::UByteArray* cellVisibility, RivCellSetEnum geometryType, RigGridBase* grid, size_t gridIdx )
|
|
{
|
|
RigEclipseCaseData* eclipseCase = m_reservoirView->eclipseCase()->eclipseCaseData();
|
|
auto activeCellInfo = m_reservoirView->currentActiveCellInfo();
|
|
|
|
switch ( geometryType )
|
|
{
|
|
case OVERRIDDEN_CELL_VISIBILITY:
|
|
computeOverriddenCellVisibility( cellVisibility, grid );
|
|
break;
|
|
case ACTIVE:
|
|
computeNativeVisibility( cellVisibility, grid, activeCellInfo, eclipseCase->wellCellsInGrid( gridIdx ), false, false, true );
|
|
break;
|
|
case ALL_WELL_CELLS:
|
|
copyByteArray( cellVisibility, eclipseCase->wellCellsInGrid( gridIdx ) );
|
|
break;
|
|
case VISIBLE_WELL_CELLS:
|
|
{
|
|
cvf::ref<cvf::UByteArray> allWellCellsVisibility;
|
|
ensureStaticGeometryPartsCreated( ALL_WELL_CELLS );
|
|
|
|
allWellCellsVisibility = m_geometries[ALL_WELL_CELLS].cellVisibility( gridIdx );
|
|
|
|
m_reservoirView->calculateVisibleWellCellsIncFence( cellVisibility, grid );
|
|
|
|
#pragma omp parallel for
|
|
for ( int cellIdx = 0; cellIdx < static_cast<int>( cellVisibility->size() ); ++cellIdx )
|
|
{
|
|
( *cellVisibility )[cellIdx] = ( *allWellCellsVisibility )[cellIdx] && ( *cellVisibility )[cellIdx];
|
|
}
|
|
}
|
|
break;
|
|
case VISIBLE_WELL_FENCE_CELLS:
|
|
{
|
|
cvf::ref<cvf::UByteArray> allWellCellsVisibility;
|
|
ensureStaticGeometryPartsCreated( ALL_WELL_CELLS );
|
|
|
|
allWellCellsVisibility = m_geometries[ALL_WELL_CELLS].cellVisibility( gridIdx );
|
|
|
|
m_reservoirView->calculateVisibleWellCellsIncFence( cellVisibility, grid );
|
|
|
|
#pragma omp parallel for
|
|
for ( int cellIdx = 0; cellIdx < static_cast<int>( cellVisibility->size() ); ++cellIdx )
|
|
{
|
|
( *cellVisibility )[cellIdx] = !( *allWellCellsVisibility )[cellIdx] && ( *cellVisibility )[cellIdx];
|
|
}
|
|
}
|
|
break;
|
|
case INACTIVE:
|
|
computeNativeVisibility( cellVisibility,
|
|
grid,
|
|
activeCellInfo,
|
|
eclipseCase->wellCellsInGrid( gridIdx ),
|
|
m_reservoirView->showInvalidCells(),
|
|
true,
|
|
false );
|
|
break;
|
|
case RANGE_FILTERED:
|
|
{
|
|
cvf::ref<cvf::UByteArray> nativeVisibility;
|
|
ensureStaticGeometryPartsCreated( ACTIVE );
|
|
|
|
nativeVisibility = m_geometries[ACTIVE].cellVisibility( gridIdx );
|
|
computeFilterVisibility( geometryType, cellVisibility, grid, nativeVisibility.p(), m_reservoirView->cellFilterCollection() );
|
|
}
|
|
break;
|
|
case RANGE_FILTERED_INACTIVE:
|
|
{
|
|
cvf::ref<cvf::UByteArray> nativeVisibility;
|
|
ensureStaticGeometryPartsCreated( INACTIVE );
|
|
|
|
nativeVisibility = m_geometries[INACTIVE].cellVisibility( gridIdx );
|
|
computeFilterVisibility( geometryType, cellVisibility, grid, nativeVisibility.p(), m_reservoirView->cellFilterCollection() );
|
|
}
|
|
break;
|
|
case RANGE_FILTERED_WELL_CELLS:
|
|
{
|
|
cvf::ref<cvf::UByteArray> nativeVisibility;
|
|
ensureStaticGeometryPartsCreated( ALL_WELL_CELLS );
|
|
|
|
nativeVisibility = m_geometries[ALL_WELL_CELLS].cellVisibility( gridIdx );
|
|
computeFilterVisibility( geometryType, cellVisibility, grid, nativeVisibility.p(), m_reservoirView->cellFilterCollection() );
|
|
}
|
|
break;
|
|
case VISIBLE_WELL_CELLS_OUTSIDE_RANGE_FILTER:
|
|
{
|
|
cvf::ref<cvf::UByteArray> visibleWellCells;
|
|
cvf::ref<cvf::UByteArray> rangeFilteredWellCells;
|
|
|
|
ensureStaticGeometryPartsCreated( VISIBLE_WELL_CELLS );
|
|
ensureStaticGeometryPartsCreated( RANGE_FILTERED_WELL_CELLS );
|
|
|
|
visibleWellCells = m_geometries[VISIBLE_WELL_CELLS].cellVisibility( gridIdx );
|
|
rangeFilteredWellCells = m_geometries[RANGE_FILTERED_WELL_CELLS].cellVisibility( gridIdx );
|
|
|
|
cellVisibility->resize( visibleWellCells->size() );
|
|
|
|
#pragma omp parallel for
|
|
for ( int cellIdx = 0; cellIdx < static_cast<int>( cellVisibility->size() ); ++cellIdx )
|
|
{
|
|
( *cellVisibility )[cellIdx] = ( *visibleWellCells )[cellIdx] && !( *rangeFilteredWellCells )[cellIdx];
|
|
}
|
|
}
|
|
break;
|
|
case VISIBLE_WELL_FENCE_CELLS_OUTSIDE_RANGE_FILTER:
|
|
{
|
|
cvf::ref<cvf::UByteArray> visibleWellCells;
|
|
cvf::ref<cvf::UByteArray> rangeFilteredWellCells;
|
|
|
|
ensureStaticGeometryPartsCreated( VISIBLE_WELL_FENCE_CELLS );
|
|
ensureStaticGeometryPartsCreated( RANGE_FILTERED );
|
|
|
|
visibleWellCells = m_geometries[VISIBLE_WELL_FENCE_CELLS].cellVisibility( gridIdx );
|
|
rangeFilteredWellCells = m_geometries[RANGE_FILTERED].cellVisibility( gridIdx );
|
|
|
|
cellVisibility->resize( visibleWellCells->size() );
|
|
|
|
#pragma omp parallel for
|
|
for ( int cellIdx = 0; cellIdx < static_cast<int>( cellVisibility->size() ); ++cellIdx )
|
|
{
|
|
( *cellVisibility )[cellIdx] = ( *visibleWellCells )[cellIdx] && !( *rangeFilteredWellCells )[cellIdx];
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
CVF_ASSERT( false ); // Call special function for property filtered stuff
|
|
break;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::createPropertyFilteredNoneWellCellGeometry( size_t frameIndex )
|
|
{
|
|
RigEclipseCaseData* res = m_reservoirView->eclipseCase()->eclipseCaseData();
|
|
|
|
if ( frameIndex >= m_propFilteredGeometryFrames.size() )
|
|
{
|
|
m_propFilteredGeometryFrames.resize( frameIndex + 1 );
|
|
m_propFilteredGeometryFramesNeedsRegen.resize( frameIndex + 1, true );
|
|
}
|
|
|
|
if ( m_propFilteredGeometryFrames[frameIndex].isNull() ) m_propFilteredGeometryFrames[frameIndex] = new RivReservoirPartMgr;
|
|
|
|
m_propFilteredGeometryFrames[frameIndex]->clearAndSetReservoir( PROPERTY_FILTERED, m_reservoirView->eclipseCase(), m_reservoirView );
|
|
m_propFilteredGeometryFrames[frameIndex]->setTransform( m_scaleTransform.p() );
|
|
|
|
std::vector<RigGridBase*> grids;
|
|
res->allGrids( &grids );
|
|
|
|
bool hasActiveCellFilters = m_reservoirView->cellFilterCollection()->hasActiveFilters();
|
|
bool hasVisibleWellCells = m_reservoirView->wellCollection()->hasVisibleWellCells();
|
|
|
|
for ( size_t gIdx = 0; gIdx < grids.size(); ++gIdx )
|
|
{
|
|
cvf::ref<cvf::UByteArray> cellVisibility = m_propFilteredGeometryFrames[frameIndex]->cellVisibility( gIdx );
|
|
cvf::ref<cvf::UByteArray> rangeVisibility;
|
|
cvf::ref<cvf::UByteArray> fenceVisibility;
|
|
|
|
if ( hasActiveCellFilters && hasVisibleWellCells )
|
|
{
|
|
ensureStaticGeometryPartsCreated( RANGE_FILTERED );
|
|
ensureStaticGeometryPartsCreated( VISIBLE_WELL_FENCE_CELLS_OUTSIDE_RANGE_FILTER );
|
|
|
|
rangeVisibility = m_geometries[RANGE_FILTERED].cellVisibility( gIdx );
|
|
fenceVisibility = m_geometries[VISIBLE_WELL_FENCE_CELLS_OUTSIDE_RANGE_FILTER].cellVisibility( gIdx );
|
|
}
|
|
else if ( hasActiveCellFilters && !hasVisibleWellCells )
|
|
{
|
|
ensureStaticGeometryPartsCreated( RANGE_FILTERED );
|
|
|
|
rangeVisibility = m_geometries[RANGE_FILTERED].cellVisibility( gIdx );
|
|
fenceVisibility = m_geometries[RANGE_FILTERED].cellVisibility( gIdx );
|
|
}
|
|
else if ( !hasActiveCellFilters && hasVisibleWellCells )
|
|
{
|
|
ensureStaticGeometryPartsCreated( VISIBLE_WELL_FENCE_CELLS );
|
|
|
|
rangeVisibility = m_geometries[VISIBLE_WELL_FENCE_CELLS].cellVisibility( gIdx );
|
|
fenceVisibility = m_geometries[VISIBLE_WELL_FENCE_CELLS].cellVisibility( gIdx );
|
|
}
|
|
else if ( !hasActiveCellFilters && !hasVisibleWellCells )
|
|
{
|
|
ensureStaticGeometryPartsCreated( ACTIVE );
|
|
|
|
rangeVisibility = m_geometries[ACTIVE].cellVisibility( gIdx );
|
|
fenceVisibility = m_geometries[ACTIVE].cellVisibility( gIdx );
|
|
}
|
|
|
|
cellVisibility->resize( rangeVisibility->size() );
|
|
|
|
#pragma omp parallel for
|
|
for ( int cellIdx = 0; cellIdx < static_cast<int>( cellVisibility->size() ); ++cellIdx )
|
|
{
|
|
( *cellVisibility )[cellIdx] = ( *rangeVisibility )[cellIdx] || ( *fenceVisibility )[cellIdx];
|
|
}
|
|
|
|
computePropertyVisibility( cellVisibility.p(),
|
|
grids[gIdx],
|
|
frameIndex,
|
|
cellVisibility.p(),
|
|
m_reservoirView->eclipsePropertyFilterCollection() );
|
|
|
|
m_propFilteredGeometryFrames[frameIndex]->setCellVisibility( gIdx, cellVisibility.p() );
|
|
}
|
|
|
|
m_propFilteredGeometryFramesNeedsRegen[frameIndex] = false;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::createPropertyFilteredWellGeometry( size_t frameIndex )
|
|
{
|
|
RigEclipseCaseData* res = m_reservoirView->eclipseCase()->eclipseCaseData();
|
|
|
|
if ( frameIndex >= m_propFilteredWellGeometryFrames.size() )
|
|
{
|
|
m_propFilteredWellGeometryFrames.resize( frameIndex + 1 );
|
|
m_propFilteredWellGeometryFramesNeedsRegen.resize( frameIndex + 1, true );
|
|
}
|
|
|
|
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]->setTransform( m_scaleTransform.p() );
|
|
|
|
std::vector<RigGridBase*> grids;
|
|
res->allGrids( &grids );
|
|
|
|
bool hasActiveCellFilters = m_reservoirView->cellFilterCollection()->hasActiveFilters();
|
|
bool hasVisibleWellCells = m_reservoirView->wellCollection()->hasVisibleWellCells();
|
|
|
|
for ( size_t gIdx = 0; gIdx < grids.size(); ++gIdx )
|
|
{
|
|
cvf::ref<cvf::UByteArray> cellVisibility = m_propFilteredWellGeometryFrames[frameIndex]->cellVisibility( gIdx );
|
|
cvf::ref<cvf::UByteArray> rangeVisibility;
|
|
cvf::ref<cvf::UByteArray> wellCellsOutsideRange;
|
|
cvf::ref<cvf::UByteArray> wellFenceCells;
|
|
|
|
if ( hasActiveCellFilters && hasVisibleWellCells )
|
|
{
|
|
ensureStaticGeometryPartsCreated( RANGE_FILTERED_WELL_CELLS );
|
|
rangeVisibility = m_geometries[RANGE_FILTERED_WELL_CELLS].cellVisibility( gIdx );
|
|
|
|
ensureStaticGeometryPartsCreated( VISIBLE_WELL_CELLS_OUTSIDE_RANGE_FILTER );
|
|
wellCellsOutsideRange = m_geometries[VISIBLE_WELL_CELLS_OUTSIDE_RANGE_FILTER].cellVisibility( gIdx );
|
|
|
|
ensureStaticGeometryPartsCreated( VISIBLE_WELL_FENCE_CELLS_OUTSIDE_RANGE_FILTER );
|
|
wellFenceCells = m_geometries[VISIBLE_WELL_FENCE_CELLS_OUTSIDE_RANGE_FILTER].cellVisibility( gIdx );
|
|
}
|
|
else if ( hasActiveCellFilters && !hasVisibleWellCells )
|
|
{
|
|
ensureStaticGeometryPartsCreated( RANGE_FILTERED_WELL_CELLS );
|
|
rangeVisibility = m_geometries[RANGE_FILTERED_WELL_CELLS].cellVisibility( gIdx );
|
|
wellCellsOutsideRange = rangeVisibility;
|
|
wellFenceCells = rangeVisibility;
|
|
}
|
|
else if ( !hasActiveCellFilters && hasVisibleWellCells )
|
|
{
|
|
ensureStaticGeometryPartsCreated( VISIBLE_WELL_CELLS );
|
|
wellCellsOutsideRange = m_geometries[VISIBLE_WELL_CELLS].cellVisibility( gIdx );
|
|
|
|
ensureStaticGeometryPartsCreated( VISIBLE_WELL_FENCE_CELLS );
|
|
wellFenceCells = m_geometries[VISIBLE_WELL_FENCE_CELLS].cellVisibility( gIdx );
|
|
|
|
rangeVisibility = wellCellsOutsideRange;
|
|
}
|
|
else if ( !hasActiveCellFilters && !hasVisibleWellCells )
|
|
{
|
|
ensureStaticGeometryPartsCreated( ALL_WELL_CELLS );
|
|
wellFenceCells = m_geometries[ALL_WELL_CELLS].cellVisibility( gIdx );
|
|
wellCellsOutsideRange = wellFenceCells;
|
|
rangeVisibility = wellFenceCells;
|
|
}
|
|
|
|
cellVisibility->resize( rangeVisibility->size() );
|
|
|
|
#pragma omp parallel for
|
|
for ( int cellIdx = 0; cellIdx < static_cast<int>( cellVisibility->size() ); ++cellIdx )
|
|
{
|
|
( *cellVisibility )[cellIdx] = ( *wellFenceCells )[cellIdx] || ( *rangeVisibility )[cellIdx] ||
|
|
( *wellCellsOutsideRange )[cellIdx];
|
|
}
|
|
|
|
computePropertyVisibility( cellVisibility.p(),
|
|
grids[gIdx],
|
|
frameIndex,
|
|
cellVisibility.p(),
|
|
m_reservoirView->eclipsePropertyFilterCollection() );
|
|
|
|
m_propFilteredWellGeometryFrames[frameIndex]->setCellVisibility( gIdx, cellVisibility.p() );
|
|
}
|
|
|
|
m_propFilteredWellGeometryFramesNeedsRegen[frameIndex] = false;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// Evaluate visibility based on cell state
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::computeNativeVisibility( cvf::UByteArray* cellVisibility,
|
|
const RigGridBase* grid,
|
|
const RigActiveCellInfo* activeCellInfo,
|
|
const cvf::UByteArray* cellIsInWellStatuses,
|
|
bool invalidCellsIsVisible,
|
|
bool inactiveCellsIsVisible,
|
|
bool activeCellsIsVisible )
|
|
{
|
|
CVF_ASSERT( cellVisibility != nullptr );
|
|
CVF_ASSERT( grid != nullptr );
|
|
CVF_ASSERT( activeCellInfo != nullptr );
|
|
CVF_ASSERT( cellIsInWellStatuses != nullptr );
|
|
CVF_ASSERT( cellIsInWellStatuses->size() >= grid->cellCount() );
|
|
|
|
cellVisibility->resize( grid->cellCount() );
|
|
|
|
if ( auto activeGrid = dynamic_cast<const RigActiveCellGrid*>( grid ) )
|
|
{
|
|
auto reservoirIndices = activeGrid->activeReservoirCellIndices();
|
|
#pragma omp parallel for
|
|
for ( int i = 0; i < static_cast<int>( reservoirIndices.size() ); i++ )
|
|
{
|
|
size_t cellIndex = reservoirIndices[i];
|
|
|
|
if ( ( !activeCellsIsVisible ) || ( *cellIsInWellStatuses )[cellIndex] )
|
|
{
|
|
( *cellVisibility )[cellIndex] = false;
|
|
}
|
|
else
|
|
{
|
|
( *cellVisibility )[cellIndex] = true;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
#pragma omp parallel for
|
|
for ( int cellIndex = 0; cellIndex < static_cast<int>( grid->cellCount() ); cellIndex++ )
|
|
{
|
|
const RigCell& cell = grid->cell( cellIndex );
|
|
size_t reservoirCellIndex = grid->reservoirCellIndex( cellIndex );
|
|
bool isCellActive = activeCellInfo->isActive( reservoirCellIndex );
|
|
|
|
if ( ( !invalidCellsIsVisible && cell.isInvalid() ) || ( !inactiveCellsIsVisible && !isCellActive ) ||
|
|
( !activeCellsIsVisible && isCellActive ) || ( *cellIsInWellStatuses )[cellIndex] )
|
|
{
|
|
( *cellVisibility )[cellIndex] = false;
|
|
}
|
|
else
|
|
{
|
|
( *cellVisibility )[cellIndex] = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::computeOverriddenCellVisibility( cvf::UByteArray* cellVisibility, const RigGridBase* grid )
|
|
{
|
|
RimViewController* masterViewLink = m_reservoirView->viewController();
|
|
|
|
CVF_ASSERT( masterViewLink );
|
|
|
|
RimGridView* masterView = dynamic_cast<RimGridView*>( masterViewLink->ownerViewLinker()->masterView() );
|
|
if ( !masterView ) return;
|
|
|
|
// get cell visibility
|
|
#if 1
|
|
cvf::ref<cvf::UByteArray> totCellVisibility = masterView->currentTotalCellVisibility();
|
|
#else
|
|
// Could get something more like
|
|
std::vector<std::vector<cvf::UByteArray*>> gridsWithCellSetVisibility = masterView->getAllGridsCurrentCellSetsCellVisibility();
|
|
#endif
|
|
|
|
CVF_ASSERT( cellVisibility != nullptr );
|
|
CVF_ASSERT( grid != nullptr );
|
|
|
|
size_t gridCellCount = grid->cellCount();
|
|
cellVisibility->resize( gridCellCount );
|
|
cellVisibility->setAll( false );
|
|
|
|
const RigCaseToCaseCellMapper* cellMapper = masterViewLink->cellMapper();
|
|
|
|
for ( size_t lcIdx = 0; lcIdx < gridCellCount; ++lcIdx )
|
|
{
|
|
#if 1
|
|
int reservoirCellIdx = static_cast<int>( grid->reservoirCellIndex( lcIdx ) );
|
|
int cellCount = 0;
|
|
const int* cellIndicesInMasterCase = cellMapper->masterCaseCellIndices( reservoirCellIdx, &cellCount );
|
|
|
|
for ( int mcIdx = 0; mcIdx < cellCount; ++mcIdx )
|
|
{
|
|
( *cellVisibility )[lcIdx] |= ( *totCellVisibility )[cellIndicesInMasterCase[mcIdx]]; // If any is
|
|
// visible, show
|
|
}
|
|
|
|
#else
|
|
|
|
const RigGridCells& masterCaseCells = cellMapper->masterCaseGridAndLocalCellIndex( grid->gridIndex, lcIdx );
|
|
|
|
for ( int mcIdx = 0; mcIdx < masterCaseCells.cellCount(); ++mcIdx )
|
|
{
|
|
int cellSetCount = gridsWithCellSetVisibility[masterCaseCells.gridIndex[mcIdx]].size();
|
|
for ( int csIdx = 0; csIdx < cellSetCount; ++csIdx )
|
|
{
|
|
( *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.
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::copyByteArray( cvf::UByteArray* destination, const cvf::UByteArray* source )
|
|
{
|
|
CVF_ASSERT( destination != nullptr );
|
|
CVF_ASSERT( source != nullptr );
|
|
|
|
if ( destination->size() != source->size() )
|
|
{
|
|
destination->resize( source->size() );
|
|
}
|
|
|
|
#pragma omp parallel for
|
|
for ( int cellIndex = 0; cellIndex < static_cast<int>( source->size() ); cellIndex++ )
|
|
{
|
|
( *destination )[cellIndex] = ( *source )[cellIndex];
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::computeFilterVisibility( RivCellSetEnum geometryType,
|
|
cvf::UByteArray* cellVisibility,
|
|
const RigGridBase* grid,
|
|
const cvf::UByteArray* nativeVisibility,
|
|
const RimCellFilterCollection* cellFilterColl )
|
|
{
|
|
CVF_ASSERT( cellVisibility != nullptr );
|
|
CVF_ASSERT( nativeVisibility != nullptr );
|
|
CVF_ASSERT( cellFilterColl != nullptr );
|
|
|
|
CVF_ASSERT( grid != nullptr );
|
|
CVF_ASSERT( nativeVisibility->size() == grid->cellCount() );
|
|
|
|
// Initialize filter with native visibility
|
|
if ( cellVisibility != nativeVisibility ) ( *cellVisibility ) = ( *nativeVisibility );
|
|
|
|
if ( cellFilterColl->hasActiveFilters() || m_reservoirView->wellCollection()->hasVisibleWellCells() )
|
|
{
|
|
cvf::UByteArray indexIncludeVisibility = ( *cellVisibility );
|
|
cvf::UByteArray indexExcludeVisibility = ( *cellVisibility );
|
|
|
|
// Build cell filter for current grid
|
|
cvf::CellRangeFilter gridCellRangeFilter;
|
|
cellFilterColl->compoundCellRangeFilter( &gridCellRangeFilter, grid->gridIndex() );
|
|
cellFilterColl->updateCellVisibilityByIndex( &indexIncludeVisibility, &indexExcludeVisibility, grid->gridIndex() );
|
|
|
|
const RigLocalGrid* lgr = nullptr;
|
|
cvf::ref<cvf::UByteArray> parentGridVisibilities;
|
|
|
|
if ( !grid->isMainGrid() )
|
|
{
|
|
lgr = static_cast<const RigLocalGrid*>( grid );
|
|
|
|
size_t parentGridIndex = lgr->parentGrid()->gridIndex();
|
|
CVF_ASSERT( parentGridIndex < grid->gridIndex() );
|
|
|
|
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
|
|
}
|
|
|
|
RivReservoirPartMgr* reservoirGridPartMgr = &m_geometries[geometryType];
|
|
|
|
parentGridVisibilities = reservoirGridPartMgr->cellVisibility( parentGridIndex );
|
|
}
|
|
|
|
const bool hasAdditiveRangeFilters = cellFilterColl->hasActiveIncludeRangeFilters() ||
|
|
m_reservoirView->wellCollection()->hasVisibleWellCells();
|
|
const bool hasAdditiveIndexFilters = cellFilterColl->hasActiveIncludeIndexFilters();
|
|
|
|
const bool useAndOperation = cellFilterColl->useAndOperation();
|
|
|
|
#pragma omp parallel for
|
|
for ( int cellIndex = 0; cellIndex < static_cast<int>( grid->cellCount() ); cellIndex++ )
|
|
{
|
|
if ( ( *nativeVisibility )[cellIndex] )
|
|
{
|
|
const RigCell& cell = grid->cell( cellIndex );
|
|
bool visibleDueToParentGrid = false;
|
|
if ( lgr )
|
|
{
|
|
size_t parentGridCellIndex = cell.parentCellIndex();
|
|
visibleDueToParentGrid = parentGridVisibilities->get( parentGridCellIndex );
|
|
}
|
|
|
|
// Normal grid visibility
|
|
size_t mainGridI;
|
|
size_t mainGridJ;
|
|
size_t mainGridK;
|
|
|
|
const bool isInSubGridArea = cell.subGrid() != nullptr;
|
|
grid->ijkFromCellIndex( cellIndex, &mainGridI, &mainGridJ, &mainGridK );
|
|
|
|
bool nativeRangeVisibility = false;
|
|
|
|
if ( hasAdditiveRangeFilters )
|
|
{
|
|
if ( hasAdditiveIndexFilters )
|
|
{
|
|
if ( useAndOperation )
|
|
{
|
|
nativeRangeVisibility = indexIncludeVisibility[cellIndex] &&
|
|
gridCellRangeFilter.isCellVisible( mainGridI, mainGridJ, mainGridK, isInSubGridArea );
|
|
}
|
|
else
|
|
{
|
|
nativeRangeVisibility = indexIncludeVisibility[cellIndex] ||
|
|
gridCellRangeFilter.isCellVisible( mainGridI, mainGridJ, mainGridK, isInSubGridArea );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nativeRangeVisibility = gridCellRangeFilter.isCellVisible( mainGridI, mainGridJ, mainGridK, isInSubGridArea );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nativeRangeVisibility = indexIncludeVisibility[cellIndex];
|
|
}
|
|
|
|
( *cellVisibility )[cellIndex] = ( visibleDueToParentGrid || nativeRangeVisibility ) &&
|
|
!gridCellRangeFilter.isCellExcluded( mainGridI, mainGridJ, mainGridK, isInSubGridArea ) &&
|
|
indexExcludeVisibility[cellIndex];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
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 );
|
|
CVF_ASSERT( propFilterColl != nullptr );
|
|
|
|
CVF_ASSERT( grid->cellCount() > 0 );
|
|
CVF_ASSERT( rangeFilterVisibility->size() == grid->cellCount() );
|
|
|
|
// Copy if not equal
|
|
if ( cellVisibility != rangeFilterVisibility ) ( *cellVisibility ) = *rangeFilterVisibility;
|
|
|
|
if ( propFilterColl->hasActiveFilters() )
|
|
{
|
|
for ( size_t i = 0; i < propFilterColl->propertyFilters().size(); i++ )
|
|
{
|
|
RimEclipsePropertyFilter* propertyFilter = propFilterColl->propertyFilters()[i];
|
|
|
|
if ( propertyFilter->isActive() && propertyFilter->resultDefinition()->hasResult() )
|
|
{
|
|
propertyFilter->resultDefinition()->loadResult();
|
|
|
|
const RimCellFilter::FilterModeType filterType = propertyFilter->filterMode();
|
|
|
|
RigEclipseCaseData* eclipseCase = propFilterColl->reservoirView()->eclipseCase()->eclipseCaseData();
|
|
|
|
cvf::ref<RigResultAccessor> resultAccessor =
|
|
RigResultAccessorFactory::createFromResultDefinition( eclipseCase,
|
|
grid->gridIndex(),
|
|
timeStepIndex,
|
|
propertyFilter->resultDefinition() );
|
|
|
|
CVF_ASSERT( resultAccessor.notNull() );
|
|
|
|
if ( propertyFilter->isCategorySelectionActive() )
|
|
{
|
|
std::vector<int> integerVector = propertyFilter->selectedCategoryValues();
|
|
std::set<int> integerSet;
|
|
for ( auto val : integerVector )
|
|
{
|
|
integerSet.insert( val );
|
|
}
|
|
|
|
for ( int cellIndex = 0; cellIndex < static_cast<int>( grid->cellCount() ); cellIndex++ )
|
|
{
|
|
if ( ( *cellVisibility )[cellIndex] )
|
|
{
|
|
size_t resultValueIndex = cellIndex;
|
|
|
|
double scalarValue = resultAccessor->cellScalar( resultValueIndex );
|
|
if ( integerSet.find( scalarValue ) != integerSet.end() )
|
|
{
|
|
if ( filterType == RimCellFilter::EXCLUDE )
|
|
{
|
|
( *cellVisibility )[cellIndex] = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( filterType == RimCellFilter::INCLUDE )
|
|
{
|
|
( *cellVisibility )[cellIndex] = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
double lowerBound = 0.0;
|
|
double upperBound = 0.0;
|
|
propertyFilter->rangeValues( &lowerBound, &upperBound );
|
|
|
|
for ( int cellIndex = 0; cellIndex < static_cast<int>( grid->cellCount() ); cellIndex++ )
|
|
{
|
|
if ( ( *cellVisibility )[cellIndex] )
|
|
{
|
|
size_t resultValueIndex = cellIndex;
|
|
|
|
double scalarValue = resultAccessor->cellScalar( resultValueIndex );
|
|
if ( lowerBound <= scalarValue && scalarValue <= upperBound )
|
|
{
|
|
if ( filterType == RimCellFilter::EXCLUDE )
|
|
{
|
|
( *cellVisibility )[cellIndex] = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( filterType == RimCellFilter::INCLUDE )
|
|
{
|
|
( *cellVisibility )[cellIndex] = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::updateCellColor( RivCellSetEnum geometryType, size_t timeStepIndex, cvf::Color4f color )
|
|
{
|
|
RivReservoirPartMgr* pmgr = reservoirPartManager( geometryType, timeStepIndex );
|
|
pmgr->updateCellColor( color );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::updateCellResultColor( RivCellSetEnum geometryType, size_t timeStepIndex, RimEclipseCellColors* cellResultColors )
|
|
{
|
|
RivReservoirPartMgr* pmgr = reservoirPartManager( geometryType, timeStepIndex );
|
|
pmgr->updateCellResultColor( timeStepIndex, cellResultColors );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::updateCellEdgeResultColor( RivCellSetEnum geometryType,
|
|
size_t timeStepIndex,
|
|
RimEclipseCellColors* cellResultColors,
|
|
RimCellEdgeColors* cellEdgeResultColors )
|
|
{
|
|
RivReservoirPartMgr* pmgr = reservoirPartManager( geometryType, timeStepIndex );
|
|
pmgr->updateCellEdgeResultColor( timeStepIndex, cellResultColors, cellEdgeResultColors );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::updateFaultCellEdgeResultColor( RivCellSetEnum geometryType,
|
|
size_t timeStepIndex,
|
|
RimEclipseCellColors* cellResultColors,
|
|
RimCellEdgeColors* cellEdgeResultColors )
|
|
{
|
|
RivReservoirPartMgr* pmgr = reservoirPartManager( geometryType, timeStepIndex );
|
|
pmgr->updateFaultCellEdgeResultColor( timeStepIndex, cellResultColors, cellEdgeResultColors );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
const cvf::UByteArray* RivReservoirViewPartMgr::cellVisibility( RivCellSetEnum geometryType, size_t gridIndex, size_t timeStepIndex )
|
|
{
|
|
ensureDynamicGeometryPartsCreated( geometryType, timeStepIndex );
|
|
ensureStaticGeometryPartsCreated( geometryType );
|
|
|
|
RivReservoirPartMgr* pmgr = ( const_cast<RivReservoirViewPartMgr*>( this ) )->reservoirPartManager( geometryType, timeStepIndex );
|
|
|
|
return pmgr->cellVisibility( gridIndex ).p();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RivReservoirPartMgr* RivReservoirViewPartMgr::reservoirPartManager( RivCellSetEnum geometryType, size_t timeStepIndex )
|
|
{
|
|
if ( geometryType == PROPERTY_FILTERED )
|
|
{
|
|
return m_propFilteredGeometryFrames[timeStepIndex].p();
|
|
}
|
|
else if ( geometryType == PROPERTY_FILTERED_WELL_CELLS )
|
|
{
|
|
return m_propFilteredWellGeometryFrames[timeStepIndex].p();
|
|
}
|
|
else
|
|
{
|
|
return &m_geometries[geometryType];
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::updateFaultColors( RivCellSetEnum geometryType, size_t timeStepIndex, RimEclipseCellColors* cellResultColors )
|
|
{
|
|
if ( geometryType == PROPERTY_FILTERED && timeStepIndex >= m_propFilteredGeometryFrames.size() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if ( geometryType == PROPERTY_FILTERED_WELL_CELLS && timeStepIndex >= m_propFilteredWellGeometryFrames.size() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
RivReservoirPartMgr* pmgr = reservoirPartManager( geometryType, timeStepIndex );
|
|
pmgr->updateFaultColors( timeStepIndex, cellResultColors );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::appendFaultsStaticGeometryPartsToModel( cvf::ModelBasicList* model, RivCellSetEnum geometryType )
|
|
{
|
|
if ( geometryType >= PROPERTY_FILTERED ) return;
|
|
|
|
ensureStaticGeometryPartsCreated( geometryType );
|
|
|
|
/*
|
|
QString text;
|
|
switch (geometryType)
|
|
{
|
|
case OVERRIDDEN_CELL_VISIBILITY:
|
|
text = "OVERRIDDEN_CELL_VISIBILITY";
|
|
break;
|
|
case ALL_CELLS:
|
|
text = "ALL_CELLS";
|
|
break;
|
|
case ACTIVE:
|
|
text = "ACTIVE";
|
|
break;
|
|
case ALL_WELL_CELLS:
|
|
text = "ALL_WELL_CELLS";
|
|
break;
|
|
case VISIBLE_WELL_CELLS:
|
|
text = "VISIBLE_WELL_CELLS";
|
|
break;
|
|
case VISIBLE_WELL_FENCE_CELLS:
|
|
text = "VISIBLE_WELL_FENCE_CELLS";
|
|
break;
|
|
case INACTIVE:
|
|
text = "INACTIVE";
|
|
break;
|
|
case RANGE_FILTERED:
|
|
text = "RANGE_FILTERED";
|
|
break;
|
|
case RANGE_FILTERED_INACTIVE:
|
|
text = "RANGE_FILTERED_INACTIVE";
|
|
break;
|
|
case RANGE_FILTERED_WELL_CELLS:
|
|
text = "RANGE_FILTERED_WELL_CELLS";
|
|
break;
|
|
case VISIBLE_WELL_CELLS_OUTSIDE_RANGE_FILTER:
|
|
text = "VISIBLE_WELL_CELLS_OUTSIDE_RANGE_FILTER";
|
|
break;
|
|
case VISIBLE_WELL_FENCE_CELLS_OUTSIDE_RANGE_FILTER:
|
|
text = "VISIBLE_WELL_FENCE_CELLS_OUTSIDE_RANGE_FILTER";
|
|
break;
|
|
case PROPERTY_FILTERED:
|
|
text = "PROPERTY_FILTERED";
|
|
break;
|
|
case PROPERTY_FILTERED_WELL_CELLS:
|
|
text = "PROPERTY_FILTERED_WELL_CELLS";
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
qDebug() << text;
|
|
*/
|
|
|
|
m_geometries[geometryType].appendFaultPartsToModel( model );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::appendFaultsDynamicGeometryPartsToModel( cvf::ModelBasicList* model, RivCellSetEnum geometryType, size_t frameIndex )
|
|
{
|
|
if ( geometryType == PROPERTY_FILTERED )
|
|
{
|
|
// qDebug() << "PROPERTY_FILTERED";
|
|
|
|
m_propFilteredGeometryFrames[frameIndex]->appendFaultPartsToModel( model );
|
|
}
|
|
else if ( geometryType == PROPERTY_FILTERED_WELL_CELLS )
|
|
{
|
|
// qDebug() << "PROPERTY_FILTERED_WELL_CELLS";
|
|
|
|
m_propFilteredWellGeometryFrames[frameIndex]->appendFaultPartsToModel( model );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RivCellSetEnum RivReservoirViewPartMgr::geometryTypeForFaultLabels( const std::set<RivCellSetEnum>& geometryTypes,
|
|
bool showFaultsOutsideFilters ) const
|
|
{
|
|
for ( RivCellSetEnum cellSetType : geometryTypes )
|
|
{
|
|
if ( !showFaultsOutsideFilters )
|
|
{
|
|
if ( cellSetType == PROPERTY_FILTERED )
|
|
{
|
|
return PROPERTY_FILTERED;
|
|
}
|
|
|
|
if ( cellSetType == RANGE_FILTERED )
|
|
{
|
|
return RANGE_FILTERED;
|
|
}
|
|
}
|
|
}
|
|
|
|
return ACTIVE;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::appendFaultLabelsStaticGeometryPartsToModel( cvf::ModelBasicList* model, RivCellSetEnum geometryType )
|
|
{
|
|
ensureStaticGeometryPartsCreated( geometryType );
|
|
m_geometries[geometryType].appendFaultLabelPartsToModel( model );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::appendFaultLabelsDynamicGeometryPartsToModel( cvf::ModelBasicList* model,
|
|
RivCellSetEnum geometryType,
|
|
size_t frameIndex )
|
|
{
|
|
m_propFilteredGeometryFrames[frameIndex]->appendFaultLabelPartsToModel( model );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::appendElementVectorResultDynamicGeometryPartsToModel( cvf::ModelBasicList* model,
|
|
RivCellSetEnum geometryType,
|
|
size_t frameIndex )
|
|
{
|
|
ensureDynamicGeometryPartsCreated( geometryType, frameIndex );
|
|
if ( geometryType == PROPERTY_FILTERED )
|
|
{
|
|
m_propFilteredGeometryFrames[frameIndex]->appendElementVectorResultPartsToModel( model, frameIndex );
|
|
}
|
|
else if ( geometryType == PROPERTY_FILTERED_WELL_CELLS )
|
|
{
|
|
m_propFilteredWellGeometryFrames[frameIndex]->appendElementVectorResultPartsToModel( model, frameIndex );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::forceWatertightGeometryOnForType( RivCellSetEnum geometryType )
|
|
{
|
|
if ( geometryType == PROPERTY_FILTERED )
|
|
{
|
|
for ( size_t i = 0; i < m_propFilteredGeometryFrames.size(); ++i )
|
|
{
|
|
if ( m_propFilteredGeometryFrames[i].p() ) m_propFilteredGeometryFrames[i]->forceWatertightGeometryOn();
|
|
}
|
|
}
|
|
else if ( geometryType == PROPERTY_FILTERED_WELL_CELLS )
|
|
{
|
|
for ( size_t i = 0; i < m_propFilteredWellGeometryFrames.size(); ++i )
|
|
{
|
|
if ( m_propFilteredWellGeometryFrames[i].p() ) m_propFilteredWellGeometryFrames[i]->forceWatertightGeometryOn();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ensureStaticGeometryPartsCreated( geometryType );
|
|
m_geometries[geometryType].forceWatertightGeometryOn();
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RivReservoirViewPartMgr::clearWatertightGeometryFlags()
|
|
{
|
|
for ( size_t i = 0; i < m_propFilteredGeometryFrames.size(); ++i )
|
|
{
|
|
if ( m_propFilteredGeometryFrames[i].p() ) m_propFilteredGeometryFrames[i]->clearWatertightGeometryFlag();
|
|
}
|
|
|
|
for ( size_t i = 0; i < m_propFilteredWellGeometryFrames.size(); ++i )
|
|
{
|
|
if ( m_propFilteredWellGeometryFrames[i].p() ) m_propFilteredWellGeometryFrames[i]->clearWatertightGeometryFlag();
|
|
}
|
|
|
|
for ( int i = 0; i < PROPERTY_FILTERED; i++ )
|
|
{
|
|
m_geometries[RivCellSetEnum( i )].clearWatertightGeometryFlag();
|
|
}
|
|
}
|