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
Download Patch File Download Diff File Expand all files Collapse all files

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 );