mirror of
https://github.com/OPM/ResInsight.git
synced 2025-01-24 07:16:53 -06:00
1037 lines
47 KiB
C++
1037 lines
47 KiB
C++
/////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (C) Statoil ASA
|
|
// Copyright (C) Ceetron Solutions 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 "RiuResultTextBuilder.h"
|
|
|
|
#include "RigCaseCellResultsData.h"
|
|
#include "RigEclipseCaseData.h"
|
|
#include "RigFormationNames.h"
|
|
#include "RigMainGrid.h"
|
|
#include "RigResultAccessor.h"
|
|
#include "RigResultAccessorFactory.h"
|
|
#include "RigSimWellData.h"
|
|
|
|
#include "Rim2dIntersectionView.h"
|
|
#include "RimCellEdgeColors.h"
|
|
#include "RimEclipseCase.h"
|
|
#include "RimEclipseCellColors.h"
|
|
#include "RimEclipseFaultColors.h"
|
|
#include "RimEclipseView.h"
|
|
#include "RimExtrudedCurveIntersection.h"
|
|
#include "RimFormationNames.h"
|
|
#include "RimRegularLegendConfig.h"
|
|
#include "RimReservoirCellResultsStorage.h"
|
|
|
|
#include "RivExtrudedCurveIntersectionPartMgr.h"
|
|
|
|
#include "RigAllenDiagramData.h"
|
|
#include "RimIntersectionResultDefinition.h"
|
|
#include "cafDisplayCoordTransform.h"
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RiuResultTextBuilder::RiuResultTextBuilder( RimGridView* settingsView,
|
|
RimEclipseResultDefinition* eclResDef,
|
|
size_t gridIndex,
|
|
size_t cellIndex,
|
|
size_t timeStepIndex )
|
|
{
|
|
CVF_ASSERT( eclResDef );
|
|
|
|
m_displayCoordView = settingsView;
|
|
m_viewWithFaultsSettings = dynamic_cast<RimEclipseView*>( settingsView );
|
|
m_eclResDef = eclResDef;
|
|
m_gridIndex = gridIndex;
|
|
m_cellIndex = cellIndex;
|
|
m_timeStepIndex = timeStepIndex;
|
|
|
|
m_nncIndex = cvf::UNDEFINED_SIZE_T;
|
|
m_intersectionPointInDisplay = cvf::Vec3d::UNDEFINED;
|
|
m_face = cvf::StructGridInterface::NO_FACE;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RiuResultTextBuilder::RiuResultTextBuilder( RimGridView* settingsView,
|
|
RimEclipseResultDefinition* eclResDef,
|
|
size_t reservoirCellIndex,
|
|
size_t timeStepIndex )
|
|
{
|
|
CVF_ASSERT( eclResDef );
|
|
|
|
m_displayCoordView = settingsView;
|
|
m_viewWithFaultsSettings = dynamic_cast<RimEclipseView*>( settingsView );
|
|
m_eclResDef = eclResDef;
|
|
m_gridIndex = 0;
|
|
m_cellIndex = 0;
|
|
m_timeStepIndex = timeStepIndex;
|
|
|
|
RimEclipseCase* eclipseCase = eclResDef->eclipseCase();
|
|
if ( eclipseCase && eclipseCase->eclipseCaseData() )
|
|
{
|
|
RigEclipseCaseData* caseData = eclipseCase->eclipseCaseData();
|
|
RigMainGrid* mainGrid = caseData->mainGrid();
|
|
|
|
const RigCell& cell = caseData->mainGrid()->globalCellArray()[reservoirCellIndex];
|
|
|
|
for ( size_t i = 0; i < mainGrid->gridCount(); i++ )
|
|
{
|
|
if ( mainGrid->gridByIndex( i ) == cell.hostGrid() )
|
|
{
|
|
m_gridIndex = i;
|
|
m_cellIndex = cell.gridLocalCellIndex();
|
|
}
|
|
}
|
|
}
|
|
|
|
m_nncIndex = cvf::UNDEFINED_SIZE_T;
|
|
m_intersectionPointInDisplay = cvf::Vec3d::UNDEFINED;
|
|
m_face = cvf::StructGridInterface::NO_FACE;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RiuResultTextBuilder::setNncIndex( size_t nncIndex )
|
|
{
|
|
m_nncIndex = nncIndex;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RiuResultTextBuilder::setIntersectionPointInDisplay( cvf::Vec3d intersectionPointInDisplay )
|
|
{
|
|
m_intersectionPointInDisplay = intersectionPointInDisplay;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RiuResultTextBuilder::set2dIntersectionView( Rim2dIntersectionView* intersectionView )
|
|
{
|
|
m_2dIntersectionView = intersectionView;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RiuResultTextBuilder::setFace( cvf::StructGridInterface::FaceType face )
|
|
{
|
|
m_face = face;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RiuResultTextBuilder::mainResultText()
|
|
{
|
|
QString text;
|
|
|
|
// Produce result text for all variants
|
|
// Priority defined as follows : NNC, Fault, Grid
|
|
{
|
|
QString nncText = nncResultText();
|
|
if ( !nncText.isEmpty() )
|
|
{
|
|
text = "NNC : " + nncText;
|
|
}
|
|
else if ( m_cellIndex != cvf::UNDEFINED_SIZE_T )
|
|
{
|
|
QString faultText = faultResultText();
|
|
|
|
if ( !faultResultText().isEmpty() )
|
|
{
|
|
text = "Fault : " + faultText;
|
|
}
|
|
else
|
|
{
|
|
text = "Grid cell : " + gridResultText();
|
|
}
|
|
}
|
|
|
|
text += "\n";
|
|
}
|
|
|
|
QString topoText = this->geometrySelectionText( "\n" );
|
|
text += topoText;
|
|
appendDetails( text, formationDetails() );
|
|
text += "\n";
|
|
|
|
appendDetails( text, nncDetails() );
|
|
|
|
if ( m_cellIndex != cvf::UNDEFINED_SIZE_T )
|
|
{
|
|
appendDetails( text, faultResultDetails() );
|
|
appendDetails( text, cellEdgeResultDetails() );
|
|
appendDetails( text, gridResultDetails() );
|
|
appendDetails( text, wellResultText() );
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RiuResultTextBuilder::geometrySelectionText( QString itemSeparator )
|
|
{
|
|
QString text;
|
|
|
|
if ( m_eclResDef && m_eclResDef->eclipseCase() )
|
|
{
|
|
const RigEclipseCaseData* eclipseCase = m_eclResDef->eclipseCase()->eclipseCaseData();
|
|
if ( eclipseCase )
|
|
{
|
|
if ( m_cellIndex != cvf::UNDEFINED_SIZE_T )
|
|
{
|
|
size_t i = 0;
|
|
size_t j = 0;
|
|
size_t k = 0;
|
|
|
|
const RigGridBase* grid = eclipseCase->grid( m_gridIndex );
|
|
if ( grid->ijkFromCellIndex( m_cellIndex, &i, &j, &k ) )
|
|
{
|
|
// Adjust to 1-based Eclipse indexing
|
|
i++;
|
|
j++;
|
|
k++;
|
|
|
|
if ( m_face != cvf::StructGridInterface::NO_FACE )
|
|
{
|
|
cvf::StructGridInterface::FaceEnum faceEnum( m_face );
|
|
|
|
QString faceText = faceEnum.text();
|
|
|
|
text += QString( "Face : %1" ).arg( faceText ) + itemSeparator;
|
|
}
|
|
|
|
QString gridName = QString::fromStdString( grid->gridName() );
|
|
text += QString( "Grid : %1 [%2]" ).arg( gridName ).arg( m_gridIndex ) + itemSeparator;
|
|
|
|
text += QString( "Cell : [%1, %2, %3]" ).arg( i ).arg( j ).arg( k ) + itemSeparator;
|
|
|
|
size_t globalCellIndex = grid->reservoirCellIndex( m_cellIndex );
|
|
text += QString( "Global Cell Index : %4" ).arg( globalCellIndex ) + itemSeparator;
|
|
}
|
|
}
|
|
|
|
if ( m_intersectionPointInDisplay != cvf::Vec3d::UNDEFINED )
|
|
{
|
|
QString formattedText;
|
|
if ( m_2dIntersectionView )
|
|
{
|
|
formattedText.sprintf( "Horizontal length from well start: %.2f", m_intersectionPointInDisplay.x() );
|
|
text += formattedText + itemSeparator;
|
|
|
|
cvf::Mat4d t = m_2dIntersectionView->flatIntersectionPartMgr()->unflattenTransformMatrix(
|
|
m_intersectionPointInDisplay );
|
|
if ( !t.isZero() )
|
|
{
|
|
cvf::Vec3d intPt = m_intersectionPointInDisplay.getTransformedPoint( t );
|
|
formattedText.sprintf( "Intersection point : [E: %.2f, N: %.2f, Depth: %.2f]",
|
|
intPt.x(),
|
|
intPt.y(),
|
|
-intPt.z() );
|
|
text += formattedText;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( m_displayCoordView )
|
|
{
|
|
cvf::ref<caf::DisplayCoordTransform> transForm = m_displayCoordView->displayCoordTransform();
|
|
cvf::Vec3d domainCoord = transForm->translateToDomainCoord( m_intersectionPointInDisplay );
|
|
|
|
formattedText.sprintf( "Intersection point : [E: %.2f, N: %.2f, Depth: %.2f]",
|
|
domainCoord.x(),
|
|
domainCoord.y(),
|
|
-domainCoord.z() );
|
|
text += formattedText;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RiuResultTextBuilder::gridResultDetails()
|
|
{
|
|
QString text;
|
|
|
|
if ( m_eclResDef->eclipseCase() && m_eclResDef->eclipseCase()->eclipseCaseData() )
|
|
{
|
|
RigEclipseCaseData* eclipseCaseData = m_eclResDef->eclipseCase()->eclipseCaseData();
|
|
|
|
this->appendTextFromResultColors( eclipseCaseData, m_gridIndex, m_cellIndex, m_timeStepIndex, m_eclResDef, &text );
|
|
|
|
if ( !text.isEmpty() )
|
|
{
|
|
text.prepend( "-- Grid cell result details --\n" );
|
|
}
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RiuResultTextBuilder::faultResultDetails()
|
|
{
|
|
QString text;
|
|
|
|
if ( m_eclResDef->eclipseCase() && m_eclResDef->eclipseCase()->eclipseCaseData() )
|
|
{
|
|
RigEclipseCaseData* eclipseCaseData = m_eclResDef->eclipseCase()->eclipseCaseData();
|
|
RigGridBase* grid = eclipseCaseData->grid( m_gridIndex );
|
|
RigMainGrid* mainGrid = grid->mainGrid();
|
|
|
|
const RigFault* fault = mainGrid->findFaultFromCellIndexAndCellFace( m_cellIndex, m_face );
|
|
if ( fault )
|
|
{
|
|
text += "-- Fault result details --\n";
|
|
|
|
text += QString( "Fault Name: %1\n" ).arg( fault->name() );
|
|
|
|
cvf::StructGridInterface::FaceEnum faceHelper( m_face );
|
|
text += "Fault Face : " + faceHelper.text() + "\n";
|
|
|
|
if ( m_viewWithFaultsSettings && m_viewWithFaultsSettings->faultResultSettings()->hasValidCustomResult() )
|
|
{
|
|
if ( m_viewWithFaultsSettings->faultResultSettings()->customFaultResult()->resultType() !=
|
|
RiaDefines::ResultCatType::ALLEN_DIAGRAMS )
|
|
{
|
|
text += "Fault result data:\n";
|
|
this->appendTextFromResultColors( eclipseCaseData,
|
|
m_gridIndex,
|
|
m_cellIndex,
|
|
m_timeStepIndex,
|
|
m_viewWithFaultsSettings->currentFaultResultColors(),
|
|
&text );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RiuResultTextBuilder::formationDetails()
|
|
{
|
|
QString text;
|
|
RimCase* rimCase = m_eclResDef->eclipseCase();
|
|
if ( rimCase )
|
|
{
|
|
if ( rimCase->activeFormationNames() && rimCase->activeFormationNames()->formationNamesData() )
|
|
{
|
|
RigFormationNames* formNames = rimCase->activeFormationNames()->formationNamesData();
|
|
|
|
size_t k = cvf::UNDEFINED_SIZE_T;
|
|
{
|
|
const RigEclipseCaseData* eclipseData = m_eclResDef->eclipseCase()->eclipseCaseData();
|
|
if ( eclipseData )
|
|
{
|
|
if ( m_cellIndex != cvf::UNDEFINED_SIZE_T )
|
|
{
|
|
size_t i = cvf::UNDEFINED_SIZE_T;
|
|
size_t j = cvf::UNDEFINED_SIZE_T;
|
|
|
|
eclipseData->grid( m_gridIndex )->ijkFromCellIndex( m_cellIndex, &i, &j, &k );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( k != cvf::UNDEFINED_SIZE_T )
|
|
{
|
|
QString formName = formNames->formationNameFromKLayerIdx( k );
|
|
if ( !formName.isEmpty() )
|
|
{
|
|
// text += "-- Formation details --\n";
|
|
|
|
text += QString( "Formation Name: %1\n" ).arg( formName );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RiuResultTextBuilder::gridResultText()
|
|
{
|
|
QString text = cellResultText( m_eclResDef );
|
|
|
|
return text;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RiuResultTextBuilder::faultResultText()
|
|
{
|
|
QString text;
|
|
|
|
if ( m_eclResDef->eclipseCase() && m_eclResDef->eclipseCase()->eclipseCaseData() )
|
|
{
|
|
RigEclipseCaseData* eclipseCaseData = m_eclResDef->eclipseCase()->eclipseCaseData();
|
|
|
|
RigGridBase* grid = eclipseCaseData->grid( m_gridIndex );
|
|
RigMainGrid* mainGrid = grid->mainGrid();
|
|
|
|
const RigFault* fault = mainGrid->findFaultFromCellIndexAndCellFace( m_cellIndex, m_face );
|
|
|
|
if ( fault )
|
|
{
|
|
cvf::StructGridInterface::FaceEnum faceHelper( m_face );
|
|
if ( m_viewWithFaultsSettings && m_viewWithFaultsSettings->faultResultSettings()->hasValidCustomResult() )
|
|
{
|
|
text = cellResultText( m_viewWithFaultsSettings->currentFaultResultColors() );
|
|
}
|
|
}
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RiuResultTextBuilder::nncResultText()
|
|
{
|
|
QString text;
|
|
|
|
if ( m_nncIndex != cvf::UNDEFINED_SIZE_T )
|
|
{
|
|
if ( m_eclResDef.notNull() && m_eclResDef->eclipseCase() )
|
|
{
|
|
RigEclipseCaseData* eclipseCase = m_eclResDef->eclipseCase()->eclipseCaseData();
|
|
|
|
RigMainGrid* grid = eclipseCase->mainGrid();
|
|
CVF_ASSERT( grid );
|
|
|
|
RigNNCData* nncData = grid->nncData();
|
|
CVF_ASSERT( nncData );
|
|
|
|
if ( nncData && m_nncIndex < nncData->connections().size() )
|
|
{
|
|
const RigConnection& conn = nncData->connections()[m_nncIndex];
|
|
|
|
cvf::StructGridInterface::FaceEnum face( conn.m_c1Face );
|
|
|
|
if ( m_viewWithFaultsSettings && m_viewWithFaultsSettings->currentFaultResultColors() )
|
|
{
|
|
RigEclipseResultAddress eclipseResultAddress =
|
|
m_viewWithFaultsSettings->currentFaultResultColors()->eclipseResultAddress();
|
|
RiaDefines::ResultCatType resultType =
|
|
m_viewWithFaultsSettings->currentFaultResultColors()->resultType();
|
|
|
|
const std::vector<double>* nncValues = nullptr;
|
|
|
|
if ( resultType == RiaDefines::ResultCatType::STATIC_NATIVE )
|
|
{
|
|
nncValues = nncData->staticConnectionScalarResult( eclipseResultAddress );
|
|
}
|
|
else if ( resultType == RiaDefines::ResultCatType::DYNAMIC_NATIVE )
|
|
{
|
|
if ( m_eclResDef.notNull() && m_eclResDef->eclipseCase() )
|
|
{
|
|
size_t nativeTimeStep = m_eclResDef->eclipseCase()->uiToNativeTimeStepIndex( m_timeStepIndex );
|
|
nncValues = nncData->dynamicConnectionScalarResult( eclipseResultAddress, nativeTimeStep );
|
|
}
|
|
}
|
|
|
|
if ( nncValues && ( m_nncIndex < nncValues->size() ) )
|
|
{
|
|
QString resultVar = m_viewWithFaultsSettings->currentFaultResultColors()->resultVariableUiName();
|
|
double scalarValue = ( *nncValues )[m_nncIndex];
|
|
|
|
text = QString( "%1 : %2" ).arg( resultVar ).arg( scalarValue );
|
|
}
|
|
|
|
if ( resultType == RiaDefines::ResultCatType::ALLEN_DIAGRAMS )
|
|
{
|
|
nncValues = nncData->staticConnectionScalarResult( eclipseResultAddress );
|
|
QString resultValueText;
|
|
|
|
if ( m_viewWithFaultsSettings->currentFaultResultColors()->resultVariable() ==
|
|
RiaDefines::formationAllenResultName() )
|
|
{
|
|
std::pair<int, int> fmIndexPair =
|
|
eclipseCase->allenDiagramData()->formationIndexCombinationFromCategory(
|
|
( *nncValues )[m_nncIndex] );
|
|
|
|
std::vector<QString> fmNames = eclipseCase->formationNames();
|
|
// clang-format off
|
|
if ( fmIndexPair.first >= 0 &&
|
|
fmIndexPair.second >= 0 &&
|
|
static_cast<int>(fmNames.size()) > fmIndexPair.first &&
|
|
static_cast<int>(fmNames.size()) > fmIndexPair.second )
|
|
{
|
|
resultValueText = fmNames[fmIndexPair.first] + " - " +
|
|
fmNames[fmIndexPair.second];
|
|
}
|
|
// clang-format on
|
|
}
|
|
else if ( m_viewWithFaultsSettings->currentFaultResultColors()->resultVariable() ==
|
|
RiaDefines::formationBinaryAllenResultName() )
|
|
{
|
|
resultValueText = ( *nncValues )[m_nncIndex] == 0 ? "Same formation" : "Different formation";
|
|
}
|
|
|
|
QString resultVar = m_viewWithFaultsSettings->currentFaultResultColors()->resultVariableUiName();
|
|
text = QString( "%1 : %2" ).arg( resultVar ).arg( resultValueText );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RiuResultTextBuilder::appendTextFromResultColors( RigEclipseCaseData* eclipseCase,
|
|
size_t gridIndex,
|
|
size_t cellIndex,
|
|
size_t timeStepIndex,
|
|
RimEclipseResultDefinition* resultColors,
|
|
QString* resultInfoText )
|
|
{
|
|
if ( !resultColors )
|
|
{
|
|
return;
|
|
}
|
|
|
|
RiaDefines::PorosityModelType porosityModel = resultColors->porosityModel();
|
|
if ( resultColors->isTernarySaturationSelected() )
|
|
{
|
|
RigCaseCellResultsData* gridCellResults = resultColors->currentGridCellResults();
|
|
if ( gridCellResults )
|
|
{
|
|
gridCellResults->ensureKnownResultLoaded(
|
|
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SOIL" ) );
|
|
gridCellResults->ensureKnownResultLoaded(
|
|
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SGAS" ) );
|
|
gridCellResults->ensureKnownResultLoaded(
|
|
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SWAT" ) );
|
|
|
|
cvf::ref<RigResultAccessor> dataAccessObjectX =
|
|
RigResultAccessorFactory::createFromResultAddress( eclipseCase,
|
|
gridIndex,
|
|
porosityModel,
|
|
timeStepIndex,
|
|
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
|
|
"SOIL" ) );
|
|
cvf::ref<RigResultAccessor> dataAccessObjectY =
|
|
RigResultAccessorFactory::createFromResultAddress( eclipseCase,
|
|
gridIndex,
|
|
porosityModel,
|
|
timeStepIndex,
|
|
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
|
|
"SGAS" ) );
|
|
cvf::ref<RigResultAccessor> dataAccessObjectZ =
|
|
RigResultAccessorFactory::createFromResultAddress( eclipseCase,
|
|
gridIndex,
|
|
porosityModel,
|
|
timeStepIndex,
|
|
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
|
|
"SWAT" ) );
|
|
|
|
double scalarValue = 0.0;
|
|
|
|
if ( dataAccessObjectX.notNull() )
|
|
scalarValue = dataAccessObjectX->cellScalar( cellIndex );
|
|
else
|
|
scalarValue = 0.0;
|
|
resultInfoText->append( QString( "SOIL : %1\n" ).arg( scalarValue ) );
|
|
|
|
if ( dataAccessObjectY.notNull() )
|
|
scalarValue = dataAccessObjectY->cellScalar( cellIndex );
|
|
else
|
|
scalarValue = 0.0;
|
|
resultInfoText->append( QString( "SGAS : %1\n" ).arg( scalarValue ) );
|
|
|
|
if ( dataAccessObjectZ.notNull() )
|
|
scalarValue = dataAccessObjectZ->cellScalar( cellIndex );
|
|
else
|
|
scalarValue = 0.0;
|
|
resultInfoText->append( QString( "SWAT : %1\n" ).arg( scalarValue ) );
|
|
}
|
|
|
|
return;
|
|
}
|
|
else if ( resultColors->hasResult() )
|
|
{
|
|
if ( resultColors->hasStaticResult() )
|
|
{
|
|
if ( resultColors->resultVariable().compare( RiaDefines::combinedTransmissibilityResultName(),
|
|
Qt::CaseInsensitive ) == 0 )
|
|
{
|
|
cvf::ref<RigResultAccessor> transResultAccessor =
|
|
RigResultAccessorFactory::createFromResultAddress( eclipseCase,
|
|
gridIndex,
|
|
porosityModel,
|
|
0,
|
|
RigEclipseResultAddress(
|
|
RiaDefines::combinedTransmissibilityResultName() ) );
|
|
{
|
|
double scalarValue = transResultAccessor->cellFaceScalar( cellIndex, cvf::StructGridInterface::POS_I );
|
|
resultInfoText->append( QString( "Tran X : %1\n" ).arg( scalarValue ) );
|
|
|
|
scalarValue = transResultAccessor->cellFaceScalar( cellIndex, cvf::StructGridInterface::POS_J );
|
|
resultInfoText->append( QString( "Tran Y : %1\n" ).arg( scalarValue ) );
|
|
|
|
scalarValue = transResultAccessor->cellFaceScalar( cellIndex, cvf::StructGridInterface::POS_K );
|
|
resultInfoText->append( QString( "Tran Z : %1\n" ).arg( scalarValue ) );
|
|
}
|
|
|
|
return;
|
|
}
|
|
else if ( resultColors->resultVariable().compare( RiaDefines::combinedMultResultName(),
|
|
Qt::CaseInsensitive ) == 0 )
|
|
{
|
|
cvf::ref<RigResultAccessor> multResultAccessor =
|
|
RigResultAccessorFactory::createFromResultAddress( eclipseCase,
|
|
gridIndex,
|
|
porosityModel,
|
|
0,
|
|
RigEclipseResultAddress(
|
|
RiaDefines::combinedMultResultName() ) );
|
|
{
|
|
double scalarValue = multResultAccessor->cellFaceScalar( cellIndex, cvf::StructGridInterface::POS_I );
|
|
resultInfoText->append( QString( "MULTX : %1\n" ).arg( scalarValue ) );
|
|
scalarValue = multResultAccessor->cellFaceScalar( cellIndex, cvf::StructGridInterface::NEG_I );
|
|
resultInfoText->append( QString( "MULTX- : %1\n" ).arg( scalarValue ) );
|
|
|
|
scalarValue = multResultAccessor->cellFaceScalar( cellIndex, cvf::StructGridInterface::POS_J );
|
|
resultInfoText->append( QString( "MULTY : %1\n" ).arg( scalarValue ) );
|
|
scalarValue = multResultAccessor->cellFaceScalar( cellIndex, cvf::StructGridInterface::NEG_J );
|
|
resultInfoText->append( QString( "MULTY- : %1\n" ).arg( scalarValue ) );
|
|
|
|
scalarValue = multResultAccessor->cellFaceScalar( cellIndex, cvf::StructGridInterface::POS_K );
|
|
resultInfoText->append( QString( "MULTZ : %1\n" ).arg( scalarValue ) );
|
|
scalarValue = multResultAccessor->cellFaceScalar( cellIndex, cvf::StructGridInterface::NEG_K );
|
|
resultInfoText->append( QString( "MULTZ- : %1\n" ).arg( scalarValue ) );
|
|
}
|
|
|
|
return;
|
|
}
|
|
else if ( resultColors->resultVariable().compare( RiaDefines::combinedRiTranResultName(),
|
|
Qt::CaseInsensitive ) == 0 )
|
|
{
|
|
cvf::ref<RigResultAccessor> transResultAccessor =
|
|
RigResultAccessorFactory::createFromResultAddress( eclipseCase,
|
|
gridIndex,
|
|
porosityModel,
|
|
0,
|
|
RigEclipseResultAddress(
|
|
RiaDefines::combinedRiTranResultName() ) );
|
|
{
|
|
double scalarValue = transResultAccessor->cellFaceScalar( cellIndex, cvf::StructGridInterface::POS_I );
|
|
resultInfoText->append( QString( "riTran X : %1\n" ).arg( scalarValue ) );
|
|
|
|
scalarValue = transResultAccessor->cellFaceScalar( cellIndex, cvf::StructGridInterface::POS_J );
|
|
resultInfoText->append( QString( "riTran Y : %1\n" ).arg( scalarValue ) );
|
|
|
|
scalarValue = transResultAccessor->cellFaceScalar( cellIndex, cvf::StructGridInterface::POS_K );
|
|
resultInfoText->append( QString( "riTran Z : %1\n" ).arg( scalarValue ) );
|
|
}
|
|
|
|
return;
|
|
}
|
|
else if ( resultColors->resultVariable().compare( RiaDefines::combinedRiMultResultName(),
|
|
Qt::CaseInsensitive ) == 0 )
|
|
{
|
|
cvf::ref<RigResultAccessor> resultAccessor =
|
|
RigResultAccessorFactory::createFromResultAddress( eclipseCase,
|
|
gridIndex,
|
|
porosityModel,
|
|
0,
|
|
RigEclipseResultAddress(
|
|
RiaDefines::combinedRiMultResultName() ) );
|
|
{
|
|
double scalarValue = resultAccessor->cellFaceScalar( cellIndex, cvf::StructGridInterface::POS_I );
|
|
resultInfoText->append( QString( "riMult X : %1\n" ).arg( scalarValue ) );
|
|
|
|
scalarValue = resultAccessor->cellFaceScalar( cellIndex, cvf::StructGridInterface::POS_J );
|
|
resultInfoText->append( QString( "riMult Y : %1\n" ).arg( scalarValue ) );
|
|
|
|
scalarValue = resultAccessor->cellFaceScalar( cellIndex, cvf::StructGridInterface::POS_K );
|
|
resultInfoText->append( QString( "riMult Z : %1\n" ).arg( scalarValue ) );
|
|
}
|
|
|
|
return;
|
|
}
|
|
else if ( resultColors->resultVariable().compare( RiaDefines::combinedRiAreaNormTranResultName(),
|
|
Qt::CaseInsensitive ) == 0 )
|
|
{
|
|
cvf::ref<RigResultAccessor> resultAccessor =
|
|
RigResultAccessorFactory::createFromResultAddress( eclipseCase,
|
|
gridIndex,
|
|
porosityModel,
|
|
0,
|
|
RigEclipseResultAddress(
|
|
RiaDefines::combinedRiAreaNormTranResultName() ) );
|
|
{
|
|
double scalarValue = resultAccessor->cellFaceScalar( cellIndex, cvf::StructGridInterface::POS_I );
|
|
resultInfoText->append( QString( "riTransByArea X : %1\n" ).arg( scalarValue ) );
|
|
|
|
scalarValue = resultAccessor->cellFaceScalar( cellIndex, cvf::StructGridInterface::POS_J );
|
|
resultInfoText->append( QString( "riTransByArea Y : %1\n" ).arg( scalarValue ) );
|
|
|
|
scalarValue = resultAccessor->cellFaceScalar( cellIndex, cvf::StructGridInterface::POS_K );
|
|
resultInfoText->append( QString( "riTransByArea Z : %1\n" ).arg( scalarValue ) );
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
resultInfoText->append( cellResultText( resultColors ) );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RiuResultTextBuilder::cellEdgeResultDetails()
|
|
{
|
|
QString text;
|
|
|
|
if ( m_viewWithFaultsSettings && m_viewWithFaultsSettings->cellEdgeResult()->hasResult() )
|
|
{
|
|
text += "-- Cell edge result data --\n";
|
|
|
|
if ( m_viewWithFaultsSettings->cellEdgeResult()->isUsingSingleVariable() )
|
|
{
|
|
text += cellResultText( m_viewWithFaultsSettings->cellEdgeResult()->singleVarEdgeResultColors() );
|
|
text += "\n";
|
|
}
|
|
else
|
|
{
|
|
std::vector<RimCellEdgeMetaData> metaData;
|
|
m_viewWithFaultsSettings->cellEdgeResult()->cellEdgeMetaData( &metaData );
|
|
|
|
std::set<RigEclipseResultAddress> uniqueResultIndices;
|
|
|
|
for ( int idx = 0; idx < 6; idx++ )
|
|
{
|
|
RigEclipseResultAddress resultAddr = metaData[idx].m_eclipseResultAddress;
|
|
if ( !resultAddr.isValid() ) continue;
|
|
|
|
if ( uniqueResultIndices.find( resultAddr ) != uniqueResultIndices.end() ) continue;
|
|
|
|
size_t adjustedTimeStep = m_timeStepIndex;
|
|
if ( metaData[idx].m_isStatic )
|
|
{
|
|
adjustedTimeStep = 0;
|
|
}
|
|
|
|
RiaDefines::PorosityModelType porosityModel = m_eclResDef->porosityModel();
|
|
cvf::ref<RigResultAccessor> resultAccessor =
|
|
RigResultAccessorFactory::createFromResultAddress( m_eclResDef->eclipseCase()->eclipseCaseData(),
|
|
m_gridIndex,
|
|
porosityModel,
|
|
adjustedTimeStep,
|
|
resultAddr );
|
|
if ( resultAccessor.notNull() )
|
|
{
|
|
double scalarValue = resultAccessor->cellScalar( m_cellIndex );
|
|
text.append( QString( "%1 : %2\n" ).arg( metaData[idx].m_resultVariable ).arg( scalarValue ) );
|
|
|
|
uniqueResultIndices.insert( resultAddr );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RiuResultTextBuilder::nncDetails()
|
|
{
|
|
QString text;
|
|
|
|
if ( m_nncIndex != cvf::UNDEFINED_SIZE_T )
|
|
{
|
|
if ( m_eclResDef.notNull() && m_eclResDef->eclipseCase() )
|
|
{
|
|
RigEclipseCaseData* eclipseCase = m_eclResDef->eclipseCase()->eclipseCaseData();
|
|
|
|
RigMainGrid* grid = eclipseCase->mainGrid();
|
|
CVF_ASSERT( grid );
|
|
|
|
RigNNCData* nncData = grid->nncData();
|
|
CVF_ASSERT( nncData );
|
|
|
|
if ( nncData && m_nncIndex < nncData->connections().size() )
|
|
{
|
|
text += "-- NNC details --\n";
|
|
{
|
|
const RigConnection& conn = nncData->connections()[m_nncIndex];
|
|
cvf::StructGridInterface::FaceEnum face( conn.m_c1Face );
|
|
|
|
// First cell of NNC
|
|
{
|
|
CVF_ASSERT( conn.m_c1GlobIdx < grid->globalCellArray().size() );
|
|
const RigCell& cell = grid->globalCellArray()[conn.m_c1GlobIdx];
|
|
|
|
RigGridBase* hostGrid = cell.hostGrid();
|
|
size_t gridLocalCellIndex = cell.gridLocalCellIndex();
|
|
|
|
size_t i, j, k;
|
|
if ( hostGrid->ijkFromCellIndex( gridLocalCellIndex, &i, &j, &k ) )
|
|
{
|
|
// Adjust to 1-based Eclipse indexing
|
|
i++;
|
|
j++;
|
|
k++;
|
|
|
|
QString gridName = QString::fromStdString( hostGrid->gridName() );
|
|
text.append( QString( "NNC 1 : cell [%1, %2, %3] face %4 (%5)\n" )
|
|
.arg( i )
|
|
.arg( j )
|
|
.arg( k )
|
|
.arg( face.text() )
|
|
.arg( gridName ) );
|
|
}
|
|
}
|
|
|
|
// Second cell of NNC
|
|
{
|
|
CVF_ASSERT( conn.m_c2GlobIdx < grid->globalCellArray().size() );
|
|
const RigCell& cell = grid->globalCellArray()[conn.m_c2GlobIdx];
|
|
|
|
RigGridBase* hostGrid = cell.hostGrid();
|
|
size_t gridLocalCellIndex = cell.gridLocalCellIndex();
|
|
|
|
size_t i, j, k;
|
|
if ( hostGrid->ijkFromCellIndex( gridLocalCellIndex, &i, &j, &k ) )
|
|
{
|
|
// Adjust to 1-based Eclipse indexing
|
|
i++;
|
|
j++;
|
|
k++;
|
|
|
|
QString gridName = QString::fromStdString( hostGrid->gridName() );
|
|
cvf::StructGridInterface::FaceEnum oppositeFaceEnum(
|
|
cvf::StructGridInterface::oppositeFace( face ) );
|
|
QString faceText = oppositeFaceEnum.text();
|
|
|
|
text.append( QString( "NNC 2 : cell [%1, %2, %3] face %4 (%5)\n" )
|
|
.arg( i )
|
|
.arg( j )
|
|
.arg( k )
|
|
.arg( faceText )
|
|
.arg( gridName ) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RiuResultTextBuilder::appendDetails( QString& text, const QString& details )
|
|
{
|
|
if ( !details.isEmpty() )
|
|
{
|
|
text += "\n";
|
|
text += details;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RiuResultTextBuilder::cellResultText( RimEclipseResultDefinition* eclResDef )
|
|
{
|
|
QString text;
|
|
|
|
if ( m_eclResDef->eclipseCase() && m_eclResDef->eclipseCase()->eclipseCaseData() )
|
|
{
|
|
RigEclipseCaseData* eclipseCaseData = m_eclResDef->eclipseCase()->eclipseCaseData();
|
|
|
|
if ( eclResDef->isTernarySaturationSelected() )
|
|
{
|
|
RigCaseCellResultsData* gridCellResults = m_eclResDef->currentGridCellResults();
|
|
if ( gridCellResults )
|
|
{
|
|
gridCellResults->ensureKnownResultLoaded(
|
|
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SOIL" ) );
|
|
gridCellResults->ensureKnownResultLoaded(
|
|
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SGAS" ) );
|
|
gridCellResults->ensureKnownResultLoaded(
|
|
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "SWAT" ) );
|
|
|
|
RiaDefines::PorosityModelType porosityModel = eclResDef->porosityModel();
|
|
|
|
cvf::ref<RigResultAccessor> dataAccessObjectX =
|
|
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
|
|
m_gridIndex,
|
|
porosityModel,
|
|
m_timeStepIndex,
|
|
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
|
|
"SOIL" ) );
|
|
cvf::ref<RigResultAccessor> dataAccessObjectY =
|
|
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
|
|
m_gridIndex,
|
|
porosityModel,
|
|
m_timeStepIndex,
|
|
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
|
|
"SGAS" ) );
|
|
cvf::ref<RigResultAccessor> dataAccessObjectZ =
|
|
RigResultAccessorFactory::createFromResultAddress( eclipseCaseData,
|
|
m_gridIndex,
|
|
porosityModel,
|
|
m_timeStepIndex,
|
|
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
|
|
"SWAT" ) );
|
|
|
|
double scalarValue = 0.0;
|
|
|
|
if ( dataAccessObjectX.notNull() )
|
|
scalarValue = dataAccessObjectX->cellScalar( m_cellIndex );
|
|
else
|
|
scalarValue = 0.0;
|
|
text += QString( "SOIL : %1 " ).arg( scalarValue );
|
|
|
|
if ( dataAccessObjectY.notNull() )
|
|
scalarValue = dataAccessObjectY->cellScalar( m_cellIndex );
|
|
else
|
|
scalarValue = 0.0;
|
|
text += QString( "SGAS : %1 " ).arg( scalarValue );
|
|
|
|
if ( dataAccessObjectZ.notNull() )
|
|
scalarValue = dataAccessObjectZ->cellScalar( m_cellIndex );
|
|
else
|
|
scalarValue = 0.0;
|
|
text += QString( "SWAT : %1 " ).arg( scalarValue );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
size_t adjustedTimeStep = m_timeStepIndex;
|
|
if ( eclResDef->hasStaticResult() )
|
|
{
|
|
adjustedTimeStep = 0;
|
|
}
|
|
|
|
cvf::ref<RigResultAccessor> resultAccessor =
|
|
RigResultAccessorFactory::createFromResultDefinition( eclipseCaseData, m_gridIndex, adjustedTimeStep, eclResDef );
|
|
if ( resultAccessor.notNull() )
|
|
{
|
|
double scalarValue = resultAccessor->cellFaceScalar( m_cellIndex, m_face );
|
|
QString resultVar = eclResDef->resultVariableUiName();
|
|
|
|
QString resultValueText;
|
|
if ( eclResDef->hasCategoryResult() )
|
|
{
|
|
auto resColorDef = dynamic_cast<RimEclipseCellColors*>( eclResDef );
|
|
|
|
RimRegularLegendConfig* legendConfig = nullptr;
|
|
|
|
if ( resColorDef )
|
|
{
|
|
legendConfig = resColorDef->legendConfig();
|
|
}
|
|
else
|
|
{
|
|
RimIntersectionResultDefinition* interResDef = nullptr;
|
|
eclResDef->firstAncestorOrThisOfType( interResDef );
|
|
if ( interResDef )
|
|
{
|
|
legendConfig = interResDef->regularLegendConfig();
|
|
}
|
|
}
|
|
|
|
resultValueText += legendConfig->categoryNameFromCategoryValue( scalarValue );
|
|
}
|
|
else
|
|
{
|
|
resultValueText = QString( "%1" ).arg( scalarValue );
|
|
}
|
|
|
|
text = QString( "%1 : %2" ).arg( resultVar ).arg( resultValueText );
|
|
}
|
|
}
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RiuResultTextBuilder::wellResultText()
|
|
{
|
|
QString text;
|
|
|
|
if ( m_eclResDef->eclipseCase() && m_eclResDef->eclipseCase()->eclipseCaseData() )
|
|
{
|
|
cvf::Collection<RigSimWellData> simWellData = m_eclResDef->eclipseCase()->eclipseCaseData()->wellResults();
|
|
for ( size_t i = 0; i < simWellData.size(); i++ )
|
|
{
|
|
RigSimWellData* singleWellResultData = simWellData.at( i );
|
|
|
|
if ( !singleWellResultData->hasWellResult( m_timeStepIndex ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
const RigWellResultFrame& wellResultFrame = singleWellResultData->wellResultFrame( m_timeStepIndex );
|
|
const RigWellResultPoint* wellResultCell =
|
|
wellResultFrame.findResultCellWellHeadIncluded( m_gridIndex, m_cellIndex );
|
|
if ( wellResultCell )
|
|
{
|
|
text += QString( "-- Well-cell connection info --\n Well Name: %1\n Branch Id: %2\n Segment Id: %3\n" )
|
|
.arg( singleWellResultData->m_wellName )
|
|
.arg( wellResultCell->m_ertBranchId )
|
|
.arg( wellResultCell->m_ertSegmentId );
|
|
}
|
|
}
|
|
}
|
|
|
|
return text;
|
|
}
|