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

Add result type and create and use custom legend if possible

Browse Source 
* Update submodule
* Use postfix functions and add custom color legend

* Add type to RigEclipseResultAddress
Read types from ROFF and create default legend based on type or custom created legend.

* Use caseId to connect legend configuration to result in a case
This commit is contained in:
Magne Sjaastad 2023-05-09 11:41:56 +02:00 committed by GitHub
parent 8c91f1b1ac
commit f70d2c4949
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
34 changed files with 565 additions and 356 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
ApplicationLibCode/Application/RiaDefines.cpp
View File

@ -41,6 +41,17 @@ void caf::AppEnum<RiaDefines::ResultCatType>::setUp()
setDefault( RiaDefines::ResultCatType::DYNAMIC_NATIVE ); setDefault( RiaDefines::ResultCatType::DYNAMIC_NATIVE );
} }
template <>
void caf::AppEnum<RiaDefines::ResultDataType>::setUp()
{
addItem( RiaDefines::ResultDataType::UNKNOWN, "UNKNOWN", "Unknown" );
addItem( RiaDefines::ResultDataType::FLOAT, "FLOAT", "Float" );
addItem( RiaDefines::ResultDataType::DOUBLE, "DOUBLE", "Double" );
addItem( RiaDefines::ResultDataType::INTEGER, "INTEGER", "Integer" );
setDefault( RiaDefines::ResultDataType::FLOAT );
}
template <> template <>
void caf::AppEnum<RiaDefines::DepthUnitType>::setUp() void caf::AppEnum<RiaDefines::DepthUnitType>::setUp()
{ {
@ -159,15 +170,6 @@ void caf::AppEnum<RiaDefines::RowCount>::setUp()
} // namespace caf } // namespace caf
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RiaDefines::isNativeCategoryResult( const QString& resultName )
{
return resultName.endsWith( "NUM" ) || resultName == RiaResultNames::indexIResultName() ||
resultName == RiaResultNames::indexJResultName() || resultName == RiaResultNames::indexKResultName();
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

10
ApplicationLibCode/Application/RiaDefines.h
View File

@ -52,6 +52,14 @@ enum class ResultCatType
UNDEFINED = 999 UNDEFINED = 999
}; };
enum class ResultDataType
{
UNKNOWN,
FLOAT,
DOUBLE,
INTEGER
};
// WARNING: DO NOT CHANGE THE ORDER WITHOUT KNOWING WHAT YOU ARE DOING! // WARNING: DO NOT CHANGE THE ORDER WITHOUT KNOWING WHAT YOU ARE DOING!
// You may well change the behaviour of property filters. // You may well change the behaviour of property filters.
enum class WellPathComponentType enum class WellPathComponentType
@ -79,8 +87,6 @@ enum class MeshModeType
NO_MESH NO_MESH
}; };
bool isNativeCategoryResult( const QString& resultName );
// Mock model text identifiers // Mock model text identifiers
QString mockModelBasic(); QString mockModelBasic();
QString mockModelBasicWithResults(); QString mockModelBasicWithResults();

10
ApplicationLibCode/Application/RiaResultNames.cpp
View File

@ -20,6 +20,8 @@
#include "RiaResultNames.h" #include "RiaResultNames.h"
#include "RigEclipseResultAddress.h"
#include "cafAppEnum.h" #include "cafAppEnum.h"
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -361,6 +363,14 @@ QString RiaResultNames::indexKResultName()
return "INDEX_K"; return "INDEX_K";
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigEclipseResultAddress RiaResultNames::staticIntegerAddress( const QString& resultName )
{
return RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::ResultDataType::INTEGER, resultName );
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

10
ApplicationLibCode/Application/RiaResultNames.h
View File

@ -20,7 +20,10 @@
#pragma once #pragma once
class RigEclipseResultAddress;
#include <QString> #include <QString>
#include <set> #include <set>
#include <vector> #include <vector>
@ -66,9 +69,10 @@ QString faultReactAssessmentPrefix();
QString completionTypeResultName(); QString completionTypeResultName();
QString indexIResultName(); QString indexIResultName();
QString indexJResultName(); QString indexJResultName();
QString indexKResultName(); QString indexKResultName();
RigEclipseResultAddress staticIntegerAddress( const QString& resultName );
QString faultDistanceName(); QString faultDistanceName();

10
ApplicationLibCode/Application/Tools/RiaImportEclipseCaseTools.cpp
View File

@ -569,6 +569,7 @@ RimRoffCase* RiaImportEclipseCaseTools::openRoffCaseFromFileName( const QString&
} }
analysisModels->cases.push_back( roffCase ); analysisModels->cases.push_back( roffCase );
analysisModels->updateConnectedEditors();
RimEclipseView* eclipseView = nullptr; RimEclipseView* eclipseView = nullptr;
if ( createDefaultView ) if ( createDefaultView )
@ -576,16 +577,17 @@ RimRoffCase* RiaImportEclipseCaseTools::openRoffCaseFromFileName( const QString&
eclipseView = roffCase->createAndAddReservoirView(); eclipseView = roffCase->createAndAddReservoirView();
eclipseView->cellResult()->setResultType( RiaDefines::ResultCatType::INPUT_PROPERTY ); eclipseView->cellResult()->setResultType( RiaDefines::ResultCatType::INPUT_PROPERTY );
eclipseView->loadDataAndUpdate();
roffCase->updateAllRequiredEditors();
if ( RiaGuiApplication::isRunning() ) if ( RiaGuiApplication::isRunning() )
{ {
if ( RiuMainWindow::instance() ) RiuMainWindow::instance()->selectAsCurrentItem( eclipseView->cellResult() ); if ( RiuMainWindow::instance() ) RiuMainWindow::instance()->selectAsCurrentItem( eclipseView->cellResult() );
// Make sure the call to setExpanded is done after the call to selectAsCurrentItem
Riu3DMainWindowTools::setExpanded( eclipseView );
} }
eclipseView->loadDataAndUpdate();
} }
analysisModels->updateConnectedEditors();
return roffCase; return roffCase;
} }

5
ApplicationLibCode/FileInterface/RifEclipseInputPropertyLoader.cpp
View File

@ -176,7 +176,10 @@ bool RifEclipseInputPropertyLoader::appendNewInputPropertyResult( RigEclipseCase
return false; return false;
} }
RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::INPUT_PROPERTY, resultName ); bool endsWithNum = eclipseKeyword.ends_with( "NUM" );
auto dataType = endsWithNum ? RiaDefines::ResultDataType::INTEGER : RiaDefines::ResultDataType::FLOAT;
RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::INPUT_PROPERTY, dataType, resultName );
caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->createResultEntry( resAddr, false ); caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->createResultEntry( resAddr, false );
auto newPropertyData = caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->modifiableCellScalarResultTimesteps( resAddr ); auto newPropertyData = caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->modifiableCellScalarResultTimesteps( resAddr );

94
ApplicationLibCode/FileInterface/RifEclipseOutputFileTools.cpp
View File

@ -56,58 +56,18 @@ RifEclipseOutputFileTools::~RifEclipseOutputFileTools()
{ {
} }
struct KeywordItemCounter //--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RifKeywordValueCount> RifEclipseOutputFileTools::keywordValueCounts( const std::vector<ecl_file_type*>& ecl_files )
{ {
KeywordItemCounter( const std::string& keyword, size_t aggregatedItemCount ) auto reportstepMetaData = RifEclipseOutputFileTools::createReportStepsMetaData( ecl_files );
: m_keyword( keyword ) return reportstepMetaData.keywordValueCounts();
, m_aggregatedItemCount( aggregatedItemCount ) }
, m_reportStepCount( 1 )
{
}
bool operator==( const std::string& rhs ) const { return this->m_keyword == rhs; }
std::string m_keyword;
size_t m_aggregatedItemCount;
size_t m_reportStepCount;
};
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RifEclipseOutputFileTools::findKeywordsAndItemCount( std::vector<ecl_file_type*> ecl_files,
QStringList* resultNames,
std::vector<size_t>* resultDataItemCounts )
{
std::vector<RifRestartReportStep> reportSteps;
RifEclipseOutputFileTools::createReportStepsMetaData( ecl_files, &reportSteps );
std::vector<KeywordItemCounter> foundKeywords;
for ( auto reportStep : reportSteps )
{
for ( auto keywordItemCount : reportStep.m_keywords.keywordsWithAggregatedItemCount() )
{
auto it = std::find( foundKeywords.begin(), foundKeywords.end(), keywordItemCount.first );
if ( it == foundKeywords.end() )
{
foundKeywords.push_back( KeywordItemCounter( keywordItemCount.first, keywordItemCount.second ) );
}
else
{
it->m_aggregatedItemCount += keywordItemCount.second;
it->m_reportStepCount++;
}
}
}
for ( auto stdKeyword : foundKeywords )
{
resultNames->push_back( QString::fromStdString( stdKeyword.m_keyword ) );
resultDataItemCounts->push_back( stdKeyword.m_aggregatedItemCount );
}
}
void getDayMonthYear( const ecl_kw_type* intehead_kw, int* day, int* month, int* year ) void getDayMonthYear( const ecl_kw_type* intehead_kw, int* day, int* month, int* year )
{ {
assert( day && month && year ); assert( day && month && year );
@ -636,9 +596,9 @@ FILE* RifEclipseOutputFileTools::fopen( const QString& filePath, const QString&
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RifEclipseOutputFileTools::createReportStepsMetaData( std::vector<ecl_file_type*> ecl_files, std::vector<RifRestartReportStep>* reportSteps ) RifRestartReportKeywords RifEclipseOutputFileTools::createReportStepsMetaData( const std::vector<ecl_file_type*>& ecl_files )
{ {
if ( !reportSteps ) return; RifRestartReportKeywords reportSteps;
for ( auto ecl_file : ecl_files ) for ( auto ecl_file : ecl_files )
{ {
@ -658,15 +618,6 @@ void RifEclipseOutputFileTools::createReportStepsMetaData( std::vector<ecl_file_
{ {
ecl_file_select_block( ecl_file, INTEHEAD_KW, reportStepIndex ); ecl_file_select_block( ecl_file, INTEHEAD_KW, reportStepIndex );
RifRestartReportStep reportStep;
// Set Date
{
QDateTime reportDateTime =
RiaQDateTimeTools::createDateTime( QDate( restart_header->year, restart_header->month, restart_header->day ) );
reportStep.dateTime = reportDateTime;
}
// Find number of keywords within this report step // Find number of keywords within this report step
int numKeywords = ecl_file_get_num_distinct_kw( ecl_file ); int numKeywords = ecl_file_get_num_distinct_kw( ecl_file );
for ( int iKey = 0; iKey < numKeywords; iKey++ ) for ( int iKey = 0; iKey < numKeywords; iKey++ )
@ -676,19 +627,32 @@ void RifEclipseOutputFileTools::createReportStepsMetaData( std::vector<ecl_file_
int namedKeywordCount = ecl_file_get_num_named_kw( ecl_file, kw ); int namedKeywordCount = ecl_file_get_num_named_kw( ecl_file, kw );
for ( int iOcc = 0; iOcc < namedKeywordCount; iOcc++ ) for ( int iOcc = 0; iOcc < namedKeywordCount; iOcc++ )
{ {
ecl_data_type dataType = ecl_file_iget_named_data_type( ecl_file, kw, iOcc ); ecl_data_type dataTypeOnFile = ecl_file_iget_named_data_type( ecl_file, kw, iOcc );
ecl_type_enum dataTypeEmum = ecl_type_get_type( dataType ); ecl_type_enum dataTypeEnumOnFile = ecl_type_get_type( dataTypeOnFile );
if ( dataTypeEmum != ECL_DOUBLE_TYPE && dataTypeEmum != ECL_FLOAT_TYPE && dataTypeEmum != ECL_INT_TYPE ) if ( dataTypeEnumOnFile != ECL_DOUBLE_TYPE && dataTypeEnumOnFile != ECL_FLOAT_TYPE &&
dataTypeEnumOnFile != ECL_INT_TYPE )
{ {
continue; continue;
} }
RifKeywordValueCount::KeywordDataType dataType = RifKeywordValueCount::KeywordDataType::UNKNOWN;
if ( dataTypeEnumOnFile == ECL_DOUBLE_TYPE )
{
dataType = RifKeywordValueCount::KeywordDataType::DOUBLE;
}
else if ( dataTypeEnumOnFile == ECL_FLOAT_TYPE )
{
dataType = RifKeywordValueCount::KeywordDataType::FLOAT;
}
else if ( dataTypeEnumOnFile == ECL_INT_TYPE )
{
dataType = RifKeywordValueCount::KeywordDataType::INTEGER;
}
int itemCount = ecl_file_iget_named_size( ecl_file, kw, iOcc ); int itemCount = ecl_file_iget_named_size( ecl_file, kw, iOcc );
reportStep.m_keywords.appendKeyword( kw, itemCount, iOcc ); reportSteps.appendKeywordCount( kw, itemCount, dataType );
} }
} }
reportSteps->push_back( reportStep );
} }
ecl_file_pop_block( ecl_file ); ecl_file_pop_block( ecl_file );
@ -697,4 +661,6 @@ void RifEclipseOutputFileTools::createReportStepsMetaData( std::vector<ecl_file_
} }
} }
} }
return reportSteps;
} }

5
ApplicationLibCode/FileInterface/RifEclipseOutputFileTools.h
View File

@ -48,8 +48,7 @@ public:
RifEclipseOutputFileTools(); RifEclipseOutputFileTools();
virtual ~RifEclipseOutputFileTools(); virtual ~RifEclipseOutputFileTools();
static void static std::vector<RifKeywordValueCount> keywordValueCounts( const std::vector<ecl_file_type*>& ecl_files );
findKeywordsAndItemCount( std::vector<ecl_file_type*> ecl_files, QStringList* resultNames, std::vector<size_t>* resultDataItemCounts );
static bool keywordData( const ecl_file_type* ecl_file, const QString& keyword, size_t fileKeywordOccurrence, std::vector<double>* values ); static bool keywordData( const ecl_file_type* ecl_file, const QString& keyword, size_t fileKeywordOccurrence, std::vector<double>* values );
static bool keywordData( const ecl_file_type* ecl_file, const QString& keyword, size_t fileKeywordOccurrence, std::vector<int>* values ); static bool keywordData( const ecl_file_type* ecl_file, const QString& keyword, size_t fileKeywordOccurrence, std::vector<int>* values );
@ -87,5 +86,5 @@ public:
static FILE* fopen( const QString& filePath, const QString& mode ); static FILE* fopen( const QString& filePath, const QString& mode );
private: private:
static void createReportStepsMetaData( std::vector<ecl_file_type*> ecl_files, std::vector<RifRestartReportStep>* reportSteps ); static RifRestartReportKeywords createReportStepsMetaData( const std::vector<ecl_file_type*>& ecl_files );
}; };

88
ApplicationLibCode/FileInterface/RifEclipseRestartDataAccess.cpp
View File

@ -35,68 +35,40 @@ RifEclipseRestartDataAccess::~RifEclipseRestartDataAccess()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RifRestartReportKeywords::RifRestartReportKeywords() void RifRestartReportKeywords::appendKeywordCount( const std::string& keyword, size_t valueCount, RifKeywordValueCount::KeywordDataType dataType )
{ {
} auto it = m_keywordValueCounts.find( keyword );
//-------------------------------------------------------------------------------------------------- if ( it == m_keywordValueCounts.end() )
///
//--------------------------------------------------------------------------------------------------
void RifRestartReportKeywords::appendKeyword( const std::string& keyword, size_t itemCount, int globalIndex )
{
m_keywordNameAndItemCount.push_back( RifKeywordLocation( keyword, itemCount, globalIndex ) );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<std::pair<std::string, size_t>> RifRestartReportKeywords::keywordsWithAggregatedItemCount()
{
std::vector<std::pair<std::string, size_t>> tmp;
for ( auto uni : uniqueKeywords() )
{ {
size_t sum = 0; m_keywordValueCounts[keyword] = RifKeywordValueCount( keyword, valueCount, dataType );
for ( auto loc : objectsForKeyword( uni ) )
{
sum += loc.itemCount();
}
tmp.push_back( std::make_pair( uni, sum ) );
} }
else
{
it->second.addValueCount( valueCount );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RifRestartReportKeywords::appendKeywordCount( const RifRestartReportKeywords& other )
{
for ( const auto& [keyword, keywordInfo] : other.m_keywordValueCounts )
{
appendKeywordCount( keyword, keywordInfo.valueCount(), keywordInfo.dataType() );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RifKeywordValueCount> RifRestartReportKeywords::keywordValueCounts() const
{
std::vector<RifKeywordValueCount> tmp;
for ( const auto& [keyword, info] : m_keywordValueCounts )
{
tmp.push_back( info );
}
return tmp; return tmp;
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RifKeywordLocation> RifRestartReportKeywords::objectsForKeyword( const std::string& keyword )
{
std::vector<RifKeywordLocation> tmp;
for ( auto a : m_keywordNameAndItemCount )
{
if ( a.keyword() == keyword )
{
tmp.push_back( a );
}
}
return tmp;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::set<std::string> RifRestartReportKeywords::uniqueKeywords()
{
std::set<std::string> unique;
for ( auto a : m_keywordNameAndItemCount )
{
unique.insert( a.keyword() );
}
return unique;
}

82
ApplicationLibCode/FileInterface/RifEclipseRestartDataAccess.h
View File

@ -31,50 +31,74 @@
#include "RifReaderInterface.h" #include "RifReaderInterface.h"
class RifKeywordLocation //==================================================================================================
//
//==================================================================================================
class RifKeywordValueCount
{ {
public: public:
RifKeywordLocation( const std::string& keyword, size_t itemCount, int indexWithinReportStep ) enum class KeywordDataType
{
UNKNOWN,
FLOAT,
DOUBLE,
INTEGER,
};
public:
RifKeywordValueCount( const std::string& keyword, size_t itemCount, KeywordDataType dataType )
: m_keyword( keyword ) : m_keyword( keyword )
, m_itemCount( itemCount ) , m_valueCount( itemCount )
, m_indexWithinReportStep( indexWithinReportStep ) , m_dataType( dataType )
{ {
} }
std::string keyword() const { return m_keyword; } RifKeywordValueCount()
size_t itemCount() const { return m_itemCount; } : m_valueCount( 0 )
int indexWithinReportStep() const { return m_indexWithinReportStep; } , m_dataType( KeywordDataType::UNKNOWN )
{
}
void addValueCount( size_t valueCount ) { m_valueCount += valueCount; }
std::string keyword() const { return m_keyword; }
size_t valueCount() const { return m_valueCount; }
KeywordDataType dataType() const { return m_dataType; }
static RiaDefines::ResultDataType mapType( RifKeywordValueCount::KeywordDataType dataType )
{
switch ( dataType )
{
case RifKeywordValueCount::KeywordDataType::FLOAT:
return RiaDefines::ResultDataType::FLOAT;
case RifKeywordValueCount::KeywordDataType::DOUBLE:
return RiaDefines::ResultDataType::DOUBLE;
case RifKeywordValueCount::KeywordDataType::INTEGER:
return RiaDefines::ResultDataType::INTEGER;
}
return RiaDefines::ResultDataType::UNKNOWN;
}
private: private:
std::string m_keyword; std::string m_keyword;
size_t m_itemCount; size_t m_valueCount;
int m_indexWithinReportStep; KeywordDataType m_dataType;
}; };
//==================================================================================================
//
//==================================================================================================
class RifRestartReportKeywords class RifRestartReportKeywords
{ {
public: public:
RifRestartReportKeywords(); void appendKeywordCount( const RifRestartReportKeywords& other );
void appendKeywordCount( const std::string& keyword, size_t valueCount, RifKeywordValueCount::KeywordDataType dataType );
void appendKeyword( const std::string& keyword, size_t itemCount, int globalIndex ); std::vector<RifKeywordValueCount> keywordValueCounts() const;
std::vector<std::pair<std::string, size_t>> keywordsWithAggregatedItemCount();
private: private:
std::vector<RifKeywordLocation> objectsForKeyword( const std::string& keyword ); std::map<std::string, RifKeywordValueCount> m_keywordValueCounts;
std::set<std::string> uniqueKeywords();
private:
std::vector<RifKeywordLocation> m_keywordNameAndItemCount;
};
class RifRestartReportStep
{
public:
// int globalIndex;
QDateTime dateTime;
RifRestartReportKeywords m_keywords;
}; };
//================================================================================================== //==================================================================================================
@ -97,7 +121,7 @@ public:
virtual void timeSteps( std::vector<QDateTime>* timeSteps, std::vector<double>* daysSinceSimulationStart ) = 0; virtual void timeSteps( std::vector<QDateTime>* timeSteps, std::vector<double>* daysSinceSimulationStart ) = 0;
virtual std::vector<int> reportNumbers() = 0; virtual std::vector<int> reportNumbers() = 0;
virtual void resultNames( QStringList* resultNames, std::vector<size_t>* resultDataItemCounts ) = 0; virtual std::vector<RifKeywordValueCount> keywordValueCounts() = 0;
virtual bool results( const QString& resultName, size_t timeStep, size_t gridCount, std::vector<double>* values ) = 0; virtual bool results( const QString& resultName, size_t timeStep, size_t gridCount, std::vector<double>* values ) = 0;
virtual bool dynamicNNCResults( const ecl_grid_type* grid, virtual bool dynamicNNCResults( const ecl_grid_type* grid,

4
ApplicationLibCode/FileInterface/RifEclipseRestartFilesetAccess.cpp
View File

@ -158,7 +158,7 @@ void RifEclipseRestartFilesetAccess::timeSteps( std::vector<QDateTime>* timeStep
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// Get list of result names /// Get list of result names
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RifEclipseRestartFilesetAccess::resultNames( QStringList* resultNames, std::vector<size_t>* resultDataItemCounts ) std::vector<RifKeywordValueCount> RifEclipseRestartFilesetAccess::keywordValueCounts()
{ {
CVF_ASSERT( timeStepCount() > 0 ); CVF_ASSERT( timeStepCount() > 0 );
@ -167,7 +167,7 @@ void RifEclipseRestartFilesetAccess::resultNames( QStringList* resultNames, std:
openTimeStep( i ); openTimeStep( i );
} }
RifEclipseOutputFileTools::findKeywordsAndItemCount( m_ecl_files, resultNames, resultDataItemCounts ); return RifEclipseOutputFileTools::keywordValueCounts( m_ecl_files );
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

2
ApplicationLibCode/FileInterface/RifEclipseRestartFilesetAccess.h
View File

@ -46,7 +46,7 @@ public:
void timeSteps( std::vector<QDateTime>* timeSteps, std::vector<double>* daysSinceSimulationStart ) override; void timeSteps( std::vector<QDateTime>* timeSteps, std::vector<double>* daysSinceSimulationStart ) override;
std::vector<int> reportNumbers() override; std::vector<int> reportNumbers() override;
void resultNames( QStringList* resultNames, std::vector<size_t>* resultDataItemCounts ) override; std::vector<RifKeywordValueCount> keywordValueCounts() override;
bool results( const QString& resultName, size_t timeStep, size_t gridCount, std::vector<double>* values ) override; bool results( const QString& resultName, size_t timeStep, size_t gridCount, std::vector<double>* values ) override;
bool dynamicNNCResults( const ecl_grid_type* grid, bool dynamicNNCResults( const ecl_grid_type* grid,

6
ApplicationLibCode/FileInterface/RifEclipseUnifiedRestartFileAccess.cpp
View File

@ -223,15 +223,17 @@ void RifEclipseUnifiedRestartFileAccess::timeSteps( std::vector<QDateTime>* time
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// Get list of result names /// Get list of result names
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RifEclipseUnifiedRestartFileAccess::resultNames( QStringList* resultNames, std::vector<size_t>* resultDataItemCounts ) std::vector<RifKeywordValueCount> RifEclipseUnifiedRestartFileAccess::keywordValueCounts()
{ {
if ( openFile() ) if ( openFile() )
{ {
std::vector<ecl_file_type*> filesUsedToFindAvailableKeywords; std::vector<ecl_file_type*> filesUsedToFindAvailableKeywords;
filesUsedToFindAvailableKeywords.push_back( m_ecl_file ); filesUsedToFindAvailableKeywords.push_back( m_ecl_file );
RifEclipseOutputFileTools::findKeywordsAndItemCount( filesUsedToFindAvailableKeywords, resultNames, resultDataItemCounts ); return RifEclipseOutputFileTools::keywordValueCounts( filesUsedToFindAvailableKeywords );
} }
return {};
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

2
ApplicationLibCode/FileInterface/RifEclipseUnifiedRestartFileAccess.h
View File

@ -47,7 +47,7 @@ public:
void timeSteps( std::vector<QDateTime>* timeSteps, std::vector<double>* daysSinceSimulationStart ) override; void timeSteps( std::vector<QDateTime>* timeSteps, std::vector<double>* daysSinceSimulationStart ) override;
std::vector<int> reportNumbers() override; std::vector<int> reportNumbers() override;
void resultNames( QStringList* resultNames, std::vector<size_t>* resultDataItemCounts ) override; std::vector<RifKeywordValueCount> keywordValueCounts() override;
bool results( const QString& resultName, size_t timeStep, size_t gridCount, std::vector<double>* values ) override; bool results( const QString& resultName, size_t timeStep, size_t gridCount, std::vector<double>* values ) override;
bool dynamicNNCResults( const ecl_grid_type* grid, bool dynamicNNCResults( const ecl_grid_type* grid,

135
ApplicationLibCode/FileInterface/RifReaderEclipseOutput.cpp
View File

@ -922,39 +922,37 @@ void RifReaderEclipseOutput::buildMetaData( ecl_grid_type* grid )
timeStepInfos = createFilteredTimeStepInfos(); timeStepInfos = createFilteredTimeStepInfos();
QStringList resultNames; auto keywordValueCounts = m_dynamicResultsAccess->keywordValueCounts();
std::vector<size_t> resultNamesDataItemCounts;
m_dynamicResultsAccess->resultNames( &resultNames, &resultNamesDataItemCounts );
{ {
QStringList matrixResultNames = auto validKeywords = validKeywordsForPorosityModel( keywordValueCounts,
validKeywordsForPorosityModel( resultNames, m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL ),
resultNamesDataItemCounts, m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL ),
m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL ), RiaDefines::PorosityModelType::MATRIX_MODEL,
m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL ), m_dynamicResultsAccess->timeStepCount() );
RiaDefines::PorosityModelType::MATRIX_MODEL,
m_dynamicResultsAccess->timeStepCount() );
for ( int i = 0; i < matrixResultNames.size(); ++i ) for ( const auto& keywordData : validKeywords )
{ {
RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE, matrixResultNames[i] ); RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RifKeywordValueCount::mapType( keywordData.dataType() ),
QString::fromStdString( keywordData.keyword() ) );
matrixModelResults->createResultEntry( resAddr, false ); matrixModelResults->createResultEntry( resAddr, false );
matrixModelResults->setTimeStepInfos( resAddr, timeStepInfos ); matrixModelResults->setTimeStepInfos( resAddr, timeStepInfos );
} }
} }
{ {
QStringList fractureResultNames = auto validKeywords = validKeywordsForPorosityModel( keywordValueCounts,
validKeywordsForPorosityModel( resultNames, m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL ),
resultNamesDataItemCounts, m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL ),
m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL ), RiaDefines::PorosityModelType::FRACTURE_MODEL,
m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL ), m_dynamicResultsAccess->timeStepCount() );
RiaDefines::PorosityModelType::FRACTURE_MODEL,
m_dynamicResultsAccess->timeStepCount() );
for ( int i = 0; i < fractureResultNames.size(); ++i ) for ( const auto& keywordData : validKeywords )
{ {
RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE, fractureResultNames[i] ); RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RifKeywordValueCount::mapType( keywordData.dataType() ),
QString::fromStdString( keywordData.keyword() ) );
fractureModelResults->createResultEntry( resAddr, false ); fractureModelResults->createResultEntry( resAddr, false );
fractureModelResults->setTimeStepInfos( resAddr, timeStepInfos ); fractureModelResults->setTimeStepInfos( resAddr, timeStepInfos );
} }
@ -1002,12 +1000,10 @@ void RifReaderEclipseOutput::buildMetaData( ecl_grid_type* grid )
if ( m_ecl_init_file ) if ( m_ecl_init_file )
{ {
QStringList resultNames;
std::vector<size_t> resultNamesDataItemCounts;
std::vector<ecl_file_type*> filesUsedToFindAvailableKeywords; std::vector<ecl_file_type*> filesUsedToFindAvailableKeywords;
filesUsedToFindAvailableKeywords.push_back( m_ecl_init_file ); filesUsedToFindAvailableKeywords.push_back( m_ecl_init_file );
RifEclipseOutputFileTools::findKeywordsAndItemCount( filesUsedToFindAvailableKeywords, &resultNames, &resultNamesDataItemCounts ); auto keywordInfo = RifEclipseOutputFileTools::keywordValueCounts( filesUsedToFindAvailableKeywords );
std::vector<RigEclipseTimeStepInfo> staticTimeStepInfo; std::vector<RigEclipseTimeStepInfo> staticTimeStepInfo;
if ( !timeStepInfos.empty() ) if ( !timeStepInfos.empty() )
@ -1016,39 +1012,37 @@ void RifReaderEclipseOutput::buildMetaData( ecl_grid_type* grid )
} }
{ {
QStringList matrixResultNames = auto validKeywords = validKeywordsForPorosityModel( keywordInfo,
validKeywordsForPorosityModel( resultNames, m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL ),
resultNamesDataItemCounts, m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL ),
m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL ), RiaDefines::PorosityModelType::MATRIX_MODEL,
m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL ), 1 );
RiaDefines::PorosityModelType::MATRIX_MODEL,
1 );
// Add ACTNUM validKeywords.push_back( RifKeywordValueCount( "ACTNUM", 0, RifKeywordValueCount::KeywordDataType::INTEGER ) );
matrixResultNames += "ACTNUM";
for ( int i = 0; i < matrixResultNames.size(); ++i ) for ( const auto& keywordData : validKeywords )
{ {
RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::STATIC_NATIVE, matrixResultNames[i] ); RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::STATIC_NATIVE,
RifKeywordValueCount::mapType( keywordData.dataType() ),
QString::fromStdString( keywordData.keyword() ) );
matrixModelResults->createResultEntry( resAddr, false ); matrixModelResults->createResultEntry( resAddr, false );
matrixModelResults->setTimeStepInfos( resAddr, staticTimeStepInfo ); matrixModelResults->setTimeStepInfos( resAddr, staticTimeStepInfo );
} }
} }
{ {
QStringList fractureResultNames = auto validKeywords = validKeywordsForPorosityModel( keywordInfo,
validKeywordsForPorosityModel( resultNames, m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL ),
resultNamesDataItemCounts, m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL ),
m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL ), RiaDefines::PorosityModelType::FRACTURE_MODEL,
m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL ), 1 );
RiaDefines::PorosityModelType::FRACTURE_MODEL, validKeywords.push_back( RifKeywordValueCount( "ACTNUM", 0, RifKeywordValueCount::KeywordDataType::INTEGER ) );
1 );
// Add ACTNUM
fractureResultNames += "ACTNUM";
for ( int i = 0; i < fractureResultNames.size(); ++i ) for ( const auto& keywordData : validKeywords )
{ {
RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::STATIC_NATIVE, fractureResultNames[i] ); RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::STATIC_NATIVE,
RifKeywordValueCount::mapType( keywordData.dataType() ),
QString::fromStdString( keywordData.keyword() ) );
fractureModelResults->createResultEntry( resAddr, false ); fractureModelResults->createResultEntry( resAddr, false );
fractureModelResults->setTimeStepInfos( resAddr, staticTimeStepInfo ); fractureModelResults->setTimeStepInfos( resAddr, staticTimeStepInfo );
} }
@ -2110,60 +2104,55 @@ void RifReaderEclipseOutput::readWellCells( const ecl_grid_type* mainEclGrid, bo
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
QStringList RifReaderEclipseOutput::validKeywordsForPorosityModel( const QStringList& keywords, std::vector<RifKeywordValueCount>
const std::vector<size_t>& keywordDataItemCounts, RifReaderEclipseOutput::validKeywordsForPorosityModel( const std::vector<RifKeywordValueCount>& keywordItemCounts,
const RigActiveCellInfo* matrixActiveCellInfo, const RigActiveCellInfo* matrixActiveCellInfo,
const RigActiveCellInfo* fractureActiveCellInfo, const RigActiveCellInfo* fractureActiveCellInfo,
RiaDefines::PorosityModelType porosityModel, RiaDefines::PorosityModelType porosityModel,
size_t timeStepCount ) const size_t timeStepCount ) const
{ {
CVF_ASSERT( matrixActiveCellInfo ); CVF_ASSERT( matrixActiveCellInfo );
if ( keywords.size() != static_cast<int>( keywordDataItemCounts.size() ) )
{
return QStringList();
}
if ( porosityModel == RiaDefines::PorosityModelType::FRACTURE_MODEL ) if ( porosityModel == RiaDefines::PorosityModelType::FRACTURE_MODEL )
{ {
if ( fractureActiveCellInfo->reservoirActiveCellCount() == 0 ) if ( fractureActiveCellInfo->reservoirActiveCellCount() == 0 )
{ {
return QStringList(); return {};
} }
} }
QStringList keywordsWithCorrectNumberOfDataItems; std::vector<RifKeywordValueCount> keywordsWithCorrectNumberOfDataItems;
for ( int i = 0; i < keywords.size(); i++ ) for ( const auto& keywordValueCount : keywordItemCounts )
{ {
QString keyword = keywords[i]; QString keyword = QString::fromStdString( keywordValueCount.keyword() );
size_t keywordDataItemCount = keywordDataItemCounts[i]; size_t valueCount = keywordValueCount.valueCount();
bool validKeyword = false; bool validKeyword = false;
size_t timeStepsAllCellsRest = keywordDataItemCount % matrixActiveCellInfo->reservoirCellCount(); size_t timeStepsAllCellsRest = valueCount % matrixActiveCellInfo->reservoirCellCount();
if ( timeStepsAllCellsRest == 0 && keywordDataItemCount <= timeStepCount * matrixActiveCellInfo->reservoirCellCount() ) if ( timeStepsAllCellsRest == 0 && valueCount <= timeStepCount * matrixActiveCellInfo->reservoirCellCount() )
{ {
// Found result for all cells for N time steps, usually a static dataset for one time step // Found result for all cells for N time steps, usually a static dataset for one time step
validKeyword = true; validKeyword = true;
} }
else else
{ {
size_t timeStepsMatrixRest = keywordDataItemCount % matrixActiveCellInfo->reservoirActiveCellCount(); size_t timeStepsMatrixRest = valueCount % matrixActiveCellInfo->reservoirActiveCellCount();
size_t timeStepsFractureRest = 0; size_t timeStepsFractureRest = 0;
if ( fractureActiveCellInfo->reservoirActiveCellCount() > 0 ) if ( fractureActiveCellInfo->reservoirActiveCellCount() > 0 )
{ {
timeStepsFractureRest = keywordDataItemCount % fractureActiveCellInfo->reservoirActiveCellCount(); timeStepsFractureRest = valueCount % fractureActiveCellInfo->reservoirActiveCellCount();
} }
size_t sumFractureMatrixActiveCellCount = matrixActiveCellInfo->reservoirActiveCellCount() + size_t sumFractureMatrixActiveCellCount = matrixActiveCellInfo->reservoirActiveCellCount() +
fractureActiveCellInfo->reservoirActiveCellCount(); fractureActiveCellInfo->reservoirActiveCellCount();
size_t timeStepsMatrixAndFractureRest = keywordDataItemCount % sumFractureMatrixActiveCellCount; size_t timeStepsMatrixAndFractureRest = valueCount % sumFractureMatrixActiveCellCount;
if ( porosityModel == RiaDefines::PorosityModelType::MATRIX_MODEL && timeStepsMatrixRest == 0 ) if ( porosityModel == RiaDefines::PorosityModelType::MATRIX_MODEL && timeStepsMatrixRest == 0 )
{ {
if ( keywordDataItemCount <= if ( valueCount <=
timeStepCount * std::max( matrixActiveCellInfo->reservoirActiveCellCount(), sumFractureMatrixActiveCellCount ) ) timeStepCount * std::max( matrixActiveCellInfo->reservoirActiveCellCount(), sumFractureMatrixActiveCellCount ) )
{ {
validKeyword = true; validKeyword = true;
@ -2172,7 +2161,7 @@ QStringList RifReaderEclipseOutput::validKeywordsForPorosityModel( const QString
else if ( porosityModel == RiaDefines::PorosityModelType::FRACTURE_MODEL && else if ( porosityModel == RiaDefines::PorosityModelType::FRACTURE_MODEL &&
fractureActiveCellInfo->reservoirActiveCellCount() > 0 && timeStepsFractureRest == 0 ) fractureActiveCellInfo->reservoirActiveCellCount() > 0 && timeStepsFractureRest == 0 )
{ {
if ( keywordDataItemCount <= if ( valueCount <=
timeStepCount * std::max( fractureActiveCellInfo->reservoirActiveCellCount(), sumFractureMatrixActiveCellCount ) ) timeStepCount * std::max( fractureActiveCellInfo->reservoirActiveCellCount(), sumFractureMatrixActiveCellCount ) )
{ {
validKeyword = true; validKeyword = true;
@ -2180,7 +2169,7 @@ QStringList RifReaderEclipseOutput::validKeywordsForPorosityModel( const QString
} }
else if ( timeStepsMatrixAndFractureRest == 0 ) else if ( timeStepsMatrixAndFractureRest == 0 )
{ {
if ( keywordDataItemCount <= timeStepCount * sumFractureMatrixActiveCellCount ) if ( valueCount <= timeStepCount * sumFractureMatrixActiveCellCount )
{ {
validKeyword = true; validKeyword = true;
} }
@ -2195,8 +2184,8 @@ QStringList RifReaderEclipseOutput::validKeywordsForPorosityModel( const QString
size_t mainGridMatrixActiveCellCount = matrixActiveCellInfo->gridActiveCellCounts( 0 ); size_t mainGridMatrixActiveCellCount = matrixActiveCellInfo->gridActiveCellCounts( 0 );
size_t mainGridFractureActiveCellCount = fractureActiveCellInfo->gridActiveCellCounts( 0 ); size_t mainGridFractureActiveCellCount = fractureActiveCellInfo->gridActiveCellCounts( 0 );
if ( keywordDataItemCount == mainGridMatrixActiveCellCount || keywordDataItemCount == mainGridFractureActiveCellCount || if ( valueCount == mainGridMatrixActiveCellCount || valueCount == mainGridFractureActiveCellCount ||
keywordDataItemCount == mainGridMatrixActiveCellCount + mainGridFractureActiveCellCount ) valueCount == mainGridMatrixActiveCellCount + mainGridFractureActiveCellCount )
{ {
validKeyword = true; validKeyword = true;
} }
@ -2205,7 +2194,7 @@ QStringList RifReaderEclipseOutput::validKeywordsForPorosityModel( const QString
if ( validKeyword ) if ( validKeyword )
{ {
keywordsWithCorrectNumberOfDataItems.push_back( keyword ); keywordsWithCorrectNumberOfDataItems.push_back( keywordValueCount );
} }
} }

12
ApplicationLibCode/FileInterface/RifReaderEclipseOutput.h
View File

@ -36,6 +36,7 @@ class RigEclipseTimeStepInfo;
class RigGridBase; class RigGridBase;
class RigMainGrid; class RigMainGrid;
class QDateTime; class QDateTime;
class RifKeywordValueCount;
struct RigWellResultPoint; struct RigWellResultPoint;
@ -113,12 +114,11 @@ private:
void ensureDynamicResultAccessIsPresent(); void ensureDynamicResultAccessIsPresent();
QStringList validKeywordsForPorosityModel( const QStringList& keywords, std::vector<RifKeywordValueCount> validKeywordsForPorosityModel( const std::vector<RifKeywordValueCount>& keywordItemCounts,
const std::vector<size_t>& keywordDataItemCounts, const RigActiveCellInfo* activeCellInfo,
const RigActiveCellInfo* activeCellInfo, const RigActiveCellInfo* fractureActiveCellInfo,
const RigActiveCellInfo* fractureActiveCellInfo, RiaDefines::PorosityModelType matrixOrFracture,
RiaDefines::PorosityModelType matrixOrFracture, size_t timeStepCount ) const;
size_t timeStepCount ) const;
std::vector<RigEclipseTimeStepInfo> createFilteredTimeStepInfos(); std::vector<RigEclipseTimeStepInfo> createFilteredTimeStepInfos();

85
ApplicationLibCode/FileInterface/RifRoffFileTools.cpp
View File

@ -26,6 +26,10 @@
#include "RigEclipseCaseData.h" #include "RigEclipseCaseData.h"
#include "RigMainGrid.h" #include "RigMainGrid.h"
#include "RimColorLegendCollection.h"
#include "RimEclipseCase.h"
#include "RimProject.h"
#include "cafProgressInfo.h" #include "cafProgressInfo.h"
#include <chrono> #include <chrono>
@ -147,10 +151,10 @@ bool RifRoffFileTools::openGridFile( const QString& fileName, RigEclipseCaseData
RiaLogging::info( QString( "Scale: %1 %2 %3" ).arg( xScale ).arg( yScale ).arg( zScale ) ); RiaLogging::info( QString( "Scale: %1 %2 %3" ).arg( xScale ).arg( yScale ).arg( zScale ) );
} }
std::vector<float> cornerLines = reader.getFloatArray( "cornerLines.data" ); std::vector<float> cornerLines = reader.getFloatArray( "cornerLines" + roff::Parser::postFixData() );
std::vector<float> zValues = reader.getFloatArray( "zvalues.data" ); std::vector<float> zValues = reader.getFloatArray( "zvalues" + roff::Parser::postFixData() );
std::vector<char> splitEnz = reader.getByteArray( "zvalues.splitEnz" ); std::vector<char> splitEnz = reader.getByteArray( "zvalues.splitEnz" );
std::vector<char> active = reader.getByteArray( "active.data" ); std::vector<char> active = reader.getByteArray( "active" + roff::Parser::postFixData() );
const auto parsingDone = high_resolution_clock::now(); const auto parsingDone = high_resolution_clock::now();
@ -521,7 +525,7 @@ std::pair<bool, std::map<QString, QString>> RifRoffFileTools::createInputPropert
QString newResultName = eclipseCaseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL ) QString newResultName = eclipseCaseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
->makeResultNameUnique( QString::fromStdString( keyword ) ); ->makeResultNameUnique( QString::fromStdString( keyword ) );
// Special handling for active.data ==> ACTNUM // Special handling for active.data ==> ACTNUM
if ( newResultName == "active.data" ) if ( newResultName == QString( "active" ) + QString::fromStdString( roff::Parser::postFixData() ) )
{ {
newResultName = "ACTNUM"; newResultName = "ACTNUM";
} }
@ -533,6 +537,59 @@ std::pair<bool, std::map<QString, QString>> RifRoffFileTools::createInputPropert
return std::make_pair( false, keywordMapping ); return std::make_pair( false, keywordMapping );
} }
// Create color legend
{
const std::string codeNamesKeyword = keyword + roff::Parser::postFixCodeNames();
const std::string codeValuesKeyword = keyword + roff::Parser::postFixCodeValues();
auto codeNamesSize = reader.getArrayLength( codeNamesKeyword );
auto codeValuesSize = reader.getArrayLength( codeValuesKeyword );
if ( codeNamesSize != 0 && codeNamesSize == codeValuesSize )
{
const auto fileCodeNames = reader.getStringArray( codeNamesKeyword );
const auto fileCodeValues = reader.getIntArray( codeValuesKeyword );
QStringList trimmedCodeNames;
bool anyValidName = false;
for ( const std::string& codeName : fileCodeNames )
{
QString trimmedCodeName = QString::fromStdString( codeName ).trimmed();
trimmedCodeNames.push_back( trimmedCodeName );
if ( !trimmedCodeName.isEmpty() )
{
anyValidName = true;
}
}
if ( anyValidName )
{
std::vector<std::pair<int, QString>> valuesAndNames;
for ( int i = 0; i < static_cast<int>( trimmedCodeNames.size() ); i++ )
{
const auto& codeName = trimmedCodeNames[i];
valuesAndNames.emplace_back( fileCodeValues[i], codeName );
}
RimColorLegendCollection* colorLegendCollection = RimProject::current()->colorLegendCollection;
int caseId = 0;
auto rimCase = eclipseCaseData->ownerCase();
if ( rimCase ) caseId = rimCase->caseId();
// Delete existing color legend, as new legend will be populated by values from file
colorLegendCollection->deleteColorLegend( caseId, newResultName );
auto colorLegend = colorLegendCollection->createColorLegend( newResultName, valuesAndNames );
colorLegendCollection->setDefaultColorLegendForResult( caseId, newResultName, colorLegend );
colorLegendCollection->updateAllRequiredEditors();
}
}
}
keywordMapping[QString::fromStdString( keyword )] = newResultName; keywordMapping[QString::fromStdString( keyword )] = newResultName;
} }
} }
@ -568,7 +625,7 @@ bool RifRoffFileTools::hasGridData( const QString& filename )
const std::vector<std::pair<std::string, roff::Token::Kind>> arrayTypes = reader.getNamedArrayTypes(); const std::vector<std::pair<std::string, roff::Token::Kind>> arrayTypes = reader.getNamedArrayTypes();
const std::string cornerLinesDataKeyword = "cornerLines.data"; const std::string cornerLinesDataKeyword = "cornerLines" + roff::Parser::postFixData();
auto cornerLinesDataItr = std::find_if( arrayTypes.begin(), auto cornerLinesDataItr = std::find_if( arrayTypes.begin(),
arrayTypes.end(), arrayTypes.end(),
[&cornerLinesDataKeyword]( const auto& arrayType ) [&cornerLinesDataKeyword]( const auto& arrayType )
@ -640,7 +697,7 @@ bool RifRoffFileTools::appendNewInputPropertyResult( RigEclipseCaseData* caseDat
} }
} }
RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::INPUT_PROPERTY, resultName ); RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::INPUT_PROPERTY, RifRoffFileTools::mapFromType( kind ), resultName );
caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->createResultEntry( resAddr, false ); caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->createResultEntry( resAddr, false );
auto newPropertyData = caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->modifiableCellScalarResultTimesteps( resAddr ); auto newPropertyData = caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->modifiableCellScalarResultTimesteps( resAddr );
@ -649,3 +706,19 @@ bool RifRoffFileTools::appendNewInputPropertyResult( RigEclipseCaseData* caseDat
return true; return true;
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaDefines::ResultDataType RifRoffFileTools::mapFromType( roff::Token::Kind kind )
{
switch ( kind )
{
case roff::Token::Kind::BOOL:
return RiaDefines::ResultDataType::INTEGER;
case roff::Token::Kind::INT:
return RiaDefines::ResultDataType::INTEGER;
}
return RiaDefines::ResultDataType::FLOAT;
}

3
ApplicationLibCode/FileInterface/RifRoffFileTools.h
View File

@ -28,6 +28,7 @@
#include <map> #include <map>
#include <vector> #include <vector>
#include "RiaDefines.h"
#include "Token.hpp" #include "Token.hpp"
class RigEclipseCaseData; class RigEclipseCaseData;
@ -83,4 +84,6 @@ private:
const std::string& keyword, const std::string& keyword,
roff::Token::Kind token, roff::Token::Kind token,
roff::Reader& reader ); roff::Reader& reader );
static RiaDefines::ResultDataType mapFromType( roff::Token::Kind kind );
}; };

5
ApplicationLibCode/FileInterface/RifRoffReader.cpp
View File

@ -21,6 +21,7 @@
#include <QFile> #include <QFile>
#include <QTextStream> #include <QTextStream>
#include "roffcpp/src/Parser.hpp"
#include "roffcpp/src/Reader.hpp" #include "roffcpp/src/Reader.hpp"
#include <fstream> #include <fstream>
@ -41,8 +42,8 @@ void RifRoffReader::readCodeNames( const QString& filename, const QString& param
std::vector<std::pair<std::string, roff::Token::Kind>> arrayTypes = reader.getNamedArrayTypes(); std::vector<std::pair<std::string, roff::Token::Kind>> arrayTypes = reader.getNamedArrayTypes();
// Find array types by keywords // Find array types by keywords
const std::string codeNamesKeyword = parameterTagName.toStdString() + ".codeNames"; const std::string codeNamesKeyword = parameterTagName.toStdString() + roff::Parser::postFixCodeNames();
const std::string codeValuesKeyword = parameterTagName.toStdString() + ".codeValues"; const std::string codeValuesKeyword = parameterTagName.toStdString() + roff::Parser::postFixCodeValues();
auto codeNamesItr = std::find_if( arrayTypes.begin(), auto codeNamesItr = std::find_if( arrayTypes.begin(),
arrayTypes.end(), arrayTypes.end(),
[&codeNamesKeyword]( const auto& arrayType ) { return arrayType.first == codeNamesKeyword; } ); [&codeNamesKeyword]( const auto& arrayType ) { return arrayType.first == codeNamesKeyword; } );

5
ApplicationLibCode/ProjectDataModel/Intersections/RimIntersectionResultDefinition.cpp
View File

@ -387,7 +387,10 @@ void RimIntersectionResultDefinition::setDefaultEclipseLegendConfig()
auto eclResultDef = this->eclipseResultDefinition(); auto eclResultDef = this->eclipseResultDefinition();
eclResultDef->updateRangesForExplicitLegends( this->regularLegendConfig(), this->ternaryLegendConfig(), this->timeStep() ); eclResultDef->updateRangesForExplicitLegends( this->regularLegendConfig(), this->ternaryLegendConfig(), this->timeStep() );
m_legendConfig->setDefaultConfigForResultName( m_eclipseResultDefinition->resultVariable(), useDiscreteLogLevels, isCategoryResult ); m_legendConfig->setDefaultConfigForResultName( m_case->caseId(),
m_eclipseResultDefinition->resultVariable(),
useDiscreteLogLevels,
isCategoryResult );
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

75
ApplicationLibCode/ProjectDataModel/RimColorLegendCollection.cpp
View File

@ -18,6 +18,7 @@
#include "RimColorLegendCollection.h" #include "RimColorLegendCollection.h"
#include "RiaColorTables.h"
#include "RiaFractureDefines.h" #include "RiaFractureDefines.h"
#include "RimColorLegend.h" #include "RimColorLegend.h"
@ -76,9 +77,59 @@ bool RimColorLegendCollection::isStandardColorLegend( RimColorLegend* legend )
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimColorLegendCollection::deleteCustomColorLegends() void RimColorLegendCollection::deleteCustomColorLegends()
{ {
m_defaultColorLegendNameForResult.clear();
m_customColorLegends.deleteChildren(); m_customColorLegends.deleteChildren();
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimColorLegend* RimColorLegendCollection::createColorLegend( const QString& name, const std::vector<std::pair<int, QString>>& valuesAndNames )
{
auto colors = RiaColorTables::categoryPaletteColors().color3ubArray();
auto colorLegend = new RimColorLegend();
colorLegend->setColorLegendName( name );
int colorIndex = 0;
for ( const auto& [value, name] : valuesAndNames )
{
auto item = new RimColorLegendItem();
auto color = colors[colorIndex++ % colors.size()];
cvf::Color3f color3f( color );
item->setValues( name, value, color3f );
colorLegend->appendColorLegendItem( item );
}
appendCustomColorLegend( colorLegend );
return colorLegend;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimColorLegendCollection::deleteColorLegend( int caseId, const QString& resultName )
{
m_defaultColorLegendNameForResult.erase( createLookupKey( caseId, resultName ) );
auto legend = findDefaultLegendForResult( caseId, resultName );
if ( !legend ) return;
m_customColorLegends.removeChild( legend );
delete legend;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimColorLegendCollection::setDefaultColorLegendForResult( int caseId, const QString& resultName, RimColorLegend* colorLegend )
{
auto key = createLookupKey( caseId, resultName );
m_defaultColorLegendNameForResult[key] = colorLegend;
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -170,6 +221,22 @@ RimColorLegend* RimColorLegendCollection::findByName( const QString& name ) cons
return nullptr; return nullptr;
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimColorLegend* RimColorLegendCollection::findDefaultLegendForResult( int caseId, const QString& resultName ) const
{
auto key = createLookupKey( caseId, resultName );
auto it = m_defaultColorLegendNameForResult.find( key );
if ( it != m_defaultColorLegendNameForResult.end() )
{
return it->second;
}
return nullptr;
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -246,6 +313,14 @@ RimColorLegend* RimColorLegendCollection::createRockTypeColorLegend() const
return colorLegend; return colorLegend;
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimColorLegendCollection::createLookupKey( int caseId, const QString& resultName )
{
return QString( "%1 (case %2)" ).arg( resultName ).arg( caseId );
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

9
ApplicationLibCode/ProjectDataModel/RimColorLegendCollection.h
View File

@ -47,9 +47,14 @@ public:
bool isStandardColorLegend( RimColorLegend* colorLegend ); bool isStandardColorLegend( RimColorLegend* colorLegend );
void deleteCustomColorLegends(); void deleteCustomColorLegends();
RimColorLegend* createColorLegend( const QString& name, const std::vector<std::pair<int, QString>>& valuesAndNames );
void deleteColorLegend( int caseId, const QString& resultName );
void setDefaultColorLegendForResult( int caseId, const QString& resultName, RimColorLegend* colorLegend );
std::vector<RimColorLegend*> allColorLegends() const; std::vector<RimColorLegend*> allColorLegends() const;
RimColorLegend* findByName( const QString& name ) const; RimColorLegend* findByName( const QString& name ) const;
RimColorLegend* findDefaultLegendForResult( int caseId, const QString& resultName ) const;
protected: protected:
void initAfterRead() override; void initAfterRead() override;
@ -58,6 +63,10 @@ private:
RimColorLegendItem* createColorLegendItem( const QString& name, int r, int g, int b ) const; RimColorLegendItem* createColorLegendItem( const QString& name, int r, int g, int b ) const;
RimColorLegend* createRockTypeColorLegend() const; RimColorLegend* createRockTypeColorLegend() const;
static QString createLookupKey( int caseId, const QString& resultName );
caf::PdmChildArrayField<RimColorLegend*> m_standardColorLegends; // ResInsight standard (built-in) legends caf::PdmChildArrayField<RimColorLegend*> m_standardColorLegends; // ResInsight standard (built-in) legends
caf::PdmChildArrayField<RimColorLegend*> m_customColorLegends; // user specified legends caf::PdmChildArrayField<RimColorLegend*> m_customColorLegends; // user specified legends
std::map<QString, caf::PdmPointer<RimColorLegend>> m_defaultColorLegendNameForResult;
}; };

23
ApplicationLibCode/ProjectDataModel/RimEclipseCase.cpp
View File

@ -305,22 +305,19 @@ RimEclipseView* RimEclipseCase::createAndAddReservoirView()
rimEclipseView->setEclipseCase( this ); rimEclipseView->setEclipseCase( this );
// Set default values // Set default values
if ( rimEclipseView->currentGridCellResults() )
{ {
rimEclipseView->cellResult()->setResultType( RiaDefines::ResultCatType::DYNAMIC_NATIVE ); auto defaultResult = rimEclipseView->currentGridCellResults()->defaultResult();
rimEclipseView->cellResult()->setFromEclipseResultAddress( defaultResult );
auto prefs = RiaPreferences::current();
if ( prefs->loadAndShowSoil )
{
rimEclipseView->cellResult()->setResultVariable( RiaResultNames::soil() );
}
rimEclipseView->faultCollection()->showFaultCollection = prefs->enableFaultsByDefault();
rimEclipseView->cellEdgeResult()->setResultVariable( "MULT" );
rimEclipseView->cellEdgeResult()->setActive( false );
rimEclipseView->fractureColors()->setDefaultResultName();
} }
auto prefs = RiaPreferences::current();
rimEclipseView->faultCollection()->showFaultCollection = prefs->enableFaultsByDefault();
rimEclipseView->cellEdgeResult()->setResultVariable( "MULT" );
rimEclipseView->cellEdgeResult()->setActive( false );
rimEclipseView->fractureColors()->setDefaultResultName();
caf::PdmDocument::updateUiIconStateRecursively( rimEclipseView ); caf::PdmDocument::updateUiIconStateRecursively( rimEclipseView );
reservoirViews().push_back( rimEclipseView ); reservoirViews().push_back( rimEclipseView );

11
ApplicationLibCode/ProjectDataModel/RimEclipseCellColors.cpp
View File

@ -142,7 +142,11 @@ void RimEclipseCellColors::changeLegendConfig( QString resultVarNameOfNewLegend
if ( !found ) if ( !found )
{ {
auto newLegend = createLegendForResult( resultVarNameOfNewLegend, this->m_useDiscreteLogLevels, this->hasCategoryResult() ); int caseId = 0;
if ( eclipseCase() ) caseId = eclipseCase()->caseId();
auto newLegend =
createLegendForResult( caseId, resultVarNameOfNewLegend, this->m_useDiscreteLogLevels, this->hasCategoryResult() );
newLegend->changed.connect( this, &RimEclipseCellColors::onLegendConfigChanged ); newLegend->changed.connect( this, &RimEclipseCellColors::onLegendConfigChanged );
@ -165,12 +169,13 @@ void RimEclipseCellColors::onLegendConfigChanged( const caf::SignalEmitter* emit
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RimRegularLegendConfig* RimEclipseCellColors::createLegendForResult( const QString& resultName, bool useDiscreteLogLevels, bool isCategoryResult ) RimRegularLegendConfig*
RimEclipseCellColors::createLegendForResult( int caseId, const QString& resultName, bool useDiscreteLogLevels, bool isCategoryResult )
{ {
auto* newLegend = new RimRegularLegendConfig; auto* newLegend = new RimRegularLegendConfig;
newLegend->resultVariableName = resultName; newLegend->resultVariableName = resultName;
newLegend->setDefaultConfigForResultName( resultName, useDiscreteLogLevels, isCategoryResult ); newLegend->setDefaultConfigForResultName( caseId, resultName, useDiscreteLogLevels, isCategoryResult );
return newLegend; return newLegend;
} }

6
ApplicationLibCode/ProjectDataModel/RimEclipseCellColors.h
View File

@ -76,9 +76,9 @@ protected:
void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override; void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;
private: private:
void changeLegendConfig( QString resultVarNameOfNewLegend ); void changeLegendConfig( QString resultVarNameOfNewLegend );
void onLegendConfigChanged( const caf::SignalEmitter* emitter, RimLegendConfigChangeType changeType ); void onLegendConfigChanged( const caf::SignalEmitter* emitter, RimLegendConfigChangeType changeType );
static RimRegularLegendConfig* createLegendForResult( const QString& resultName, bool useDiscreteLevels, bool isCategoryResult ); static RimRegularLegendConfig* createLegendForResult( int caseId, const QString& resultName, bool useDiscreteLevels, bool isCategoryResult );
caf::PdmChildArrayField<RimRegularLegendConfig*> m_legendConfigData; caf::PdmChildArrayField<RimRegularLegendConfig*> m_legendConfigData;
caf::PdmPtrField<RimRegularLegendConfig*> m_legendConfigPtrField; caf::PdmPtrField<RimRegularLegendConfig*> m_legendConfigPtrField;

17
ApplicationLibCode/ProjectDataModel/RimEclipseResultDefinition.cpp
View File

@ -1469,6 +1469,19 @@ bool RimEclipseResultDefinition::isCompletionTypeSelected() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RimEclipseResultDefinition::hasCategoryResult() const bool RimEclipseResultDefinition::hasCategoryResult() const
{ {
if ( auto* gridCellResults = currentGridCellResults() )
{
const auto addresses = gridCellResults->existingResults();
for ( const auto& address : addresses )
{
if ( address.resultCatType() == m_resultType() && address.resultName() == m_resultVariable() )
{
if ( address.dataType() == RiaDefines::ResultDataType::INTEGER ) return true;
break;
}
}
}
if ( this->m_resultType() == RiaDefines::ResultCatType::FORMATION_NAMES && m_eclipseCase && m_eclipseCase->eclipseCaseData() && if ( this->m_resultType() == RiaDefines::ResultCatType::FORMATION_NAMES && m_eclipseCase && m_eclipseCase->eclipseCaseData() &&
!m_eclipseCase->eclipseCaseData()->formationNames().empty() ) !m_eclipseCase->eclipseCaseData()->formationNames().empty() )
return true; return true;
@ -1486,9 +1499,7 @@ bool RimEclipseResultDefinition::hasCategoryResult() const
return true; return true;
} }
if ( !this->hasStaticResult() ) return false; return false;
return RiaDefines::isNativeCategoryResult( this->resultVariable() );
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

10
ApplicationLibCode/ProjectDataModel/RimRegularLegendConfig.cpp
View File

@ -1167,7 +1167,7 @@ QString RimRegularLegendConfig::valueToText( double value ) const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimRegularLegendConfig::setDefaultConfigForResultName( const QString& resultName, bool useDiscreteLogLevels, bool isCategoryResult ) void RimRegularLegendConfig::setDefaultConfigForResultName( int caseId, const QString& resultName, bool useDiscreteLogLevels, bool isCategoryResult )
{ {
bool useLog = RiaResultNames::isLogarithmicResult( resultName ); bool useLog = RiaResultNames::isLogarithmicResult( resultName );
@ -1215,7 +1215,13 @@ void RimRegularLegendConfig::setDefaultConfigForResultName( const QString& resul
setTickNumberFormat( numberFormat ); setTickNumberFormat( numberFormat );
updateTickCountAndUserDefinedRange(); updateTickCountAndUserDefinedRange();
if ( colorRangeType != RimRegularLegendConfig::ColorRangesType::UNDEFINED ) RimProject* project = RimProject::current();
auto defaultLegend = project->colorLegendCollection()->findDefaultLegendForResult( caseId, resultName );
if ( defaultLegend )
{
setColorLegend( defaultLegend );
}
else if ( colorRangeType != RimRegularLegendConfig::ColorRangesType::UNDEFINED )
{ {
RimColorLegend* colorLegend = RimRegularLegendConfig::mapToColorLegend( colorRangeType ); RimColorLegend* colorLegend = RimRegularLegendConfig::mapToColorLegend( colorRangeType );

2
ApplicationLibCode/ProjectDataModel/RimRegularLegendConfig.h
View File

@ -170,7 +170,7 @@ public:
QString valueToText( double value ) const; QString valueToText( double value ) const;
void setDefaultConfigForResultName( const QString& resultName, bool useDiscreteLogLevels, bool isCategoryResult ); void setDefaultConfigForResultName( int caseId, const QString& resultName, bool useDiscreteLogLevels, bool isCategoryResult );
void defineUiOrderingColorOnly( caf::PdmUiOrdering* colorGroup ); void defineUiOrderingColorOnly( caf::PdmUiOrdering* colorGroup );

12
ApplicationLibCode/ReservoirDataModel/ResultCalculators/RigIndexIjkResultCalculator.cpp
View File

@ -58,12 +58,12 @@ void RigIndexIjkResultCalculator::calculate( const RigEclipseResultAddress& resV
size_t reservoirCellCount = m_resultsData->activeCellInfo()->reservoirCellCount(); size_t reservoirCellCount = m_resultsData->activeCellInfo()->reservoirCellCount();
if ( reservoirCellCount == 0 ) return; if ( reservoirCellCount == 0 ) return;
size_t iResultIndex = m_resultsData->findScalarResultIndexFromAddress( size_t iResultIndex =
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::indexIResultName() ) ); m_resultsData->findScalarResultIndexFromAddress( RiaResultNames::staticIntegerAddress( RiaResultNames::indexIResultName() ) );
size_t jResultIndex = m_resultsData->findScalarResultIndexFromAddress( size_t jResultIndex =
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::indexJResultName() ) ); m_resultsData->findScalarResultIndexFromAddress( RiaResultNames::staticIntegerAddress( RiaResultNames::indexJResultName() ) );
size_t kResultIndex = m_resultsData->findScalarResultIndexFromAddress( size_t kResultIndex =
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::indexKResultName() ) ); m_resultsData->findScalarResultIndexFromAddress( RiaResultNames::staticIntegerAddress( RiaResultNames::indexKResultName() ) );
if ( iResultIndex == cvf::UNDEFINED_SIZE_T || jResultIndex == cvf::UNDEFINED_SIZE_T || kResultIndex == cvf::UNDEFINED_SIZE_T ) return; if ( iResultIndex == cvf::UNDEFINED_SIZE_T || jResultIndex == cvf::UNDEFINED_SIZE_T || kResultIndex == cvf::UNDEFINED_SIZE_T ) return;

112
ApplicationLibCode/ReservoirDataModel/RigCaseCellResultsData.cpp
View File

@ -24,8 +24,11 @@
#include "RiaDefines.h" #include "RiaDefines.h"
#include "RiaEclipseUnitTools.h" #include "RiaEclipseUnitTools.h"
#include "RiaLogging.h" #include "RiaLogging.h"
#include "RiaPreferences.h"
#include "RiaResultNames.h" #include "RiaResultNames.h"
#include "RifReaderEclipseOutput.h"
#include "RigAllanDiagramData.h" #include "RigAllanDiagramData.h"
#include "RigAllanUtil.h" #include "RigAllanUtil.h"
#include "RigCaseCellResultCalculator.h" #include "RigCaseCellResultCalculator.h"
@ -51,8 +54,6 @@
#include "RimGridCalculationCollection.h" #include "RimGridCalculationCollection.h"
#include "RimProject.h" #include "RimProject.h"
#include "RifReaderEclipseOutput.h"
#include "cafAssert.h" #include "cafAssert.h"
#include "cafProgressInfo.h" #include "cafProgressInfo.h"
#include "cvfGeometryTools.h" #include "cvfGeometryTools.h"
@ -746,6 +747,45 @@ size_t RigCaseCellResultsData::addStaticScalarResult( RiaDefines::ResultCatType
return resultIdx; return resultIdx;
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigEclipseResultAddress RigCaseCellResultsData::defaultResult() const
{
auto allResults = existingResults();
if ( maxTimeStepCount() > 0 )
{
auto prefs = RiaPreferences::current();
if ( prefs->loadAndShowSoil ) return RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, RiaResultNames::soil() );
auto dynamicResult = std::find_if( allResults.begin(),
allResults.end(),
[]( const RigEclipseResultAddress& adr )
{ return adr.resultCatType() == RiaDefines::ResultCatType::DYNAMIC_NATIVE; } );
if ( dynamicResult != allResults.end() ) return *dynamicResult;
}
// If any input property exists, use that
auto inputProperty = std::find_if( allResults.begin(),
allResults.end(),
[]( const RigEclipseResultAddress& adr )
{ return adr.resultCatType() == RiaDefines::ResultCatType::INPUT_PROPERTY; } );
if ( inputProperty != allResults.end() ) return *inputProperty;
// If any static property exists, use that
auto staticResult = std::find_if( allResults.begin(),
allResults.end(),
[]( const RigEclipseResultAddress& adr )
{ return adr.resultCatType() == RiaDefines::ResultCatType::STATIC_NATIVE; } );
if ( staticResult != allResults.end() ) return *staticResult;
return {};
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -882,6 +922,7 @@ void RigCaseCellResultsData::setRemovedTagOnGeneratedResult( const RigEclipseRes
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RigCaseCellResultsData::createPlaceholderResultEntries() void RigCaseCellResultsData::createPlaceholderResultEntries()
{ {
bool needsToBeStored = false;
// SOIL // SOIL
{ {
if ( !hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, RiaResultNames::soil() ) ) ) if ( !hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, RiaResultNames::soil() ) ) )
@ -891,7 +932,7 @@ void RigCaseCellResultsData::createPlaceholderResultEntries()
{ {
size_t soilIndex = findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, size_t soilIndex = findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaResultNames::soil() ), RiaResultNames::soil() ),
false ); needsToBeStored );
this->setMustBeCalculated( soilIndex ); this->setMustBeCalculated( soilIndex );
} }
} }
@ -904,7 +945,7 @@ void RigCaseCellResultsData::createPlaceholderResultEntries()
{ {
findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaResultNames::riOilVolumeResultName() ), RiaResultNames::riOilVolumeResultName() ),
false ); needsToBeStored );
} }
} }
@ -912,18 +953,18 @@ void RigCaseCellResultsData::createPlaceholderResultEntries()
{ {
findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaResultNames::completionTypeResultName() ), RiaResultNames::completionTypeResultName() ),
false ); needsToBeStored );
} }
// Fault results // Fault results
{ {
findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::ALLAN_DIAGRAMS, findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::ALLAN_DIAGRAMS,
RiaResultNames::formationBinaryAllanResultName() ), RiaResultNames::formationBinaryAllanResultName() ),
false ); needsToBeStored );
findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::ALLAN_DIAGRAMS, findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::ALLAN_DIAGRAMS,
RiaResultNames::formationAllanResultName() ), RiaResultNames::formationAllanResultName() ),
false ); needsToBeStored );
} }
// FLUX // FLUX
@ -934,7 +975,7 @@ void RigCaseCellResultsData::createPlaceholderResultEntries()
{ {
findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaResultNames::combinedWaterFluxResultName() ), RiaResultNames::combinedWaterFluxResultName() ),
false ); needsToBeStored );
} }
if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLROILI+" ) ) && if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLROILI+" ) ) &&
@ -943,7 +984,7 @@ void RigCaseCellResultsData::createPlaceholderResultEntries()
{ {
findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaResultNames::combinedOilFluxResultName() ), RiaResultNames::combinedOilFluxResultName() ),
false ); needsToBeStored );
} }
if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRGASI+" ) ) && if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRGASI+" ) ) &&
@ -952,7 +993,7 @@ void RigCaseCellResultsData::createPlaceholderResultEntries()
{ {
findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaResultNames::combinedGasFluxResultName() ), RiaResultNames::combinedGasFluxResultName() ),
false ); needsToBeStored );
} }
} }
@ -960,7 +1001,10 @@ void RigCaseCellResultsData::createPlaceholderResultEntries()
{ {
if ( hasCompleteTransmissibilityResults() ) if ( hasCompleteTransmissibilityResults() )
{ {
addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::combinedTransmissibilityResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaResultNames::combinedTransmissibilityResultName(),
needsToBeStored,
0 );
} }
} }
// MULTXYZ // MULTXYZ
@ -972,7 +1016,7 @@ void RigCaseCellResultsData::createPlaceholderResultEntries()
hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTZ" ) ) && hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTZ" ) ) &&
hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTZ-" ) ) ) hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTZ-" ) ) )
{ {
addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::combinedMultResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::combinedMultResultName(), needsToBeStored, 0 );
} }
} }
@ -982,10 +1026,10 @@ void RigCaseCellResultsData::createPlaceholderResultEntries()
hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PERMY" ) ) && hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PERMY" ) ) &&
hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PERMZ" ) ) ) hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PERMZ" ) ) )
{ {
addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riTranXResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riTranXResultName(), needsToBeStored, 0 );
addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riTranYResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riTranYResultName(), needsToBeStored, 0 );
addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riTranZResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riTranZResultName(), needsToBeStored, 0 );
addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::combinedRiTranResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::combinedRiTranResultName(), needsToBeStored, 0 );
} }
} }
@ -996,10 +1040,10 @@ void RigCaseCellResultsData::createPlaceholderResultEntries()
hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riTranYResultName() ) ) && hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riTranYResultName() ) ) &&
hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riTranZResultName() ) ) ) hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riTranZResultName() ) ) )
{ {
addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riMultXResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riMultXResultName(), needsToBeStored, 0 );
addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riMultYResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riMultYResultName(), needsToBeStored, 0 );
addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riMultZResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riMultZResultName(), needsToBeStored, 0 );
addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::combinedRiMultResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::combinedRiMultResultName(), needsToBeStored, 0 );
} }
} }
@ -1007,54 +1051,54 @@ void RigCaseCellResultsData::createPlaceholderResultEntries()
{ {
if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANX" ) ) ) if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANX" ) ) )
{ {
addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riAreaNormTranXResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riAreaNormTranXResultName(), needsToBeStored, 0 );
} }
if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANY" ) ) ) if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANY" ) ) )
{ {
addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riAreaNormTranYResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riAreaNormTranYResultName(), needsToBeStored, 0 );
} }
if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANZ" ) ) ) if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANZ" ) ) )
{ {
addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riAreaNormTranZResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riAreaNormTranZResultName(), needsToBeStored, 0 );
} }
} }
// riTRANSXYZbyArea // riTRANSXYZbyArea
{ {
if ( hasCompleteTransmissibilityResults() ) if ( hasCompleteTransmissibilityResults() )
{ {
addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::combinedRiAreaNormTranResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaResultNames::combinedRiAreaNormTranResultName(),
needsToBeStored,
0 );
} }
} }
// Cell Volume // Cell Volume
{ {
addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riCellVolumeResultName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riCellVolumeResultName(), needsToBeStored, 0 );
} }
// Mobile Pore Volume // Mobile Pore Volume
{ {
if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PORV" ) ) ) if ( hasResultEntry( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "PORV" ) ) )
{ {
addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::mobilePoreVolumeName(), false, 0 ); addStaticScalarResult( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::mobilePoreVolumeName(), needsToBeStored, 0 );
} }
} }
// I/J/K indexes // I/J/K indexes
{ {
findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::indexIResultName() ), findOrCreateScalarResultIndex( RiaResultNames::staticIntegerAddress( RiaResultNames::indexIResultName() ), needsToBeStored );
false ); findOrCreateScalarResultIndex( RiaResultNames::staticIntegerAddress( RiaResultNames::indexJResultName() ), needsToBeStored );
findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::indexJResultName() ), findOrCreateScalarResultIndex( RiaResultNames::staticIntegerAddress( RiaResultNames::indexKResultName() ), needsToBeStored );
false );
findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::indexKResultName() ),
false );
} }
// Fault distance // Fault distance
{ {
findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::faultDistanceName() ), findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::faultDistanceName() ),
false ); needsToBeStored );
} }
} }

2
ApplicationLibCode/ReservoirDataModel/RigCaseCellResultsData.h
View File

@ -147,6 +147,8 @@ public:
size_t addStaticScalarResult( RiaDefines::ResultCatType type, const QString& resultName, bool needsToBeStored, size_t resultValueCount ); size_t addStaticScalarResult( RiaDefines::ResultCatType type, const QString& resultName, bool needsToBeStored, size_t resultValueCount );
RigEclipseResultAddress defaultResult() const;
private: private:
size_t findOrLoadKnownScalarResult( const RigEclipseResultAddress& resVarAddr ); size_t findOrLoadKnownScalarResult( const RigEclipseResultAddress& resVarAddr );
size_t findOrLoadKnownScalarResultByResultTypeOrder( const RigEclipseResultAddress& resVarAddr, size_t findOrLoadKnownScalarResultByResultTypeOrder( const RigEclipseResultAddress& resVarAddr,

28
ApplicationLibCode/ReservoirDataModel/RigEclipseResultAddress.h
View File

@ -27,6 +27,7 @@ class RigEclipseResultAddress
public: public:
RigEclipseResultAddress() RigEclipseResultAddress()
: m_resultCatType( RiaDefines::ResultCatType::UNDEFINED ) : m_resultCatType( RiaDefines::ResultCatType::UNDEFINED )
, m_resultDataType( RiaDefines::ResultDataType::UNKNOWN )
, m_timeLapseBaseFrameIdx( NO_TIME_LAPSE ) , m_timeLapseBaseFrameIdx( NO_TIME_LAPSE )
, m_differenceCaseId( NO_CASE_DIFF ) , m_differenceCaseId( NO_CASE_DIFF )
, m_divideByCellFaceArea( false ) , m_divideByCellFaceArea( false )
@ -35,6 +36,7 @@ public:
explicit RigEclipseResultAddress( const QString& resultName ) explicit RigEclipseResultAddress( const QString& resultName )
: m_resultCatType( RiaDefines::ResultCatType::UNDEFINED ) : m_resultCatType( RiaDefines::ResultCatType::UNDEFINED )
, m_resultDataType( RiaDefines::ResultDataType::UNKNOWN )
, m_resultName( resultName ) , m_resultName( resultName )
, m_timeLapseBaseFrameIdx( NO_TIME_LAPSE ) , m_timeLapseBaseFrameIdx( NO_TIME_LAPSE )
, m_differenceCaseId( NO_CASE_DIFF ) , m_differenceCaseId( NO_CASE_DIFF )
@ -48,12 +50,22 @@ public:
int differenceCaseId = NO_CASE_DIFF, int differenceCaseId = NO_CASE_DIFF,
bool divideByCellFaceArea = false ) bool divideByCellFaceArea = false )
: m_resultCatType( type ) : m_resultCatType( type )
, m_resultDataType( RiaDefines::ResultDataType::UNKNOWN )
, m_resultName( resultName ) , m_resultName( resultName )
, m_timeLapseBaseFrameIdx( timeLapseBaseTimeStep ) , m_timeLapseBaseFrameIdx( timeLapseBaseTimeStep )
, m_differenceCaseId( differenceCaseId ) , m_differenceCaseId( differenceCaseId )
, m_divideByCellFaceArea( divideByCellFaceArea )
{
}
explicit RigEclipseResultAddress( RiaDefines::ResultCatType type, RiaDefines::ResultDataType dataType, const QString& resultName )
: m_resultCatType( type )
, m_resultDataType( dataType )
, m_resultName( resultName )
, m_timeLapseBaseFrameIdx( NO_TIME_LAPSE )
, m_differenceCaseId( NO_CASE_DIFF )
, m_divideByCellFaceArea( false ) , m_divideByCellFaceArea( false )
{ {
enableDivideByCellFaceArea( divideByCellFaceArea );
} }
bool isValid() const bool isValid() const
@ -68,6 +80,9 @@ public:
} }
} }
void setDataType( RiaDefines::ResultDataType dataType ) { m_resultDataType = dataType; }
RiaDefines::ResultDataType dataType() const { return m_resultDataType; }
// Delta Time Step // Delta Time Step
bool isDeltaTimeStepActive() const { return m_timeLapseBaseFrameIdx > NO_TIME_LAPSE; } bool isDeltaTimeStepActive() const { return m_timeLapseBaseFrameIdx > NO_TIME_LAPSE; }
void setDeltaTimeStepIndex( int timeStepIndex ) { m_timeLapseBaseFrameIdx = timeStepIndex; } void setDeltaTimeStepIndex( int timeStepIndex ) { m_timeLapseBaseFrameIdx = timeStepIndex; }
@ -131,11 +146,12 @@ public:
void setResultCatType( RiaDefines::ResultCatType catType ) { m_resultCatType = catType; } void setResultCatType( RiaDefines::ResultCatType catType ) { m_resultCatType = catType; }
private: private:
int m_timeLapseBaseFrameIdx; RiaDefines::ResultCatType m_resultCatType;
int m_differenceCaseId; RiaDefines::ResultDataType m_resultDataType;
bool m_divideByCellFaceArea; QString m_resultName;
RiaDefines::ResultCatType m_resultCatType; int m_timeLapseBaseFrameIdx;
QString m_resultName; int m_differenceCaseId;
bool m_divideByCellFaceArea;
static const int ALL_TIME_LAPSES = -2; static const int ALL_TIME_LAPSES = -2;
static const int NO_TIME_LAPSE = -1; static const int NO_TIME_LAPSE = -1;

19
ApplicationLibCode/UnitTests/RifReaderEclipseOutput-Test.cpp
View File

@ -111,26 +111,11 @@ TEST( RigReservoirTest, BasicTest10kRestart )
filenames << filePath; filenames << filePath;
unrstAccess.setRestartFiles( filenames ); unrstAccess.setRestartFiles( filenames );
QStringList resultNames; auto keywordValueCounts = unrstAccess.keywordValueCounts();
std::vector<size_t> dataItemCount; EXPECT_EQ( (size_t)83, keywordValueCounts.size() );
unrstAccess.resultNames( &resultNames, &dataItemCount );
EXPECT_EQ( resultNames.size(), (int)dataItemCount.size() );
EXPECT_EQ( 83, resultNames.size() );
/* for (int i = 0; i < resultNames.size(); i++)
{
qDebug() << resultNames[i] << "\t" << dataItemCount[i];
} */
auto reportNums = unrstAccess.reportNumbers(); auto reportNums = unrstAccess.reportNumbers();
EXPECT_EQ( (size_t)9, reportNums.size() ); EXPECT_EQ( (size_t)9, reportNums.size() );
/* for (auto reportNum : reportNums)
{
qDebug() << reportNum;
} */
} }
TEST( RigReservoirTest, BasicTest10k_NativeECL ) TEST( RigReservoirTest, BasicTest10k_NativeECL )

2
ThirdParty/roffcpp vendored

@ -1 +1 @@
Subproject commit 60cde44a49eecb8004abe5d38e3463db46c81bd9 Subproject commit 5661a1d4ed60743b47c3cf3e3308febc92c01494