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

#8893 Rename quantity name -> vector name

Browse Source
This commit is contained in:
Magne Sjaastad 2022-05-06 16:34:37 +02:00
parent 6f1819ba96
commit f52acd9a64
64 changed files with 359 additions and 367 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ApplicationLibCode/Application/RiaSummaryCurveDefinition.cpp
View File

@ -229,7 +229,7 @@ void RiaSummaryCurveDefinitionAnalyser::setCurveDefinitions( const std::vector<R
{
m_singleSummaryCases.clear();
m_ensembles.clear();
m_quantityNames.clear();
m_vectorNames.clear();
m_summaryAdresses.clear();
for ( const auto& curveDef : curveDefs )
@ -255,7 +255,7 @@ void RiaSummaryCurveDefinitionAnalyser::setCurveDefinitions( const std::vector<R
{
const RifEclipseSummaryAddress& address = curveDef.summaryAddress();
m_quantityNames.insert( address.quantityName() );
m_vectorNames.insert( address.vectorName() );
m_summaryAdresses.insert( address );
}
}

2
ApplicationLibCode/Application/RiaSummaryCurveDefinition.h
View File

@ -75,5 +75,5 @@ public:
std::set<RimSummaryCaseCollection*> m_ensembles; // All the ensembles referenced by the summary cases
std::set<RifEclipseSummaryAddress> m_summaryAdresses;
std::set<std::string> m_quantityNames; // Quantity names from the addresses
std::set<std::string> m_vectorNames;
};

4
ApplicationLibCode/Application/Tools/RiaSummaryAddressAnalyzer.cpp
View File

@ -383,9 +383,9 @@ void RiaSummaryAddressAnalyzer::analyzeSingleAddress( const RifEclipseSummaryAdd
m_wellNames.insert( { wellName, address } );
}
if ( !address.quantityName().empty() )
if ( !address.vectorName().empty() )
{
m_quantities.insert( address.quantityName() );
m_quantities.insert( address.vectorName() );
}
if ( !address.groupName().empty() )

2
ApplicationLibCode/Application/Tools/RiaSummaryStringTools.cpp
View File

@ -261,7 +261,7 @@ std::set<RifEclipseSummaryAddress>
std::set<RifEclipseSummaryAddress> addressesWithoutDiffVectors;
for ( const auto& adr : addresses )
{
if ( RiaStdStringTools::endsWith( adr.quantityName(), diffText ) ) continue;
if ( RiaStdStringTools::endsWith( adr.vectorName(), diffText ) ) continue;
addressesWithoutDiffVectors.insert( adr );
}

2
ApplicationLibCode/Commands/PlotTemplateCommands/RicSummaryPlotTemplateTools.cpp
View File

@ -490,7 +490,7 @@ RifEclipseSummaryAddress
{
for ( const auto& a : allAddresses )
{
if ( sourceAddress.quantityName() == a.quantityName() )
if ( sourceAddress.vectorName() == a.vectorName() )
{
return a;
}

4
ApplicationLibCode/Commands/SummaryPlotCommands/RicNewEnsembleCurveFilterFeature.cpp
View File

@ -70,8 +70,8 @@ void RicNewEnsembleCurveFilterFeature::onActionTriggered( bool isChecked )
std::vector<RifEclipseSummaryAddress> addresses;
auto candidateAdr = newFilter->parentCurveSet()->summaryAddress();
auto nativeQuantityName = RimObjectiveFunctionTools::nativeQuantityName( candidateAdr.quantityName() );
candidateAdr.setQuantityName( nativeQuantityName );
auto nativeQuantityName = RimObjectiveFunctionTools::nativeQuantityName( candidateAdr.vectorName() );
candidateAdr.setVectorName( nativeQuantityName );
addresses.push_back( candidateAdr );
newFilter->setSummaryAddresses( addresses );
}

4
ApplicationLibCode/Commands/SummaryPlotCommands/RicSummaryPlotFeatureImpl.cpp
View File

@ -86,7 +86,7 @@ RimSummaryCurve* RicSummaryPlotFeatureImpl::createHistoryCurve( const RifEclipse
RimSummaryCase* summaryCasesToUse )
{
RifEclipseSummaryAddress historyAddr = addr;
historyAddr.setQuantityName( historyAddr.quantityName() + "H" );
historyAddr.setVectorName( historyAddr.vectorName() + "H" );
if ( summaryCasesToUse->summaryReader()->allResultAddresses().count( historyAddr ) )
{
return createCurve( summaryCasesToUse, historyAddr );
@ -730,7 +730,7 @@ std::vector<RimSummaryCurve*> RicSummaryPlotFeatureImpl::addCurvesFromAddressFil
std::vector<RifEclipseSummaryAddress> historyAddressesToUse;
for ( RifEclipseSummaryAddress historyAddr : curveAddressesToUse )
{
historyAddr.setQuantityName( historyAddr.quantityName() + "H" );
historyAddr.setVectorName( historyAddr.vectorName() + "H" );
if ( addrs.count( historyAddr ) )
{
historyAddressesToUse.push_back( historyAddr );

8
ApplicationLibCode/FileInterface/RifColumnBasedUserData.cpp
View File

@ -196,27 +196,27 @@ std::vector<time_t> RifColumnBasedUserData::createTimeSteps( const TableData& ta
const Column& ci = tableData.columnInfos()[columIndex];
if ( dateColumnIndex == tableData.columnInfos().size() &&
RifEclipseUserDataKeywordTools::isDate( ci.summaryAddress.quantityName() ) )
RifEclipseUserDataKeywordTools::isDate( ci.summaryAddress.vectorName() ) )
{
dateColumnIndex = columIndex;
}
if ( daysColumnIndex == tableData.columnInfos().size() &&
RifEclipseUserDataKeywordTools::isTime( ci.summaryAddress.quantityName() ) &&
RifEclipseUserDataKeywordTools::isTime( ci.summaryAddress.vectorName() ) &&
RifEclipseUserDataKeywordTools::isDays( ci.unitName ) )
{
daysColumnIndex = columIndex;
}
if ( yearsColumnIndex == tableData.columnInfos().size() &&
RifEclipseUserDataKeywordTools::isYears( ci.summaryAddress.quantityName() ) &&
RifEclipseUserDataKeywordTools::isYears( ci.summaryAddress.vectorName() ) &&
RifEclipseUserDataKeywordTools::isYears( ci.unitName ) )
{
yearsColumnIndex = columIndex;
}
if ( yearXColumnIndex == tableData.columnInfos().size() &&
RifEclipseUserDataKeywordTools::isYearX( ci.summaryAddress.quantityName() ) &&
RifEclipseUserDataKeywordTools::isYearX( ci.summaryAddress.vectorName() ) &&
RifEclipseUserDataKeywordTools::isYears( ci.unitName ) )
{
yearXColumnIndex = columIndex;

2
ApplicationLibCode/FileInterface/RifColumnBasedUserDataParser.cpp
View File

@ -105,7 +105,7 @@ void RifColumnBasedUserDataParser::parseTableData( const QString& data )
int stepTypeIndex = -1;
for ( size_t i = 0; i < columnInfos.size(); i++ )
{
if ( RifEclipseUserDataKeywordTools::isStepType( columnInfos[i].summaryAddress.quantityName() ) )
if ( RifEclipseUserDataKeywordTools::isStepType( columnInfos[i].summaryAddress.vectorName() ) )
{
stepTypeIndex = static_cast<int>( i );
}

2
ApplicationLibCode/FileInterface/RifCsvUserDataParser.cpp
View File

@ -379,7 +379,7 @@ bool RifCsvUserDataParser::parseColumnBasedData( const AsciiDataParseOptions& pa
// Determine column data type
if ( col.dataType == Column::NONE )
{
if ( QString::fromStdString( col.summaryAddress.quantityName() ) == parseOptions.timeSeriesColumnName )
if ( QString::fromStdString( col.summaryAddress.vectorName() ) == parseOptions.timeSeriesColumnName )
{
col.dataType = Column::DATETIME;
}

145
ApplicationLibCode/FileInterface/RifEclipseSummaryAddress.cpp
View File

@ -105,8 +105,7 @@ RifEclipseSummaryAddress::RifEclipseSummaryAddress( SummaryVarCategory
break;
}
// Set quantity for all categories
m_quantityName = identifiers[INPUT_VECTOR_NAME];
m_vectorName = identifiers[INPUT_VECTOR_NAME];
}
//--------------------------------------------------------------------------------------------------
@ -134,7 +133,7 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::fromEclipseTextAddressParseEr
if ( address.category() == SUMMARY_INVALID || address.category() == SUMMARY_IMPORTED )
{
// Address category not recognized, use incoming text string without error prefix as quantity name
// Address category not recognized, use incoming text string without error prefix as vector name
auto text = RiaStdStringTools::joinStrings( tokens, ':' );
address = importedAddress( text );
}
@ -156,14 +155,14 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::fromEclipseTextAddress( const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress::SummaryVarCategory RifEclipseSummaryAddress::identifyCategory( const std::string& quantityName )
RifEclipseSummaryAddress::SummaryVarCategory RifEclipseSummaryAddress::identifyCategory( const std::string& vectorName )
{
if ( quantityName.size() < 3 || quantityName.size() > 8 ) return SUMMARY_INVALID;
if ( vectorName.size() < 3 || vectorName.size() > 8 ) return SUMMARY_INVALID;
auto strippedQuantityName = baseQuantityName( quantityName );
auto strippedQuantityName = baseVectorName( vectorName );
// First, try to lookup vector in vector table
auto category = RiuSummaryQuantityNameInfoProvider::instance()->categoryFromQuantityName( strippedQuantityName );
auto category = RiuSummaryQuantityNameInfoProvider::instance()->categoryFromVectorName( strippedQuantityName );
if ( category != SUMMARY_INVALID ) return category;
// Then check LGR categories
@ -180,22 +179,22 @@ RifEclipseSummaryAddress::SummaryVarCategory RifEclipseSummaryAddress::identifyC
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress RifEclipseSummaryAddress::fieldAddress( const std::string& quantityName )
RifEclipseSummaryAddress RifEclipseSummaryAddress::fieldAddress( const std::string& vectorName )
{
RifEclipseSummaryAddress addr;
addr.m_variableCategory = SUMMARY_FIELD;
addr.m_quantityName = quantityName;
addr.m_vectorName = vectorName;
return addr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress RifEclipseSummaryAddress::aquiferAddress( const std::string& quantityName, int aquiferNumber )
RifEclipseSummaryAddress RifEclipseSummaryAddress::aquiferAddress( const std::string& vectorName, int aquiferNumber )
{
RifEclipseSummaryAddress addr;
addr.m_variableCategory = SUMMARY_AQUIFER;
addr.m_quantityName = quantityName;
addr.m_vectorName = vectorName;
addr.m_aquiferNumber = aquiferNumber;
return addr;
}
@ -203,33 +202,33 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::aquiferAddress( const std::st
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress RifEclipseSummaryAddress::networkAddress( const std::string& quantityName )
RifEclipseSummaryAddress RifEclipseSummaryAddress::networkAddress( const std::string& vectorName )
{
RifEclipseSummaryAddress addr;
addr.m_variableCategory = SUMMARY_NETWORK;
addr.m_quantityName = quantityName;
addr.m_vectorName = vectorName;
return addr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress RifEclipseSummaryAddress::miscAddress( const std::string& quantityName )
RifEclipseSummaryAddress RifEclipseSummaryAddress::miscAddress( const std::string& vectorName )
{
RifEclipseSummaryAddress addr;
addr.m_variableCategory = SUMMARY_MISC;
addr.m_quantityName = quantityName;
addr.m_vectorName = vectorName;
return addr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress RifEclipseSummaryAddress::regionAddress( const std::string& quantityName, int regionNumber )
RifEclipseSummaryAddress RifEclipseSummaryAddress::regionAddress( const std::string& vectorName, int regionNumber )
{
RifEclipseSummaryAddress addr;
addr.m_variableCategory = SUMMARY_REGION;
addr.m_quantityName = quantityName;
addr.m_vectorName = vectorName;
addr.m_regionNumber = regionNumber;
return addr;
}
@ -238,11 +237,11 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::regionAddress( const std::str
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress
RifEclipseSummaryAddress::regionToRegionAddress( const std::string& quantityName, int regionNumber, int region2Number )
RifEclipseSummaryAddress::regionToRegionAddress( const std::string& vectorName, int regionNumber, int region2Number )
{
RifEclipseSummaryAddress addr;
addr.m_variableCategory = SUMMARY_REGION_2_REGION;
addr.m_quantityName = quantityName;
addr.m_vectorName = vectorName;
addr.m_regionNumber = regionNumber;
addr.m_regionNumber2 = region2Number;
return addr;
@ -251,12 +250,11 @@ RifEclipseSummaryAddress
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress RifEclipseSummaryAddress::groupAddress( const std::string& quantityName,
const std::string& groupName )
RifEclipseSummaryAddress RifEclipseSummaryAddress::groupAddress( const std::string& vectorName, const std::string& groupName )
{
RifEclipseSummaryAddress addr;
addr.m_variableCategory = SUMMARY_GROUP;
addr.m_quantityName = quantityName;
addr.m_vectorName = vectorName;
addr.m_groupName = groupName;
return addr;
}
@ -264,11 +262,11 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::groupAddress( const std::stri
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress RifEclipseSummaryAddress::wellAddress( const std::string& quantityName, const std::string& wellName )
RifEclipseSummaryAddress RifEclipseSummaryAddress::wellAddress( const std::string& vectorName, const std::string& wellName )
{
RifEclipseSummaryAddress addr;
addr.m_variableCategory = SUMMARY_WELL;
addr.m_quantityName = quantityName;
addr.m_vectorName = vectorName;
addr.m_wellName = wellName;
return addr;
}
@ -276,7 +274,7 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::wellAddress( const std::strin
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress RifEclipseSummaryAddress::wellCompletionAddress( const std::string& quantityName,
RifEclipseSummaryAddress RifEclipseSummaryAddress::wellCompletionAddress( const std::string& vectorName,
const std::string& wellName,
int i,
int j,
@ -284,7 +282,7 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::wellCompletionAddress( const
{
RifEclipseSummaryAddress addr;
addr.m_variableCategory = SUMMARY_WELL_COMPLETION;
addr.m_quantityName = quantityName;
addr.m_vectorName = vectorName;
addr.m_wellName = wellName;
addr.m_cellI = i;
addr.m_cellJ = j;
@ -295,13 +293,13 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::wellCompletionAddress( const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress RifEclipseSummaryAddress::wellLgrAddress( const std::string& quantityName,
RifEclipseSummaryAddress RifEclipseSummaryAddress::wellLgrAddress( const std::string& vectorName,
const std::string& lgrName,
const std::string& wellName )
{
RifEclipseSummaryAddress addr;
addr.m_variableCategory = SUMMARY_WELL_LGR;
addr.m_quantityName = quantityName;
addr.m_vectorName = vectorName;
addr.m_lgrName = lgrName;
addr.m_wellName = wellName;
return addr;
@ -310,7 +308,7 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::wellLgrAddress( const std::st
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress RifEclipseSummaryAddress::wellCompletionLgrAddress( const std::string& quantityName,
RifEclipseSummaryAddress RifEclipseSummaryAddress::wellCompletionLgrAddress( const std::string& vectorName,
const std::string& lgrName,
const std::string& wellName,
int i,
@ -319,7 +317,7 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::wellCompletionLgrAddress( con
{
RifEclipseSummaryAddress addr;
addr.m_variableCategory = SUMMARY_WELL_COMPLETION_LGR;
addr.m_quantityName = quantityName;
addr.m_vectorName = vectorName;
addr.m_lgrName = lgrName;
addr.m_wellName = wellName;
addr.m_cellI = i;
@ -331,13 +329,13 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::wellCompletionLgrAddress( con
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress RifEclipseSummaryAddress::wellSegmentAddress( const std::string& quantityName,
RifEclipseSummaryAddress RifEclipseSummaryAddress::wellSegmentAddress( const std::string& vectorName,
const std::string& wellName,
int segmentNumber )
{
RifEclipseSummaryAddress addr;
addr.m_variableCategory = SUMMARY_WELL_SEGMENT;
addr.m_quantityName = quantityName;
addr.m_vectorName = vectorName;
addr.m_wellName = wellName;
addr.m_wellSegmentNumber = segmentNumber;
return addr;
@ -346,11 +344,11 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::wellSegmentAddress( const std
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress RifEclipseSummaryAddress::blockAddress( const std::string& quantityName, int i, int j, int k )
RifEclipseSummaryAddress RifEclipseSummaryAddress::blockAddress( const std::string& vectorName, int i, int j, int k )
{
RifEclipseSummaryAddress addr;
addr.m_variableCategory = SUMMARY_BLOCK;
addr.m_quantityName = quantityName;
addr.m_vectorName = vectorName;
addr.m_cellI = i;
addr.m_cellJ = j;
addr.m_cellK = k;
@ -361,11 +359,11 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::blockAddress( const std::stri
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress
RifEclipseSummaryAddress::blockLgrAddress( const std::string& quantityName, const std::string& lgrName, int i, int j, int k )
RifEclipseSummaryAddress::blockLgrAddress( const std::string& vectorName, const std::string& lgrName, int i, int j, int k )
{
RifEclipseSummaryAddress addr;
addr.m_variableCategory = SUMMARY_BLOCK_LGR;
addr.m_quantityName = quantityName;
addr.m_vectorName = vectorName;
addr.m_lgrName = lgrName;
addr.m_cellI = i;
addr.m_cellJ = j;
@ -376,11 +374,11 @@ RifEclipseSummaryAddress
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress RifEclipseSummaryAddress::calculatedAddress( const std::string& quantityName, int id )
RifEclipseSummaryAddress RifEclipseSummaryAddress::calculatedAddress( const std::string& vectorName, int id )
{
RifEclipseSummaryAddress addr;
addr.m_variableCategory = SUMMARY_CALCULATED;
addr.m_quantityName = quantityName;
addr.m_vectorName = vectorName;
addr.m_id = id;
return addr;
}
@ -388,23 +386,23 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::calculatedAddress( const std:
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress RifEclipseSummaryAddress::importedAddress( const std::string& quantityName )
RifEclipseSummaryAddress RifEclipseSummaryAddress::importedAddress( const std::string& vectorName )
{
RifEclipseSummaryAddress addr;
addr.m_variableCategory = SUMMARY_IMPORTED;
addr.m_quantityName = quantityName;
addr.m_vectorName = vectorName;
return addr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress RifEclipseSummaryAddress::ensembleStatisticsAddress( const std::string& quantityName,
RifEclipseSummaryAddress RifEclipseSummaryAddress::ensembleStatisticsAddress( const std::string& vectorName,
const std::string& dataQuantityName )
{
RifEclipseSummaryAddress addr;
addr.m_variableCategory = SUMMARY_ENSEMBLE_STATISTICS;
addr.m_quantityName = quantityName + ":" + dataQuantityName;
addr.m_vectorName = vectorName + ":" + dataQuantityName;
return addr;
}
@ -454,19 +452,19 @@ bool RifEclipseSummaryAddress::isDependentOnWellName( SummaryVarCategory categor
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RifEclipseSummaryAddress::isHistoryQuantity() const
bool RifEclipseSummaryAddress::isHistoryVector() const
{
const std::string historyIdentifier = "H";
return RiaStdStringTools::endsWith( m_quantityName, historyIdentifier );
return RiaStdStringTools::endsWith( m_vectorName, historyIdentifier );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::string RifEclipseSummaryAddress::ensembleStatisticsQuantityName() const
const std::string RifEclipseSummaryAddress::ensembleStatisticsVectorName() const
{
QString qName = QString::fromStdString( m_quantityName );
QString qName = QString::fromStdString( m_vectorName );
return qName.split( ":" )[0].toStdString();
}
@ -479,7 +477,7 @@ std::string RifEclipseSummaryAddress::uiText() const
if ( m_isErrorResult ) text += "ERR:";
text += m_quantityName;
text += m_vectorName;
std::string itemText = itemUiText();
if ( !itemText.empty() )
@ -567,7 +565,7 @@ std::string RifEclipseSummaryAddress::itemUiText() const
break;
case SUMMARY_IMPORTED:
{
text += this->quantityName();
text += this->vectorName();
}
break;
}
@ -600,7 +598,7 @@ std::string
case INPUT_AQUIFER_NUMBER:
return std::to_string( aquiferNumber() );
case INPUT_VECTOR_NAME:
return quantityName();
return vectorName();
case INPUT_ID:
return std::to_string( id() );
}
@ -632,7 +630,7 @@ bool RifEclipseSummaryAddress::isUiTextMatchingFilterText( const QString& filter
//--------------------------------------------------------------------------------------------------
bool RifEclipseSummaryAddress::isValid() const
{
if ( m_quantityName.empty() ) return false;
if ( m_vectorName.empty() ) return false;
switch ( category() )
{
@ -721,14 +719,14 @@ bool RifEclipseSummaryAddress::hasAccumulatedData() const
{
if ( !isValidEclipseCategory() ) return false;
QString quantityForInspection = QString::fromStdString( quantityName() );
QString quantityForInspection = QString::fromStdString( vectorName() );
if ( category() == SUMMARY_ENSEMBLE_STATISTICS )
{
// Remove statistics text prefix
quantityForInspection = quantityForInspection.mid( quantityForInspection.indexOf( ":" ) + 1 );
}
QString qBaseName = QString::fromStdString( baseQuantityName( quantityForInspection.toStdString() ) );
QString qBaseName = QString::fromStdString( baseVectorName( quantityForInspection.toStdString() ) );
if ( qBaseName.endsWith( "WCT" ) || qBaseName.endsWith( "WCTH" ) )
{
@ -749,36 +747,36 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::fromTokens( const std::vector
return RifEclipseSummaryAddress();
}
std::string quantityName;
std::string vectorName;
std::string token1;
std::string token2;
quantityName = tokens[0];
vectorName = tokens[0];
if ( tokens.size() > 1 ) token1 = tokens[1];
if ( tokens.size() > 2 ) token2 = tokens[2];
SummaryVarCategory category = identifyCategory( quantityName );
SummaryVarCategory category = identifyCategory( vectorName );
switch ( category )
{
case SUMMARY_FIELD:
return fieldAddress( quantityName );
return fieldAddress( vectorName );
case SUMMARY_AQUIFER:
if ( !token1.empty() ) return aquiferAddress( quantityName, RiaStdStringTools::toInt( token1 ) );
if ( !token1.empty() ) return aquiferAddress( vectorName, RiaStdStringTools::toInt( token1 ) );
break;
case SUMMARY_NETWORK:
return networkAddress( quantityName );
return networkAddress( vectorName );
break;
case SUMMARY_MISC:
return miscAddress( quantityName );
return miscAddress( vectorName );
break;
case SUMMARY_REGION:
if ( !token1.empty() ) return regionAddress( quantityName, RiaStdStringTools::toInt( token1 ) );
if ( !token1.empty() ) return regionAddress( vectorName, RiaStdStringTools::toInt( token1 ) );
break;
case SUMMARY_REGION_2_REGION:
@ -787,7 +785,7 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::fromTokens( const std::vector
auto regions = RiaStdStringTools::splitString( token1, '-' );
if ( regions.size() == 2 )
{
return regionToRegionAddress( quantityName,
return regionToRegionAddress( vectorName,
RiaStdStringTools::toInt( regions[0] ),
RiaStdStringTools::toInt( regions[1] ) );
}
@ -795,11 +793,11 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::fromTokens( const std::vector
break;
case SUMMARY_GROUP:
if ( !token1.empty() ) return groupAddress( quantityName, token1 );
if ( !token1.empty() ) return groupAddress( vectorName, token1 );
break;
case SUMMARY_WELL:
if ( !token1.empty() ) return wellAddress( quantityName, token1 );
if ( !token1.empty() ) return wellAddress( vectorName, token1 );
break;
case SUMMARY_WELL_COMPLETION:
@ -808,7 +806,7 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::fromTokens( const std::vector
auto ijk = RiaStdStringTools::splitString( token2, ',' );
if ( ijk.size() == 3 )
{
return wellCompletionAddress( quantityName,
return wellCompletionAddress( vectorName,
token1,
RiaStdStringTools::toInt( ijk[0] ),
RiaStdStringTools::toInt( ijk[1] ),
@ -818,7 +816,7 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::fromTokens( const std::vector
break;
case SUMMARY_WELL_LGR:
if ( !token1.empty() && !token2.empty() ) return wellLgrAddress( quantityName, token1, token2 );
if ( !token1.empty() && !token2.empty() ) return wellLgrAddress( vectorName, token1, token2 );
break;
case SUMMARY_WELL_COMPLETION_LGR:
@ -828,7 +826,7 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::fromTokens( const std::vector
auto ijk = RiaStdStringTools::splitString( token3, ',' );
if ( ijk.size() == 3 )
{
return wellCompletionLgrAddress( quantityName,
return wellCompletionLgrAddress( vectorName,
token1,
token2,
RiaStdStringTools::toInt( ijk[0] ),
@ -839,8 +837,7 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::fromTokens( const std::vector
break;
case SUMMARY_WELL_SEGMENT:
if ( !token2.empty() )
return wellSegmentAddress( quantityName, token1, RiaStdStringTools::toInt( token2 ) );
if ( !token2.empty() ) return wellSegmentAddress( vectorName, token1, RiaStdStringTools::toInt( token2 ) );
break;
case SUMMARY_BLOCK:
@ -849,7 +846,7 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::fromTokens( const std::vector
auto ijk = RiaStdStringTools::splitString( token1, ',' );
if ( ijk.size() == 3 )
{
return blockAddress( quantityName,
return blockAddress( vectorName,
RiaStdStringTools::toInt( ijk[0] ),
RiaStdStringTools::toInt( ijk[1] ),
RiaStdStringTools::toInt( ijk[2] ) );
@ -863,7 +860,7 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::fromTokens( const std::vector
auto ijk = RiaStdStringTools::splitString( token2, ',' );
if ( ijk.size() == 3 )
{
return blockLgrAddress( quantityName,
return blockLgrAddress( vectorName,
token1,
RiaStdStringTools::toInt( ijk[0] ),
RiaStdStringTools::toInt( ijk[1] ),
@ -911,9 +908,9 @@ bool RifEclipseSummaryAddress::isValidEclipseCategory() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::string RifEclipseSummaryAddress::baseQuantityName( const std::string& quantityName )
std::string RifEclipseSummaryAddress::baseVectorName( const std::string& vectorName )
{
auto tmpString = quantityName;
auto tmpString = vectorName;
if ( tmpString.size() == 8 ) tmpString = tmpString.substr( 0, 5 );
@ -976,7 +973,7 @@ std::pair<int16_t, int16_t> RifEclipseSummaryAddress::regionToRegionPairFromUiTe
bool operator==( const RifEclipseSummaryAddress& first, const RifEclipseSummaryAddress& second )
{
if ( first.category() != second.category() ) return false;
if ( first.quantityName() != second.quantityName() ) return false;
if ( first.vectorName() != second.vectorName() ) return false;
switch ( first.category() )
{
case RifEclipseSummaryAddress::SUMMARY_REGION:
@ -1072,7 +1069,7 @@ bool operator!=( const RifEclipseSummaryAddress& first, const RifEclipseSummaryA
//--------------------------------------------------------------------------------------------------
bool operator<( const RifEclipseSummaryAddress& first, const RifEclipseSummaryAddress& second )
{
if ( first.quantityName() != second.quantityName() ) return first.quantityName() < second.quantityName();
if ( first.vectorName() != second.vectorName() ) return first.vectorName() < second.vectorName();
switch ( first.category() )
{

54
ApplicationLibCode/FileInterface/RifEclipseSummaryAddress.h
View File

@ -90,7 +90,7 @@ public:
}
RifEclipseSummaryAddress( SummaryVarCategory category,
const std::string& quantityName,
const std::string& vectorName,
int16_t regionNumber,
int16_t regionNumber2,
const std::string& groupName,
@ -104,7 +104,7 @@ public:
bool isErrorResult,
int32_t id )
: m_variableCategory( category )
, m_quantityName( quantityName )
, m_vectorName( vectorName )
, m_regionNumber( regionNumber )
, m_regionNumber2( regionNumber2 )
, m_groupName( groupName )
@ -127,36 +127,36 @@ public:
static RifEclipseSummaryAddress fromEclipseTextAddress( const std::string& textAddress );
static RifEclipseSummaryAddress fromEclipseTextAddressParseErrorTokens( const std::string& textAddress );
static SummaryVarCategory identifyCategory( const std::string& quantityName );
static SummaryVarCategory identifyCategory( const std::string& vectorName );
static RifEclipseSummaryAddress fieldAddress( const std::string& quantityName );
static RifEclipseSummaryAddress aquiferAddress( const std::string& quantityName, int aquiferNumber );
static RifEclipseSummaryAddress networkAddress( const std::string& quantityName );
static RifEclipseSummaryAddress miscAddress( const std::string& quantityName );
static RifEclipseSummaryAddress regionAddress( const std::string& quantityName, int regionNumber );
static RifEclipseSummaryAddress fieldAddress( const std::string& vectorName );
static RifEclipseSummaryAddress aquiferAddress( const std::string& vectorName, int aquiferNumber );
static RifEclipseSummaryAddress networkAddress( const std::string& vectorName );
static RifEclipseSummaryAddress miscAddress( const std::string& vectorName );
static RifEclipseSummaryAddress regionAddress( const std::string& vectorName, int regionNumber );
static RifEclipseSummaryAddress
regionToRegionAddress( const std::string& quantityName, int regionNumber, int region2Number );
static RifEclipseSummaryAddress groupAddress( const std::string& quantityName, const std::string& groupName );
static RifEclipseSummaryAddress wellAddress( const std::string& quantityName, const std::string& wellName );
regionToRegionAddress( const std::string& vectorName, int regionNumber, int region2Number );
static RifEclipseSummaryAddress groupAddress( const std::string& vectorName, const std::string& groupName );
static RifEclipseSummaryAddress wellAddress( const std::string& vectorName, const std::string& wellName );
static RifEclipseSummaryAddress
wellCompletionAddress( const std::string& quantityName, const std::string& wellName, int i, int j, int k );
wellCompletionAddress( const std::string& vectorName, const std::string& wellName, int i, int j, int k );
static RifEclipseSummaryAddress
wellLgrAddress( const std::string& quantityName, const std::string& lgrName, const std::string& wellName );
static RifEclipseSummaryAddress wellCompletionLgrAddress( const std::string& quantityName,
wellLgrAddress( const std::string& vectorName, const std::string& lgrName, const std::string& wellName );
static RifEclipseSummaryAddress wellCompletionLgrAddress( const std::string& vectorName,
const std::string& lgrName,
const std::string& wellName,
int i,
int j,
int k );
static RifEclipseSummaryAddress
wellSegmentAddress( const std::string& quantityName, const std::string& wellName, int segmentNumber );
static RifEclipseSummaryAddress blockAddress( const std::string& quantityName, int i, int j, int k );
wellSegmentAddress( const std::string& vectorName, const std::string& wellName, int segmentNumber );
static RifEclipseSummaryAddress blockAddress( const std::string& vectorName, int i, int j, int k );
static RifEclipseSummaryAddress
blockLgrAddress( const std::string& quantityName, const std::string& lgrName, int i, int j, int k );
static RifEclipseSummaryAddress calculatedAddress( const std::string& quantityName, int id );
static RifEclipseSummaryAddress importedAddress( const std::string& quantityName );
static RifEclipseSummaryAddress ensembleStatisticsAddress( const std::string& quantityName,
const std::string& dataQuantityName );
blockLgrAddress( const std::string& vectorName, const std::string& lgrName, int i, int j, int k );
static RifEclipseSummaryAddress calculatedAddress( const std::string& vectorName, int id );
static RifEclipseSummaryAddress importedAddress( const std::string& vectorName );
static RifEclipseSummaryAddress ensembleStatisticsAddress( const std::string& vectorName,
const std::string& datavectorName );
static std::string generateStringFromAddresses( const std::vector<RifEclipseSummaryAddress>& addressVector,
const std::string jointString = "; " );
@ -166,8 +166,8 @@ public:
// Access methods
SummaryVarCategory category() const { return m_variableCategory; }
const std::string& quantityName() const { return m_quantityName; }
bool isHistoryQuantity() const;
const std::string& vectorName() const { return m_vectorName; }
bool isHistoryVector() const;
int regionNumber() const { return m_regionNumber; }
int regionNumber2() const { return m_regionNumber2; }
@ -183,7 +183,7 @@ public:
int id() const { return m_id; }
std::string blockAsString() const;
const std::string ensembleStatisticsQuantityName() const;
const std::string ensembleStatisticsVectorName() const;
// Derived properties
@ -193,7 +193,7 @@ public:
bool isUiTextMatchingFilterText( const QString& filterString ) const;
bool isValid() const;
void setQuantityName( const std::string& quantity ) { m_quantityName = quantity; }
void setVectorName( const std::string& vectorName ) { m_vectorName = vectorName; }
void setWellName( const std::string& wellName ) { m_wellName = wellName; }
void setGroupName( const std::string& groupName ) { m_groupName = groupName; }
void setRegion( int region ) { m_regionNumber = (int16_t)region; }
@ -208,7 +208,7 @@ public:
bool hasAccumulatedData() const;
static std::string baseQuantityName( const std::string& quantityName );
static std::string baseVectorName( const std::string& vectorName );
private:
static RifEclipseSummaryAddress fromTokens( const std::vector<std::string>& tokens );
@ -218,7 +218,7 @@ private:
std::string formatUiTextRegionToRegion() const;
std::pair<int16_t, int16_t> regionToRegionPairFromUiText( const std::string& s );
std::string m_quantityName;
std::string m_vectorName;
std::string m_groupName;
std::string m_wellName;
std::string m_lgrName;

2
ApplicationLibCode/FileInterface/RifEclipseSummaryTools.cpp
View File

@ -151,7 +151,7 @@ void RifEclipseSummaryTools::dumpMetaData( RifSummaryReaderInterface* readerEcli
for ( const auto& catAddresse : catAddresses )
{
std::cout << catAddresse.quantityName() << " " << catAddresse.regionNumber() << " "
std::cout << catAddresse.vectorName() << " " << catAddresse.regionNumber() << " "
<< catAddresse.regionNumber2() << " " << catAddresse.groupName() << " "
<< catAddresse.wellName() << " " << catAddresse.wellSegmentNumber() << " "
<< catAddresse.lgrName() << " " << catAddresse.cellI() << " " << catAddresse.cellJ() << " "

2
ApplicationLibCode/FileInterface/RifEclipseUserDataKeywordTools.cpp
View File

@ -322,7 +322,7 @@ size_t RifEclipseUserDataKeywordTools::computeRequiredHeaderLineCount( const std
}
}
// Quantity and unit, scaling is optional
// Vector name and unit, scaling is optional
return 1 + maxHeaderLinesFromKeywords;
}

28
ApplicationLibCode/FileInterface/RifEclipseUserDataParserTools.cpp
View File

@ -430,17 +430,17 @@ TableData RifEclipseUserDataParserTools::tableDataFromText( std::stringstream&
continue;
}
std::string quantity = columnText[0];
std::string unit = unitNames[i];
std::string vectorName = columnText[0];
std::string unit = unitNames[i];
std::vector<std::string> columnHeader;
if ( columnText.size() > 1 )
columnHeader.insert( columnHeader.begin(), columnText.begin() + 1, columnText.end() );
RifEclipseSummaryAddress adr = RifEclipseUserDataKeywordTools::makeAndFillAddress( quantity, columnHeader );
RifEclipseSummaryAddress adr = RifEclipseUserDataKeywordTools::makeAndFillAddress( vectorName, columnHeader );
Column ci = Column::createColumnInfoFromRsmData( quantity, unit, adr );
Column ci = Column::createColumnInfoFromRsmData( vectorName, unit, adr );
columnInfos.push_back( ci );
}
@ -667,7 +667,7 @@ std::vector<Column>
{
if ( columnLines.size() == 0 ) continue;
std::string quantity = columnLines[0];
std::string vectorName = columnLines[0];
std::string unit;
size_t startIndex = 1;
@ -692,9 +692,9 @@ std::vector<Column>
restOfHeader.push_back( columnLines[i] );
}
RifEclipseSummaryAddress adr = RifEclipseUserDataKeywordTools::makeAndFillAddress( quantity, restOfHeader );
RifEclipseSummaryAddress adr = RifEclipseUserDataKeywordTools::makeAndFillAddress( vectorName, restOfHeader );
Column ci = Column::createColumnInfoFromRsmData( quantity, unit, adr );
Column ci = Column::createColumnInfoFromRsmData( vectorName, unit, adr );
table.push_back( ci );
}
@ -736,7 +736,7 @@ std::vector<TableData> RifEclipseUserDataParserTools::mergeEqualTimeSteps( const
QDateTime firstTableStartTime;
for ( auto c : tables[0].columnInfos() )
{
if ( c.summaryAddress.quantityName() == "DATE" )
if ( c.summaryAddress.vectorName() == "DATE" )
{
if ( c.itemCount() > 0 )
{
@ -766,7 +766,7 @@ std::vector<TableData> RifEclipseUserDataParserTools::mergeEqualTimeSteps( const
QDateTime tableFirstTime;
for ( auto& c : tables[i].columnInfos() )
{
if ( c.summaryAddress.quantityName() == "DATE" )
if ( c.summaryAddress.vectorName() == "DATE" )
{
if ( c.itemCount() > 0 )
{
@ -786,7 +786,7 @@ std::vector<TableData> RifEclipseUserDataParserTools::mergeEqualTimeSteps( const
{
for ( auto& c : tables[i].columnInfos() )
{
if ( c.summaryAddress.quantityName() != "DATE" )
if ( c.summaryAddress.vectorName() != "DATE" )
{
firstTable.columnInfos().push_back( c );
}
@ -866,17 +866,17 @@ size_t Column::itemCount() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Column Column::createColumnInfoFromRsmData( const std::string& quantity,
Column Column::createColumnInfoFromRsmData( const std::string& vectorName,
const std::string& unit,
const RifEclipseSummaryAddress& addr )
{
Column ci( addr, unit );
if ( RifEclipseUserDataKeywordTools::isDate( quantity ) )
if ( RifEclipseUserDataKeywordTools::isDate( vectorName ) )
{
ci.dataType = TEXT;
}
else if ( RifEclipseUserDataKeywordTools::isStepType( quantity ) )
else if ( RifEclipseUserDataKeywordTools::isStepType( vectorName ) )
{
ci.dataType = TEXT;
}
@ -924,7 +924,7 @@ QDateTime TableData::findFirstDate() const
for ( auto ci : m_columnInfos )
{
if ( RifEclipseUserDataKeywordTools::isDate( ci.summaryAddress.quantityName() ) )
if ( RifEclipseUserDataKeywordTools::isDate( ci.summaryAddress.vectorName() ) )
{
if ( ci.itemCount() > 0 )
{

2
ApplicationLibCode/FileInterface/RifEclipseUserDataParserTools.h
View File

@ -60,7 +60,7 @@ public:
size_t itemCount() const;
public:
static Column createColumnInfoFromRsmData( const std::string& quantity,
static Column createColumnInfoFromRsmData( const std::string& vectorName,
const std::string& unit,
const RifEclipseSummaryAddress& addr );
static Column createColumnInfoFromCsvData( const RifEclipseSummaryAddress& addr, const std::string& unit );

9
ApplicationLibCode/FileInterface/RifEnsembleStatisticsReader.cpp
View File

@ -57,7 +57,7 @@ bool RifEnsembleStatisticsReader::values( const RifEclipseSummaryAddress& result
if ( !validateAddress( resultAddress ) ) return false;
const std::vector<double>* sourceData = nullptr;
auto quantityName = resultAddress.ensembleStatisticsQuantityName();
auto quantityName = resultAddress.ensembleStatisticsVectorName();
if ( quantityName == ENSEMBLE_STAT_P10_QUANTITY_NAME )
sourceData = &m_ensembleStatCase->p10();
@ -88,12 +88,11 @@ std::string RifEnsembleStatisticsReader::unitName( const RifEclipseSummaryAddres
auto cases = m_ensembleStatCase->curveSet()->summaryCaseCollection()->allSummaryCases();
if ( cases.size() > 0 )
{
// get rid of the stats part of the quantity name
QString qName = QString::fromStdString( resultAddress.quantityName() );
QString qName = QString::fromStdString( resultAddress.vectorName() );
std::string orgQName = qName.split( ":" )[1].toStdString();
RifEclipseSummaryAddress address = RifEclipseSummaryAddress( resultAddress );
address.setQuantityName( orgQName );
address.setVectorName( orgQName );
retval = cases[0]->summaryReader()->unitName( address );
}
@ -114,5 +113,5 @@ RiaDefines::EclipseUnitSystem RifEnsembleStatisticsReader::unitSystem() const
//--------------------------------------------------------------------------------------------------
bool RifEnsembleStatisticsReader::validateAddress( const RifEclipseSummaryAddress& address ) const
{
return address.category() == RifEclipseSummaryAddress::SUMMARY_ENSEMBLE_STATISTICS && !address.quantityName().empty();
return address.category() == RifEclipseSummaryAddress::SUMMARY_ENSEMBLE_STATISTICS && !address.vectorName().empty();
}

2
ApplicationLibCode/FileInterface/RifOpmHdf5Summary.cpp
View File

@ -102,7 +102,7 @@ bool RifOpmHdf5Summary::values( const RifEclipseSummaryAddress& resultAddress, s
auto node = m_eSmry->summaryNodeList()[index];
int smspecIndex = static_cast<int>( node.smspecKeywordIndex );
const auto& vectorName = resultAddress.quantityName();
const auto& vectorName = resultAddress.vectorName();
*values = m_hdf5Reader->values( vectorName, smspecIndex );

18
ApplicationLibCode/FileInterface/RifReaderEclipseSummary.cpp
View File

@ -180,16 +180,16 @@ bool RifReaderEclipseSummary::values( const RifEclipseSummaryAddress& resultAddr
if ( m_differenceAddresses.count( resultAddress ) )
{
const std::string& quantityName = resultAddress.quantityName();
const std::string& quantityName = resultAddress.vectorName();
auto historyQuantity = quantityName.substr( 0, quantityName.size() - differenceIdentifier().size() ) +
historyIdentifier();
RifEclipseSummaryAddress nativeAdrNoHistory = resultAddress;
nativeAdrNoHistory.setQuantityName( historyQuantity );
nativeAdrNoHistory.setVectorName( historyQuantity );
auto quantityNoHistory = quantityName.substr( 0, historyQuantity.size() - 1 );
RifEclipseSummaryAddress nativeAdrHistory = resultAddress;
nativeAdrHistory.setQuantityName( quantityNoHistory );
nativeAdrHistory.setVectorName( quantityNoHistory );
std::vector<double> nativeValues;
std::vector<double> historyValues;
@ -259,11 +259,11 @@ void RifReaderEclipseSummary::buildMetaData()
RifEclipseSummaryAddress adrWithoutHistory;
{
const std::string& s = adr.quantityName();
const std::string& s = adr.vectorName();
if ( !RiaStdStringTools::endsWith( s, historyIdentifier() ) )
{
RifEclipseSummaryAddress candidate = adr;
candidate.setQuantityName( s + historyIdentifier() );
candidate.setVectorName( s + historyIdentifier() );
if ( m_allResultAddresses.count( candidate ) )
{
adrWithHistory = candidate;
@ -276,8 +276,8 @@ void RifReaderEclipseSummary::buildMetaData()
{
RifEclipseSummaryAddress candidate = adr;
std::string s = candidate.quantityName() + differenceIdentifier();
candidate.setQuantityName( s );
std::string s = candidate.vectorName() + differenceIdentifier();
candidate.setVectorName( s );
m_allResultAddresses.insert( candidate );
m_differenceAddresses.insert( candidate );
@ -304,7 +304,7 @@ std::string RifReaderEclipseSummary::unitName( const RifEclipseSummaryAddress& r
auto reader = currentSummaryReader();
if ( reader )
{
auto nativeName = resultAddress.quantityName();
auto nativeName = resultAddress.vectorName();
auto stringToRemove = RifReaderEclipseSummary::differenceIdentifier();
if ( RiaStdStringTools::endsWith( nativeName, stringToRemove ) )
{
@ -312,7 +312,7 @@ std::string RifReaderEclipseSummary::unitName( const RifEclipseSummaryAddress& r
}
RifEclipseSummaryAddress adr( resultAddress );
adr.setQuantityName( nativeName );
adr.setVectorName( nativeName );
return reader->unitName( adr );
}

6
ApplicationLibCode/FileInterface/RifReaderObservedData.cpp
View File

@ -154,11 +154,11 @@ const std::vector<time_t>& RifReaderObservedData::timeSteps( const RifEclipseSum
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress RifReaderObservedData::address( const QString& quantity,
RifEclipseSummaryAddress RifReaderObservedData::address( const QString& vectorName,
const QString& identifierName,
RifEclipseSummaryAddress::SummaryVarCategory summaryCategory )
{
std::string quantityName = quantity.toStdString();
std::string stdVectorName = vectorName.toStdString();
int regionNumber( -1 );
int regionNumber2( -1 );
std::string groupName;
@ -188,7 +188,7 @@ RifEclipseSummaryAddress RifReaderObservedData::address( const QString&
}
return RifEclipseSummaryAddress( summaryCategory,
quantityName,
stdVectorName,
regionNumber,
regionNumber2,
groupName,

2
ApplicationLibCode/FileInterface/RifReaderObservedData.h
View File

@ -54,7 +54,7 @@ public:
RiaDefines::EclipseUnitSystem unitSystem() const override;
private:
RifEclipseSummaryAddress address( const QString& quantity,
RifEclipseSummaryAddress address( const QString& vectorName,
const QString& identifierName,
RifEclipseSummaryAddress::SummaryVarCategory summaryCategory );

38
ApplicationLibCode/ProjectDataModel/AnalysisPlots/RimAnalysisPlot.cpp
View File

@ -68,7 +68,7 @@ void caf::AppEnum<RimAnalysisPlot::SortGroupType>::setUp()
{
addItem( RimAnalysisPlot::NONE, "NONE", "None" );
addItem( RimAnalysisPlot::SUMMARY_ITEM, "SUMMARY_ITEM", "Summary Item" );
addItem( RimAnalysisPlot::QUANTITY, "QUANTITY", "Quantity" );
addItem( RimAnalysisPlot::VECTOR, "VECTOR", "Vector" );
addItem( RimAnalysisPlot::CASE, "CASE", "Case" );
addItem( RimAnalysisPlot::ENSEMBLE, "ENSEMBLE", "Ensemble" );
addItem( RimAnalysisPlot::VALUE, "VALUE", "Value" );
@ -157,7 +157,7 @@ RimAnalysisPlot::RimAnalysisPlot()
CAF_PDM_InitField( &m_useEnsembleInBarText, "UseEnsembleInBarText", false, "Ensemble" );
CAF_PDM_InitField( &m_useSummaryItemInBarText, "UseSummaryItemInBarText", false, "Summary Item" );
CAF_PDM_InitField( &m_useTimeStepInBarText, "UseTimeStepInBarText", false, "Time Step" );
CAF_PDM_InitField( &m_useQuantityInBarText, "UseQuantityInBarText", false, "Quantity" );
CAF_PDM_InitField( &m_useVectorNameInBarText, "UseQuantityInBarText", false, "Vector" );
CAF_PDM_InitFieldNoDefault( &m_barTextFontSize, "BarTextFontSize", "Font Size" );
@ -391,7 +391,7 @@ void RimAnalysisPlot::maxMinValueFromAddress( const RifEclipseSummaryAddress&
{
RifEclipseSummaryAddress historyAddr = address;
if ( !historyAddr.isHistoryQuantity() ) historyAddr.setQuantityName( address.quantityName() + "H" );
if ( !historyAddr.isHistoryVector() ) historyAddr.setVectorName( address.vectorName() + "H" );
const std::vector<time_t>& historyTimesteps = reader->timeSteps( historyAddr );
if ( historyTimesteps.size() )
@ -498,9 +498,9 @@ void RimAnalysisPlot::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering
QString vectorNames;
if ( getOrCreateSelectedCurveDefAnalyser() )
{
for ( const std::string& quantityName : getOrCreateSelectedCurveDefAnalyser()->m_quantityNames )
for ( const std::string& vectorName : getOrCreateSelectedCurveDefAnalyser()->m_vectorNames )
{
vectorNames += QString::fromStdString( quantityName ) + ", ";
vectorNames += QString::fromStdString( vectorName ) + ", ";
}
if ( !vectorNames.isEmpty() )
@ -546,14 +546,14 @@ void RimAnalysisPlot::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering
caf::PdmUiGroup* barLabelGrp = uiOrdering.addNewGroup( "Bar Labels" );
barLabelGrp->add( &m_useBarText );
barLabelGrp->add( &m_barTextFontSize );
barLabelGrp->add( &m_useQuantityInBarText );
barLabelGrp->add( &m_useVectorNameInBarText );
barLabelGrp->add( &m_useSummaryItemInBarText );
barLabelGrp->add( &m_useCaseInBarText );
barLabelGrp->add( &m_useEnsembleInBarText );
barLabelGrp->add( &m_useTimeStepInBarText );
m_barTextFontSize.uiCapability()->setUiReadOnly( !m_useBarText );
m_useQuantityInBarText.uiCapability()->setUiReadOnly( !m_useBarText );
m_useVectorNameInBarText.uiCapability()->setUiReadOnly( !m_useBarText );
m_useSummaryItemInBarText.uiCapability()->setUiReadOnly( !m_useBarText );
m_useCaseInBarText.uiCapability()->setUiReadOnly( !m_useBarText );
m_useEnsembleInBarText.uiCapability()->setUiReadOnly( !m_useBarText );
@ -671,7 +671,7 @@ QList<caf::PdmOptionItemInfo> RimAnalysisPlot::calculateValueOptions( const caf:
QString( "%1 (%2)" ).arg( SortGroupAppEnum::uiText( SUMMARY_ITEM ) ).arg( exampleString );
options.push_back( caf::PdmOptionItemInfo( summaryItemText, SUMMARY_ITEM ) );
}
options.push_back( caf::PdmOptionItemInfo( SortGroupAppEnum::uiText( QUANTITY ), QUANTITY ) );
options.push_back( caf::PdmOptionItemInfo( SortGroupAppEnum::uiText( VECTOR ), VECTOR ) );
options.push_back( caf::PdmOptionItemInfo( SortGroupAppEnum::uiText( CASE ), CASE ) );
options.push_back( caf::PdmOptionItemInfo( SortGroupAppEnum::uiText( ENSEMBLE ), ENSEMBLE ) );
options.push_back( caf::PdmOptionItemInfo( SortGroupAppEnum::uiText( TIME_STEP ), TIME_STEP ) );
@ -991,11 +991,11 @@ QString RimAnalysisPlot::assignGroupingText( RimAnalysisPlot::SortGroupType sor
}
}
break;
case RimAnalysisPlot::QUANTITY:
case RimAnalysisPlot::VECTOR:
{
RifEclipseSummaryAddress addr = dataEntry.summaryAddress();
groupingText = QString::fromStdString( addr.quantityName() );
groupingText = QString::fromStdString( addr.vectorName() );
}
break;
case RimAnalysisPlot::TIME_STEP:
@ -1056,7 +1056,7 @@ std::vector<RiaSummaryCurveDefinition> RimAnalysisPlot::filteredCurveDefs()
RifEclipseSummaryAddress address = curveDef.summaryAddress();
address.setQuantityName( "" ); // Quantity name set to "" in order to store only unique summary items
address.setVectorName( "" ); // Vector name set to "" in order to store only unique summary items
filteredSummaryItems.insert( address );
}
}
@ -1076,7 +1076,7 @@ std::vector<RiaSummaryCurveDefinition> RimAnalysisPlot::filteredCurveDefs()
{
RimSummaryCase* sumCase = curveDefCandidate.summaryCase();
RifEclipseSummaryAddress addr = curveDefCandidate.summaryAddress();
addr.setQuantityName( "" );
addr.setVectorName( "" );
if ( filteredSumCases.count( sumCase ) && filteredSummaryItems.count( addr ) )
{
@ -1230,8 +1230,8 @@ void RimAnalysisPlot::applyFilter( const RimPlotDataFilterItem* filter,
{
RifEclipseSummaryAddress historyAddr = addrToFilterValue;
if ( !historyAddr.isHistoryQuantity() )
historyAddr.setQuantityName( addrToFilterValue.quantityName() + "H" );
if ( !historyAddr.isHistoryVector() )
historyAddr.setVectorName( addrToFilterValue.vectorName() + "H" );
const std::vector<time_t>& historyTimesteps = reader->timeSteps( historyAddr );
if ( historyTimesteps.size() )
@ -1314,13 +1314,13 @@ void RimAnalysisPlot::applyFilter( const RimPlotDataFilterItem* filter,
{
RifEclipseSummaryAddress addrToFilterValue = filter->summaryAddress();
quantityName = addrToFilterValue.quantityName();
quantityName = addrToFilterValue.vectorName();
}
for ( auto sumItem : *filteredSummaryItems )
{
RifEclipseSummaryAddress addrToFilterValue = sumItem;
addrToFilterValue.setQuantityName( quantityName );
addrToFilterValue.setVectorName( quantityName );
if ( filter->filterOperation() == RimPlotDataFilterItem::RANGE )
{
@ -1541,9 +1541,9 @@ void RimAnalysisPlot::addDataToChartBuilder( RiuGroupedBarChartBuilder& chartBui
if ( m_useBarText() )
{
QStringList barTextComponents;
if ( m_useQuantityInBarText )
if ( m_useVectorNameInBarText )
{
barTextComponents += QString::fromStdString( curveDef.summaryAddress().quantityName() );
barTextComponents += QString::fromStdString( curveDef.summaryAddress().vectorName() );
}
if ( m_useSummaryItemInBarText )
@ -1625,7 +1625,7 @@ void RimAnalysisPlot::updatePlotTitle()
QString::fromStdString( getOrCreateSelectedCurveDefAnalyser()->m_summaryAdresses.begin()->itemUiText() );
}
for ( std::string quantName : getOrCreateSelectedCurveDefAnalyser()->m_quantityNames )
for ( std::string quantName : getOrCreateSelectedCurveDefAnalyser()->m_vectorNames )
{
if ( !autoTitle.isEmpty() ) autoTitle += separator;
autoTitle += QString::fromStdString( quantName );

4
ApplicationLibCode/ProjectDataModel/AnalysisPlots/RimAnalysisPlot.h
View File

@ -58,7 +58,7 @@ public:
{
NONE,
SUMMARY_ITEM,
QUANTITY,
VECTOR,
CASE,
ENSEMBLE,
VALUE,
@ -214,7 +214,7 @@ private:
caf::PdmField<bool> m_useEnsembleInBarText;
caf::PdmField<bool> m_useSummaryItemInBarText;
caf::PdmField<bool> m_useTimeStepInBarText;
caf::PdmField<bool> m_useQuantityInBarText;
caf::PdmField<bool> m_useVectorNameInBarText;
caf::PdmField<caf::FontTools::RelativeSizeEnum> m_barTextFontSize;
caf::PdmChildField<RimPlotAxisProperties*> m_valueAxisProperties;

2
ApplicationLibCode/ProjectDataModel/AnalysisPlots/RimAnalysisPlotCollection.cpp
View File

@ -209,7 +209,7 @@ void RimAnalysisPlotCollection::applySummaryCaseCollectionAndFieldAddressToPlot(
{
if ( address.category() == RifEclipseSummaryAddress::SUMMARY_FIELD )
{
if ( quantityName.empty() || quantityName == address.quantityName() )
if ( quantityName.empty() || quantityName == address.vectorName() )
{
for ( auto summaryCase : summaryCaseCollection->allSummaryCases() )
{

2
ApplicationLibCode/ProjectDataModel/AnalysisPlots/RimPlotDataFilterItem.cpp
View File

@ -365,7 +365,7 @@ void RimPlotDataFilterItem::defineUiOrdering( QString uiConfigName, caf::PdmUiOr
eParm = selectedEnsembleParameter();
}
if ( m_filterTarget() == ENSEMBLE_CASE && eParm.isText() ) // Ensemble Quantity is a category value
if ( m_filterTarget() == ENSEMBLE_CASE && eParm.isText() ) // Ensemble vector is a category value
{
uiOrdering.add( &m_ensembleParameterValueCategories );
}

6
ApplicationLibCode/ProjectDataModel/AnalysisPlots/RimPlotDataFilterItem.h
View File

@ -41,7 +41,7 @@ class RimPlotAxisProperties;
class RimSummaryAddress;
// Filter of type :
// Only [Cases/SummaryItem/Case by ensemble param] where the [Quantity]
// Only [Cases/SummaryItem/Case by ensemble param] where the [Vector]
// is [within range/top N/min N]
// considering the [Plot Source/Last/First/Last with History/all] timestep(s) [range/1,2..]
@ -122,9 +122,7 @@ private:
caf::PdmField<caf::AppEnum<FilterTarget>> m_filterTarget;
// Quantity
// Complete address or quantity name only
// Complete address or vector name only
caf::PdmChildField<RimSummaryAddress*> m_filterAddress;
caf::PdmField<QString> m_filterEnsembleParameter;
caf::PdmField<RifEclipseSummaryAddress> m_filterQuantityUiField;

6
ApplicationLibCode/ProjectDataModel/CorrelationPlots/RimAbstractCorrelationPlot.cpp
View File

@ -707,10 +707,10 @@ time_t RimAbstractCorrelationPlot::timeDiff( time_t lhs, time_t rhs )
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimAbstractCorrelationPlot::selectedQuantitiesText()
QString RimAbstractCorrelationPlot::selectedVectorNamesText()
{
QString vectorNames;
for ( const std::string& quantityName : getOrCreateSelectedCurveDefAnalyser()->m_quantityNames )
for ( const std::string& quantityName : getOrCreateSelectedCurveDefAnalyser()->m_vectorNames )
{
vectorNames += QString::fromStdString( quantityName ) + ", ";
}
@ -758,7 +758,7 @@ void RimAbstractCorrelationPlot::appendDataSourceFields( QString uiConfigName, c
{
caf::PdmUiGroup* curveDataGroup = uiOrdering.addNewGroup( "Summary Vector" );
m_selectedVarsUiField = selectedQuantitiesText();
m_selectedVarsUiField = selectedVectorNamesText();
curveDataGroup->add( &m_selectedVarsUiField );
curveDataGroup->add( &m_pushButtonSelectSummaryAddress, { false, 1, 0 } );

2
ApplicationLibCode/ProjectDataModel/CorrelationPlots/RimAbstractCorrelationPlot.h
View File

@ -118,7 +118,7 @@ protected:
static time_t timeDiff( time_t lhs, time_t rhs );
QString selectedQuantitiesText();
QString selectedVectorNamesText();
QString completeAddressText();
void initAfterRead() final;

2
ApplicationLibCode/ProjectDataModel/CorrelationPlots/RimCorrelationMatrixPlot.cpp
View File

@ -366,7 +366,7 @@ void RimCorrelationMatrixPlot::onLoadDataAndUpdate()
{
updateMdiWindowVisibility();
m_selectedVarsUiField = selectedQuantitiesText();
m_selectedVarsUiField = selectedVectorNamesText();
if ( m_plotWidget )
{

2
ApplicationLibCode/ProjectDataModel/CorrelationPlots/RimCorrelationPlot.cpp
View File

@ -175,7 +175,7 @@ void RimCorrelationPlot::onLoadDataAndUpdate()
{
updateMdiWindowVisibility();
m_selectedVarsUiField = selectedQuantitiesText();
m_selectedVarsUiField = selectedVectorNamesText();
if ( m_plotWidget && m_analyserOfSelectedCurveDefs )
{

2
ApplicationLibCode/ProjectDataModel/CorrelationPlots/RimParameterResultCrossPlot.cpp
View File

@ -162,7 +162,7 @@ void RimParameterResultCrossPlot::onLoadDataAndUpdate()
{
updateMdiWindowVisibility();
m_selectedVarsUiField = selectedQuantitiesText();
m_selectedVarsUiField = selectedVectorNamesText();
if ( m_plotWidget && m_analyserOfSelectedCurveDefs )
{

12
ApplicationLibCode/ProjectDataModel/RimDataSourceSteppingTools.cpp
View File

@ -168,9 +168,9 @@ bool RimDataSourceSteppingTools::updateHistoryAndSummaryQuantityIfMatching( cons
std::string oldString = oldValue.toString().toStdString();
std::string newString = newValue.toString().toStdString();
if ( adr->quantityName() == oldString )
if ( adr->vectorName() == oldString )
{
adr->setQuantityName( newString );
adr->setVectorName( newString );
return true;
}
@ -178,9 +178,9 @@ bool RimDataSourceSteppingTools::updateHistoryAndSummaryQuantityIfMatching( cons
std::string correspondingOldString = RiaSummaryAddressAnalyzer::correspondingHistorySummaryCurveName( oldString );
std::string correspondingNewString = RiaSummaryAddressAnalyzer::correspondingHistorySummaryCurveName( newString );
if ( adr->quantityName() == correspondingOldString )
if ( adr->vectorName() == correspondingOldString )
{
adr->setQuantityName( correspondingNewString );
adr->setVectorName( correspondingNewString );
return true;
}
@ -200,9 +200,9 @@ bool RimDataSourceSteppingTools::updateQuantityIfMatching( const QVariant&
std::string oldString = oldValue.toString().toStdString();
std::string newString = newValue.toString().toStdString();
if ( adr->quantityName() == oldString )
if ( adr->vectorName() == oldString )
{
adr->setQuantityName( newString );
adr->setVectorName( newString );
return true;
}

4
ApplicationLibCode/ProjectDataModel/RimSimWellInViewCollection.cpp
View File

@ -533,7 +533,7 @@ QList<caf::PdmOptionItemInfo>
{
if ( addr.category() == RifEclipseSummaryAddress::SUMMARY_WELL )
{
summaries.insert( addr.quantityName() );
summaries.insert( addr.vectorName() );
}
}
}
@ -543,7 +543,7 @@ QList<caf::PdmOptionItemInfo>
QString displayName;
std::string longVectorName =
RiuSummaryQuantityNameInfoProvider::instance()->longNameFromQuantityName( itemName );
RiuSummaryQuantityNameInfoProvider::instance()->longNameFromVectorName( itemName );
if ( longVectorName.empty() )
{

4
ApplicationLibCode/ProjectDataModel/Summary/RimEnsembleCurveFilter.cpp
View File

@ -361,8 +361,8 @@ void RimEnsembleCurveFilter::fieldChangedByUi( const caf::PdmFieldHandle* change
RifEclipseSummaryAddress candidateAdr = parentCurveSet()->summaryAddress();
auto nativeQuantityName = RimObjectiveFunctionTools::nativeQuantityName( candidateAdr.quantityName() );
candidateAdr.setQuantityName( nativeQuantityName );
auto nativeQuantityName = RimObjectiveFunctionTools::nativeQuantityName( candidateAdr.vectorName() );
candidateAdr.setVectorName( nativeQuantityName );
summaryAddress->setAddress( candidateAdr );
m_objectiveValuesSummaryAddresses.push_back( summaryAddress );
updateAddressesUiField();

12
ApplicationLibCode/ProjectDataModel/Summary/RimEnsembleCurveSet.cpp
View File

@ -1777,16 +1777,16 @@ void RimEnsembleCurveSet::updateStatisticsCurves( const std::vector<RimSummaryCa
if ( m_statistics->showP10Curve() && m_ensembleStatCase->hasP10Data() )
addresses.push_back(
SAddr::ensembleStatisticsAddress( ENSEMBLE_STAT_P10_QUANTITY_NAME, dataAddress.quantityName() ) );
SAddr::ensembleStatisticsAddress( ENSEMBLE_STAT_P10_QUANTITY_NAME, dataAddress.vectorName() ) );
if ( m_statistics->showP50Curve() && m_ensembleStatCase->hasP50Data() )
addresses.push_back(
SAddr::ensembleStatisticsAddress( ENSEMBLE_STAT_P50_QUANTITY_NAME, dataAddress.quantityName() ) );
SAddr::ensembleStatisticsAddress( ENSEMBLE_STAT_P50_QUANTITY_NAME, dataAddress.vectorName() ) );
if ( m_statistics->showP90Curve() && m_ensembleStatCase->hasP90Data() )
addresses.push_back(
SAddr::ensembleStatisticsAddress( ENSEMBLE_STAT_P90_QUANTITY_NAME, dataAddress.quantityName() ) );
SAddr::ensembleStatisticsAddress( ENSEMBLE_STAT_P90_QUANTITY_NAME, dataAddress.vectorName() ) );
if ( m_statistics->showMeanCurve() && m_ensembleStatCase->hasMeanData() )
addresses.push_back(
SAddr::ensembleStatisticsAddress( ENSEMBLE_STAT_MEAN_QUANTITY_NAME, dataAddress.quantityName() ) );
SAddr::ensembleStatisticsAddress( ENSEMBLE_STAT_MEAN_QUANTITY_NAME, dataAddress.vectorName() ) );
}
deleteStatisticsCurves();
@ -1807,7 +1807,7 @@ void RimEnsembleCurveSet::updateStatisticsCurves( const std::vector<RimSummaryCa
curve->setSymbolSkipDistance( 150 );
if ( m_statistics->showCurveLabels() )
{
curve->setSymbolLabel( QString::fromStdString( address.ensembleStatisticsQuantityName() ) );
curve->setSymbolLabel( QString::fromStdString( address.ensembleStatisticsVectorName() ) );
}
curve->setLineStyle( RiuQwtPlotCurveDefines::LineStyleEnum::STYLE_SOLID );
curve->setSummaryCaseY( m_ensembleStatCase.get() );
@ -2066,7 +2066,7 @@ void RimEnsembleCurveSet::updateLegendMappingMode()
//--------------------------------------------------------------------------------------------------
RiuPlotCurveSymbol::PointSymbolEnum statisticsCurveSymbolFromAddress( const RifEclipseSummaryAddress& address )
{
auto qName = QString::fromStdString( address.quantityName() );
auto qName = QString::fromStdString( address.vectorName() );
if ( qName.contains( ENSEMBLE_STAT_P10_QUANTITY_NAME ) ) return RiuPlotCurveSymbol::SYMBOL_TRIANGLE;
if ( qName.contains( ENSEMBLE_STAT_P90_QUANTITY_NAME ) ) return RiuPlotCurveSymbol::SYMBOL_DOWN_TRIANGLE;

10
ApplicationLibCode/ProjectDataModel/Summary/RimEnsembleCurveSetCollection.cpp
View File

@ -260,21 +260,21 @@ std::vector<RimEnsembleCurveSet*> RimEnsembleCurveSetCollection::curveSetsForSou
{
// Add corresponding history/summary curve with or without H
std::string quantity = m_curveSetForSourceStepping->summaryAddress().quantityName();
std::string vectorName = m_curveSetForSourceStepping->summaryAddress().vectorName();
std::string candidateName;
if ( m_curveSetForSourceStepping->summaryAddress().isHistoryQuantity() )
if ( m_curveSetForSourceStepping->summaryAddress().isHistoryVector() )
{
candidateName = quantity.substr( 0, quantity.size() - 1 );
candidateName = vectorName.substr( 0, vectorName.size() - 1 );
}
else
{
candidateName = quantity + "H";
candidateName = vectorName + "H";
}
for ( const auto& c : curveSets() )
{
if ( c->summaryAddress().quantityName() == candidateName )
if ( c->summaryAddress().vectorName() == candidateName )
{
steppingCurveSets.push_back( c );
}

8
ApplicationLibCode/ProjectDataModel/Summary/RimMultipleSummaryPlotNameHelper.cpp
View File

@ -49,12 +49,12 @@ QString RimMultiSummaryPlotNameHelper::plotTitle() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimMultiSummaryPlotNameHelper::isPlotDisplayingSingleQuantity() const
bool RimMultiSummaryPlotNameHelper::isPlotDisplayingSingleVectorName() const
{
int plotCountWithSingleQuantity = 0;
for ( auto nameHelper : m_nameHelpers )
{
if ( nameHelper->isPlotDisplayingSingleQuantity() ) plotCountWithSingleQuantity++;
if ( nameHelper->isPlotDisplayingSingleVectorName() ) plotCountWithSingleQuantity++;
}
if ( plotCountWithSingleQuantity == 1 ) return true;
@ -148,11 +148,11 @@ QString RimMultiSummaryPlotNameHelper::caseName() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::string RimMultiSummaryPlotNameHelper::titleQuantity() const
std::string RimMultiSummaryPlotNameHelper::titleVectorName() const
{
for ( auto nameHelper : m_nameHelpers )
{
if ( nameHelper->isPlotDisplayingSingleQuantity() ) return nameHelper->titleQuantity();
if ( nameHelper->isPlotDisplayingSingleVectorName() ) return nameHelper->titleVectorName();
}
return "";

4
ApplicationLibCode/ProjectDataModel/Summary/RimMultipleSummaryPlotNameHelper.h
View File

@ -30,7 +30,7 @@ public:
QString plotTitle() const override;
bool isPlotDisplayingSingleQuantity() const override;
bool isPlotDisplayingSingleVectorName() const override;
bool isWellNameInTitle() const override;
bool isGroupNameInTitle() const override;
bool isRegionInTitle() const override;
@ -41,7 +41,7 @@ public:
QString caseName() const override;
std::string titleQuantity() const override;
std::string titleVectorName() const override;
std::string titleWellName() const override;
std::string titleGroupName() const override;
std::string titleRegion() const override;

14
ApplicationLibCode/ProjectDataModel/Summary/RimObjectiveFunction.cpp
View File

@ -108,20 +108,20 @@ double RimObjectiveFunction::value( RimSummaryCase*
for ( auto vectorSummaryAddress : vectorSummaryAddresses )
{
std::string s = vectorSummaryAddress.quantityName() + RifReaderEclipseSummary::differenceIdentifier();
if ( !vectorSummaryAddress.quantityName().empty() )
std::string s = vectorSummaryAddress.vectorName() + RifReaderEclipseSummary::differenceIdentifier();
if ( !vectorSummaryAddress.vectorName().empty() )
{
if ( vectorSummaryAddress.quantityName().find( RifReaderEclipseSummary::differenceIdentifier() ) !=
if ( vectorSummaryAddress.vectorName().find( RifReaderEclipseSummary::differenceIdentifier() ) !=
std::string::npos )
{
s = vectorSummaryAddress.quantityName();
s = vectorSummaryAddress.vectorName();
}
RifEclipseSummaryAddress vectorSummaryAddressDiff = vectorSummaryAddress;
vectorSummaryAddressDiff.setQuantityName( s );
vectorSummaryAddressDiff.setVectorName( s );
RifEclipseSummaryAddress vectorSummaryAddressHistory = vectorSummaryAddress;
vectorSummaryAddressHistory.setQuantityName( vectorSummaryAddress.quantityName() +
RifReaderEclipseSummary::historyIdentifier() );
vectorSummaryAddressHistory.setVectorName( vectorSummaryAddress.vectorName() +
RifReaderEclipseSummary::historyIdentifier() );
if ( readerInterface->allResultAddresses().count( vectorSummaryAddressDiff ) )
{

4
ApplicationLibCode/ProjectDataModel/Summary/RimObjectiveFunctionTools.cpp
View File

@ -46,9 +46,9 @@ RimCustomObjectiveFunctionWeight* RimObjectiveFunctionTools::addWeight( RimCusto
candidateAdr = newWeight->parentCurveSet()->summaryAddress();
}
auto nativeQuantityName = RimObjectiveFunctionTools::nativeQuantityName( candidateAdr.quantityName() );
auto nativeQuantityName = RimObjectiveFunctionTools::nativeQuantityName( candidateAdr.vectorName() );
candidateAdr.setQuantityName( nativeQuantityName );
candidateAdr.setVectorName( nativeQuantityName );
newWeight->setSummaryAddress( candidateAdr );
return newWeight;

18
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryAddress.cpp
View File

@ -61,7 +61,7 @@ RimSummaryAddress::RimSummaryAddress()
CAF_PDM_InitObject( "SummaryAddress", ":/DataVector.png", "", "" );
CAF_PDM_InitFieldNoDefault( &m_category, "SummaryVarType", "Type" );
CAF_PDM_InitFieldNoDefault( &m_quantityName, "SummaryQuantityName", "Quantity" );
CAF_PDM_InitFieldNoDefault( &m_vectorName, "SummaryQuantityName", "Vector" );
CAF_PDM_InitFieldNoDefault( &m_regionNumber, "SummaryRegion", "Region" );
CAF_PDM_InitFieldNoDefault( &m_regionNumber2, "SummaryRegion2", "Region2" );
CAF_PDM_InitFieldNoDefault( &m_groupName, "SummaryWellGroup", "Group" );
@ -117,7 +117,7 @@ RimSummaryAddress* RimSummaryAddress::wrapFileReaderAddress( const RifEclipseSum
void RimSummaryAddress::setAddress( const RifEclipseSummaryAddress& addr )
{
m_category = addr.category();
m_quantityName = addr.quantityName().c_str();
m_vectorName = addr.vectorName().c_str();
m_regionNumber = addr.regionNumber();
m_regionNumber2 = addr.regionNumber2();
m_groupName = addr.groupName().c_str();
@ -132,7 +132,7 @@ void RimSummaryAddress::setAddress( const RifEclipseSummaryAddress& addr )
m_cellK = addr.cellK();
m_calculationId = addr.id();
setUiName( m_quantityName );
setUiName( m_vectorName );
}
//--------------------------------------------------------------------------------------------------
@ -141,7 +141,7 @@ void RimSummaryAddress::setAddress( const RifEclipseSummaryAddress& addr )
RifEclipseSummaryAddress RimSummaryAddress::address() const
{
return RifEclipseSummaryAddress( m_category(),
m_quantityName().toStdString(),
m_vectorName().toStdString(),
m_regionNumber(),
m_regionNumber2(),
m_groupName().toStdString(),
@ -169,7 +169,7 @@ void RimSummaryAddress::ensureCalculationIdIsAssigned()
{
QString description = c->description();
if ( description == m_quantityName )
if ( description == m_vectorName )
{
m_calculationId = c->id();
}
@ -183,15 +183,15 @@ void RimSummaryAddress::ensureCalculationIdIsAssigned()
//--------------------------------------------------------------------------------------------------
RiaDefines::PhaseType RimSummaryAddress::addressPhaseType() const
{
if ( QRegularExpression( "^.OP" ).match( m_quantityName ).hasMatch() )
if ( QRegularExpression( "^.OP" ).match( m_vectorName ).hasMatch() )
{
return RiaDefines::PhaseType::OIL_PHASE;
}
else if ( QRegularExpression( "^.GP" ).match( m_quantityName ).hasMatch() )
else if ( QRegularExpression( "^.GP" ).match( m_vectorName ).hasMatch() )
{
return RiaDefines::PhaseType::GAS_PHASE;
}
else if ( QRegularExpression( "^.WP" ).match( m_quantityName ).hasMatch() )
else if ( QRegularExpression( "^.WP" ).match( m_vectorName ).hasMatch() )
{
return RiaDefines::PhaseType::WATER_PHASE;
}
@ -241,7 +241,7 @@ int RimSummaryAddress::caseId() const
//--------------------------------------------------------------------------------------------------
QString RimSummaryAddress::quantityName() const
{
return m_quantityName;
return m_vectorName;
}
//--------------------------------------------------------------------------------------------------

2
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryAddress.h
View File

@ -71,7 +71,7 @@ protected:
private:
caf::PdmField<caf::AppEnum<RifEclipseSummaryAddress::SummaryVarCategory>> m_category;
caf::PdmField<QString> m_quantityName;
caf::PdmField<QString> m_vectorName;
caf::PdmField<int> m_regionNumber;
caf::PdmField<int> m_regionNumber2;
caf::PdmField<QString> m_groupName;

2
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryAddressCollection.cpp
View File

@ -112,7 +112,7 @@ bool RimSummaryAddressCollection::hasDataVector( const std::string quantityName
//--------------------------------------------------------------------------------------------------
void RimSummaryAddressCollection::addAddress( const RifEclipseSummaryAddress& address, int caseId, int ensembleId )
{
if ( !hasDataVector( address.quantityName() ) )
if ( !hasDataVector( address.vectorName() ) )
{
m_adresses.push_back( RimSummaryAddress::wrapFileReaderAddress( address, caseId, ensembleId ) );
if ( m_caseId == -1 ) m_caseId = caseId;

2
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryCurve.cpp
View File

@ -1000,7 +1000,7 @@ void RimSummaryCurve::setCurveAppearanceFromCaseType()
}
}
if ( m_yValuesSummaryAddress && m_yValuesSummaryAddress->address().isHistoryQuantity() )
if ( m_yValuesSummaryAddress && m_yValuesSummaryAddress->address().isHistoryVector() )
{
RiaPreferencesSummary* prefs = RiaPreferencesSummary::current();

12
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryCurveAppearanceCalculator.cpp
View File

@ -277,8 +277,8 @@ void RimSummaryCurveAppearanceCalculator::setupCurveLook( RimSummaryCurve* curve
m_currentCurveBaseColor = cvf::Color3f( 0.5f, 0.5f, 0.5f );
m_currentCurveGradient = 0.0f;
std::string quantityName = curve->summaryAddressY().quantityName();
if ( curve->summaryAddressY().isHistoryQuantity() )
std::string quantityName = curve->summaryAddressY().vectorName();
if ( curve->summaryAddressY().isHistoryVector() )
{
quantityName = quantityName.substr( 0, quantityName.size() - 1 );
}
@ -325,7 +325,7 @@ void RimSummaryCurveAppearanceCalculator::setupCurveLook( RimSummaryCurve* curve
void RimSummaryCurveAppearanceCalculator::assignColorByPhase( RimSummaryCurve* curve, int colorIndex )
{
char secondChar = 0;
std::string varname = curve->summaryAddressY().quantityName();
std::string varname = curve->summaryAddressY().vectorName();
if ( varname.size() > 1 )
{
@ -380,11 +380,11 @@ void RimSummaryCurveAppearanceCalculator::init( const std::vector<RiaSummaryCurv
if ( !( curveDef.summaryAddress().regionNumber() == -1 ) )
m_regToAppearanceIdxMap[curveDef.summaryAddress().regionNumber()] = -1;
if ( !curveDef.summaryAddress().quantityName().empty() )
if ( !curveDef.summaryAddress().vectorName().empty() )
{
std::string varname = curveDef.summaryAddress().quantityName();
std::string varname = curveDef.summaryAddress().vectorName();
if ( curveDef.summaryAddress().isHistoryQuantity() )
if ( curveDef.summaryAddress().isHistoryVector() )
{
varname = varname.substr( 0, varname.size() - 1 );
}

12
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryCurveAutoName.cpp
View File

@ -190,26 +190,26 @@ QString RimSummaryCurveAutoName::buildCurveName( const RifEclipseSummaryAddress&
if ( m_vectorName )
{
bool skipSubString = nameHelper && nameHelper->isPlotDisplayingSingleQuantity();
bool skipSubString = nameHelper && nameHelper->isPlotDisplayingSingleVectorName();
if ( !skipSubString )
{
if ( m_longVectorName() )
{
auto quantityName = summaryAddress.quantityName();
if ( summaryAddress.isHistoryQuantity() )
auto quantityName = summaryAddress.vectorName();
if ( summaryAddress.isHistoryVector() )
quantityName = quantityName.substr( 0, quantityName.size() - 1 );
text = RiuSummaryQuantityNameInfoProvider::instance()->longNameFromQuantityName( quantityName );
text = RiuSummaryQuantityNameInfoProvider::instance()->longNameFromVectorName( quantityName );
}
else
{
text = summaryAddress.quantityName();
text = summaryAddress.vectorName();
}
}
if ( summaryAddress.category() == RifEclipseSummaryAddress::SUMMARY_ENSEMBLE_STATISTICS )
{
text = summaryAddress.quantityName();
text = summaryAddress.vectorName();
}
else if ( summaryAddress.category() == RifEclipseSummaryAddress::SUMMARY_CALCULATED )
{

16
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryCurveCollection.cpp
View File

@ -254,25 +254,25 @@ std::vector<RimSummaryCurve*>
const std::string historyIdentifier = "H";
std::string quantity;
std::string vectorName;
if ( steppingType == RimSummaryDataSourceStepping::Axis::X_AXIS )
{
quantity = m_curveForSourceStepping->summaryAddressX().quantityName();
vectorName = m_curveForSourceStepping->summaryAddressX().vectorName();
}
else if ( steppingType == RimSummaryDataSourceStepping::Axis::Y_AXIS )
{
quantity = m_curveForSourceStepping->summaryAddressY().quantityName();
vectorName = m_curveForSourceStepping->summaryAddressY().vectorName();
}
std::string candidateName;
if ( RiaStdStringTools::endsWith( quantity, historyIdentifier ) )
if ( RiaStdStringTools::endsWith( vectorName, historyIdentifier ) )
{
candidateName = quantity.substr( 0, quantity.size() - 1 );
candidateName = vectorName.substr( 0, vectorName.size() - 1 );
}
else
{
candidateName = quantity + historyIdentifier;
candidateName = vectorName + historyIdentifier;
}
for ( const auto& c : curves() )
@ -280,7 +280,7 @@ std::vector<RimSummaryCurve*>
if ( steppingType == RimSummaryDataSourceStepping::Axis::X_AXIS )
{
if ( c->summaryCaseX() == m_curveForSourceStepping->summaryCaseX() &&
c->summaryAddressX().quantityName() == candidateName )
c->summaryAddressX().vectorName() == candidateName )
{
stepCurves.push_back( c );
}
@ -288,7 +288,7 @@ std::vector<RimSummaryCurve*>
else if ( steppingType == RimSummaryDataSourceStepping::Axis::Y_AXIS )
{
if ( c->summaryCaseY() == m_curveForSourceStepping->summaryCaseY() &&
c->summaryAddressY().quantityName() == candidateName )
c->summaryAddressY().vectorName() == candidateName )
{
stepCurves.push_back( c );
}

11
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryMultiPlot.cpp
View File

@ -673,7 +673,7 @@ void RimSummaryMultiPlot::setDefaultRangeAggregationSteppingDimension()
rangeAggregation = AxisRangeAggregation::SUB_PLOTS;
}
auto stepDimension = RimSummaryPlotSourceStepping::SourceSteppingDimension::QUANTITY;
auto stepDimension = RimSummaryPlotSourceStepping::SourceSteppingDimension::VECTOR;
if ( analyzer.wellNames().size() == 1 )
{
stepDimension = RimSummaryPlotSourceStepping::SourceSteppingDimension::WELL;
@ -828,9 +828,8 @@ void RimSummaryMultiPlot::computeAggregatedAxisRange()
if ( axisRangeAggregation == AxisRangeAggregation::REALIZATIONS )
{
RifEclipseSummaryAddress addr =
RifEclipseSummaryAddress::fieldAddress( curve->summaryAddressY().quantityName() );
addresses = { addr };
RifEclipseSummaryAddress addr = RifEclipseSummaryAddress::fieldAddress( curve->summaryAddressY().vectorName() );
addresses = { addr };
}
else if ( axisRangeAggregation == AxisRangeAggregation::WELLS ||
axisRangeAggregation == AxisRangeAggregation::REGIONS )
@ -851,7 +850,7 @@ void RimSummaryMultiPlot::computeAggregatedAxisRange()
for ( const auto& wellName : analyzer.wellNames() )
{
addresses.push_back(
RifEclipseSummaryAddress::wellAddress( curve->summaryAddressY().quantityName(), wellName ) );
RifEclipseSummaryAddress::wellAddress( curve->summaryAddressY().vectorName(), wellName ) );
}
}
@ -859,7 +858,7 @@ void RimSummaryMultiPlot::computeAggregatedAxisRange()
{
for ( auto regionNumber : analyzer.regionNumbers() )
{
addresses.push_back( RifEclipseSummaryAddress::regionAddress( curve->summaryAddressY().quantityName(),
addresses.push_back( RifEclipseSummaryAddress::regionAddress( curve->summaryAddressY().vectorName(),
regionNumber ) );
}
}

6
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryNameHelper.cpp
View File

@ -78,12 +78,12 @@ QString RimSummaryNameHelper::aggregatedPlotTitle( const RimSummaryNameHelper& o
title += "Completion : " + QString::fromStdString( completion );
}
auto quantity = this->titleQuantity();
if ( ( other.titleQuantity() != this->titleQuantity() ) && ( !quantity.empty() ) )
auto vectorName = this->titleVectorName();
if ( ( other.titleVectorName() != this->titleVectorName() ) && ( !vectorName.empty() ) )
{
if ( !title.isEmpty() ) title += ", ";
title += QString::fromStdString(
RiuSummaryQuantityNameInfoProvider::instance()->longNameFromQuantityName( quantity, true ) );
RiuSummaryQuantityNameInfoProvider::instance()->longNameFromVectorName( vectorName, true ) );
}
return title;

18
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryNameHelper.h
View File

@ -37,18 +37,18 @@ public:
QString aggregatedPlotTitle( const RimSummaryNameHelper& summaryMultiPlotNameHelper ) const;
virtual bool isPlotDisplayingSingleQuantity() const = 0;
virtual bool isWellNameInTitle() const = 0;
virtual bool isGroupNameInTitle() const = 0;
virtual bool isRegionInTitle() const = 0;
virtual bool isCaseInTitle() const = 0;
virtual bool isBlockInTitle() const = 0;
virtual bool isSegmentInTitle() const = 0;
virtual bool isCompletionInTitle() const = 0;
virtual bool isPlotDisplayingSingleVectorName() const = 0;
virtual bool isWellNameInTitle() const = 0;
virtual bool isGroupNameInTitle() const = 0;
virtual bool isRegionInTitle() const = 0;
virtual bool isCaseInTitle() const = 0;
virtual bool isBlockInTitle() const = 0;
virtual bool isSegmentInTitle() const = 0;
virtual bool isCompletionInTitle() const = 0;
virtual QString caseName() const = 0;
virtual std::string titleQuantity() const = 0;
virtual std::string titleVectorName() const = 0;
virtual std::string titleWellName() const = 0;
virtual std::string titleGroupName() const = 0;
virtual std::string titleRegion() const = 0;

6
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryPlot.cpp
View File

@ -928,7 +928,7 @@ bool RimSummaryPlot::isOnlyWaterCutCurvesVisible( RiuPlotAxis plotAxis )
auto curves = visibleSummaryCurvesForAxis( plotAxis );
for ( auto c : curves )
{
auto quantityName = c->summaryAddressY().quantityName();
auto quantityName = c->summaryAddressY().vectorName();
if ( RiaStdStringTools::endsWith( quantityName, "WCT" ) ) waterCutCurveCount++;
}
@ -2485,7 +2485,7 @@ void RimSummaryPlot::updateCurveNames()
if ( c->isCurveVisible() )
{
c->updateCurveNameNoLegendUpdate();
shortCurveNames.append( QString::fromStdString( c->summaryAddressY().quantityName() ) );
shortCurveNames.append( QString::fromStdString( c->summaryAddressY().vectorName() ) );
}
}
}
@ -2496,7 +2496,7 @@ void RimSummaryPlot::updateCurveNames()
if ( curveSet->isCurvesVisible() )
{
shortCurveNames.append( QString::fromStdString( curveSet->summaryAddress().quantityName() ) );
shortCurveNames.append( QString::fromStdString( curveSet->summaryAddress().vectorName() ) );
}
}

9
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryPlotAxisFormatter.cpp
View File

@ -212,12 +212,11 @@ QString RimSummaryPlotAxisFormatter::autoAxisTitle() const
std::map<std::string, std::set<std::string>> unitToQuantityNameMap;
auto addToUnitToQuantityMap = [&]( const std::string& unitText, const RifEclipseSummaryAddress& sumAddress ) {
// remove any stats prefix from the quantity name
size_t cutPos = sumAddress.quantityName().find( ':' );
size_t cutPos = sumAddress.vectorName().find( ':' );
if ( cutPos == std::string::npos ) cutPos = -1;
std::string titleText;
const std::string& quantityName = sumAddress.quantityName().substr( cutPos + 1 );
const std::string& quantityName = sumAddress.vectorName().substr( cutPos + 1 );
if ( sumAddress.category() == RifEclipseSummaryAddress::SUMMARY_CALCULATED )
{
@ -229,9 +228,9 @@ QString RimSummaryPlotAxisFormatter::autoAxisTitle() const
{
auto candidateName = quantityName;
if ( sumAddress.isHistoryQuantity() ) candidateName = quantityName.substr( 0, quantityName.size() - 1 );
if ( sumAddress.isHistoryVector() ) candidateName = quantityName.substr( 0, quantityName.size() - 1 );
titleText = RiuSummaryQuantityNameInfoProvider::instance()->longNameFromQuantityName( candidateName );
titleText = RiuSummaryQuantityNameInfoProvider::instance()->longNameFromVectorName( candidateName );
}
if ( m_axisProperties->showAcronym() )

2
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryPlotFilterTextCurveSetEditor.cpp
View File

@ -635,7 +635,7 @@ void RimSummaryPlotFilterTextCurveSetEditor::insertFilteredAddressesInSet(
for ( const auto& adr : candidateAddresses )
{
if ( RiaStdStringTools::endsWith( adr.quantityName(), diffText ) ) continue;
if ( RiaStdStringTools::endsWith( adr.vectorName(), diffText ) ) continue;
tmp.insert( adr );
}

4
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryPlotNameHelper.cpp
View File

@ -102,7 +102,7 @@ QString RimSummaryPlotNameHelper::plotTitle() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimSummaryPlotNameHelper::isPlotDisplayingSingleQuantity() const
bool RimSummaryPlotNameHelper::isPlotDisplayingSingleVectorName() const
{
if ( m_analyzer->quantities().size() == 2 )
{
@ -186,7 +186,7 @@ QString RimSummaryPlotNameHelper::caseName() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::string RimSummaryPlotNameHelper::titleQuantity() const
std::string RimSummaryPlotNameHelper::titleVectorName() const
{
return m_titleQuantity;
}

4
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryPlotNameHelper.h
View File

@ -51,7 +51,7 @@ public:
QString plotTitle() const override;
bool isPlotDisplayingSingleQuantity() const override;
bool isPlotDisplayingSingleVectorName() const override;
bool isWellNameInTitle() const override;
bool isGroupNameInTitle() const override;
bool isRegionInTitle() const override;
@ -62,7 +62,7 @@ public:
QString caseName() const override;
std::string titleQuantity() const override;
std::string titleVectorName() const override;
std::string titleWellName() const override;
std::string titleGroupName() const override;
std::string titleRegion() const override;

38
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryPlotSourceStepping.cpp
View File

@ -56,7 +56,7 @@ namespace caf
template <>
void AppEnum<RimSummaryPlotSourceStepping::SourceSteppingDimension>::setUp()
{
addItem( RimSummaryPlotSourceStepping::SourceSteppingDimension::QUANTITY, "QUANTITY", "Quantity" );
addItem( RimSummaryPlotSourceStepping::SourceSteppingDimension::VECTOR, "VECTOR", "Vector" );
addItem( RimSummaryPlotSourceStepping::SourceSteppingDimension::WELL, "WELL", "Well" );
addItem( RimSummaryPlotSourceStepping::SourceSteppingDimension::SUMMARY_CASE, "SUMMARY_CASE", "Summary Case" );
addItem( RimSummaryPlotSourceStepping::SourceSteppingDimension::ENSEMBLE, "ENSEMBLE", "Ensemble" );
@ -64,7 +64,7 @@ void AppEnum<RimSummaryPlotSourceStepping::SourceSteppingDimension>::setUp()
addItem( RimSummaryPlotSourceStepping::SourceSteppingDimension::REGION, "REGION", "Region" );
addItem( RimSummaryPlotSourceStepping::SourceSteppingDimension::BLOCK, "BLOCK", "Block" );
addItem( RimSummaryPlotSourceStepping::SourceSteppingDimension::AQUIFER, "AQUIFER", "Aquifer" );
setDefault( RimSummaryPlotSourceStepping::SourceSteppingDimension::QUANTITY );
setDefault( RimSummaryPlotSourceStepping::SourceSteppingDimension::VECTOR );
}
} // namespace caf
@ -90,7 +90,7 @@ RimSummaryPlotSourceStepping::RimSummaryPlotSourceStepping()
CAF_PDM_InitFieldNoDefault( &m_wellName, "WellName", "Well Name" );
CAF_PDM_InitFieldNoDefault( &m_groupName, "GroupName", "Group Name" );
CAF_PDM_InitFieldNoDefault( &m_region, "Region", "Region" );
CAF_PDM_InitFieldNoDefault( &m_quantity, "Quantities", "Quantity" );
CAF_PDM_InitFieldNoDefault( &m_vectorName, "VectorName", "Vector" );
CAF_PDM_InitFieldNoDefault( &m_cellBlock, "CellBlock", "Block" );
CAF_PDM_InitFieldNoDefault( &m_segment, "Segment", "Segment" );
@ -232,7 +232,7 @@ QList<caf::PdmOptionItemInfo>
auto addresses = adressesForSourceStepping();
if ( !addresses.empty() )
{
if ( fieldNeedingOptions == &m_quantity )
if ( fieldNeedingOptions == &m_vectorName )
{
std::map<QString, QString> displayAndValueStrings = optionsForQuantity( addresses );
@ -383,7 +383,7 @@ void RimSummaryPlotSourceStepping::fieldChangedByUi( const caf::PdmFieldHandle*
m_wellName.uiCapability()->updateConnectedEditors();
m_groupName.uiCapability()->updateConnectedEditors();
m_region.uiCapability()->updateConnectedEditors();
m_quantity.uiCapability()->updateConnectedEditors();
m_vectorName.uiCapability()->updateConnectedEditors();
}
else if ( changedField == &m_ensemble )
{
@ -406,9 +406,9 @@ void RimSummaryPlotSourceStepping::fieldChangedByUi( const caf::PdmFieldHandle*
m_wellName.uiCapability()->updateConnectedEditors();
m_groupName.uiCapability()->updateConnectedEditors();
m_region.uiCapability()->updateConnectedEditors();
m_quantity.uiCapability()->updateConnectedEditors();
m_vectorName.uiCapability()->updateConnectedEditors();
}
else if ( changedField == &m_quantity )
else if ( changedField == &m_vectorName )
{
for ( auto curve : curves )
{
@ -438,11 +438,11 @@ void RimSummaryPlotSourceStepping::fieldChangedByUi( const caf::PdmFieldHandle*
curveSet->setSummaryAddress( adr );
}
}
m_quantity.uiCapability()->updateConnectedEditors();
m_vectorName.uiCapability()->updateConnectedEditors();
triggerLoadDataAndUpdate = true;
}
if ( changedField != &m_quantity )
if ( changedField != &m_vectorName )
{
RifEclipseSummaryAddress::SummaryVarCategory summaryCategoryToModify = RifEclipseSummaryAddress::SUMMARY_INVALID;
if ( changedField == &m_wellName )
@ -577,8 +577,8 @@ caf::PdmValueField* RimSummaryPlotSourceStepping::fieldToModify()
case SourceSteppingDimension::REGION:
return &m_region;
case SourceSteppingDimension::QUANTITY:
return &m_quantity;
case SourceSteppingDimension::VECTOR:
return &m_vectorName;
case SourceSteppingDimension::BLOCK:
return &m_cellBlock;
@ -821,10 +821,10 @@ std::vector<caf::PdmFieldHandle*> RimSummaryPlotSourceStepping::activeFieldsForD
if ( !analyzer.quantityNameForTitle().empty() )
{
QString txt = QString::fromStdString( analyzer.quantityNameForTitle() );
m_quantity = txt;
QString txt = QString::fromStdString( analyzer.quantityNameForTitle() );
m_vectorName = txt;
fieldsCommonForAllCurves.push_back( &m_quantity );
fieldsCommonForAllCurves.push_back( &m_vectorName );
}
}
}
@ -1051,7 +1051,7 @@ RifEclipseSummaryAddress RimSummaryPlotSourceStepping::stepAddress( RifEclipseSu
}
break;
case SourceSteppingDimension::QUANTITY:
case SourceSteppingDimension::VECTOR:
{
auto options = optionsForQuantity( addresses );
@ -1061,7 +1061,7 @@ RifEclipseSummaryAddress RimSummaryPlotSourceStepping::stepAddress( RifEclipseSu
values.push_back( it->second );
}
QString qName = QString::fromStdString( addr.quantityName() );
QString qName = QString::fromStdString( addr.vectorName() );
auto found = std::find( values.begin(), values.end(), qName );
if ( found != values.end() )
{
@ -1073,7 +1073,7 @@ RifEclipseSummaryAddress RimSummaryPlotSourceStepping::stepAddress( RifEclipseSu
{
if ( found != values.begin() ) found--;
}
if ( found != values.end() ) addr.setQuantityName( ( *found ).toStdString() );
if ( found != values.end() ) addr.setVectorName( ( *found ).toStdString() );
}
}
break;
@ -1154,8 +1154,8 @@ void RimSummaryPlotSourceStepping::syncWithStepper( RimSummaryPlotSourceStepping
m_region = other->m_region();
break;
case SourceSteppingDimension::QUANTITY:
m_quantity = other->m_quantity();
case SourceSteppingDimension::VECTOR:
m_vectorName = other->m_vectorName();
break;
case SourceSteppingDimension::BLOCK:

4
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryPlotSourceStepping.h
View File

@ -51,7 +51,7 @@ public:
WELL,
GROUP,
REGION,
QUANTITY,
VECTOR,
BLOCK,
AQUIFER
};
@ -125,7 +125,7 @@ private:
caf::PdmField<QString> m_wellName;
caf::PdmField<QString> m_groupName;
caf::PdmField<int> m_region;
caf::PdmField<QString> m_quantity;
caf::PdmField<QString> m_vectorName;
caf::PdmField<QString> m_placeholderForLabel;
caf::PdmField<QString> m_cellBlock;

4
ApplicationLibCode/UnitTests/ObservedDataParser-Test.cpp
View File

@ -563,7 +563,7 @@ TEST( RifColumnBasedRsmspecParserTest, TestTableValues )
EXPECT_EQ( 3.0, tables.at( 1 ).columnInfos().at( 0 ).values.at( 2 ) );
EXPECT_EQ( 370.0, tables.at( 1 ).columnInfos().at( 3 ).values.at( 3 ) );
EXPECT_EQ( "WOPR", tables.at( 0 ).columnInfos().at( 1 ).summaryAddress.quantityName() );
EXPECT_EQ( "WOPR", tables.at( 0 ).columnInfos().at( 1 ).summaryAddress.vectorName() );
EXPECT_EQ( "P-15P", tables.at( 0 ).columnInfos().at( 5 ).summaryAddress.wellName() );
EXPECT_EQ( "P-9P", tables.at( 1 ).columnInfos().at( 1 ).summaryAddress.wellName() );
EXPECT_NE( "P-9P", tables.at( 1 ).columnInfos().at( 0 ).summaryAddress.wellName() );
@ -875,7 +875,7 @@ TEST( RifKeywordBasedRsmspecParserTest, TestShutins )
EXPECT_EQ( 2014.39, tables.at( 0 ).columnInfos().at( 1 ).values[2] );
EXPECT_EQ( "WOPR", tables.at( 0 ).columnInfos().at( 2 ).summaryAddress.quantityName() );
EXPECT_EQ( "WOPR", tables.at( 0 ).columnInfos().at( 2 ).summaryAddress.vectorName() );
EXPECT_EQ( "OP-1", tables.at( 0 ).columnInfos().at( 2 ).summaryAddress.wellName() );
EXPECT_NE( "OP-1", tables.at( 0 ).columnInfos().at( 1 ).summaryAddress.wellName() );

50
ApplicationLibCode/UnitTests/RifEclipseSummaryAddress-Test.cpp
View File

@ -16,7 +16,7 @@ TEST( RifEclipseSummaryAddressTest, TestEclipseAddressParsing_Field )
EXPECT_TRUE( addr.isValid() );
EXPECT_EQ( RifEclipseSummaryAddress::SUMMARY_FIELD, addr.category() );
EXPECT_EQ( "FOPT", addr.quantityName() );
EXPECT_EQ( "FOPT", addr.vectorName() );
EXPECT_FALSE( addr.isErrorResult() );
}
@ -28,7 +28,7 @@ TEST( RifEclipseSummaryAddressTest, TestEclipseAddressParsing_Aquifer )
EXPECT_TRUE( addr.isValid() );
EXPECT_EQ( RifEclipseSummaryAddress::SUMMARY_AQUIFER, addr.category() );
EXPECT_EQ( "AAQR", addr.quantityName() );
EXPECT_EQ( "AAQR", addr.vectorName() );
EXPECT_EQ( 456, addr.aquiferNumber() );
EXPECT_FALSE( addr.isErrorResult() );
}
@ -41,7 +41,7 @@ TEST( RifEclipseSummaryAddressTest, TestEclipseAddressParsing_Network )
EXPECT_TRUE( addr.isValid() );
EXPECT_EQ( RifEclipseSummaryAddress::SUMMARY_NETWORK, addr.category() );
EXPECT_EQ( "NETW", addr.quantityName() );
EXPECT_EQ( "NETW", addr.vectorName() );
EXPECT_FALSE( addr.isErrorResult() );
}
@ -53,7 +53,7 @@ TEST( RifEclipseSummaryAddressTest, DISABLED_TestEclipseAddressParsing_Misc )
EXPECT_TRUE( addr.isValid() );
EXPECT_EQ( RifEclipseSummaryAddress::SUMMARY_MISC, addr.category() );
EXPECT_EQ( "CPU", addr.quantityName() );
EXPECT_EQ( "CPU", addr.vectorName() );
EXPECT_FALSE( addr.isErrorResult() );
}
@ -65,7 +65,7 @@ TEST( RifEclipseSummaryAddressTest, TestEclipseAddressParsing_Region )
EXPECT_TRUE( addr.isValid() );
EXPECT_EQ( RifEclipseSummaryAddress::SUMMARY_REGION, addr.category() );
EXPECT_EQ( "RPR", addr.quantityName() );
EXPECT_EQ( "RPR", addr.vectorName() );
EXPECT_EQ( 7081, addr.regionNumber() );
EXPECT_FALSE( addr.isErrorResult() );
}
@ -78,7 +78,7 @@ TEST( RifEclipseSummaryAddressTest, TestEclipseAddressParsing_RegionToRegion )
EXPECT_TRUE( addr.isValid() );
EXPECT_EQ( RifEclipseSummaryAddress::SUMMARY_REGION_2_REGION, addr.category() );
EXPECT_EQ( "ROFR", addr.quantityName() );
EXPECT_EQ( "ROFR", addr.vectorName() );
EXPECT_EQ( 7081, addr.regionNumber() );
EXPECT_EQ( 8001, addr.regionNumber2() );
EXPECT_FALSE( addr.isErrorResult() );
@ -92,7 +92,7 @@ TEST( RifEclipseSummaryAddressTest, TestEclipseAddressParsing_WellGroup )
EXPECT_TRUE( addr.isValid() );
EXPECT_EQ( RifEclipseSummaryAddress::SUMMARY_GROUP, addr.category() );
EXPECT_EQ( "GOPR", addr.quantityName() );
EXPECT_EQ( "GOPR", addr.vectorName() );
EXPECT_EQ( "WELLS1", addr.groupName() );
EXPECT_FALSE( addr.isErrorResult() );
}
@ -105,7 +105,7 @@ TEST( RifEclipseSummaryAddressTest, TestEclipseAddressParsing_Well )
EXPECT_TRUE( addr.isValid() );
EXPECT_EQ( RifEclipseSummaryAddress::SUMMARY_WELL, addr.category() );
EXPECT_EQ( "WOPR", addr.quantityName() );
EXPECT_EQ( "WOPR", addr.vectorName() );
EXPECT_EQ( "B-2H", addr.wellName() );
EXPECT_FALSE( addr.isErrorResult() );
}
@ -118,7 +118,7 @@ TEST( RifEclipseSummaryAddressTest, TestEclipseAddressParsing_WellCompletion )
EXPECT_TRUE( addr.isValid() );
EXPECT_EQ( RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION, addr.category() );
EXPECT_EQ( "COFRL", addr.quantityName() );
EXPECT_EQ( "COFRL", addr.vectorName() );
EXPECT_EQ( "B-1H", addr.wellName() );
EXPECT_EQ( 15, addr.cellI() );
EXPECT_EQ( 13, addr.cellJ() );
@ -134,7 +134,7 @@ TEST( RifEclipseSummaryAddressTest, TestEclipseAddressParsing_WellLgr )
EXPECT_TRUE( addr.isValid() );
EXPECT_EQ( RifEclipseSummaryAddress::SUMMARY_WELL_LGR, addr.category() );
EXPECT_EQ( "LWABC", addr.quantityName() );
EXPECT_EQ( "LWABC", addr.vectorName() );
EXPECT_EQ( "LGRNA", addr.lgrName() );
EXPECT_EQ( "B-10H", addr.wellName() );
EXPECT_FALSE( addr.isErrorResult() );
@ -148,7 +148,7 @@ TEST( RifEclipseSummaryAddressTest, TestEclipseAddressParsing_WellCompletionLgr
EXPECT_TRUE( addr.isValid() );
EXPECT_EQ( RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION_LGR, addr.category() );
EXPECT_EQ( "LCGAS", addr.quantityName() );
EXPECT_EQ( "LCGAS", addr.vectorName() );
EXPECT_EQ( "LGR1", addr.lgrName() );
EXPECT_EQ( "B-1H", addr.wellName() );
EXPECT_EQ( 11, addr.cellI() );
@ -165,7 +165,7 @@ TEST( RifEclipseSummaryAddressTest, TestEclipseAddressParsing_WellSegment )
EXPECT_TRUE( addr.isValid() );
EXPECT_EQ( RifEclipseSummaryAddress::SUMMARY_WELL_SEGMENT, addr.category() );
EXPECT_EQ( "SOFR", addr.quantityName() );
EXPECT_EQ( "SOFR", addr.vectorName() );
EXPECT_EQ( "B-5H", addr.wellName() );
EXPECT_EQ( 32, addr.wellSegmentNumber() );
EXPECT_FALSE( addr.isErrorResult() );
@ -179,7 +179,7 @@ TEST( RifEclipseSummaryAddressTest, TestEclipseAddressParsing_Block )
EXPECT_TRUE( addr.isValid() );
EXPECT_EQ( RifEclipseSummaryAddress::SUMMARY_BLOCK, addr.category() );
EXPECT_EQ( "BPR", addr.quantityName() );
EXPECT_EQ( "BPR", addr.vectorName() );
EXPECT_EQ( 123, addr.cellI() );
EXPECT_EQ( 122, addr.cellJ() );
EXPECT_EQ( 121, addr.cellK() );
@ -194,7 +194,7 @@ TEST( RifEclipseSummaryAddressTest, TestEclipseAddressParsing_BlockLgr )
EXPECT_TRUE( addr.isValid() );
EXPECT_EQ( RifEclipseSummaryAddress::SUMMARY_BLOCK_LGR, addr.category() );
EXPECT_EQ( "LBABC", addr.quantityName() );
EXPECT_EQ( "LBABC", addr.vectorName() );
EXPECT_EQ( "LGRN", addr.lgrName() );
EXPECT_EQ( 45, addr.cellI() );
EXPECT_EQ( 47, addr.cellJ() );
@ -210,7 +210,7 @@ TEST( RifEclipseSummaryAddressTest, TestEclipseAddressParsing_Imported )
EXPECT_TRUE( addr.isValid() );
EXPECT_EQ( RifEclipseSummaryAddress::SUMMARY_IMPORTED, addr.category() );
EXPECT_EQ( "FAULT (Imp)", addr.quantityName() );
EXPECT_EQ( "FAULT (Imp)", addr.vectorName() );
EXPECT_FALSE( addr.isErrorResult() );
}
@ -222,7 +222,7 @@ TEST( RifEclipseSummaryAddressTest, TestEclipseAddressParsing_ErrorResult1 )
EXPECT_TRUE( addr.isValid() );
EXPECT_EQ( RifEclipseSummaryAddress::SUMMARY_AQUIFER, addr.category() );
EXPECT_EQ( "AAQR", addr.quantityName() );
EXPECT_EQ( "AAQR", addr.vectorName() );
EXPECT_EQ( 456, addr.aquiferNumber() );
EXPECT_TRUE( addr.isErrorResult() );
}
@ -235,7 +235,7 @@ TEST( RifEclipseSummaryAddressTest, TestEclipseAddressParsing_ErrorResult2 )
EXPECT_TRUE( addr.isValid() );
EXPECT_EQ( RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION_LGR, addr.category() );
EXPECT_EQ( "LCGAS", addr.quantityName() );
EXPECT_EQ( "LCGAS", addr.vectorName() );
EXPECT_EQ( "LGR1", addr.lgrName() );
EXPECT_EQ( "B-1H", addr.wellName() );
EXPECT_EQ( 11, addr.cellI() );
@ -252,7 +252,7 @@ TEST( RifEclipseSummaryAddressTest, TestEclipseAddressParsing_ErrorResult3 )
EXPECT_TRUE( addr.isValid() );
EXPECT_EQ( RifEclipseSummaryAddress::SUMMARY_IMPORTED, addr.category() );
EXPECT_EQ( "FAULT (Imp)", addr.quantityName() );
EXPECT_EQ( "FAULT (Imp)", addr.vectorName() );
EXPECT_TRUE( addr.isErrorResult() );
}
@ -269,7 +269,7 @@ TEST( RifEclipseSummaryAddressTest, TestEclipseAddressIjkParsing )
EXPECT_TRUE( addr.isValid() );
EXPECT_EQ( RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION, addr.category() );
EXPECT_EQ( "WOPR", addr.quantityName() );
EXPECT_EQ( "WOPR", addr.vectorName() );
EXPECT_EQ( "1-BH", addr.wellName() );
EXPECT_EQ( 6, addr.cellI() );
EXPECT_EQ( 7, addr.cellJ() );
@ -289,7 +289,7 @@ TEST( RifEclipseSummaryAddressTest, TestEclipseAddressRegToRegParsing )
EXPECT_TRUE( addr.isValid() );
EXPECT_EQ( RifEclipseSummaryAddress::SUMMARY_REGION_2_REGION, addr.category() );
EXPECT_EQ( "ROFR", addr.quantityName() );
EXPECT_EQ( "ROFR", addr.vectorName() );
EXPECT_EQ( 123, addr.regionNumber() );
EXPECT_EQ( 456, addr.regionNumber2() );
EXPECT_TRUE( !addr.isErrorResult() );
@ -298,28 +298,28 @@ TEST( RifEclipseSummaryAddressTest, TestEclipseAddressRegToRegParsing )
TEST( RifEclipseSummaryAddressTest, TestQuantityNameManipulations )
{
{
auto s = RifEclipseSummaryAddress::baseQuantityName( "FOPT" );
auto s = RifEclipseSummaryAddress::baseVectorName( "FOPT" );
EXPECT_EQ( "FOPT", s );
}
{
auto s = RifEclipseSummaryAddress::baseQuantityName( "FOPT_1" );
auto s = RifEclipseSummaryAddress::baseVectorName( "FOPT_1" );
EXPECT_EQ( "FOPT", s );
}
{
auto s = RifEclipseSummaryAddress::baseQuantityName( "FOPR" );
auto s = RifEclipseSummaryAddress::baseVectorName( "FOPR" );
EXPECT_EQ( "FOPR", s );
}
{
auto s = RifEclipseSummaryAddress::baseQuantityName( "FOPR_1" );
auto s = RifEclipseSummaryAddress::baseVectorName( "FOPR_1" );
EXPECT_EQ( "FOPR", s );
}
{
// https://github.com/OPM/ResInsight/issues/6481
auto s = RifEclipseSummaryAddress::baseQuantityName( "FCMIT_1" );
auto s = RifEclipseSummaryAddress::baseVectorName( "FCMIT_1" );
EXPECT_EQ( "FCMIT", s );
}
}

2
ApplicationLibCode/UnitTests/RifReaderEclipseSummary-Test.cpp
View File

@ -133,7 +133,7 @@ resulting
for (size_t i = 0; i < addresses.size(); i++)
{
RifEclipseSummaryAddress adr(addresses[i].category(), addresses[i].simulationItemName(),
addresses[i].quantityName()); myAddresses.push_back(adr);
addresses[i].vectorName()); myAddresses.push_back(adr);
}
for (size_t i = 0; i < addresses.size(); i++)

26
ApplicationLibCode/UnitTests/RiuSummaryVectorDescriptionMap-Test.cpp
View File

@ -10,40 +10,40 @@ TEST( RiuSummaryQuantityNameInfoProvider, TestInit )
{
{
std::string s( "SRSFC" );
auto cat = RiuSummaryQuantityNameInfoProvider::instance()->categoryFromQuantityName( s );
auto cat = RiuSummaryQuantityNameInfoProvider::instance()->categoryFromVectorName( s );
EXPECT_TRUE( cat == RifEclipseSummaryAddress::SUMMARY_WELL_SEGMENT );
auto longName = RiuSummaryQuantityNameInfoProvider::instance()->longNameFromQuantityName( s );
auto longName = RiuSummaryQuantityNameInfoProvider::instance()->longNameFromVectorName( s );
EXPECT_TRUE( longName == "Reach brine concentration" );
}
{
std::string s( "SRSFC" );
auto test = RiuSummaryQuantityNameInfoProvider::instance()->longNameFromQuantityName( s );
auto test = RiuSummaryQuantityNameInfoProvider::instance()->longNameFromVectorName( s );
EXPECT_TRUE( test == "Reach brine concentration" );
}
{
std::string s( "does not exist" );
auto cat = RiuSummaryQuantityNameInfoProvider::instance()->categoryFromQuantityName( s );
auto cat = RiuSummaryQuantityNameInfoProvider::instance()->categoryFromVectorName( s );
EXPECT_TRUE( cat == RifEclipseSummaryAddress::SUMMARY_INVALID );
auto longName = RiuSummaryQuantityNameInfoProvider::instance()->longNameFromQuantityName( s );
auto longName = RiuSummaryQuantityNameInfoProvider::instance()->longNameFromVectorName( s );
EXPECT_TRUE( longName == "" );
}
{
std::string s( "does not exist" );
auto test = RiuSummaryQuantityNameInfoProvider::instance()->longNameFromQuantityName( s );
auto test = RiuSummaryQuantityNameInfoProvider::instance()->longNameFromVectorName( s );
EXPECT_TRUE( test == "" );
}
{
std::string s( "does not exist" );
auto test = RiuSummaryQuantityNameInfoProvider::instance()->longNameFromQuantityName( s, true );
auto test = RiuSummaryQuantityNameInfoProvider::instance()->longNameFromVectorName( s, true );
EXPECT_TRUE( test == s );
}
@ -56,16 +56,16 @@ TEST( RiuSummaryQuantityNameInfoProvider, TestCustomNaming )
{
{
std::string s( "SRSFCABC" );
auto cat = RiuSummaryQuantityNameInfoProvider::instance()->categoryFromQuantityName( s );
auto cat = RiuSummaryQuantityNameInfoProvider::instance()->categoryFromVectorName( s );
EXPECT_TRUE( cat == RifEclipseSummaryAddress::SUMMARY_WELL_SEGMENT );
auto longName = RiuSummaryQuantityNameInfoProvider::instance()->longNameFromQuantityName( s );
auto longName = RiuSummaryQuantityNameInfoProvider::instance()->longNameFromVectorName( s );
EXPECT_TRUE( longName == "Reach brine concentration" );
}
{
std::string s( "BHD__ABC" );
auto test = RiuSummaryQuantityNameInfoProvider::instance()->longNameFromQuantityName( s );
auto test = RiuSummaryQuantityNameInfoProvider::instance()->longNameFromVectorName( s );
EXPECT_TRUE( test == "Hydraulic head" );
}
@ -78,13 +78,13 @@ TEST( RiuSummaryQuantityNameInfoProvider, Test6x )
{
{
std::string s( "GLIT" );
auto cat = RiuSummaryQuantityNameInfoProvider::instance()->categoryFromQuantityName( s );
auto cat = RiuSummaryQuantityNameInfoProvider::instance()->categoryFromVectorName( s );
EXPECT_TRUE( cat == RifEclipseSummaryAddress::SUMMARY_GROUP );
}
{
std::string s( "WSBVPROP" );
auto cat = RiuSummaryQuantityNameInfoProvider::instance()->categoryFromQuantityName( s );
auto cat = RiuSummaryQuantityNameInfoProvider::instance()->categoryFromVectorName( s );
EXPECT_TRUE( cat == RifEclipseSummaryAddress::SUMMARY_WELL );
}
}
@ -108,7 +108,7 @@ TEST( DISABLED_RiuSummaryQuantityNameInfoProvider, PerformanceLookup )
{
for ( const auto& s : values )
{
RiuSummaryQuantityNameInfoProvider::instance()->categoryFromQuantityName( s );
RiuSummaryQuantityNameInfoProvider::instance()->categoryFromVectorName( s );
}
}

20
ApplicationLibCode/UserInterface/RiuSummaryQuantityNameInfoProvider.cpp
View File

@ -33,9 +33,9 @@ RiuSummaryQuantityNameInfoProvider* RiuSummaryQuantityNameInfoProvider::instance
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress::SummaryVarCategory
RiuSummaryQuantityNameInfoProvider::categoryFromQuantityName( const std::string& quantity ) const
RiuSummaryQuantityNameInfoProvider::categoryFromVectorName( const std::string& vectorName ) const
{
auto info = quantityInfo( quantity );
auto info = quantityInfo( vectorName );
return info.category;
}
@ -44,16 +44,16 @@ RifEclipseSummaryAddress::SummaryVarCategory
///
//--------------------------------------------------------------------------------------------------
RiuSummaryQuantityNameInfoProvider::RiuSummaryQuantityInfo
RiuSummaryQuantityNameInfoProvider::quantityInfo( const std::string& quantity ) const
RiuSummaryQuantityNameInfoProvider::quantityInfo( const std::string& vectorName ) const
{
auto it = m_summaryToDescMap.find( quantity );
auto it = m_summaryToDescMap.find( vectorName );
if ( it != m_summaryToDescMap.end() )
{
return it->second;
}
if ( quantity.size() > 1 && quantity[1] == 'U' )
if ( vectorName.size() > 1 && vectorName[1] == 'U' )
{
// User defined vector name
// The summary type is given by the first letter, and U defines user-defined
@ -63,12 +63,12 @@ RiuSummaryQuantityNameInfoProvider::RiuSummaryQuantityInfo
return RiuSummaryQuantityInfo();
}
if ( quantity.size() > 5 )
if ( vectorName.size() > 5 )
{
// Check for custom vector naming
std::string postfix = quantity.substr( quantity.size() - 5, 5 );
std::string baseName = quantity.substr( 0, 5 );
std::string postfix = vectorName.substr( vectorName.size() - 5, 5 );
std::string baseName = vectorName.substr( 0, 5 );
while ( baseName.back() == '_' )
baseName.pop_back();
@ -92,8 +92,8 @@ RiuSummaryQuantityNameInfoProvider::RiuSummaryQuantityInfo
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::string RiuSummaryQuantityNameInfoProvider::longNameFromQuantityName( const std::string& vectorName,
bool returnVectorNameIfNotFound ) const
std::string RiuSummaryQuantityNameInfoProvider::longNameFromVectorName( const std::string& vectorName,
bool returnVectorNameIfNotFound ) const
{
auto info = quantityInfo( vectorName );
return info.category != RifEclipseSummaryAddress::SUMMARY_INVALID || !returnVectorNameIfNotFound ? info.longName

6
ApplicationLibCode/UserInterface/RiuSummaryQuantityNameInfoProvider.h
View File

@ -31,8 +31,8 @@ class RiuSummaryQuantityNameInfoProvider
public:
static RiuSummaryQuantityNameInfoProvider* instance();
RifEclipseSummaryAddress::SummaryVarCategory categoryFromQuantityName( const std::string& quantity ) const;
std::string longNameFromQuantityName( const std::string& quantity, bool returnVectorNameIfNotFound = false ) const;
RifEclipseSummaryAddress::SummaryVarCategory categoryFromVectorName( const std::string& vectorName ) const;
std::string longNameFromVectorName( const std::string& vectorName, bool returnVectorNameIfNotFound = false ) const;
private:
class RiuSummaryQuantityInfo
@ -55,7 +55,7 @@ private:
private:
RiuSummaryQuantityNameInfoProvider();
RiuSummaryQuantityInfo quantityInfo( const std::string& quantity ) const;
RiuSummaryQuantityInfo quantityInfo( const std::string& vectorName ) const;
static std::unordered_map<std::string, RiuSummaryQuantityInfo> createInfoForEclipseKeywords();
static std::unordered_map<std::string, RiuSummaryQuantityInfo> createInfoFor6xKeywords();

10
ApplicationLibCode/UserInterface/RiuSummaryVectorSelectionUi.cpp
View File

@ -1115,22 +1115,22 @@ std::set<RifEclipseSummaryAddress>
for ( const auto& adr : addrUnion )
{
if ( m_hideHistoryVectors && adr.isHistoryQuantity() ) continue;
if ( m_hideHistoryVectors && adr.isHistoryVector() ) continue;
if ( m_hideDifferenceVectors )
{
const auto diffText = RifReaderEclipseSummary::differenceIdentifier();
if ( RiaStdStringTools::endsWith( adr.quantityName(), diffText ) ) continue;
if ( RiaStdStringTools::endsWith( adr.vectorName(), diffText ) ) continue;
}
if ( m_hideVectorsWithoutHistory )
{
auto candidateName = adr.quantityName() + RifReaderEclipseSummary::historyIdentifier();
auto candidateName = adr.vectorName() + RifReaderEclipseSummary::historyIdentifier();
bool found = false;
for ( const auto& ad : addrUnion )
{
if ( ad.quantityName() == candidateName ) found = true;
if ( ad.vectorName() == candidateName ) found = true;
}
if ( !found ) continue;
@ -1549,7 +1549,7 @@ void RiuSummaryVectorSelectionUi::appendOptionItemsForSubCategoriesAndVectors( Q
if ( isVectorField )
{
std::string longVectorName =
RiuSummaryQuantityNameInfoProvider::instance()->longNameFromQuantityName( itemName );
RiuSummaryQuantityNameInfoProvider::instance()->longNameFromVectorName( itemName );
if ( longVectorName.empty() )
{