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

#7739 Show only visible categories in legend

Browse Source 
For the main Cell Result Legend, add an option to only show visible categories
This commit is contained in:
Magne Sjaastad
2021-05-31 08:19:12 +02:00
parent 6e0dadbdaa
commit b3467a2fca
6 changed files with 374 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
ApplicationLibCode/ReservoirDataModel/CMakeLists_files.cmake
View File

@@ -83,7 +83,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RigGocadData.h
${CMAKE_CURRENT_LIST_DIR}/RigElasticProperties.h
${CMAKE_CURRENT_LIST_DIR}/RigEnsembleFractureStatisticsCalculator.h
${CMAKE_CURRENT_LIST_DIR}/RigHistogramData.h
${CMAKE_CURRENT_LIST_DIR}/RigVisibleTracerFilter.h
${CMAKE_CURRENT_LIST_DIR}/RigVisibleCategoriesCalculator.h
${CMAKE_CURRENT_LIST_DIR}/RigTracerPoint.h
${CMAKE_CURRENT_LIST_DIR}/RigTracer.h
${CMAKE_CURRENT_LIST_DIR}/RigStimPlanModelTools.h
@@ -168,7 +168,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RigGocadData.cpp
${CMAKE_CURRENT_LIST_DIR}/RigElasticProperties.cpp
${CMAKE_CURRENT_LIST_DIR}/RigEnsembleFractureStatisticsCalculator.cpp
${CMAKE_CURRENT_LIST_DIR}/RigHistogramData.cpp
${CMAKE_CURRENT_LIST_DIR}/RigVisibleTracerFilter.cpp
${CMAKE_CURRENT_LIST_DIR}/RigVisibleCategoriesCalculator.cpp
${CMAKE_CURRENT_LIST_DIR}/RigTracerPoint.cpp
${CMAKE_CURRENT_LIST_DIR}/RigTracer.cpp
${CMAKE_CURRENT_LIST_DIR}/RigStimPlanModelTools.cpp

252
ApplicationLibCode/ReservoirDataModel/RigVisibleCategoriesCalculator.cpp Normal file
View File

@@ -0,0 +1,252 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2021- Equinor ASA
//
// 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 "RigVisibleCategoriesCalculator.h"
#include "RiaResultNames.h"
#include "RigEclipseCaseData.h"
#include "RigEclipseNativeVisibleCellsStatCalc.h"
#include "RigFault.h"
#include "RigFlowDiagResults.h"
#include "RigFlowDiagVisibleCellsStatCalc.h"
#include "RigMainGrid.h"
#include "RigNNCData.h"
#include "RigResultAccessorFactory.h"
#include "RimBoxIntersection.h"
#include "RimEclipseCase.h"
#include "RimEclipseCellColors.h"
#include "RimEclipseFaultColors.h"
#include "RimEclipseView.h"
#include "RimExtrudedCurveIntersection.h"
#include "RimFaultInView.h"
#include "RimFaultInViewCollection.h"
#include "RimIntersection.h"
#include "RimIntersectionCollection.h"
#include "RimIntersectionResultsDefinitionCollection.h"
#include "RimSurface.h"
#include "RimSurfaceCollection.h"
#include "RimSurfaceInView.h"
#include "RimSurfaceInViewCollection.h"
#include "RivHexGridIntersectionTools.h"
#include <cmath>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::set<int> RigVisibleCategoriesCalculator::visibleFlowDiagCategories( RimEclipseView& eclView,
RigFlowDiagResults& flowDiagResults,
const RigFlowDiagResultAddress& resVarAddr,
size_t timeStepIndex )
{
cvf::ref<cvf::UByteArray> cellVisibilities = eclView.currentTotalCellVisibility();
cvf::ref<RigFlowDiagVisibleCellsStatCalc> calculator =
cvf::make_ref<RigFlowDiagVisibleCellsStatCalc>( &flowDiagResults, resVarAddr, cellVisibilities.p() );
std::set<int> visibleTracers;
calculator->uniqueValues( timeStepIndex, visibleTracers );
return visibleTracers;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::set<size_t> RigVisibleCategoriesCalculator::visibleAllanCategories( RimEclipseView* eclView )
{
if ( !( eclView && eclView->mainGrid() ) ) return {};
RigNNCData* nncData = eclView->mainGrid()->nncData();
std::set<size_t> usedAllanIndices;
auto fnAllanNncResults = nncData->staticConnectionScalarResultByName( RiaResultNames::formationAllanResultName() );
if ( fnAllanNncResults )
{
auto visibleConnectionIndices = visibleNncConnectionIndices( eclView );
for ( auto connIdx : visibleConnectionIndices )
{
auto allanValue = fnAllanNncResults->at( connIdx );
usedAllanIndices.insert( allanValue );
}
}
return usedAllanIndices;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::set<int> RigVisibleCategoriesCalculator::visibleCategories( RimEclipseView* eclView )
{
std::set<int> visibleCategoryValues;
{
// Visible eclipse grid cells
RimEclipseResultDefinition* resDef = eclView->cellResult();
RigEclipseNativeVisibleCellsStatCalc calc( resDef->currentGridCellResults(),
resDef->eclipseResultAddress(),
eclView->currentTotalCellVisibility().p() );
calc.uniqueValues( eclView->currentTimeStep(), visibleCategoryValues );
}
{
// Visible cells in faults and intersections
std::set<size_t> visibleReservoirCells;
RigVisibleCategoriesCalculator::appendVisibleFaultCells( eclView, visibleReservoirCells );
RigVisibleCategoriesCalculator::appendVisibleIntersectionCells( eclView, visibleReservoirCells );
RimEclipseResultDefinition* resDef = eclView->cellResult();
cvf::ref<RigResultAccessor> resultAccessor =
RigResultAccessorFactory::createFromResultDefinition( eclView->eclipseCase()->eclipseCaseData(),
0,
eclView->currentTimeStep(),
resDef );
if ( resultAccessor.notNull() )
{
for ( auto cIdx : visibleReservoirCells )
{
const auto resultVal = resultAccessor->cellScalarGlobIdx( cIdx );
if ( resultVal != HUGE_VAL )
{
visibleCategoryValues.insert( resultVal );
}
}
}
}
return visibleCategoryValues;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::set<size_t> RigVisibleCategoriesCalculator::visibleNncConnectionIndices( RimEclipseView* eclView )
{
if ( !eclView->faultCollection() || !eclView->faultCollection()->showFaultCollection ) return {};
std::set<size_t> visibleConnectionIndices;
std::vector<RimFaultInView*> visibleFaults;
for ( auto f : eclView->faultCollection()->faults() )
{
if ( f->showFault() )
{
visibleFaults.push_back( f );
auto nncConnectionIndices = f->faultGeometry()->connectionIndices();
for ( const auto& c : nncConnectionIndices )
{
visibleConnectionIndices.insert( c );
}
}
}
return visibleConnectionIndices;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigVisibleCategoriesCalculator::appendVisibleFaultCells( RimEclipseView* eclView, std::set<size_t>& visibleCells )
{
if ( eclView->faultCollection() && eclView->faultCollection()->showFaultCollection &&
!eclView->faultResultSettings()->showCustomFaultResult() )
{
for ( const auto& f : eclView->faultCollection()->faults() )
{
if ( f->showFault() )
{
for ( const auto& faultFace : f->faultGeometry()->faultFaces() )
{
visibleCells.insert( faultFace.m_nativeReservoirCellIndex );
visibleCells.insert( faultFace.m_oppositeReservoirCellIndex );
}
}
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigVisibleCategoriesCalculator::appendVisibleIntersectionCells( RimEclipseView* eclView, std::set<size_t>& visibleCells )
{
// Intersections
std::vector<const RivIntersectionGeometryGeneratorIF*> intersectionGeoGenerators;
if ( !eclView->separateIntersectionResultsCollection()->isActive() )
{
if ( eclView->intersectionCollection()->isActive() )
{
for ( auto intersection : eclView->intersectionCollection()->intersections() )
{
if ( intersection->isActive() )
{
auto geoGenerator = intersection->intersectionGeometryGenerator();
if ( geoGenerator )
{
intersectionGeoGenerators.push_back( geoGenerator );
}
}
}
for ( auto intersection : eclView->intersectionCollection()->intersectionBoxes() )
{
if ( intersection->isActive() )
{
auto geoGenerator = intersection->intersectionGeometryGenerator();
if ( geoGenerator )
{
intersectionGeoGenerators.push_back( geoGenerator );
}
}
}
}
}
if ( eclView->separateSurfaceResultsCollection()->isActive() )
{
// Surfaces in view
if ( eclView->surfaceInViewCollection() && eclView->surfaceInViewCollection()->isChecked() )
{
auto geoGenerators = eclView->surfaceInViewCollection()->intersectionGeometryGenerators();
intersectionGeoGenerators.insert( intersectionGeoGenerators.end(), geoGenerators.begin(), geoGenerators.end() );
}
}
for ( const auto geoGenerator : intersectionGeoGenerators )
{
for ( const auto& cIdx : geoGenerator->triangleToCellIndex() )
{
visibleCells.insert( cIdx );
}
}
}

20
ApplicationLibCode/ReservoirDataModel/RigVisibleTracerFilter.h → ApplicationLibCode/ReservoirDataModel/RigVisibleCategoriesCalculator.h
View File

@@ -28,12 +28,20 @@ class RigFlowDiagResultAddress;
//==================================================================================================
///
//==================================================================================================
class RigVisibleTracerFilter
class RigVisibleCategoriesCalculator
{
public:
static void filterByVisibility( RimEclipseView& eclView,
RigFlowDiagResults& flowDiagResults,
const RigFlowDiagResultAddress& resVarAddr,
size_t timeStepIndex,
std::set<int>& visibleTracers );
static std::set<int> visibleFlowDiagCategories( RimEclipseView& eclView,
RigFlowDiagResults& flowDiagResults,
const RigFlowDiagResultAddress& resVarAddr,
size_t timeStepIndex );
static std::set<size_t> visibleAllanCategories( RimEclipseView* eclView );
static std::set<int> visibleCategories( RimEclipseView* eclView );
private:
static std::set<size_t> visibleNncConnectionIndices( RimEclipseView* eclView );
static void appendVisibleFaultCells( RimEclipseView* eclView, std::set<size_t>& visibleCells );
static void appendVisibleIntersectionCells( RimEclipseView* eclView, std::set<size_t>& visibleCells );
};

44
ApplicationLibCode/ReservoirDataModel/RigVisibleTracerFilter.cpp
View File

@@ -1,44 +0,0 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2021- Equinor ASA
//
// 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 "RigVisibleTracerFilter.h"
#include "RigFlowDiagResults.h"
#include "RigFlowDiagVisibleCellsStatCalc.h"
#include "RimEclipseView.h"
#include "cvfArray.h"
#include <cmath>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigVisibleTracerFilter::filterByVisibility( RimEclipseView& eclView,
RigFlowDiagResults& flowDiagResults,
const RigFlowDiagResultAddress& resVarAddr,
size_t timeStepIndex,
std::set<int>& visibleTracers )
{
cvf::ref<cvf::UByteArray> cellVisibilities = eclView.currentTotalCellVisibility();
cvf::ref<RigFlowDiagVisibleCellsStatCalc> calculator =
cvf::make_ref<RigFlowDiagVisibleCellsStatCalc>( &flowDiagResults, resVarAddr, cellVisibilities.p() );
calculator->uniqueValues( timeStepIndex, visibleTracers );
}